aimio-py 0.1.0__tar.gz

aimio_py-0.1.0/.gitmodules

@@ -0,0 +1,6 @@
+[submodule "AimIO"]
+	path = external/AimIO
+	url = https://github.com/Numerics88/AimIO
+[submodule "n88util"]
+	path = external/n88util
+	url = https://github.com/Numerics88/n88util

aimio_py-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Eric Nodwell & Steven Boyd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aimio_py-0.1.0/MANIFEST.in

@@ -0,0 +1,10 @@
+include LICENSE
+include README.md
+include pyproject.toml
+include setup.py
+include setup.cfg
+include .gitmodules
+recursive-include bindings *.cpp
+recursive-include external/AimIO/include *.h
+recursive-include external/AimIO/source *.h *.cxx
+recursive-include external/n88util/include *.hpp

aimio_py-0.1.0/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: aimio-py
+Version: 0.1.0
+Summary: Python bindings for the Numerics88 AimIO C++ library
+Home-page: https://github.com/wallematthias/aimio-py
+Author: Matthias Walle
+Author-email: matthias.walle@ucalgary.ca
+License: MIT
+Project-URL: Documentation, https://github.com/wallematthias/aimio-py#readme
+Project-URL: Source, https://github.com/wallematthias/aimio-py
+Project-URL: Issues, https://github.com/wallematthias/aimio-py/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: C++
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: cibuildwheel; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: sphinx>=7; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=7; extra == "docs"
+Dynamic: license-file
+
+# aimio-py
+
+[![Coverage (CI)](https://img.shields.io/github/actions/workflow/status/wallematthias/aimio-py/tests.yml?label=coverage%20(ci))](https://github.com/wallematthias/aimio-py/actions/workflows/tests.yml)
+[![Wheel Build](https://img.shields.io/github/actions/workflow/status/wallematthias/aimio-py/build-wheels.yml?label=wheels)](https://github.com/wallematthias/aimio-py/actions/workflows/build-wheels.yml)
+[![PyPI](https://img.shields.io/pypi/v/aimio-py)](https://pypi.org/project/aimio-py/)
+
+Python bindings for the [Numerics88 AimIO](https://github.com/Numerics88/AimIO) C++ library.
+
+`aimio-py` provides a small Python API to read and write AIM files as NumPy arrays, inspect metadata, and work with processing logs.
+
+## Features
+
+- Read AIM files into NumPy arrays
+- Write AIM files from NumPy arrays
+- Access AIM header metadata (`aim_info`)
+- Convert processing logs between text and dictionary formats
+- Optional density/HU conversion helpers
+
+## Installation
+
+From PyPI (recommended):
+
+```bash
+pip install aimio-py
+```
+
+From source:
+
+```bash
+git clone https://github.com/wallematthias/aimio-py.git
+cd aimio-py
+git submodule update --init --recursive
+pip install -e .
+```
+
+## Quickstart
+
+```python
+from py_aimio import read_aim, write_aim
+
+array, meta = read_aim("scan.AIM")
+write_aim("copy.AIM", array, meta)
+```
+
+## API
+
+- `aim_info(path)`
+- `read_aim(path, density=False, hu=False) -> (array, meta)`
+- `write_aim(path, array, meta=None, unit=None)`
+- `get_aim_density_equation(processing_log)`
+- `get_aim_hu_equation(processing_log)`
+- `log_to_dict(log)`
+- `dict_to_log(dct)`
+
+## Development
+
+Run tests:
+
+```bash
+pytest -q
+```
+
+Run tests with coverage:
+
+```bash
+pytest -q --cov=py_aimio --cov-report=term-missing --cov-report=xml:coverage.xml
+```
+
+Build local artifacts:
+
+```bash
+python -m build --wheel --sdist
+```
+
+Build documentation from docstrings:
+
+```bash
+pip install sphinx
+make -C docs html
+```
+
+Generated HTML will be in `docs/build/html/index.html`.
+
+### Important build note
+
+This project depends on the `external/AimIO` and `external/n88util` git submodules. If they are missing, extension builds will fail.
+
+## Release and PyPI Publishing
+
+Wheels and sdist are built by GitHub Actions on:
+
+- `pull_request` to `main`/`master`
+- pushes to `main`/`master`
+- tags matching `v*`
+
+When a `v*` tag is pushed, the workflow publishes to PyPI via trusted publishing (`pypa/gh-action-pypi-publish`).
+
+See [`docs/PUBLISHING.md`](docs/PUBLISHING.md) for the release checklist and `docs/source/` for Sphinx documentation sources.
+
+## Attribution
+
+- `py_aimio/calibration.py` is adapted from [Bonelab/Bonelab](https://github.com/Bonelab/Bonelab/).
+- `py_aimio/header_log.py` is by Matthias Walle.
+
+## License
+
+MIT

aimio_py-0.1.0/README.md

@@ -0,0 +1,107 @@
+# aimio-py
+
+[![Coverage (CI)](https://img.shields.io/github/actions/workflow/status/wallematthias/aimio-py/tests.yml?label=coverage%20(ci))](https://github.com/wallematthias/aimio-py/actions/workflows/tests.yml)
+[![Wheel Build](https://img.shields.io/github/actions/workflow/status/wallematthias/aimio-py/build-wheels.yml?label=wheels)](https://github.com/wallematthias/aimio-py/actions/workflows/build-wheels.yml)
+[![PyPI](https://img.shields.io/pypi/v/aimio-py)](https://pypi.org/project/aimio-py/)
+
+Python bindings for the [Numerics88 AimIO](https://github.com/Numerics88/AimIO) C++ library.
+
+`aimio-py` provides a small Python API to read and write AIM files as NumPy arrays, inspect metadata, and work with processing logs.
+
+## Features
+
+- Read AIM files into NumPy arrays
+- Write AIM files from NumPy arrays
+- Access AIM header metadata (`aim_info`)
+- Convert processing logs between text and dictionary formats
+- Optional density/HU conversion helpers
+
+## Installation
+
+From PyPI (recommended):
+
+```bash
+pip install aimio-py
+```
+
+From source:
+
+```bash
+git clone https://github.com/wallematthias/aimio-py.git
+cd aimio-py
+git submodule update --init --recursive
+pip install -e .
+```
+
+## Quickstart
+
+```python
+from py_aimio import read_aim, write_aim
+
+array, meta = read_aim("scan.AIM")
+write_aim("copy.AIM", array, meta)
+```
+
+## API
+
+- `aim_info(path)`
+- `read_aim(path, density=False, hu=False) -> (array, meta)`
+- `write_aim(path, array, meta=None, unit=None)`
+- `get_aim_density_equation(processing_log)`
+- `get_aim_hu_equation(processing_log)`
+- `log_to_dict(log)`
+- `dict_to_log(dct)`
+
+## Development
+
+Run tests:
+
+```bash
+pytest -q
+```
+
+Run tests with coverage:
+
+```bash
+pytest -q --cov=py_aimio --cov-report=term-missing --cov-report=xml:coverage.xml
+```
+
+Build local artifacts:
+
+```bash
+python -m build --wheel --sdist
+```
+
+Build documentation from docstrings:
+
+```bash
+pip install sphinx
+make -C docs html
+```
+
+Generated HTML will be in `docs/build/html/index.html`.
+
+### Important build note
+
+This project depends on the `external/AimIO` and `external/n88util` git submodules. If they are missing, extension builds will fail.
+
+## Release and PyPI Publishing
+
+Wheels and sdist are built by GitHub Actions on:
+
+- `pull_request` to `main`/`master`
+- pushes to `main`/`master`
+- tags matching `v*`
+
+When a `v*` tag is pushed, the workflow publishes to PyPI via trusted publishing (`pypa/gh-action-pypi-publish`).
+
+See [`docs/PUBLISHING.md`](docs/PUBLISHING.md) for the release checklist and `docs/source/` for Sphinx documentation sources.
+
+## Attribution
+
+- `py_aimio/calibration.py` is adapted from [Bonelab/Bonelab](https://github.com/Bonelab/Bonelab/).
+- `py_aimio/header_log.py` is by Matthias Walle.
+
+## License
+
+MIT

aimio_py-0.1.0/aimio_py.egg-info/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: aimio-py
+Version: 0.1.0
+Summary: Python bindings for the Numerics88 AimIO C++ library
+Home-page: https://github.com/wallematthias/aimio-py
+Author: Matthias Walle
+Author-email: matthias.walle@ucalgary.ca
+License: MIT
+Project-URL: Documentation, https://github.com/wallematthias/aimio-py#readme
+Project-URL: Source, https://github.com/wallematthias/aimio-py
+Project-URL: Issues, https://github.com/wallematthias/aimio-py/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: C++
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: cibuildwheel; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: sphinx>=7; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=7; extra == "docs"
+Dynamic: license-file
+
+# aimio-py
+
+[![Coverage (CI)](https://img.shields.io/github/actions/workflow/status/wallematthias/aimio-py/tests.yml?label=coverage%20(ci))](https://github.com/wallematthias/aimio-py/actions/workflows/tests.yml)
+[![Wheel Build](https://img.shields.io/github/actions/workflow/status/wallematthias/aimio-py/build-wheels.yml?label=wheels)](https://github.com/wallematthias/aimio-py/actions/workflows/build-wheels.yml)
+[![PyPI](https://img.shields.io/pypi/v/aimio-py)](https://pypi.org/project/aimio-py/)
+
+Python bindings for the [Numerics88 AimIO](https://github.com/Numerics88/AimIO) C++ library.
+
+`aimio-py` provides a small Python API to read and write AIM files as NumPy arrays, inspect metadata, and work with processing logs.
+
+## Features
+
+- Read AIM files into NumPy arrays
+- Write AIM files from NumPy arrays
+- Access AIM header metadata (`aim_info`)
+- Convert processing logs between text and dictionary formats
+- Optional density/HU conversion helpers
+
+## Installation
+
+From PyPI (recommended):
+
+```bash
+pip install aimio-py
+```
+
+From source:
+
+```bash
+git clone https://github.com/wallematthias/aimio-py.git
+cd aimio-py
+git submodule update --init --recursive
+pip install -e .
+```
+
+## Quickstart
+
+```python
+from py_aimio import read_aim, write_aim
+
+array, meta = read_aim("scan.AIM")
+write_aim("copy.AIM", array, meta)
+```
+
+## API
+
+- `aim_info(path)`
+- `read_aim(path, density=False, hu=False) -> (array, meta)`
+- `write_aim(path, array, meta=None, unit=None)`
+- `get_aim_density_equation(processing_log)`
+- `get_aim_hu_equation(processing_log)`
+- `log_to_dict(log)`
+- `dict_to_log(dct)`
+
+## Development
+
+Run tests:
+
+```bash
+pytest -q
+```
+
+Run tests with coverage:
+
+```bash
+pytest -q --cov=py_aimio --cov-report=term-missing --cov-report=xml:coverage.xml
+```
+
+Build local artifacts:
+
+```bash
+python -m build --wheel --sdist
+```
+
+Build documentation from docstrings:
+
+```bash
+pip install sphinx
+make -C docs html
+```
+
+Generated HTML will be in `docs/build/html/index.html`.
+
+### Important build note
+
+This project depends on the `external/AimIO` and `external/n88util` git submodules. If they are missing, extension builds will fail.
+
+## Release and PyPI Publishing
+
+Wheels and sdist are built by GitHub Actions on:
+
+- `pull_request` to `main`/`master`
+- pushes to `main`/`master`
+- tags matching `v*`
+
+When a `v*` tag is pushed, the workflow publishes to PyPI via trusted publishing (`pypa/gh-action-pypi-publish`).
+
+See [`docs/PUBLISHING.md`](docs/PUBLISHING.md) for the release checklist and `docs/source/` for Sphinx documentation sources.
+
+## Attribution
+
+- `py_aimio/calibration.py` is adapted from [Bonelab/Bonelab](https://github.com/Bonelab/Bonelab/).
+- `py_aimio/header_log.py` is by Matthias Walle.
+
+## License
+
+MIT

aimio_py-0.1.0/aimio_py.egg-info/SOURCES.txt

@@ -0,0 +1,50 @@
+.gitmodules
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.cfg
+setup.py
+aimio_py.egg-info/PKG-INFO
+aimio_py.egg-info/SOURCES.txt
+aimio_py.egg-info/dependency_links.txt
+aimio_py.egg-info/not-zip-safe
+aimio_py.egg-info/requires.txt
+aimio_py.egg-info/top_level.txt
+bindings/aimio_bindings.cpp
+external/AimIO/include/AimIO/AimIO.h
+external/AimIO/include/AimIO/DateTime.h
+external/AimIO/include/AimIO/Definitions.h
+external/AimIO/include/AimIO/Exception.h
+external/AimIO/include/AimIO/IsqIO.h
+external/AimIO/source/AimIO.cxx
+external/AimIO/source/Compression.cxx
+external/AimIO/source/Compression.h
+external/AimIO/source/DateTime.cxx
+external/AimIO/source/IsqIO.cxx
+external/AimIO/source/PlatformFloat.h
+external/AimIO/source/aix.cxx
+external/AimIO/source/ctheader.cxx
+external/n88util/include/n88util/ObjectGroup.hpp
+external/n88util/include/n88util/TimeStamp.hpp
+external/n88util/include/n88util/TrackingAllocator.hpp
+external/n88util/include/n88util/array.hpp
+external/n88util/include/n88util/arraymath.hpp
+external/n88util/include/n88util/binhex.hpp
+external/n88util/include/n88util/configuration.hpp
+external/n88util/include/n88util/const_array.hpp
+external/n88util/include/n88util/exception.hpp
+external/n88util/include/n88util/floating_point_comparisons.hpp
+external/n88util/include/n88util/logger.hpp
+external/n88util/include/n88util/netcdf_templated.hpp
+external/n88util/include/n88util/printarray.hpp
+external/n88util/include/n88util/text.hpp
+external/n88util/include/n88util/tuplet.hpp
+py_aimio/__init__.py
+py_aimio/calibration.py
+py_aimio/header_log.py
+tests/test_api_unit.py
+tests/test_bindings.py
+tests/test_calibration_unit.py
+tests/test_header_log_unit.py
+tests/test_processing_log_roundtrip.py

aimio_py-0.1.0/aimio_py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aimio_py-0.1.0/aimio_py.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

aimio_py-0.1.0/aimio_py.egg-info/requires.txt

@@ -0,0 +1,12 @@
+numpy>=1.20
+
+[dev]
+build
+cibuildwheel
+pytest
+pytest-cov
+twine
+sphinx>=7
+
+[docs]
+sphinx>=7

aimio_py-0.1.0/aimio_py.egg-info/top_level.txt

@@ -0,0 +1 @@
+py_aimio

aimio_py-0.1.0/bindings/aimio_bindings.cpp

@@ -0,0 +1,109 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+#include <pybind11/stl.h>
+#include <string>
+
+namespace py = pybind11;
+
+// If AimIO headers are available (when the AimIO submodule is added), include them.
+#include "AimIO/AimIO.h"
+
+static py::dict aimfile_to_dict(const AimIO::AimFile &af) {
+    py::dict d;
+    d["filename"] = af.filename;
+    d["version"] = static_cast<int>(af.version);
+    d["id"] = af.id;
+    d["reference"] = af.reference;
+    d["aim_type"] = static_cast<int>(af.aim_type);
+    d["buffer_type"] = static_cast<int>(af.buffer_type);
+    d["position"] = py::make_tuple(af.position[0], af.position[1], af.position[2]);
+    d["dimensions"] = py::make_tuple(af.dimensions[0], af.dimensions[1], af.dimensions[2]);
+    d["offset"] = py::make_tuple(af.offset[0], af.offset[1], af.offset[2]);
+    d["element_size"] = py::make_tuple(af.element_size[0], af.element_size[1], af.element_size[2]);
+    d["processing_log"] = af.processing_log;
+    d["byte_offset"] = af.byte_offset;
+    return d;
+}
+
+PYBIND11_MODULE(_aimio, m) {
+    m.doc() = "AimIO C++ bindings: read_aim(path) -> (ndarray, meta), write_aim(path, array, meta), aim_info(path) -> meta";
+
+    m.def("aim_info", [](const std::string &path) {
+        AimIO::AimFile af(path.c_str());
+        af.ReadImageInfo();
+        return aimfile_to_dict(af);
+    }, py::arg("path"));
+
+    m.def("read_aim", [](const std::string &path) {
+        AimIO::AimFile af(path.c_str());
+        af.ReadImageInfo();
+
+        int nx = af.dimensions[0];
+        int ny = af.dimensions[1];
+        int nz = af.dimensions[2];
+        size_t n = static_cast<size_t>(nx) * ny * nz;
+
+        if (af.buffer_type == AimIO::AimFile::AIMFILE_TYPE_CHAR) {
+            std::vector<int8_t> buf(n);
+            af.ReadImageData(reinterpret_cast<char*>(buf.data()), n);
+            // numpy shape (z,y,x)
+            py::array_t<int8_t> arr({nz, ny, nx}, {static_cast<size_t>(ny*nx), static_cast<size_t>(nx), sizeof(int8_t)}, buf.data());
+            // need to copy since buf will be freed
+            return py::make_tuple(py::array(arr), aimfile_to_dict(af));
+        } else if (af.buffer_type == AimIO::AimFile::AIMFILE_TYPE_SHORT) {
+            std::vector<int16_t> buf(n);
+            af.ReadImageData(buf.data(), n);
+            py::array_t<int16_t> arr({nz, ny, nx}, {static_cast<size_t>(ny*nx)*sizeof(int16_t), static_cast<size_t>(nx)*sizeof(int16_t), sizeof(int16_t)}, buf.data());
+            return py::make_tuple(py::array(arr), aimfile_to_dict(af));
+        } else if (af.buffer_type == AimIO::AimFile::AIMFILE_TYPE_FLOAT) {
+            std::vector<float> buf(n);
+            af.ReadImageData(buf.data(), n);
+            py::array_t<float> arr({nz, ny, nx}, {static_cast<size_t>(ny*nx)*sizeof(float), static_cast<size_t>(nx)*sizeof(float), sizeof(float)}, buf.data());
+            return py::make_tuple(py::array(arr), aimfile_to_dict(af));
+        } else {
+            throw std::runtime_error("Unsupported buffer type in AIM file");
+        }
+    }, py::arg("path"));
+
+    m.def("write_aim", [](const std::string &path, py::buffer b, py::dict meta) {
+        // Acquire buffer info
+        py::buffer_info info = b.request();
+        if (info.ndim != 3) throw std::runtime_error("Expected 3D array (z,y,x)");
+
+        int nz = static_cast<int>(info.shape[0]);
+        int ny = static_cast<int>(info.shape[1]);
+        int nx = static_cast<int>(info.shape[2]);
+        size_t n = static_cast<size_t>(nx) * ny * nz;
+
+        AimIO::AimFile af;
+        af.filename = path;
+        af.dimensions[0] = nx;
+        af.dimensions[1] = ny;
+        af.dimensions[2] = nz;
+
+        // optional metadata
+        if (meta.contains("element_size")) {
+            auto es = meta["element_size"].cast<std::vector<double>>();
+            af.element_size[0] = es[0]; af.element_size[1] = es[1]; af.element_size[2] = es[2];
+        }
+        if (meta.contains("processing_log")) {
+            // ensure we set the processing log so it is written back into the AIM header
+            if (py::isinstance<py::str>(meta["processing_log"])) {
+                af.processing_log = meta["processing_log"].cast<std::string>();
+            }
+        }
+
+        // Determine dtype and call appropriate writer
+        if (info.format == py::format_descriptor<int8_t>::format()) {
+            af.WriteImageData(reinterpret_cast<const char*>(info.ptr));
+        } else if (info.format == py::format_descriptor<int16_t>::format()) {
+            af.WriteImageData(reinterpret_cast<const short*>(info.ptr));
+        } else if (info.format == py::format_descriptor<float>::format()) {
+            af.WriteImageData(reinterpret_cast<const float*>(info.ptr));
+        } else {
+            throw std::runtime_error("Unsupported array dtype for write_aim (use int8, int16, or float32)");
+        }
+
+        return aimfile_to_dict(af);
+    }, py::arg("path"), py::arg("array"), py::arg("meta") = py::dict());
+}