pye57 0.3.1__cp310-cp310-win_amd64.whl → 0.4.2__cp310-cp310-win_amd64.whl

pye57/__version__.py

@@ -1 +1 @@
-__version__ = "0.3.1"
+__version__ = "0.4.2"

pye57/e57.py

@@ -1,7 +1,7 @@
 import uuid
 import os
-
 from typing import Dict
+from enum import Enum
 
 import numpy as np
 from pyquaternion import Quaternion
@@ -9,6 +9,7 @@ from pyquaternion import Quaternion
 from pye57.__version__ import __version__
 from pye57 import libe57
 from pye57 import ScanHeader
+from pye57.utils import convert_spherical_to_cartesian
 
 try:
     from exceptions import WindowsError
@@ -16,10 +17,26 @@ except ImportError:
     class WindowsError(OSError):
         pass
 
-SUPPORTED_POINT_FIELDS = {
+
+SUPPORTED_CARTESIAN_POINT_FIELDS = {
     "cartesianX": "d",
     "cartesianY": "d",
     "cartesianZ": "d",
+}
+
+SUPPORTED_SPHERICAL_POINT_FIELDS = {
+    "sphericalRange": "d",
+    "sphericalAzimuth": "d",
+    "sphericalElevation": "d",
+}
+
+class COORDINATE_SYSTEMS(Enum):
+    CARTESIAN = SUPPORTED_CARTESIAN_POINT_FIELDS
+    SPHERICAL = SUPPORTED_SPHERICAL_POINT_FIELDS
+
+SUPPORTED_POINT_FIELDS = {
+    **SUPPORTED_CARTESIAN_POINT_FIELDS,
+    **SUPPORTED_SPHERICAL_POINT_FIELDS,
     "intensity": "f",
     "colorRed": "B",
     "colorGreen": "B",
@@ -27,6 +44,7 @@ SUPPORTED_POINT_FIELDS = {
     "rowIndex": "H",
     "columnIndex": "H",
     "cartesianInvalidState": "b",
+    "sphericalInvalidState": "b",
 }
 
 
@@ -147,7 +165,13 @@ class E57:
         header = self.get_header(index)
         n_points = header.point_count
 
-        fields = ["cartesianX", "cartesianY", "cartesianZ"]
+        coordinate_system = header.get_coordinate_system(COORDINATE_SYSTEMS)
+        if coordinate_system is COORDINATE_SYSTEMS.CARTESIAN:
+            validState = "cartesianInvalidState"
+            fields = list(SUPPORTED_CARTESIAN_POINT_FIELDS.keys())
+        elif coordinate_system is COORDINATE_SYSTEMS.SPHERICAL: 
+            validState = "sphericalInvalidState"
+            fields = list(SUPPORTED_SPHERICAL_POINT_FIELDS.keys())
         if intensity:
             fields.append("intensity")
         if colors:
@@ -157,7 +181,7 @@ class E57:
         if row_column:
             fields.append("rowIndex")
             fields.append("columnIndex")
-        fields.append("cartesianInvalidState")
+        fields.append(validState)
 
         for field in fields[:]:
             if field not in header.point_fields:
@@ -170,22 +194,27 @@ class E57:
         data, buffers = self.make_buffers(fields, n_points)
         header.points.reader(buffers).read()
 
-        if "cartesianInvalidState" in data.keys():
-            valid = ~data["cartesianInvalidState"].astype("?")
+        if validState in data:
+            valid = ~data[validState].astype("?")
 
             for field in data:
                 data[field] = data[field][valid]
 
-            del data["cartesianInvalidState"]
+            del data[validState]
 
         if transform:
-            xyz = np.array([data["cartesianX"], data["cartesianY"], data["cartesianZ"]]).T
+            if coordinate_system is COORDINATE_SYSTEMS.CARTESIAN:
+                xyz = np.array([data["cartesianX"], data["cartesianY"], data["cartesianZ"]]).T
+            elif coordinate_system is COORDINATE_SYSTEMS.SPHERICAL:
+                rae = np.array([data["sphericalRange"], data["sphericalAzimuth"], data["sphericalElevation"]]).T
+                # rae to xyz
+                xyz = convert_spherical_to_cartesian(rae)
+            # translation to global coordinates
             if header.has_pose():
                 xyz = self.to_global(xyz, header.rotation, header.translation)
             data["cartesianX"] = xyz[:, 0]
             data["cartesianY"] = xyz[:, 1]
             data["cartesianZ"] = xyz[:, 2]
-
         return data
 
     def write_scan_raw(self, data: Dict, *, name=None, rotation=None, translation=None, scan_header=None):
@@ -194,7 +223,7 @@ class E57:
                 raise ValueError("Unsupported point field: %s" % field)
 
         if rotation is None:
-            rotation = getattr(scan_header, "rotation", np.array([0, 0, 0, 0]))
+            rotation = getattr(scan_header, "rotation", np.array([1, 0, 0, 0]))
 
         if translation is None:
             translation = getattr(scan_header, "translation", np.array([0, 0, 0]))

pye57/scan_header.py

@@ -4,7 +4,6 @@ from pyquaternion import Quaternion
 from pye57 import libe57
 from pye57.utils import get_fields, get_node
 
-
 class ScanHeader:
     def __init__(self, scan_node):
         self.node = scan_node
@@ -53,6 +52,15 @@ class ScanHeader:
 
     def __getitem__(self, item):
         return self.node[item]
+    
+    def get_coordinate_system(self, COORDINATE_SYSTEMS):
+        if all(x in self.point_fields for x in COORDINATE_SYSTEMS.CARTESIAN.value):
+            coordinate_system = COORDINATE_SYSTEMS.CARTESIAN
+        elif all(x in self.point_fields for x in COORDINATE_SYSTEMS.SPHERICAL.value):
+            coordinate_system = COORDINATE_SYSTEMS.SPHERICAL
+        else:
+            raise Exception(f"Scans coordinate system not supported, unsupported point field {self.point_fields}")
+        return coordinate_system            
 
     @property
     def guid(self):
@@ -138,6 +146,34 @@ class ScanHeader:
     def zMaximum(self):
         return self.cartesianBounds["zMaximum"].value()
 
+    @property
+    def sphericalBounds(self):
+        return self["sphericalBounds"]
+
+    @property
+    def rangeMinimum(self):
+        return self.sphericalBounds["rangeMinimum"].value()
+
+    @property
+    def rangeMaximum(self):
+        return self.sphericalBounds["rangeMaximum"].value()
+
+    @property
+    def elevationMinimum(self):
+        return self.sphericalBounds["elevationMinimum"].value()
+    
+    @property
+    def elevationMaximum(self):
+        return self.sphericalBounds["elevationMaximum"].value()
+    
+    @property
+    def azimuthStart(self):
+        return self.sphericalBounds["azimuthStart"].value()
+    
+    @property
+    def azimuthEnd(self):
+        return self.sphericalBounds["azimuthEnd"].value()
+    
     @property
     def pose(self):
         return self["pose"]

pye57/utils.py

@@ -1,6 +1,9 @@
+from typing import Type
+
 from pye57 import libe57
 from pye57.libe57 import NodeType
 
+import numpy as np
 
 def get_fields(node):
     return [node.get(id_).elementName() for id_ in range(node.childCount())]
@@ -19,3 +22,21 @@ def get_node(node, name):
     }
     n = node.get(name)
     return cast[n.type()](n)
+
+def convert_spherical_to_cartesian(rae):
+    """
+    Converts spherical(rae) to cartesian(xyz), where rae = range, azimuth(theta), 
+    elevation(phi). Where range is in meters and angles are in radians.
+    
+    Reference for formula: http://www.libe57.org/bestCoordinates.html (Note: the 
+    formula is different from the one online, so please use formula at the above reference)
+    """
+    range_ = rae[:, :1]
+    theta = rae[:, 1:2]
+    phi =  rae[:, 2:3]
+    range_cos_phi = range_ * np.cos(phi)
+    return np.concatenate((
+        range_cos_phi * np.cos(theta),
+        range_cos_phi * np.sin(theta),
+        range_ * np.sin(phi)
+    ), axis=1)

{pye57-0.3.1.dist-info → pye57-0.4.2.dist-info}/METADATA

@@ -1,144 +1,142 @@
-Metadata-Version: 2.1
-Name: pye57
-Version: 0.3.1
-Summary: Python .e57 files reader/writer
-Home-page: https://www.github.com/davidcaron/pye57
-Author: David Caron
-Author-email: dcaron05@gmail.com
-License: MIT
-Platform: UNKNOWN
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy
-Requires-Dist: pyquaternion
-Provides-Extra: test
-Requires-Dist: pytest ; extra == 'test'
-
-
-# pye57
-
-[![PyPI](https://img.shields.io/pypi/v/pye57.svg)](https://pypi.org/project/pye57)
-[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pye57.svg)](https://pypi.org/project/pye57)
-![GitHub](https://img.shields.io/github/workflow/status/davidcaron/pye57/build)
-
-Python wrapper of [LibE57Format](https://github.com/asmaloney/libE57Format) to read and write .e57 point cloud files
-
-## Example usage
-
-```python
-import numpy as np
-import pye57
-
-e57 = pye57.E57("e57_file.e57")
-
-# read scan at index 0
-data = e57.read_scan(0)
-
-# 'data' is a dictionary with the point types as keys
-assert isinstance(data["cartesianX"], np.ndarray)
-assert isinstance(data["cartesianY"], np.ndarray)
-assert isinstance(data["cartesianZ"], np.ndarray)
-
-# other attributes can be read using:
-data = e57.read_scan(0, intensity=True, colors=True, row_column=True)
-assert isinstance(data["cartesianX"], np.ndarray)
-assert isinstance(data["cartesianY"], np.ndarray)
-assert isinstance(data["cartesianZ"], np.ndarray)
-assert isinstance(data["intensity"], np.ndarray)
-assert isinstance(data["colorRed"], np.ndarray)
-assert isinstance(data["colorGreen"], np.ndarray)
-assert isinstance(data["colorBlue"], np.ndarray)
-assert isinstance(data["rowIndex"], np.ndarray)
-assert isinstance(data["columnIndex"], np.ndarray)
-
-# the 'read_scan' method filters points using the 'cartesianInvalidState' field
-# if you want to get everything as raw, untransformed data, use:
-data_raw = e57.read_scan_raw(0)
-
-# writing is also possible, but only using raw data for now
-e57_write = pye57.E57("e57_file_write.e57", mode='w')
-e57_write.write_scan_raw(data_raw)
-# you can specify a header to copy information from
-e57_write.write_scan_raw(data_raw, scan_header=e57.get_header(0))
-
-# the ScanHeader object wraps most of the scan information:
-header = e57.get_header(0)
-print(header.point_count)
-print(header.rotation_matrix)
-print(header.translation)
-
-# all the header information can be printed using:
-for line in header.pretty_print():
-    print(line)
-
-# the scan position can be accessed with:
-position_scan_0 = e57.scan_position(0)
-
-# the binding is very close to the E57Foundation API
-# you can modify the nodes easily from python
-imf = e57.image_file
-root = imf.root()
-data3d = root["data3D"]
-scan_0 = data3d[0]
-translation_x = scan_0["pose"]["translation"]["x"]
-```
-
-## Installation
-
-If you're on linux or Windows, a wheel should be available.
-
-`python -m pip install pye57`
-
-## Building from source
-
-### Cloning the repository and required submodules
-
-Clone a new repository along with the required submodules
-
-`git clone https://github.com/davidcaron/pye57.git --recursive`
-
-If the repository has already been previously cloned, but without the --recursive flag
-
-```
-cd pye57 # go to the cloned repository
-git submodule init # this will initialise the submodules in the repository
-git submodule update # this will update the submodules in the repository
-```
-
-### Dependencies on Linux
-
-Install libxerces-c-dev first.
-
-`sudo apt install libxerces-c-dev`
-
-### Dependencies on Windows
-
-To get xerces-c, you can either build from source or if you're using conda:
-
-`conda install -y xerces-c`
-
-### Run `pip install` from the repo source
-
-```
-cd pye57
-python -m pip install .
-```
-
-### Uninstalling
-
-Use pip again
-
-```
-python -m pip uninstall pye57
-```
-
-
+Metadata-Version: 2.1
+Name: pye57
+Version: 0.4.2
+Summary: Python .e57 files reader/writer
+Home-page: https://www.github.com/davidcaron/pye57
+Author: David Caron
+Author-email: dcaron05@gmail.com
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pyquaternion
+Provides-Extra: test
+Requires-Dist: pytest ; extra == 'test'
+
+
+# pye57
+
+[![PyPI](https://img.shields.io/pypi/v/pye57.svg)](https://pypi.org/project/pye57)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pye57.svg)](https://pypi.org/project/pye57)
+![GitHub](https://img.shields.io/github/actions/workflow/status/davidcaron/pye57/build.yml?branch=master)
+
+Python wrapper of [LibE57Format](https://github.com/asmaloney/libE57Format) to read and write .e57 point cloud files
+
+## Example usage
+
+```python
+import numpy as np
+import pye57
+
+e57 = pye57.E57("e57_file.e57")
+
+# read scan at index 0
+data = e57.read_scan(0)
+
+# 'data' is a dictionary with the point types as keys
+assert isinstance(data["cartesianX"], np.ndarray)
+assert isinstance(data["cartesianY"], np.ndarray)
+assert isinstance(data["cartesianZ"], np.ndarray)
+
+# other attributes can be read using:
+data = e57.read_scan(0, intensity=True, colors=True, row_column=True)
+assert isinstance(data["cartesianX"], np.ndarray)
+assert isinstance(data["cartesianY"], np.ndarray)
+assert isinstance(data["cartesianZ"], np.ndarray)
+assert isinstance(data["intensity"], np.ndarray)
+assert isinstance(data["colorRed"], np.ndarray)
+assert isinstance(data["colorGreen"], np.ndarray)
+assert isinstance(data["colorBlue"], np.ndarray)
+assert isinstance(data["rowIndex"], np.ndarray)
+assert isinstance(data["columnIndex"], np.ndarray)
+
+# the 'read_scan' method filters points using the 'cartesianInvalidState' field
+# if you want to get everything as raw, untransformed data, use:
+data_raw = e57.read_scan_raw(0)
+
+# writing is also possible, but only using raw data for now
+e57_write = pye57.E57("e57_file_write.e57", mode='w')
+e57_write.write_scan_raw(data_raw)
+# you can specify a header to copy information from
+e57_write.write_scan_raw(data_raw, scan_header=e57.get_header(0))
+
+# the ScanHeader object wraps most of the scan information:
+header = e57.get_header(0)
+print(header.point_count)
+print(header.rotation_matrix)
+print(header.translation)
+
+# all the header information can be printed using:
+for line in header.pretty_print():
+    print(line)
+
+# the scan position can be accessed with:
+position_scan_0 = e57.scan_position(0)
+
+# the binding is very close to the E57Foundation API
+# you can modify the nodes easily from python
+imf = e57.image_file
+root = imf.root()
+data3d = root["data3D"]
+scan_0 = data3d[0]
+translation_x = scan_0["pose"]["translation"]["x"]
+```
+
+## Installation
+
+If you're on linux or Windows, a wheel should be available.
+
+`python -m pip install pye57`
+
+## Building from source
+
+### Cloning the repository and required submodules
+
+Clone a new repository along with the required submodules
+
+`git clone https://github.com/davidcaron/pye57.git --recursive`
+
+If the repository has already been previously cloned, but without the --recursive flag
+
+```
+cd pye57 # go to the cloned repository
+git submodule init # this will initialise the submodules in the repository
+git submodule update # this will update the submodules in the repository
+```
+
+### Dependencies on Linux
+
+Install libxerces-c-dev first.
+
+`sudo apt install libxerces-c-dev`
+
+### Dependencies on Windows
+
+To get xerces-c, you can either build from source or if you're using conda:
+
+`conda install -y xerces-c`
+
+### Run `pip install` from the repo source
+
+```
+cd pye57
+python -m pip install .
+```
+
+### Uninstalling
+
+Use pip again
+
+```
+python -m pip uninstall pye57
+```

pye57-0.4.2.dist-info/RECORD

@@ -0,0 +1,13 @@
+pye57/__init__.py,sha256=keWVF2W7Jau5voY0aufr6bayvjfDJSWf_bmawIvvj88,95
+pye57/__version__.py,sha256=6fbhlJpSCHhbEgnXa9Y3-1DhheoIUBV900vpMNv9wnw,23
+pye57/e57.py,sha256=ec9_zxTvZ9TlnIVPMrzzB2wRHQg428F6EtWCCeg05K0,18950
+pye57/exception.py,sha256=9Qgriir0IsSpHhStN5uvI5mlbKrc_P5ZURsi_PIW_q8,50
+pye57/libe57.cp310-win_amd64.pyd,sha256=b-LiKSsUhn2mH7uJRlUoHMcAmyv_q9n92-1nIlg0Djs,738304
+pye57/scan_header.py,sha256=39FD40CBcJL5azN_HjVNvSnFrQR3uO-MIQFFNRhUqRU,6036
+pye57/utils.py,sha256=GbuzETqw22KeDpnVc6dB9EUFBAs3gmhstoy67IyJDqU,1418
+pye57/xerces-c_3_2.dll,sha256=uNGJPhQyZPqwjWzp3tijMKE69iRpqUrBf3OAIkT4NG0,2787328
+pye57-0.4.2.dist-info/LICENSE,sha256=Q0K1iCfVm6UmnR4AAyqME5q7flnU6aGh5OarEIa2K6Y,1056
+pye57-0.4.2.dist-info/METADATA,sha256=bTS9FfTB6QmoUz6Z6QWPQDBvSWgOJ4h7gyeycDhBiyw,4359
+pye57-0.4.2.dist-info/WHEEL,sha256=5JPYeYl5ZdvdSkrGS4u21mmpPzpFx42qrXOSIgWf4pg,102
+pye57-0.4.2.dist-info/top_level.txt,sha256=xD9HDzQ3BfGMuz1kI2uNKUR0KXcR-RtNEKigrkh48Nk,6
+pye57-0.4.2.dist-info/RECORD,,

{pye57-0.3.1.dist-info → pye57-0.4.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.1)
+Generator: bdist_wheel (0.42.0)
 Root-Is-Purelib: false
 Tag: cp310-cp310-win_amd64
 

pye57/libe57_wrapper.cpp

@@ -1,526 +0,0 @@
-
-#include <pybind11/pybind11.h>
-#include <pybind11/stl_bind.h>
-#include <pybind11/numpy.h>
-
-#include <E57Exception.h>
-#include <E57Format.h>
-#include <E57Version.h>
-
-namespace py = pybind11;
-using namespace pybind11::literals;
-
-using namespace e57;
-
-PYBIND11_MAKE_OPAQUE(std::vector<SourceDestBuffer>);
-
-auto cast_node (Node &n) {
-    NodeType type = n.type();
-    if (type == NodeType::E57_BLOB)
-        return py::cast(BlobNode(n));
-    else if (type == NodeType::E57_COMPRESSED_VECTOR)
-        return py::cast(CompressedVectorNode(n));
-    else if (type == NodeType::E57_FLOAT)
-        return py::cast(FloatNode(n));
-    else if (type == NodeType::E57_INTEGER)
-        return py::cast(IntegerNode(n));
-    else if (type == NodeType::E57_SCALED_INTEGER)
-        return py::cast(ScaledIntegerNode(n));
-    else if (type == NodeType::E57_STRING)
-        return py::cast(StringNode(n));
-    else if (type == NodeType::E57_STRUCTURE)
-        return py::cast(StructureNode(n));
-    else if (type == NodeType::E57_VECTOR)
-        return py::cast(VectorNode(n));
-}
-
-PYBIND11_MODULE(libe57, m) {
-    m.doc() = "E57 reader/writer for python.";
-
-    static py::exception<E57Exception> exc(m, "E57Exception");
-    py::register_exception_translator([](std::exception_ptr p) {
-    try {
-        if (p) std::rethrow_exception(p);
-    } catch (const E57Exception &e) {
-        exc(Utilities::errorCodeToString(e.errorCode()).c_str());
-    }
-    });
-
-    m.attr("E57_FORMAT_MAJOR") = E57_FORMAT_MAJOR;
-    m.attr("E57_FORMAT_MINOR") = E57_FORMAT_MINOR;
-    m.attr("E57_LIBRARY_ID") = REVISION_ID;
-    m.attr("E57_V1_0_URI") = "http://www.astm.org/COMMIT/E57/2010-e57-v1.0";
-    m.attr("CHECKSUM_POLICY_NONE") = CHECKSUM_POLICY_NONE;
-    m.attr("CHECKSUM_POLICY_SPARSE") = CHECKSUM_POLICY_SPARSE;
-    m.attr("CHECKSUM_POLICY_HALF") = CHECKSUM_POLICY_HALF;
-    m.attr("CHECKSUM_POLICY_ALL") = CHECKSUM_POLICY_ALL;
-    m.attr("E57_INT8_MIN") = E57_INT8_MIN;
-    m.attr("E57_INT8_MAX") = E57_INT8_MAX;
-    m.attr("E57_INT16_MIN") = E57_INT16_MIN;
-    m.attr("E57_INT16_MAX") = E57_INT16_MAX;
-    m.attr("E57_INT32_MIN") = E57_INT32_MIN;
-    m.attr("E57_INT32_MAX") = E57_INT32_MAX;
-    m.attr("E57_INT64_MIN") = E57_INT64_MIN;
-    m.attr("E57_INT64_MAX") = E57_INT64_MAX;
-    m.attr("E57_UINT8_MIN") = E57_UINT8_MIN;
-    m.attr("E57_UINT8_MAX") = E57_UINT8_MAX;
-    m.attr("E57_UINT16_MIN") = E57_UINT16_MIN;
-    m.attr("E57_UINT16_MAX") = E57_UINT16_MAX;
-    m.attr("E57_UINT32_MIN") = E57_UINT32_MIN;
-    m.attr("E57_UINT32_MAX") = E57_UINT32_MAX;
-    m.attr("E57_UINT64_MIN") = E57_UINT64_MIN;
-    m.attr("E57_UINT64_MAX") = E57_UINT64_MAX;
-    m.attr("E57_FLOAT_MIN") = E57_FLOAT_MIN;
-    m.attr("E57_FLOAT_MAX") = E57_FLOAT_MAX;
-    m.attr("E57_DOUBLE_MIN") = E57_DOUBLE_MIN;
-    m.attr("E57_DOUBLE_MAX") = E57_DOUBLE_MAX;
-    py::enum_<NodeType>(m, "NodeType")
-        .value("E57_STRUCTURE", NodeType::E57_STRUCTURE)
-        .value("E57_VECTOR", NodeType::E57_VECTOR)
-        .value("E57_COMPRESSED_VECTOR", NodeType::E57_COMPRESSED_VECTOR)
-        .value("E57_INTEGER", NodeType::E57_INTEGER)
-        .value("E57_SCALED_INTEGER", NodeType::E57_SCALED_INTEGER)
-        .value("E57_FLOAT", NodeType::E57_FLOAT)
-        .value("E57_STRING", NodeType::E57_STRING)
-        .value("E57_BLOB", NodeType::E57_BLOB)
-        .export_values();
-    py::enum_<FloatPrecision>(m, "FloatPrecision")
-        .value("E57_SINGLE", FloatPrecision::E57_SINGLE)
-        .value("E57_DOUBLE", FloatPrecision::E57_DOUBLE)
-        .export_values();
-    py::enum_<MemoryRepresentation>(m, "MemoryRepresentation")
-        .value("E57_INT8", MemoryRepresentation::E57_INT8)
-        .value("E57_UINT8", MemoryRepresentation::E57_UINT8)
-        .value("E57_INT16", MemoryRepresentation::E57_INT16)
-        .value("E57_UINT16", MemoryRepresentation::E57_UINT16)
-        .value("E57_INT32", MemoryRepresentation::E57_INT32)
-        .value("E57_UINT32", MemoryRepresentation::E57_UINT32)
-        .value("E57_INT64", MemoryRepresentation::E57_INT64)
-        .value("E57_BOOL", MemoryRepresentation::E57_BOOL)
-        .value("E57_REAL32", MemoryRepresentation::E57_REAL32)
-        .value("E57_REAL64", MemoryRepresentation::E57_REAL64)
-        .value("E57_USTRING", MemoryRepresentation::E57_USTRING)
-        .export_values();
-    py::enum_<ErrorCode>(m, "ErrorCode")
-        .value("E57_SUCCESS", ErrorCode::E57_SUCCESS)
-        .value("E57_ERROR_BAD_CV_HEADER", ErrorCode::E57_ERROR_BAD_CV_HEADER)
-        .value("E57_ERROR_BAD_CV_PACKET", ErrorCode::E57_ERROR_BAD_CV_PACKET)
-        .value("E57_ERROR_CHILD_INDEX_OUT_OF_BOUNDS", ErrorCode::E57_ERROR_CHILD_INDEX_OUT_OF_BOUNDS)
-        .value("E57_ERROR_SET_TWICE", ErrorCode::E57_ERROR_SET_TWICE)
-        .value("E57_ERROR_HOMOGENEOUS_VIOLATION", ErrorCode::E57_ERROR_HOMOGENEOUS_VIOLATION)
-        .value("E57_ERROR_VALUE_NOT_REPRESENTABLE", ErrorCode::E57_ERROR_VALUE_NOT_REPRESENTABLE)
-        .value("E57_ERROR_SCALED_VALUE_NOT_REPRESENTABLE", ErrorCode::E57_ERROR_SCALED_VALUE_NOT_REPRESENTABLE)
-        .value("E57_ERROR_REAL64_TOO_LARGE", ErrorCode::E57_ERROR_REAL64_TOO_LARGE)
-        .value("E57_ERROR_EXPECTING_NUMERIC", ErrorCode::E57_ERROR_EXPECTING_NUMERIC)
-        .value("E57_ERROR_EXPECTING_USTRING", ErrorCode::E57_ERROR_EXPECTING_USTRING)
-        .value("E57_ERROR_INTERNAL", ErrorCode::E57_ERROR_INTERNAL)
-        .value("E57_ERROR_BAD_XML_FORMAT", ErrorCode::E57_ERROR_BAD_XML_FORMAT)
-        .value("E57_ERROR_XML_PARSER", ErrorCode::E57_ERROR_XML_PARSER)
-        .value("E57_ERROR_BAD_API_ARGUMENT", ErrorCode::E57_ERROR_BAD_API_ARGUMENT)
-        .value("E57_ERROR_FILE_IS_READ_ONLY", ErrorCode::E57_ERROR_FILE_IS_READ_ONLY)
-        .value("E57_ERROR_BAD_CHECKSUM", ErrorCode::E57_ERROR_BAD_CHECKSUM)
-        .value("E57_ERROR_OPEN_FAILED", ErrorCode::E57_ERROR_OPEN_FAILED)
-        .value("E57_ERROR_CLOSE_FAILED", ErrorCode::E57_ERROR_CLOSE_FAILED)
-        .value("E57_ERROR_READ_FAILED", ErrorCode::E57_ERROR_READ_FAILED)
-        .value("E57_ERROR_WRITE_FAILED", ErrorCode::E57_ERROR_WRITE_FAILED)
-        .value("E57_ERROR_LSEEK_FAILED", ErrorCode::E57_ERROR_LSEEK_FAILED)
-        .value("E57_ERROR_PATH_UNDEFINED", ErrorCode::E57_ERROR_PATH_UNDEFINED)
-        .value("E57_ERROR_BAD_BUFFER", ErrorCode::E57_ERROR_BAD_BUFFER)
-        .value("E57_ERROR_NO_BUFFER_FOR_ELEMENT", ErrorCode::E57_ERROR_NO_BUFFER_FOR_ELEMENT)
-        .value("E57_ERROR_BUFFER_SIZE_MISMATCH", ErrorCode::E57_ERROR_BUFFER_SIZE_MISMATCH)
-        .value("E57_ERROR_BUFFER_DUPLICATE_PATHNAME", ErrorCode::E57_ERROR_BUFFER_DUPLICATE_PATHNAME)
-        .value("E57_ERROR_BAD_FILE_SIGNATURE", ErrorCode::E57_ERROR_BAD_FILE_SIGNATURE)
-        .value("E57_ERROR_UNKNOWN_FILE_VERSION", ErrorCode::E57_ERROR_UNKNOWN_FILE_VERSION)
-        .value("E57_ERROR_BAD_FILE_LENGTH", ErrorCode::E57_ERROR_BAD_FILE_LENGTH)
-        .value("E57_ERROR_XML_PARSER_INIT", ErrorCode::E57_ERROR_XML_PARSER_INIT)
-        .value("E57_ERROR_DUPLICATE_NAMESPACE_PREFIX", ErrorCode::E57_ERROR_DUPLICATE_NAMESPACE_PREFIX)
-        .value("E57_ERROR_DUPLICATE_NAMESPACE_URI", ErrorCode::E57_ERROR_DUPLICATE_NAMESPACE_URI)
-        .value("E57_ERROR_BAD_PROTOTYPE", ErrorCode::E57_ERROR_BAD_PROTOTYPE)
-        .value("E57_ERROR_BAD_CODECS", ErrorCode::E57_ERROR_BAD_CODECS)
-        .value("E57_ERROR_VALUE_OUT_OF_BOUNDS", ErrorCode::E57_ERROR_VALUE_OUT_OF_BOUNDS)
-        .value("E57_ERROR_CONVERSION_REQUIRED", ErrorCode::E57_ERROR_CONVERSION_REQUIRED)
-        .value("E57_ERROR_BAD_PATH_NAME", ErrorCode::E57_ERROR_BAD_PATH_NAME)
-        .value("E57_ERROR_NOT_IMPLEMENTED", ErrorCode::E57_ERROR_NOT_IMPLEMENTED)
-        .value("E57_ERROR_BAD_NODE_DOWNCAST", ErrorCode::E57_ERROR_BAD_NODE_DOWNCAST)
-        .value("E57_ERROR_WRITER_NOT_OPEN", ErrorCode::E57_ERROR_WRITER_NOT_OPEN)
-        .value("E57_ERROR_READER_NOT_OPEN", ErrorCode::E57_ERROR_READER_NOT_OPEN)
-        .value("E57_ERROR_NODE_UNATTACHED", ErrorCode::E57_ERROR_NODE_UNATTACHED)
-        .value("E57_ERROR_ALREADY_HAS_PARENT", ErrorCode::E57_ERROR_ALREADY_HAS_PARENT)
-        .value("E57_ERROR_DIFFERENT_DEST_IMAGEFILE", ErrorCode::E57_ERROR_DIFFERENT_DEST_IMAGEFILE)
-        .value("E57_ERROR_IMAGEFILE_NOT_OPEN", ErrorCode::E57_ERROR_IMAGEFILE_NOT_OPEN)
-        .value("E57_ERROR_BUFFERS_NOT_COMPATIBLE", ErrorCode::E57_ERROR_BUFFERS_NOT_COMPATIBLE)
-        .value("E57_ERROR_TOO_MANY_WRITERS", ErrorCode::E57_ERROR_TOO_MANY_WRITERS)
-        .value("E57_ERROR_TOO_MANY_READERS", ErrorCode::E57_ERROR_TOO_MANY_READERS)
-        .value("E57_ERROR_BAD_CONFIGURATION", ErrorCode::E57_ERROR_BAD_CONFIGURATION)
-        .value("E57_ERROR_INVARIANCE_VIOLATION", ErrorCode::E57_ERROR_INVARIANCE_VIOLATION)
-        .export_values();
-    py::class_<Node> cls_Node(m, "Node");
-    cls_Node.def("type", &Node::type);
-    cls_Node.def("isRoot", &Node::isRoot);
-    cls_Node.def("parent", &Node::parent);
-    cls_Node.def("pathName", &Node::pathName);
-    cls_Node.def("elementName", &Node::elementName);
-    cls_Node.def("destImageFile", &Node::destImageFile);
-    cls_Node.def("isAttached", &Node::isAttached);
-    cls_Node.def("checkInvariant", &Node::checkInvariant, "doRecurse"_a=true, "doDowncast"_a=true);
-    cls_Node.def("__repr__", [](const Node &node) {
-        return "<Node '" + node.elementName() + "'>";
-    });
-
-    py::class_<StructureNode> cls_StructureNode(m, "StructureNode");
-    cls_StructureNode.def(py::init<e57::ImageFile>(), "destImageFile"_a);
-    cls_StructureNode.def("childCount", &StructureNode::childCount);
-    cls_StructureNode.def("isDefined", &StructureNode::isDefined, "pathName"_a);
-    cls_StructureNode.def("get", (Node (StructureNode::*)(int64_t) const) &StructureNode::get, "index"_a);
-    cls_StructureNode.def("get", (Node (StructureNode::*)(const std::string &) const) &StructureNode::get, "pathName"_a);
-    // Maybe there is a more elegant way to do this
-    cls_StructureNode.def("set", [](StructureNode &node, const std::string &pathName, StructureNode &n){
-        node.set(pathName, n);
-    }, "pathName"_a, "n"_a);
-    cls_StructureNode.def("set", [](StructureNode &node, const std::string &pathName, VectorNode &n){
-        node.set(pathName, n);
-    }, "pathName"_a, "n"_a);
-    cls_StructureNode.def("set", [](StructureNode &node, const std::string &pathName, CompressedVectorNode &n){
-        node.set(pathName, n);
-    }, "pathName"_a, "n"_a);
-    cls_StructureNode.def("set", [](StructureNode &node, const std::string &pathName, IntegerNode &n){
-        node.set(pathName, n);
-    }, "pathName"_a, "n"_a);
-    cls_StructureNode.def("set", [](StructureNode &node, const std::string &pathName, ScaledIntegerNode &n){
-        node.set(pathName, n);
-    }, "pathName"_a, "n"_a);
-    cls_StructureNode.def("set", [](StructureNode &node, const std::string &pathName, FloatNode &n){
-        node.set(pathName, n);
-    }, "pathName"_a, "n"_a);
-    cls_StructureNode.def("set", [](StructureNode &node, const std::string &pathName, StringNode &n){
-        node.set(pathName, n);
-    }, "pathName"_a, "n"_a);
-    cls_StructureNode.def(py::init<const e57::Node &>(), "n"_a);
-    cls_StructureNode.def("isRoot", &StructureNode::isRoot);
-    cls_StructureNode.def("parent", &StructureNode::parent);
-    cls_StructureNode.def("pathName", &StructureNode::pathName);
-    cls_StructureNode.def("elementName", &StructureNode::elementName);
-    cls_StructureNode.def("destImageFile", &StructureNode::destImageFile);
-    cls_StructureNode.def("isAttached", &StructureNode::isAttached);
-    cls_StructureNode.def("checkInvariant", &StructureNode::checkInvariant, "doRecurse"_a=true, "doUpcast"_a=true);
-    cls_StructureNode.def("__len__", &StructureNode::childCount);
-    cls_StructureNode.def("__getitem__", [](const StructureNode &node, const std::string &pathName) {
-        Node n = node.get(pathName);
-        return cast_node(n);
-    });
-    cls_StructureNode.def("__getitem__", [](const StructureNode &node, int64_t index) {
-        if (index >= node.childCount() || index < 0)
-            throw py::index_error();
-        Node n = node.get(index);
-        return cast_node(n);
-    });
-    cls_StructureNode.def("__repr__", [](const StructureNode &node) {
-        return "<StructureNode '" + node.elementName() + "'>";
-    });
-
-    py::class_<VectorNode> cls_VectorNode(m, "VectorNode");
-    cls_VectorNode.def(py::init<e57::ImageFile, bool>(), "destImageFile"_a, "allowHeteroChildren"_a=false);
-    cls_VectorNode.def("allowHeteroChildren", &VectorNode::allowHeteroChildren);
-    cls_VectorNode.def("childCount", &VectorNode::childCount);
-    cls_VectorNode.def("isDefined", &VectorNode::isDefined, "pathName"_a);
-    cls_VectorNode.def("get", (Node (VectorNode::*)(int64_t) const) &VectorNode::get, "index"_a);
-    cls_VectorNode.def("get", (Node (VectorNode::*)(const std::string &) const) &VectorNode::get, "pathName"_a);
-    // Maybe there is a more elegant way to do this
-    cls_VectorNode.def("append", [](VectorNode &v, StructureNode &node) { v.append(node); });
-    cls_VectorNode.def("append", [](VectorNode &v, VectorNode &node) { v.append(node); });
-    cls_VectorNode.def("append", [](VectorNode &v, CompressedVectorNode &node) { v.append(node); });
-    cls_VectorNode.def("append", [](VectorNode &v, IntegerNode &node) { v.append(node); });
-    cls_VectorNode.def("append", [](VectorNode &v, ScaledIntegerNode &node) { v.append(node); });
-    cls_VectorNode.def("append", [](VectorNode &v, FloatNode &node) { v.append(node); });
-    cls_VectorNode.def("append", [](VectorNode &v, StringNode &node) { v.append(node); });
-    cls_VectorNode.def(py::init<const e57::Node &>(), "n"_a);
-    cls_VectorNode.def("isRoot", &VectorNode::isRoot);
-    cls_VectorNode.def("parent", &VectorNode::parent);
-    cls_VectorNode.def("pathName", &VectorNode::pathName);
-    cls_VectorNode.def("elementName", &VectorNode::elementName);
-    cls_VectorNode.def("destImageFile", &VectorNode::destImageFile);
-    cls_VectorNode.def("isAttached", &VectorNode::isAttached);
-    cls_VectorNode.def("checkInvariant", &VectorNode::checkInvariant, "doRecurse"_a=true, "doUpcast"_a=true);
-    cls_VectorNode.def("__len__", &VectorNode::childCount);
-    cls_VectorNode.def("__getitem__", [](const VectorNode &node, const std::string &pathName) {
-        Node n = node.get(pathName);
-        return cast_node(n);
-    });
-    cls_VectorNode.def("__getitem__", [](const VectorNode &node, int64_t index) {
-        if (index >= node.childCount() || index < 0)
-            throw py::index_error();
-        Node n = node.get(index);
-        return cast_node(n);
-    });
-    cls_VectorNode.def("__repr__", [](const VectorNode &node) {
-        return "<VectorNode '" + node.elementName() + "'>";
-    });
-
-    py::class_<SourceDestBuffer> cls_SourceDestBuffer(m, "SourceDestBuffer");
-    cls_SourceDestBuffer.def("__init__", [](SourceDestBuffer &s,
-                                            e57::ImageFile imf,
-                                            const std::string pathName,
-                                            py::buffer np_array,
-                                            const size_t capacity,
-                                            bool doConversion,
-                                            bool doScaling,
-                                            size_t stride=0) {
-        py::buffer_info info = np_array.request();
-
-        if (info.ndim != 1)
-            throw std::runtime_error("Incompatible buffer dimension!");
-
-        if (info.format == "b")
-            new (&s) SourceDestBuffer(imf, pathName, static_cast<int8_t *>(info.ptr), capacity, doConversion, doScaling, (stride == 0) ? sizeof(int8_t) : stride);
-        else if (info.format == "B")
-            new (&s) SourceDestBuffer(imf, pathName, static_cast<uint8_t *>(info.ptr), capacity, doConversion, doScaling, (stride == 0) ? sizeof(uint8_t) : stride);
-        else if (info.format == "h")
-            new (&s) SourceDestBuffer(imf, pathName, static_cast<int16_t *>(info.ptr), capacity, doConversion, doScaling, (stride == 0) ? sizeof(int16_t) : stride);
-        else if (info.format == "H")
-            new (&s) SourceDestBuffer(imf, pathName, static_cast<uint16_t *>(info.ptr), capacity, doConversion, doScaling, (stride == 0) ? sizeof(uint16_t) : stride);
-        else if (info.format == "l")
-            new (&s) SourceDestBuffer(imf, pathName, static_cast<int32_t *>(info.ptr), capacity, doConversion, doScaling, (stride == 0) ? sizeof(int32_t) : stride);
-        else if (info.format == "L")
-            new (&s) SourceDestBuffer(imf, pathName, static_cast<uint32_t *>(info.ptr), capacity, doConversion, doScaling, (stride == 0) ? sizeof(uint32_t) : stride);
-        else if (info.format == "q")
-            new (&s) SourceDestBuffer(imf, pathName, static_cast<int64_t *>(info.ptr), capacity, doConversion, doScaling, (stride == 0) ? sizeof(int64_t) : stride);
-        else if (info.format == "?")
-            new (&s) SourceDestBuffer(imf, pathName, static_cast<bool *>(info.ptr), capacity, doConversion, doScaling, (stride == 0) ? sizeof(bool) : stride);
-        else if (info.format == "f")
-            new (&s) SourceDestBuffer(imf, pathName, static_cast<float *>(info.ptr), capacity, doConversion, doScaling, (stride == 0) ? sizeof(float) : stride);
-        else if (info.format == "d")
-            new (&s) SourceDestBuffer(imf, pathName, static_cast<double *>(info.ptr), capacity, doConversion, doScaling, (stride == 0) ? sizeof(double) : stride);
-        else
-            throw py::value_error("Incompatible type (integers: bBhHlLq, bool: ?, floats: fd)");
-    },
-    "destImageFile"_a, "pathName"_a, "b"_a, "capacity"_a, "doConversion"_a=false, "doScaling"_a=false, "stride"_a=0);
-//    cls_SourceDestBuffer.def(py::init<e57::ImageFile, const std::string, int8_t *, const size_t, bool, bool, size_t>(), "destImageFile"_a, "pathName"_a, "b"_a, "capacity"_a, "doConversion"_a=false, "doScaling"_a=false, "stride"_a=sizeof(int8_t));
-//    cls_SourceDestBuffer.def(py::init<e57::ImageFile, const std::string, uint8_t *, const size_t, bool, bool, size_t>(), "destImageFile"_a, "pathName"_a, "b"_a, "capacity"_a, "doConversion"_a=false, "doScaling"_a=false, "stride"_a=sizeof(uint8_t));
-//    cls_SourceDestBuffer.def(py::init<e57::ImageFile, const std::string, int16_t *, const size_t, bool, bool, size_t>(), "destImageFile"_a, "pathName"_a, "b"_a, "capacity"_a, "doConversion"_a=false, "doScaling"_a=false, "stride"_a=sizeof(int16_t));
-//    cls_SourceDestBuffer.def(py::init<e57::ImageFile, const std::string, uint16_t *, const size_t, bool, bool, size_t>(), "destImageFile"_a, "pathName"_a, "b"_a, "capacity"_a, "doConversion"_a=false, "doScaling"_a=false, "stride"_a=sizeof(uint16_t));
-//    cls_SourceDestBuffer.def(py::init<e57::ImageFile, const std::string, int32_t *, const size_t, bool, bool, size_t>(), "destImageFile"_a, "pathName"_a, "b"_a, "capacity"_a, "doConversion"_a=false, "doScaling"_a=false, "stride"_a=sizeof(int32_t));
-//    cls_SourceDestBuffer.def(py::init<e57::ImageFile, const std::string, uint32_t *, const size_t, bool, bool, size_t>(), "destImageFile"_a, "pathName"_a, "b"_a, "capacity"_a, "doConversion"_a=false, "doScaling"_a=false, "stride"_a=sizeof(uint32_t));
-//    cls_SourceDestBuffer.def(py::init<e57::ImageFile, const std::string, int64_t *, const size_t, bool, bool, size_t>(), "destImageFile"_a, "pathName"_a, "b"_a, "capacity"_a, "doConversion"_a=false, "doScaling"_a=false, "stride"_a=sizeof(int64_t));
-//    cls_SourceDestBuffer.def(py::init<e57::ImageFile, const std::string, bool *, const size_t, bool, bool, size_t>(), "destImageFile"_a, "pathName"_a, "b"_a, "capacity"_a, "doConversion"_a=false, "doScaling"_a=false, "stride"_a=sizeof(bool));
-//    cls_SourceDestBuffer.def(py::init<e57::ImageFile, const std::string, float *, const size_t, bool, bool, size_t>(), "destImageFile"_a, "pathName"_a, "b"_a, "capacity"_a, "doConversion"_a=false, "doScaling"_a=false, "stride"_a=sizeof(float));
-//    cls_SourceDestBuffer.def(py::init<e57::ImageFile, const std::string, double *, const size_t, bool, bool, size_t>(), "destImageFile"_a, "pathName"_a, "b"_a, "capacity"_a, "doConversion"_a=false, "doScaling"_a=false, "stride"_a=sizeof(double));
-//    cls_SourceDestBuffer.def(py::init<e57::ImageFile, const std::string, std::vector<ustring> *>(), "destImageFile"_a, "pathName"_a, "b"_a);
-    cls_SourceDestBuffer.def("pathName", &SourceDestBuffer::pathName);
-    cls_SourceDestBuffer.def("capacity", &SourceDestBuffer::capacity);
-    cls_SourceDestBuffer.def("doConversion", &SourceDestBuffer::doConversion);
-    cls_SourceDestBuffer.def("doScaling", &SourceDestBuffer::doScaling);
-    cls_SourceDestBuffer.def("stride", &SourceDestBuffer::stride);
-    cls_SourceDestBuffer.def("checkInvariant", &SourceDestBuffer::checkInvariant, "doRecurse"_a=true);
-    cls_SourceDestBuffer.def("__repr__", [](const SourceDestBuffer &bf) {
-        return "<SourceDestBuffer '" + bf.pathName() + "'>";
-    });
-
-    py::class_<CompressedVectorReader> cls_CompressedVectorReader(m, "CompressedVectorReader");
-    cls_CompressedVectorReader.def("read", (unsigned (CompressedVectorReader::*)(void)) &CompressedVectorReader::read);
-    cls_CompressedVectorReader.def("read", (unsigned (CompressedVectorReader::*)(std::vector<SourceDestBuffer> &)) &CompressedVectorReader::read, "dbufs"_a);
-    cls_CompressedVectorReader.def("seek", &CompressedVectorReader::seek, "recordNumber"_a);
-    cls_CompressedVectorReader.def("close", &CompressedVectorReader::close);
-    cls_CompressedVectorReader.def("isOpen", &CompressedVectorReader::isOpen);
-    cls_CompressedVectorReader.def("compressedVectorNode", &CompressedVectorReader::compressedVectorNode);
-    cls_CompressedVectorReader.def("checkInvariant", &CompressedVectorReader::checkInvariant, "doRecurse"_a=true);
-    cls_CompressedVectorReader.def("__del__", [](CompressedVectorReader &r) { r.close(); });
-
-    py::class_<CompressedVectorWriter> cls_CompressedVectorWriter(m, "CompressedVectorWriter");
-    cls_CompressedVectorWriter.def("write", (void (CompressedVectorWriter::*)(const size_t)) &CompressedVectorWriter::write, "requestedRecordCount"_a);
-    cls_CompressedVectorWriter.def("write", (void (CompressedVectorWriter::*)(std::vector<SourceDestBuffer> &, const size_t)) &CompressedVectorWriter::write, "sbufs"_a, "requestedRecordCount"_a);
-    cls_CompressedVectorWriter.def("close", &CompressedVectorWriter::close);
-    cls_CompressedVectorWriter.def("isOpen", &CompressedVectorWriter::isOpen);
-    cls_CompressedVectorWriter.def("compressedVectorNode", &CompressedVectorWriter::compressedVectorNode);
-    cls_CompressedVectorWriter.def("checkInvariant", &CompressedVectorWriter::checkInvariant, "doRecurse"_a=true);
-    cls_CompressedVectorWriter.def("__del__", [](CompressedVectorWriter &r) { r.close(); });
-
-    py::class_<CompressedVectorNode> cls_CompressedVectorNode(m, "CompressedVectorNode");
-    cls_CompressedVectorNode.def(py::init<e57::ImageFile, e57::Node, e57::VectorNode>(), "destImageFile"_a, "prototype"_a, "codecs"_a);
-    cls_CompressedVectorNode.def("__init__", [](CompressedVectorNode &n, e57::ImageFile &imf, e57::StructureNode &node, e57::VectorNode &vector_node) {
-        new (&n) CompressedVectorNode(imf, node, vector_node);
-    });
-    cls_CompressedVectorNode.def("childCount", &CompressedVectorNode::childCount);
-    cls_CompressedVectorNode.def("prototype", &CompressedVectorNode::prototype);
-    cls_CompressedVectorNode.def("codecs", &CompressedVectorNode::codecs);
-    cls_CompressedVectorNode.def("writer", &CompressedVectorNode::writer, "sbufs"_a);
-    cls_CompressedVectorNode.def("reader", &CompressedVectorNode::reader, "dbufs"_a);
-    cls_CompressedVectorNode.def(py::init<const e57::Node &>(), "n"_a);
-    cls_CompressedVectorNode.def("isRoot", &CompressedVectorNode::isRoot);
-    cls_CompressedVectorNode.def("parent", &CompressedVectorNode::parent);
-    cls_CompressedVectorNode.def("pathName", &CompressedVectorNode::pathName);
-    cls_CompressedVectorNode.def("elementName", &CompressedVectorNode::elementName);
-    cls_CompressedVectorNode.def("destImageFile", &CompressedVectorNode::destImageFile);
-    cls_CompressedVectorNode.def("isAttached", &CompressedVectorNode::isAttached);
-    cls_CompressedVectorNode.def("checkInvariant", &CompressedVectorNode::checkInvariant, "doRecurse"_a=true, "doUpcast"_a=true);
-    cls_CompressedVectorNode.def("__repr__", [](const CompressedVectorNode &node) {
-        return "<CompressedVectorNode '" + node.elementName() + "'>";
-    });
-
-    py::class_<IntegerNode> cls_IntegerNode(m, "IntegerNode");
-    cls_IntegerNode.def(py::init<e57::ImageFile, int64_t, int64_t, int64_t>(), "destImageFile"_a, "value"_a=0, "minimum"_a=E57_INT64_MIN, "maximum"_a=E57_INT64_MAX);
-    cls_IntegerNode.def("value", &IntegerNode::value);
-    cls_IntegerNode.def("minimum", &IntegerNode::minimum);
-    cls_IntegerNode.def("maximum", &IntegerNode::maximum);
-    cls_IntegerNode.def(py::init<const e57::Node &>(), "n"_a);
-    cls_IntegerNode.def("isRoot", &IntegerNode::isRoot);
-    cls_IntegerNode.def("parent", &IntegerNode::parent);
-    cls_IntegerNode.def("pathName", &IntegerNode::pathName);
-    cls_IntegerNode.def("elementName", &IntegerNode::elementName);
-    cls_IntegerNode.def("destImageFile", &IntegerNode::destImageFile);
-    cls_IntegerNode.def("isAttached", &IntegerNode::isAttached);
-    cls_IntegerNode.def("checkInvariant", &IntegerNode::checkInvariant, "doRecurse"_a=true, "doUpcast"_a=true);
-    cls_IntegerNode.def("__repr__", [](const IntegerNode &node) {
-        return "<IntegerNode '" + node.elementName() + "'>";
-    });
-
-    py::class_<ScaledIntegerNode> cls_ScaledIntegerNode(m, "ScaledIntegerNode");
-    cls_ScaledIntegerNode.def(py::init<e57::ImageFile, int64_t, int64_t, int64_t, double, double>(), "destImageFile"_a, "value"_a, "minimum"_a, "maximum"_a, "scale"_a=1.0, "offset"_a=0.0);
-    cls_ScaledIntegerNode.def(py::init<e57::ImageFile, int, int64_t, int64_t, double, double>(), "destImageFile"_a, "value"_a, "minimum"_a, "maximum"_a, "scale"_a=1.0, "offset"_a=0.0);
-    cls_ScaledIntegerNode.def(py::init<e57::ImageFile, int, int, int, double, double>(), "destImageFile"_a, "value"_a, "minimum"_a, "maximum"_a, "scale"_a=1.0, "offset"_a=0.0);
-    cls_ScaledIntegerNode.def(py::init<e57::ImageFile, double, double, double, double, double>(), "destImageFile"_a, "scaledValue"_a, "scaledMinimum"_a, "scaledMaximum"_a, "scale"_a=1.0, "offset"_a=0.0);
-    cls_ScaledIntegerNode.def("rawValue", &ScaledIntegerNode::rawValue);
-    cls_ScaledIntegerNode.def("scaledValue", &ScaledIntegerNode::scaledValue);
-    cls_ScaledIntegerNode.def("minimum", &ScaledIntegerNode::minimum);
-    cls_ScaledIntegerNode.def("scaledMinimum", &ScaledIntegerNode::scaledMinimum);
-    cls_ScaledIntegerNode.def("maximum", &ScaledIntegerNode::maximum);
-    cls_ScaledIntegerNode.def("scaledMaximum", &ScaledIntegerNode::scaledMaximum);
-    cls_ScaledIntegerNode.def("scale", &ScaledIntegerNode::scale);
-    cls_ScaledIntegerNode.def("offset", &ScaledIntegerNode::offset);
-    cls_ScaledIntegerNode.def(py::init<const e57::Node &>(), "n"_a);
-    cls_ScaledIntegerNode.def("isRoot", &ScaledIntegerNode::isRoot);
-    cls_ScaledIntegerNode.def("parent", &ScaledIntegerNode::parent);
-    cls_ScaledIntegerNode.def("pathName", &ScaledIntegerNode::pathName);
-    cls_ScaledIntegerNode.def("elementName", &ScaledIntegerNode::elementName);
-    cls_ScaledIntegerNode.def("destImageFile", &ScaledIntegerNode::destImageFile);
-    cls_ScaledIntegerNode.def("isAttached", &ScaledIntegerNode::isAttached);
-    cls_ScaledIntegerNode.def("checkInvariant", &ScaledIntegerNode::checkInvariant, "doRecurse"_a=true, "doUpcast"_a=true);
-    cls_ScaledIntegerNode.def("__repr__", [](const ScaledIntegerNode &node) {
-        return "<ScaledIntegerNode '" + node.elementName() + "'>";
-    });
-
-    py::class_<FloatNode> cls_FloatNode(m, "FloatNode");
-    cls_FloatNode.def(py::init<e57::ImageFile, double, FloatPrecision, double, double>(), "destImageFile"_a, "value"_a=0.0, "precision"_a=E57_DOUBLE, "minimum"_a=E57_DOUBLE_MIN, "maximum"_a=E57_DOUBLE_MAX);
-    cls_FloatNode.def("value", &FloatNode::value);
-    cls_FloatNode.def("precision", &FloatNode::precision);
-    cls_FloatNode.def("minimum", &FloatNode::minimum);
-    cls_FloatNode.def("maximum", &FloatNode::maximum);
-    cls_FloatNode.def(py::init<const e57::Node &>(), "n"_a);
-    cls_FloatNode.def("isRoot", &FloatNode::isRoot);
-    cls_FloatNode.def("parent", &FloatNode::parent);
-    cls_FloatNode.def("pathName", &FloatNode::pathName);
-    cls_FloatNode.def("elementName", &FloatNode::elementName);
-    cls_FloatNode.def("destImageFile", &FloatNode::destImageFile);
-    cls_FloatNode.def("isAttached", &FloatNode::isAttached);
-    cls_FloatNode.def("checkInvariant", &FloatNode::checkInvariant, "doRecurse"_a=true, "doUpcast"_a=true);
-    cls_FloatNode.def("__repr__", [](const FloatNode &node) {
-        return "<FloatNode '" + node.elementName() + "'>";
-    });
-
-    py::class_<StringNode> cls_StringNode(m, "StringNode");
-    cls_StringNode.def(py::init<e57::ImageFile, const std::string>(), "destImageFile"_a, "value"_a="");
-    cls_StringNode.def("value", &StringNode::value);
-    cls_StringNode.def(py::init<const e57::Node &>(), "n"_a);
-    cls_StringNode.def("isRoot", &StringNode::isRoot);
-    cls_StringNode.def("parent", &StringNode::parent);
-    cls_StringNode.def("pathName", &StringNode::pathName);
-    cls_StringNode.def("elementName", &StringNode::elementName);
-    cls_StringNode.def("destImageFile", &StringNode::destImageFile);
-    cls_StringNode.def("isAttached", &StringNode::isAttached);
-    cls_StringNode.def("checkInvariant", &StringNode::checkInvariant, "doRecurse"_a=true, "doUpcast"_a=true);
-    cls_StringNode.def("__repr__", [](const StringNode &node) {
-        return "<StringNode '" + node.elementName() + "'>";
-    });
-
-    py::class_<BlobNode> cls_BlobNode(m, "BlobNode");
-    cls_BlobNode.def(py::init<e57::ImageFile, int64_t>(), "destImageFile"_a, "byteCount"_a);
-    cls_BlobNode.def("byteCount", &BlobNode::byteCount);
-    cls_BlobNode.def("read", [](BlobNode& node, py::buffer buf, int64_t start, size_t count) {
-        py::buffer_info info = buf.request();
-
-        if (info.ndim != 1) {
-            throw std::runtime_error("Incompatible buffer dimension!");
-        }
-
-        if (info.format != "B") {
-            throw std::runtime_error("Incompatible buffer type!");
-        }
-
-        if (static_cast<size_t>(info.shape[0]) < count) {
-            throw std::runtime_error("Buffer not large enough to read.");
-        }
-
-        node.read(reinterpret_cast<uint8_t*>(info.ptr), start, count);
-    });
-    cls_BlobNode.def("write", [](BlobNode& node, py::buffer buf, int64_t start, size_t count) {
-        py::buffer_info info = buf.request();
-
-        if (info.ndim != 1) {
-            throw std::runtime_error("Incompatible buffer dimension!");
-        }
-
-        if (info.format != "B") {
-            throw std::runtime_error("Incompatible buffer type!");
-        }
-
-        if (static_cast<size_t>(info.shape[0]) < count) {
-            throw std::runtime_error("Buffer not large enough to write.");
-        }
-
-        node.write(reinterpret_cast<uint8_t*>(info.ptr), start, count);
-    });
-    cls_BlobNode.def(py::init<const e57::Node &>(), "n"_a);
-    cls_BlobNode.def("isRoot", &BlobNode::isRoot);
-    cls_BlobNode.def("parent", &BlobNode::parent);
-    cls_BlobNode.def("pathName", &BlobNode::pathName);
-    cls_BlobNode.def("elementName", &BlobNode::elementName);
-    cls_BlobNode.def("destImageFile", &BlobNode::destImageFile);
-    cls_BlobNode.def("isAttached", &BlobNode::isAttached);
-    cls_BlobNode.def("checkInvariant", &BlobNode::checkInvariant, "doRecurse"_a=true, "doUpcast"_a=true);
-    cls_BlobNode.def("__repr__", [](const BlobNode &node) {
-        return "<BlobNode '" + node.elementName() + "'>";
-    });
-    cls_BlobNode.def("read_buffer", [](BlobNode &node) -> py::array {
-        int64_t bufferSizeExpected = node.byteCount();
-        py::array_t<uint8_t> arr(bufferSizeExpected);
-        node.read(arr.mutable_data(), 0, bufferSizeExpected);
-        return arr;
-    });
-
-    py::class_<ImageFile> cls_ImageFile(m, "ImageFile");
-    cls_ImageFile.def(py::init<const std::string &, const std::string &, int>(), "fname"_a, "mode"_a, "checksumPolicy"_a=CHECKSUM_POLICY_ALL);
-    cls_ImageFile.def("root", &ImageFile::root);
-    cls_ImageFile.def("close", &ImageFile::close);
-    cls_ImageFile.def("cancel", &ImageFile::cancel);
-    cls_ImageFile.def("isOpen", &ImageFile::isOpen);
-    cls_ImageFile.def("isWritable", &ImageFile::isWritable);
-    cls_ImageFile.def("fileName", &ImageFile::fileName);
-    cls_ImageFile.def("writerCount", &ImageFile::writerCount);
-    cls_ImageFile.def("readerCount", &ImageFile::readerCount);
-    cls_ImageFile.def("extensionsAdd", &ImageFile::extensionsAdd, "prefix"_a, "uri"_a);
-    cls_ImageFile.def("extensionsLookupPrefix", &ImageFile::extensionsLookupPrefix, "prefix"_a, "uri"_a);
-    cls_ImageFile.def("extensionsLookupUri", &ImageFile::extensionsLookupUri, "uri"_a, "prefix"_a);
-    cls_ImageFile.def("extensionsCount", &ImageFile::extensionsCount);
-    cls_ImageFile.def("extensionsPrefix", &ImageFile::extensionsPrefix, "index"_a);
-    cls_ImageFile.def("extensionsUri", &ImageFile::extensionsUri, "index"_a);
-    cls_ImageFile.def("isElementNameExtended", &ImageFile::isElementNameExtended, "elementName"_a);
-    cls_ImageFile.def("elementNameParse", &ImageFile::elementNameParse, "elementName"_a, "prefix"_a, "localPart"_a);
-    cls_ImageFile.def("checkInvariant", &ImageFile::checkInvariant, "doRecurse"_a=true);
-    cls_ImageFile.def("__repr__", [](const ImageFile &im) {
-        return "<ImageFile '" + im.fileName() + "'>";
-    });
-
-//    py::class_<E57Exception> cls_E57Exception(m, "E57Exception");
-//    cls_E57Exception.def("errorCode", &E57Exception::errorCode);
-//    cls_E57Exception.def("context", &E57Exception::context);
-//    cls_E57Exception.def("what", &E57Exception::what);
-//    cls_E57Exception.def("sourceFileName", &E57Exception::sourceFileName);
-//    cls_E57Exception.def("sourceFunctionName", &E57Exception::sourceFunctionName);
-//    cls_E57Exception.def("sourceLineNumber", &E57Exception::sourceLineNumber);
-
-//    py::class_<E57Utilities> cls_E57Utilities(m, "E57Utilities");
-//    cls_E57Utilities.def(py::init<const std::string>(), "&"_a="");
-//    cls_E57Utilities.def("getVersions", &E57Utilities::getVersions, "astmMajor"_a, "astmMinor"_a, "libraryId"_a);
-//    cls_E57Utilities.def("errorCodeToString", &E57Utilities::errorCodeToString, "ecode"_a);
-
-    py::bind_vector<std::vector<e57::SourceDestBuffer>>(m, "VectorSourceDestBuffer");
-}

pye57-0.3.1.dist-info/RECORD

@@ -1,14 +0,0 @@
-pye57/__init__.py,sha256=keWVF2W7Jau5voY0aufr6bayvjfDJSWf_bmawIvvj88,95
-pye57/__version__.py,sha256=sNUIXY4j-uBW0UNJ1UBlk71jQtO-yq-NEWFI_pOQcKY,23
-pye57/e57.py,sha256=KZ6FYhgZOQfBP9yUbz5tqyTEuvia4jMTuLV8zqHNvmA,17730
-pye57/exception.py,sha256=9Qgriir0IsSpHhStN5uvI5mlbKrc_P5ZURsi_PIW_q8,50
-pye57/libe57.cp310-win_amd64.pyd,sha256=coZAJ-SCQE2YgYGsEstYeWc452PuTg3J1kvn574xRpM,733696
-pye57/libe57_wrapper.cpp,sha256=zx2z2XuJtsoG2KPoX87qGmUmP-rV_gkn8fsHK5W_KAA,35152
-pye57/scan_header.py,sha256=atTRXGDXtdlBxyEXenjBN7H3pjGt5sS8k1Afh5dqDXk,4742
-pye57/utils.py,sha256=Dtt1Z7fbjNwgvhy9tF_TVwEJ9dRNDyYcSQJZ3KFUi1M,701
-pye57/xerces-c_3_2.dll,sha256=3ATqlJbstvhJxO4YUuPGF6Tbpo31zS4p1nh56lBUSNg,2787328
-pye57-0.3.1.dist-info/LICENSE,sha256=Q0K1iCfVm6UmnR4AAyqME5q7flnU6aGh5OarEIa2K6Y,1056
-pye57-0.3.1.dist-info/METADATA,sha256=Hy6xYFUNGIWjwG_uOh0TTBld04-95NMcqWDcgEsz4pk,4159
-pye57-0.3.1.dist-info/WHEEL,sha256=W26pYN7HLsBT1jrDSL9udgf_mdNKJmYmL23sIP-FcgM,102
-pye57-0.3.1.dist-info/top_level.txt,sha256=xD9HDzQ3BfGMuz1kI2uNKUR0KXcR-RtNEKigrkh48Nk,6
-pye57-0.3.1.dist-info/RECORD,,