tiny-metaio 0.2.0__tar.gz → 0.3.0__tar.gz

{tiny_metaio-0.2.0 → tiny_metaio-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tiny-metaio
-Version: 0.2.0
+Version: 0.3.0
 Summary: Read and write MetaImages with minimal dependencies
 Author-email: Nicolas Cedilnik <nicolas.cedilnik@inria.fr>
 Project-URL: Homepage, https://gitlab.inria.fr/ncedilni/metaio
@@ -26,6 +26,8 @@ images (`.nii` or `.nii.gz`)
 and write `.mha` images
 in python with minimal dependencies.
 
+Bonus: provides a custom 8-bit MHA-like format when size matters: `.metaq`.
+
 ## Installation
 
 Available on pypi.org: `pip install tiny-metaio`.
@@ -57,6 +59,43 @@ array([0., 0.])
 
 ```
 
+### Custom format
+
+You need to specify a range of values covered by the quantization.
+Values outside this ranges will be clipped.
+A loss of precision is expected.
+NaNs will be implicitly converted to zero.
+
+```python
+>>> img = metaio.MetaImage([[-0.5, 1], [2.5, 5]])
+>>> img.save_quantized("some-name.metaq", min_=0, max_=2.5)
+>>> metaio.read("some-name.metaq").data
+array([[0. , 1. ],
+       [2.5, 2.5]], dtype=float32)
+
+```
+
+Additionally, if some values do not matter, you can specify a mask for further compression.
+The mask must be a binary array of the same shape as the image.
+Values where the mask is `False` will not be stored at all and restored as NaN on dequantization.
+
+```python
+>>> img = metaio.MetaImage([[-0.5, 1], [2.5, 5]])
+>>> img.save_quantized("some-name.metaq", min_=0, max_=2.5, mask=img.data <= 2.5)
+>>> metaio.read("some-name.metaq").data
+array([[0. , 1. ],
+       [2.5, nan]], dtype=float32)
+
+```
+
+### Command-line interface
+
+A command-line interface is available to convert supported input format to a MHA.
+
+```
+$ metaio /path/to/input.metaq /path/to/output.mha
+```
+
 ## Philosophy
 
 - `numpy` as only runtime dependency.
@@ -67,6 +106,8 @@ array([0., 0.])
 ## Why should I use this over SimpleITK?
 
 If you just need the IO parts and do not want the large SimpleITK package,
+or if you need to efficiently store some large MetaImage-like data,
 this package might be for you.
+
 If you do not care about having SimpleITK as a dependency for your project,
 this package is not for you.

tiny_metaio-0.3.0/README.md

@@ -0,0 +1,96 @@
+# MetaIO
+
+Read
+[MetaImages](https://docs.itk.org/en/latest/learn/metaio.html)
+(`.mha` or `.mhd`)
+and
+[NIFTI](https://en.wikipedia.org/wiki/Neuroimaging_Informatics_Technology_Initiative)
+images (`.nii` or `.nii.gz`)
+and write `.mha` images
+in python with minimal dependencies.
+
+Bonus: provides a custom 8-bit MHA-like format when size matters: `.metaq`.
+
+## Installation
+
+Available on pypi.org: `pip install tiny-metaio`.
+
+## Usage
+
+### Writing a MHA file
+
+```python
+>>> import metaio
+>>> img = metaio.MetaImage([[0, 1], [42, 43]], spacing=[1, 2])
+>>> img.save("some-name.mha")
+
+```
+
+### Reading a MHA file
+
+```python
+>>> img = metaio.read("some-name.mha")
+>>> img.spacing
+array([1., 2.])
+>>> img.data
+array([[ 0,  1],
+       [42, 43]])
+>>> img.direction
+array([1., 0., 0., 1.])
+>>> img.origin
+array([0., 0.])
+
+```
+
+### Custom format
+
+You need to specify a range of values covered by the quantization.
+Values outside this ranges will be clipped.
+A loss of precision is expected.
+NaNs will be implicitly converted to zero.
+
+```python
+>>> img = metaio.MetaImage([[-0.5, 1], [2.5, 5]])
+>>> img.save_quantized("some-name.metaq", min_=0, max_=2.5)
+>>> metaio.read("some-name.metaq").data
+array([[0. , 1. ],
+       [2.5, 2.5]], dtype=float32)
+
+```
+
+Additionally, if some values do not matter, you can specify a mask for further compression.
+The mask must be a binary array of the same shape as the image.
+Values where the mask is `False` will not be stored at all and restored as NaN on dequantization.
+
+```python
+>>> img = metaio.MetaImage([[-0.5, 1], [2.5, 5]])
+>>> img.save_quantized("some-name.metaq", min_=0, max_=2.5, mask=img.data <= 2.5)
+>>> metaio.read("some-name.metaq").data
+array([[0. , 1. ],
+       [2.5, nan]], dtype=float32)
+
+```
+
+### Command-line interface
+
+A command-line interface is available to convert supported input format to a MHA.
+
+```
+$ metaio /path/to/input.metaq /path/to/output.mha
+```
+
+## Philosophy
+
+- `numpy` as only runtime dependency.
+- idiomatic python.
+- similar behavior than SimpleITK's `GetArrayFromImage`, `GetImageFromArray`,
+  `GetDirection`, `GetOrigin`, `GetSpacing`, `ReadImage`, `WriteImage`.
+
+## Why should I use this over SimpleITK?
+
+If you just need the IO parts and do not want the large SimpleITK package,
+or if you need to efficiently store some large MetaImage-like data,
+this package might be for you.
+
+If you do not care about having SimpleITK as a dependency for your project,
+this package is not for you.

{tiny_metaio-0.2.0 → tiny_metaio-0.3.0}/pyproject.toml

@@ -23,6 +23,9 @@ Homepage = "https://gitlab.inria.fr/ncedilni/metaio"
 Issues = "https://gitlab.inria.fr/ncedilni/metaio/-/issues"
 Repository = "https://gitlab.inria.fr/ncedilni/metaio"
 
+[project.scripts]
+metaio = "metaio.__main__:main"
+
 [build-system]
 requires = ["setuptools>=64", "setuptools-scm>=8"]
 build-backend = "setuptools.build_meta"

{tiny_metaio-0.2.0 → tiny_metaio-0.3.0}/src/metaio/__init__.py

@@ -1,8 +1,7 @@
 from pathlib import Path
 
+from . import mha, nifti, quant
 from .image import MetaImage
-from .mha import read_mha
-from .nifti import load
 
 
 def read(path: Path | str) -> MetaImage:
@@ -13,11 +12,14 @@ def read(path: Path | str) -> MetaImage:
         if len(split) == 3:
             suffix = ".".join(split[-2:])
 
+    if suffix in (".metaq"):
+        return quant.load(path)
+
     if suffix in (".mha", ".mhd"):
-        return read_mha(path)
+        return mha.load(path)
 
     if suffix in (".nii", "nii.gz"):
-        return load(path)
+        return nifti.load(path)
 
     raise RuntimeError(f"Unsupported file format: {path.suffix}")
 

tiny_metaio-0.3.0/src/metaio/__main__.py

@@ -0,0 +1,41 @@
+from argparse import ArgumentParser
+from pathlib import Path
+
+from . import read
+
+
+def main() -> int:
+    parser = ArgumentParser()
+    parser.add_argument("INPUT", help="Path to a file with a supported format.")
+    parser.add_argument(
+        "OUTPUT",
+        help="Path to the output file. It must have a '.mha' or '.metaq' extension.",
+        type=Path,
+    )
+    parser.add_argument(
+        "--no-compression",
+        help="Disable compression of the output. Only effective for '.mha'.",
+        dest="compression",
+        action="store_false",
+    )
+    parser.add_argument(
+        "--quantization-range",
+        help="Quantization range. Only effective for '.metaq'.",
+        type=float,
+        nargs=2,
+        default=(None, None),
+    )
+    parser.add_argument(
+        "--mask", help="Boolean mask to use. Only effective for '.metaq'.", type=Path
+    )
+    args = parser.parse_args()
+    img = read(args.INPUT)
+    if args.OUTPUT.suffix == ".metaq":
+        mask = None if args.mask is None else read(args.mask).data.astype(bool)
+        img.save_quantized(args.OUTPUT, *args.quantization_range, mask=mask)
+    else:
+        img.save(args.OUTPUT, compress=args.compression)
+    return 0
+
+
+exit(main())

{tiny_metaio-0.2.0 → tiny_metaio-0.3.0}/src/metaio/image.py

@@ -1,4 +1,6 @@
-import os
+from __future__ import annotations
+
+import shutil
 import zlib
 from pathlib import Path
 
@@ -26,7 +28,7 @@ class MetaImage:
         self.origin = origin
         self.direction = direction
 
-        self.metadata: dict[str, str] = {}
+        self.metadata: dict[str, str] = metadata or {}
 
     @property
     def size(self) -> tuple[int, ...]:
@@ -81,7 +83,7 @@ class MetaImage:
     def ndim(self) -> int:
         return self.data.ndim - (1 if self.vector else 0)
 
-    def save(self, path: os.PathLike[str], compress: bool = False) -> None:
+    def save(self, path: Path | str, compress: bool = False) -> None:
         path = Path(path)
         data = np.asarray(self.data)
 
@@ -132,3 +134,56 @@ class MetaImage:
             line("ElementDataFile", element_data_file)
 
             hfh.write(pixel_bytes)
+
+    def save_quantized(
+        self,
+        path: Path | str,
+        min_: float | None = None,
+        max_: float | None = None,
+        *,
+        mask: npt.NDArray[np.bool] | None = None,
+    ) -> None:
+        path = Path(path)
+        if not path.suffix == ".metaq":
+            raise ValueError(
+                "For quantized images, the file extension must be '.metaq'", path.name
+            )
+        if mask is None:
+            kwargs = {}
+            data = self.data.astype(np.float32)
+        else:
+            kwargs = {"mask": np.packbits(mask.astype(bool)), "mask_shape": mask.shape}
+            data = self.data[mask].astype(np.float32)
+        if min_ is None:
+            min_ = np.nanmin(self.data)
+        if max_ is None:
+            max_ = np.nanmax(self.data)
+        quantized = _quantize(data, min_, max_)
+        meta = _dict_to_structured_array(self.metadata)
+        np.savez_compressed(
+            path,
+            data=quantized,
+            spacing=self.spacing,
+            direction=self.direction,
+            origin=self.origin,
+            min=min_,
+            max=max_,
+            meta=meta,
+            **kwargs,
+            allow_pickle=False,
+        )
+        # numpy automatically adds the `.npz` suffix, we don't want that
+        shutil.move(str(path) + ".npz", path)
+
+
+def _quantize(
+    arr: npt.NDArray[np.floating], min_: float = 0, max_: float = 20
+) -> npt.NDArray[np.uint8]:
+    clamped = np.clip(arr, min_, max_)
+    scaled = (clamped - min_) / (max_ - min_) * 255
+    return np.round(scaled).astype(np.uint8)
+
+
+def _dict_to_structured_array(dct: dict[str, str]) -> npt.NDArray[np.void]:
+    dtype = [(key, f"U{len(v)}") for key, v in dct.items()]
+    return np.array([tuple(dct.values())], dtype=dtype)

{tiny_metaio-0.2.0 → tiny_metaio-0.3.0}/src/metaio/mha.py

@@ -1,4 +1,3 @@
-import os
 import zlib
 from pathlib import Path
 from typing import BinaryIO
@@ -53,7 +52,7 @@ def _parse_header(src: BinaryIO) -> tuple[dict[str, str], int]:
 
 def _require(header: dict[str, str], key: str) -> str:
     try:
-        return header[key]
+        return header.pop(key)
     except KeyError:
         raise KeyError(f"Required MetaIO key '{key}' not found in header.") from None
 
@@ -66,7 +65,7 @@ def _parse_int_list(s: str) -> list[int]:
     return [int(x) for x in s.split()]
 
 
-def read_mha(path: str | os.PathLike[str]) -> MetaImage:
+def load(path: Path | str) -> MetaImage:
     """
     Read a MetaIO image file (``.mha`` or ``.mhd``).
 
@@ -109,34 +108,34 @@ def read_mha(path: str | os.PathLike[str]) -> MetaImage:
 
         spacing: list[float] = []
         if "ElementSpacing" in header:
-            spacing = _parse_float_list(header["ElementSpacing"])
+            spacing = _parse_float_list(header.pop("ElementSpacing"))
         elif "ElementSize" in header:
-            spacing = _parse_float_list(header["ElementSize"])
+            spacing = _parse_float_list(header.pop("ElementSize"))
 
         origin: list[float] = []
         if "Offset" in header:
-            origin = _parse_float_list(header["Offset"])
+            origin = _parse_float_list(header.pop("Offset"))
         elif "Position" in header:
-            origin = _parse_float_list(header["Position"])
+            origin = _parse_float_list(header.pop("Position"))
 
         transform_matrix: list[float] | None = None
         if "TransformMatrix" in header:
-            transform_matrix = _parse_float_list(header["TransformMatrix"])
+            transform_matrix = _parse_float_list(header.pop("TransformMatrix"))
         elif "Rotation" in header:
-            transform_matrix = _parse_float_list(header["Rotation"])
+            transform_matrix = _parse_float_list(header.pop("Rotation"))
 
         transform_matrix = (
             np.array(transform_matrix).reshape((ndim, ndim)).ravel(order="F")
         ).tolist()
 
-        big_endian_str = header.get("BinaryDataByteOrderMSB", "False").strip()
+        big_endian_str = header.pop("BinaryDataByteOrderMSB", "False").strip()
         big_endian = big_endian_str.lower() in ("true", "1")
         dtype = dtype.newbyteorder(">" if big_endian else "<")
 
-        n_channels = int(header.get("ElementNumberOfChannels", "1"))
+        n_channels = int(header.pop("ElementNumberOfChannels", "1"))
 
         element_data_file = _require(header, "ElementDataFile").strip()
-        compressed = header.get("CompressedData", "False").strip().lower() in (
+        compressed = header.pop("CompressedData", "False").strip().lower() in (
             "true",
             "1",
         )

tiny_metaio-0.3.0/src/metaio/quant.py

@@ -0,0 +1,36 @@
+from pathlib import Path
+
+import numpy as np
+import numpy.typing as npt
+
+from .image import MetaImage
+
+
+def load(path: Path | str) -> MetaImage:
+    npz = np.load(path, allow_pickle=False)
+    arr_float = _dequantize(npz["data"], npz["min"], npz["max"])
+    mask = npz.get("mask")
+    if mask is not None:
+        shape = npz["mask_shape"]
+        mask = np.unpackbits(mask, count=np.prod(shape)).reshape(shape).astype(bool)
+        data = np.full_like(mask, np.nan, dtype=np.float32)
+        data[mask] = arr_float
+        arr_float = data
+    return MetaImage(
+        arr_float,
+        spacing=npz["spacing"],
+        direction=npz["direction"],
+        origin=npz["origin"],
+        metadata=_structured_array_to_dict(npz["meta"]),
+    )
+
+
+def _dequantize(
+    arr: npt.NDArray[np.uint8], min_: float = 0, max_: float = 20
+) -> npt.NDArray[np.float32]:
+    scaled = arr.astype(np.float32) / 255
+    return scaled * np.float32(max_ - min_) + np.float32(min_)
+
+
+def _structured_array_to_dict(arr: npt.NDArray[np.void]) -> dict[str, str]:
+    return {field_name: str(arr[field_name].item()) for field_name in arr.dtype.names}  # ty:ignore[not-iterable]

{tiny_metaio-0.2.0 → tiny_metaio-0.3.0}/src/tiny_metaio.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tiny-metaio
-Version: 0.2.0
+Version: 0.3.0
 Summary: Read and write MetaImages with minimal dependencies
 Author-email: Nicolas Cedilnik <nicolas.cedilnik@inria.fr>
 Project-URL: Homepage, https://gitlab.inria.fr/ncedilni/metaio
@@ -26,6 +26,8 @@ images (`.nii` or `.nii.gz`)
 and write `.mha` images
 in python with minimal dependencies.
 
+Bonus: provides a custom 8-bit MHA-like format when size matters: `.metaq`.
+
 ## Installation
 
 Available on pypi.org: `pip install tiny-metaio`.
@@ -57,6 +59,43 @@ array([0., 0.])
 
 ```
 
+### Custom format
+
+You need to specify a range of values covered by the quantization.
+Values outside this ranges will be clipped.
+A loss of precision is expected.
+NaNs will be implicitly converted to zero.
+
+```python
+>>> img = metaio.MetaImage([[-0.5, 1], [2.5, 5]])
+>>> img.save_quantized("some-name.metaq", min_=0, max_=2.5)
+>>> metaio.read("some-name.metaq").data
+array([[0. , 1. ],
+       [2.5, 2.5]], dtype=float32)
+
+```
+
+Additionally, if some values do not matter, you can specify a mask for further compression.
+The mask must be a binary array of the same shape as the image.
+Values where the mask is `False` will not be stored at all and restored as NaN on dequantization.
+
+```python
+>>> img = metaio.MetaImage([[-0.5, 1], [2.5, 5]])
+>>> img.save_quantized("some-name.metaq", min_=0, max_=2.5, mask=img.data <= 2.5)
+>>> metaio.read("some-name.metaq").data
+array([[0. , 1. ],
+       [2.5, nan]], dtype=float32)
+
+```
+
+### Command-line interface
+
+A command-line interface is available to convert supported input format to a MHA.
+
+```
+$ metaio /path/to/input.metaq /path/to/output.mha
+```
+
 ## Philosophy
 
 - `numpy` as only runtime dependency.
@@ -67,6 +106,8 @@ array([0., 0.])
 ## Why should I use this over SimpleITK?
 
 If you just need the IO parts and do not want the large SimpleITK package,
+or if you need to efficiently store some large MetaImage-like data,
 this package might be for you.
+
 If you do not care about having SimpleITK as a dependency for your project,
 this package is not for you.

{tiny_metaio-0.2.0 → tiny_metaio-0.3.0}/src/tiny_metaio.egg-info/SOURCES.txt

@@ -6,16 +6,20 @@ README.md
 pyproject.toml
 uv.lock
 src/metaio/__init__.py
+src/metaio/__main__.py
 src/metaio/image.py
 src/metaio/mha.py
 src/metaio/nifti.py
 src/metaio/py.typed
+src/metaio/quant.py
 src/metaio/write.py
 src/tiny_metaio.egg-info/PKG-INFO
 src/tiny_metaio.egg-info/SOURCES.txt
 src/tiny_metaio.egg-info/dependency_links.txt
+src/tiny_metaio.egg-info/entry_points.txt
 src/tiny_metaio.egg-info/requires.txt
 src/tiny_metaio.egg-info/top_level.txt
 tests/conftest.py
+tests/test_quantization.py
 tests/test_symmetry.py
 tests/test_vs_simpleitk.py

tiny_metaio-0.3.0/src/tiny_metaio.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+metaio = metaio.__main__:main

{tiny_metaio-0.2.0 → tiny_metaio-0.3.0}/tests/conftest.py

@@ -8,8 +8,9 @@ import pytest
 @pytest.fixture(scope="session", autouse=True)
 def _rm_doctest_file() -> Iterator[None]:
     yield
-    if Path("some-name.mha").exists():
-        Path("some-name.mha").unlink()
+    for ext in "mha", "metaq":
+        if Path(f"some-name.{ext}").exists():
+            Path(f"some-name.{ext}").unlink()
 
 
 def get_rotation_matrix(ndim: int) -> np.typing.NDArray[np.floating]:

tiny_metaio-0.3.0/tests/test_quantization.py

@@ -0,0 +1,79 @@
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from metaio import MetaImage, read
+from metaio.image import _dict_to_structured_array, _quantize
+from metaio.quant import _dequantize, _structured_array_to_dict
+
+
+@pytest.mark.parametrize(
+    "dtype", [np.float16, np.float32, np.int64, np.int32, np.uint16, np.uint32]
+)
+@pytest.mark.parametrize("shape", [(10, 11), (3, 4, 5)])
+@pytest.mark.parametrize("min_,max_", [(0, 35), (-10, 700), (-150, 800)])
+def test_symmetry(
+    tmp_path: Path, dtype: np.dtype, shape: tuple[int, ...], min_: float, max_: float
+) -> None:
+    path = tmp_path / "image.metaq"
+    meta = {"k1": "v1", "k2": "v2", "k3": "v3"}
+
+    arr1 = np.linspace(-100, 500, np.prod(shape)).astype(dtype).reshape(shape)
+    img1 = MetaImage(
+        arr1,
+        spacing=np.array([0.5] * len(shape)),
+        origin=np.array([-4] * len(shape)),
+        direction=np.eye(len(shape)).ravel(),
+        metadata=meta,
+    )
+    img1.save_quantized(path, min_, max_)
+
+    below_mask = arr1 <= min_
+    above_mask = arr1 >= max_
+    preserved_mask = ~(below_mask | above_mask)
+
+    # ensure we are actually testing something
+    assert np.any(below_mask) or np.any(above_mask) or np.any(preserved_mask)
+
+    img2 = read(path)
+    arr2 = img2.data
+
+    assert np.all(arr2[below_mask] == min_)
+    assert np.all(arr2[above_mask] == max_)
+    assert np.allclose(
+        arr1[preserved_mask], arr2[preserved_mask], atol=(max_ - min_) / 256
+    )
+
+    assert img2.data.dtype == np.float32
+    assert np.all(img1.spacing == img2.spacing)
+    assert np.all(img1.origin == img2.origin)
+    assert np.all(img1.direction == img2.direction)
+
+    for k, v in meta.items():
+        assert img2.metadata[k] == v
+
+
+def test_quantize() -> None:
+    assert np.all(_quantize(np.array([1, 2, 3, 4, 5]), 2, 4) == [0, 0, 128, 255, 255])
+    assert np.all(_quantize(np.array([-4, 0, 4]), -4, 4) == [0, 128, 255])
+
+
+def test_dequantize() -> None:
+    arr = np.array([0, 0, 127, 255, 255])
+    arr_q = _dequantize(arr, 2, 4)
+    assert np.all(np.round(arr_q) == [2, 2, 3, 4, 4])
+
+
+def test_integer() -> None:
+    arr = np.array([0, 1, 2, 3, 4])
+    quantized = _quantize(arr, 0, 4)
+    deq = _dequantize(quantized, 0, 4)
+    assert np.allclose(arr, deq, atol=4 / 256), quantized
+
+
+def test_dict_to_struct() -> None:
+    dct1 = {"k1": "v1", "k2": "vvvv2"}
+    arr = _dict_to_structured_array(dct1)
+    dct2 = _structured_array_to_dict(arr)
+    assert dct1 == dct2

{tiny_metaio-0.2.0 → tiny_metaio-0.3.0}/tests/test_vs_simpleitk.py

@@ -90,3 +90,32 @@ def test_write(
     assert np.allclose(img_us.direction, img.GetDirection())
     assert np.all(img_us.data == array)
     assert np.all(img_us.data == sitk.GetArrayViewFromImage(img))
+
+
+@pytest.mark.parametrize("key", ["key1", "Key2"])
+@pytest.mark.parametrize("value", ["some-other-string", "some-string"])
+def test_metadata_reader(tmp_path: Path, key: str, value: str) -> None:
+    sitk_img = sitk.GetImageFromArray(np.empty([5, 5]))
+    sitk_img.SetMetaData(key, value)
+    path = tmp_path / "image.mha"
+    sitk.WriteImage(sitk_img, path)
+
+    img = read(path)
+    assert img.metadata.pop(key) == value
+    # these keys are automatically added by simpleITK
+    assert set(img.metadata.keys()) == {
+        "AnatomicalOrientation",
+        "ObjectType",
+        "BinaryData",
+        "CenterOfRotation",
+    }
+
+
+def test_metadata_writer(tmp_path: Path) -> None:
+    path = tmp_path / "image.mha"
+    meta = {"key1": "value1", "key2": "value2"}
+    img = MetaImage(np.empty([5, 5]), metadata=meta)
+    img.save(path)
+    img = read(path)
+    for k, v in meta.items():
+        assert img.metadata[k] == v

tiny_metaio-0.2.0/README.md

@@ -1,55 +0,0 @@
-# MetaIO
-
-Read
-[MetaImages](https://docs.itk.org/en/latest/learn/metaio.html)
-(`.mha` or `.mhd`)
-and
-[NIFTI](https://en.wikipedia.org/wiki/Neuroimaging_Informatics_Technology_Initiative)
-images (`.nii` or `.nii.gz`)
-and write `.mha` images
-in python with minimal dependencies.
-
-## Installation
-
-Available on pypi.org: `pip install tiny-metaio`.
-
-## Usage
-
-### Writing a MHA file
-
-```python
->>> import metaio
->>> img = metaio.MetaImage([[0, 1], [42, 43]], spacing=[1, 2])
->>> img.save("some-name.mha")
-
-```
-
-### Reading a MHA file
-
-```python
->>> img = metaio.read("some-name.mha")
->>> img.spacing
-array([1., 2.])
->>> img.data
-array([[ 0,  1],
-       [42, 43]])
->>> img.direction
-array([1., 0., 0., 1.])
->>> img.origin
-array([0., 0.])
-
-```
-
-## Philosophy
-
-- `numpy` as only runtime dependency.
-- idiomatic python.
-- similar behavior than SimpleITK's `GetArrayFromImage`, `GetImageFromArray`,
-  `GetDirection`, `GetOrigin`, `GetSpacing`, `ReadImage`, `WriteImage`.
-
-## Why should I use this over SimpleITK?
-
-If you just need the IO parts and do not want the large SimpleITK package,
-this package might be for you.
-If you do not care about having SimpleITK as a dependency for your project,
-this package is not for you.