pye57 0.3.1__tar.gz → 0.4.2__tar.gz

{pye57-0.3.1/src/pye57.egg-info → pye57-0.4.2}/PKG-INFO

@@ -1,31 +1,34 @@
 Metadata-Version: 2.1
 Name: pye57
-Version: 0.3.1
+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
-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 :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: Implementation :: CPython
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Provides-Extra: test
 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)
+![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
 
@@ -137,5 +140,3 @@ Use pip again
 ```
 python -m pip uninstall pye57
 ```
-
-

{pye57-0.3.1 → pye57-0.4.2}/README.md

@@ -2,7 +2,7 @@
 
 [![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)
+![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
 

{pye57-0.3.1 → pye57-0.4.2}/setup.py

@@ -107,7 +107,7 @@ setup(
     ext_modules=ext_modules,
     packages=["pye57"],
     package_dir={"": "src"},
-    include_package_data=True,
+    # include_package_data=True,
     package_data={"pye57": package_data},
     extras_require={"test": "pytest"},
     license="MIT",
@@ -115,13 +115,14 @@ setup(
         "License :: OSI Approved :: MIT License",
         "Programming Language :: Python",
         "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.7",
         "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
         "Programming Language :: Python :: Implementation :: CPython",
     ],
     cmdclass={"build_ext": BuildExt},
     zip_safe=False,
-    python_requires=">=3.7",
+    python_requires=">=3.8",
 )

pye57-0.4.2/src/pye57/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.4.2"

{pye57-0.3.1 → pye57-0.4.2}/src/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-0.3.1 → pye57-0.4.2}/src/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-0.4.2/src/pye57/utils.py

@@ -0,0 +1,42 @@
+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())]
+
+
+def get_node(node, name):
+    cast = {
+        NodeType.E57_BLOB: libe57.BlobNode,
+        NodeType.E57_COMPRESSED_VECTOR: libe57.CompressedVectorNode,
+        NodeType.E57_FLOAT: libe57.FloatNode,
+        NodeType.E57_INTEGER: libe57.IntegerNode,
+        NodeType.E57_SCALED_INTEGER: libe57.ScaledIntegerNode,
+        NodeType.E57_STRING: libe57.StringNode,
+        NodeType.E57_STRUCTURE: libe57.StructureNode,
+        NodeType.E57_VECTOR: libe57.VectorNode
+    }
+    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 → pye57-0.4.2/src/pye57.egg-info}/PKG-INFO

@@ -1,31 +1,34 @@
 Metadata-Version: 2.1
 Name: pye57
-Version: 0.3.1
+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
-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 :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: Implementation :: CPython
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Provides-Extra: test
 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)
+![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
 
@@ -137,5 +140,3 @@ Use pip again
 ```
 python -m pip uninstall pye57
 ```
-
-

{pye57-0.3.1 → pye57-0.4.2}/src/pye57.egg-info/SOURCES.txt

@@ -3,6 +3,34 @@ MANIFEST.in
 README.md
 pyproject.toml
 setup.py
+/home/runner/work/pye57/pye57/libE57Format/src/BlobNodeImpl.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/CheckedFile.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/Common.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/CompressedVectorNodeImpl.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/CompressedVectorReaderImpl.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/CompressedVectorWriterImpl.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/DecodeChannel.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/Decoder.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/E57Exception.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/E57Format.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/E57SimpleData.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/E57SimpleReader.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/E57SimpleWriter.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/E57XmlParser.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/Encoder.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/FloatNodeImpl.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/ImageFileImpl.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/IntegerNodeImpl.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/NodeImpl.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/Packet.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/ReaderImpl.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/ScaledIntegerNodeImpl.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/SectionHeaders.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/SourceDestBufferImpl.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/StringNodeImpl.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/StructureNodeImpl.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/VectorNodeImpl.cpp
+/home/runner/work/pye57/pye57/libE57Format/src/WriterImpl.cpp
 libE57Format/LICENSE.md
 libE57Format/README.md
 libE57Format/extern/CRCpp/LICENSE
@@ -77,4 +105,5 @@ src/pye57.egg-info/SOURCES.txt
 src/pye57.egg-info/dependency_links.txt
 src/pye57.egg-info/not-zip-safe
 src/pye57.egg-info/requires.txt
-src/pye57.egg-info/top_level.txt
+src/pye57.egg-info/top_level.txt
+tests/test_main.py

pye57-0.4.2/tests/test_main.py

@@ -0,0 +1,305 @@
+import pytest
+import os
+import time
+
+import numpy as np
+
+import pye57
+from pye57 import libe57
+from pye57.utils import get_fields
+
+try:
+    from exceptions import WindowsError
+except ImportError:
+    class WindowsError(OSError):
+        pass
+
+
+def test_hi():
+    assert libe57.__doc__
+
+
+def test_data(*args):
+    here = os.path.split(__file__)[0]
+    return os.path.join(here, "test_data", *args)
+
+
+def delete_retry(path):
+    try:
+        if os.path.exists(path):
+            os.remove(path)
+    except WindowsError:
+        time.sleep(0.1)
+        if os.path.exists(path):
+            os.remove(path)
+
+
+@pytest.fixture
+def e57_path():
+    return test_data("test.e57")
+
+@pytest.fixture
+def e57_spherical_path():
+    return test_data("testSpherical.e57")
+
+@pytest.fixture
+def temp_e57_write(request):
+    path = test_data("test_write.e57")
+    request.addfinalizer(lambda: delete_retry(path))
+    return path
+
+
+@pytest.fixture
+def image_and_points(e57_path):
+    f = libe57.ImageFile(e57_path, mode="r")
+    scan_0 = libe57.StructureNode(libe57.VectorNode(f.root().get("/data3D")).get(0))
+    points = libe57.CompressedVectorNode(scan_0.get("points"))
+    return f, points
+
+
+def test_constants():
+    assert libe57.CHECKSUM_POLICY_NONE == 0
+    assert libe57.CHECKSUM_POLICY_SPARSE == 25
+    assert libe57.CHECKSUM_POLICY_HALF == 50
+    assert libe57.CHECKSUM_POLICY_ALL == 100
+    assert libe57.E57_INT8_MIN == -128
+    assert libe57.E57_INT8_MAX == 127
+    assert libe57.E57_INT16_MIN == -32768
+    assert libe57.E57_INT16_MAX == 32767
+    assert libe57.E57_INT32_MIN == -2147483647 - 1
+    assert libe57.E57_INT32_MAX == 2147483647
+    assert libe57.E57_INT64_MIN == -9223372036854775807 - 1
+    assert libe57.E57_INT64_MAX == 9223372036854775807
+    assert libe57.E57_UINT8_MIN == 0
+    assert libe57.E57_UINT8_MAX == 255
+    assert libe57.E57_UINT16_MIN == 0
+    assert libe57.E57_UINT16_MAX == 65535
+    assert libe57.E57_UINT32_MIN == 0
+    assert libe57.E57_UINT32_MAX == 4294967295
+    assert libe57.E57_UINT64_MIN == 0
+    assert libe57.E57_UINT64_MAX == 18446744073709551615
+
+
+def test_open_imagefile(e57_path):
+    f = libe57.ImageFile(e57_path, mode="r")
+    assert f.isOpen()
+    f.close()
+
+
+def test_open_imagefile_write(temp_e57_write):
+    f = libe57.ImageFile(temp_e57_write, mode="w")
+    assert f.isOpen()
+    f.close()
+
+
+def test_e57_mode_error(temp_e57_write):
+    with pytest.raises(ValueError):
+        f = pye57.E57(temp_e57_write, mode="pasta")
+
+
+def test_get_structure_names(e57_path):
+    f = libe57.ImageFile(e57_path, "r")
+    root = f.root()
+    names = []
+    for id_ in range(root.childCount()):
+        names.append(root.get(id_).pathName())
+    assert names == ['/formatName', '/guid', '/versionMajor', '/versionMinor', '/e57LibraryVersion',
+                     '/coordinateMetadata', '/creationDateTime', '/data3D', '/images2D']
+
+
+def test_get_data3d_nodes(e57_path):
+    f = libe57.ImageFile(e57_path, "r")
+    root = f.root()
+    node = root.get("data3D")
+    data3d = libe57.VectorNode(node)
+    scan_count = data3d.childCount()
+    assert scan_count == 4
+    for scan_id in range(scan_count):
+        assert isinstance(data3d.get(scan_id), libe57.Node)
+
+
+def test_get_read_data3d(e57_path):
+    f = libe57.ImageFile(e57_path, "r")
+    scan_0 = libe57.StructureNode(libe57.VectorNode(f.root().get("/data3D")).get(0))
+    points = libe57.CompressedVectorNode(scan_0.get("points"))
+    assert points.childCount() == 281300
+
+
+def test_source_dest_buffers(e57_path):
+    f = libe57.ImageFile(e57_path, "r")
+    capacity = 1000
+    types = list("bBhHlLq?fd")
+    sizes = [1, 1, 2, 2, 4, 4, 8, 1, 4, 8]
+    buffers = libe57.VectorSourceDestBuffer()
+    for t in types:
+        data = np.zeros(capacity, t)
+        sdb = libe57.SourceDestBuffer(f, "something", data, capacity, True, True)
+        buffers.append(sdb)
+
+    for t, sdb, size, in zip(types, buffers, sizes):
+        assert sdb.pathName() == "something"
+        assert sdb.capacity() == capacity
+        assert sdb.stride() == size
+        assert sdb.doScaling()
+        assert sdb.doConversion()
+
+
+def test_unsupported_point_field(temp_e57_write):
+    with pye57.E57(temp_e57_write, mode="w") as f:
+        with pytest.raises(ValueError):
+            data = {"cartesianX": np.random.rand(10),
+                    "bananas": np.random.rand(10)}
+            f.write_scan_raw(data)
+
+
+def test_source_dest_buffers_raises(e57_path):
+    f = libe57.ImageFile(e57_path, "r")
+    capacity = 1000
+    data = np.zeros(capacity, "i")
+    with pytest.raises(ValueError):
+        libe57.SourceDestBuffer(f, "something", data, capacity, True, True)
+
+
+def test_read_points_x(image_and_points):
+    imf, points = image_and_points
+    bufs = libe57.VectorSourceDestBuffer()
+    capacity = 10000
+    X = np.zeros(capacity, "f")
+    bufs.append(libe57.SourceDestBuffer(imf, "cartesianX", X, capacity, True, True))
+    data_reader = points.reader(bufs)
+    size = data_reader.read()
+    assert size == capacity
+    assert not np.all(np.zeros(capacity, "f") == X)
+
+
+def test_index_out_of_range(e57_path):
+    f = libe57.ImageFile(e57_path, "r")
+    with pytest.raises(IndexError):
+        scan = f.root()["data3D"][-1]
+    with pytest.raises(IndexError):
+        scan = f.root()["data3D"][5]
+    scan_0 = f.root()["data3D"][0]
+    with pytest.raises(IndexError):
+        r = scan_0["pose"]["rotation"][-1]
+    with pytest.raises(IndexError):
+        r = scan_0["pose"]["rotation"][5]
+
+
+def test_read_header(e57_path):
+    f = libe57.ImageFile(e57_path, "r")
+    data3d = f.root()["data3D"]
+    headers = pye57.ScanHeader.from_data3d(data3d)
+    fields = ['cartesianX', 'cartesianY', 'cartesianZ', 'intensity', 'rowIndex', 'columnIndex', 'cartesianInvalidState']
+    for header in headers:
+        assert fields == header.point_fields
+    assert headers[0].pretty_print()
+    scan_0_rot = [[-0.4443, 0.8958, 0.],
+                  [-0.8958, -0.4443, 0.],
+                  [0., 0., 1.]]
+    assert np.allclose(scan_0_rot, headers[0].rotation_matrix, atol=1e-3)
+    scan_0_tra = [301336.23199, 5042597.23676, 15.46649]
+    assert np.allclose(scan_0_tra, headers[0].translation)
+
+
+def test_read_xyz(e57_path):
+    e57 = pye57.E57(e57_path)
+    xyz = e57.read_scan(0)
+    assert np.any(xyz)
+
+
+def test_read_header_spherical(e57_spherical_path):
+    f = libe57.ImageFile(e57_spherical_path, "r")
+    data3d = f.root()["data3D"]
+    headers = pye57.ScanHeader.from_data3d(data3d)
+    fields = ['sphericalRange', 'sphericalAzimuth', 'sphericalElevation', 'intensity', 'colorRed', 'colorGreen', 'colorBlue', 'sphericalInvalidState']
+    for header in headers:
+        assert fields == header.point_fields
+    assert headers[0].pretty_print()
+
+
+def test_read_xyz_spherical(e57_spherical_path):
+    e57 = pye57.E57(e57_spherical_path)
+    xyz = e57.read_scan(0)
+    assert np.any(xyz)
+    
+
+def test_read_raw(e57_path):
+    e57 = pye57.E57(e57_path)
+    header = e57.get_header(0)
+    fields = header.point_fields
+    data = e57.read_scan_raw(0)
+    assert sorted(fields) == sorted(data.keys())
+    assert np.any(data["cartesianX"])
+    assert len(data["cartesianX"]) == header.point_count
+
+
+def test_read_write_single_scan(e57_path, temp_e57_write):
+    e57 = pye57.E57(e57_path)
+    header_source = e57.get_header(0)
+    with pye57.E57(temp_e57_write, mode="w") as e57_write:
+        raw_data_0 = e57.read_scan_raw(0)
+        e57_write.write_scan_raw(raw_data_0, rotation=header_source.rotation, translation=header_source.translation)
+    scan_0 = pye57.E57(e57_path).read_scan_raw(0)
+    written = pye57.E57(temp_e57_write)
+    header = written.get_header(0)
+    assert np.allclose(header.rotation, header_source.rotation)
+    assert np.allclose(header.translation, header_source.translation)
+    scan_0_written = written.read_scan_raw(0)
+    fields = "cartesianX cartesianY cartesianZ intensity rowIndex columnIndex cartesianInvalidState".split()
+    for field in fields:
+        assert np.allclose(scan_0[field], scan_0_written[field])
+
+    scan_0 = e57.read_scan(0)
+    scan_0_written = written.read_scan(0)
+    for field in scan_0:
+        assert np.allclose(scan_0[field], scan_0_written[field])
+
+
+def test_copy_file(e57_path, temp_e57_write):
+    e57 = pye57.E57(e57_path)
+    with pye57.E57(temp_e57_write, mode="w") as f:
+        for scan_id in range(e57.scan_count):
+            header = e57.get_header(scan_id)
+            data = e57.read_scan_raw(scan_id)
+            f.write_scan_raw(data, scan_header=header)
+            header_written = f.get_header(scan_id)
+            assert header_written.guid
+            assert header_written.temperature == header_written.temperature
+            assert header_written.relativeHumidity == header_written.relativeHumidity
+            assert header_written.atmosphericPressure == header_written.atmosphericPressure
+            assert header_written.rowMinimum == header.rowMinimum
+            assert header_written.rowMaximum == header.rowMaximum
+            assert header_written.columnMinimum == header.columnMinimum
+            assert header_written.columnMaximum == header.columnMaximum
+            assert header_written.returnMinimum == header.returnMinimum
+            assert header_written.returnMaximum == header.returnMaximum
+            assert header_written.intensityMinimum == header.intensityMinimum
+            assert header_written.intensityMaximum == header.intensityMaximum
+            assert header_written.xMinimum == header.xMinimum
+            assert header_written.xMaximum == header.xMaximum
+            assert header_written.yMinimum == header.yMinimum
+            assert header_written.yMaximum == header.yMaximum
+            assert header_written.zMinimum == header.zMinimum
+            assert header_written.zMaximum == header.zMaximum
+            assert np.allclose(header_written.rotation, header.rotation)
+            assert np.allclose(header_written.translation, header.translation)
+            assert header_written.acquisitionStart_dateTimeValue == header.acquisitionStart_dateTimeValue
+            assert header_written.acquisitionStart_isAtomicClockReferenced == header.acquisitionStart_isAtomicClockReferenced
+            assert header_written.acquisitionEnd_dateTimeValue == header.acquisitionEnd_dateTimeValue
+            assert header_written.acquisitionEnd_isAtomicClockReferenced == header.acquisitionEnd_isAtomicClockReferenced
+            # todo: point groups
+            # header.pointGroupingSchemes["groupingByLine"]["idElementName"].value()
+            # header.pointGroupingSchemes["groupingByLine"]["groups"]
+
+        assert f.scan_count == e57.scan_count
+
+
+def test_read_color_absent(e57_path):
+    e57 = pye57.E57(e57_path)
+    with pytest.raises(ValueError):
+        data = e57.read_scan(0, colors=True)
+
+
+def test_scan_position(e57_path):
+    e57 = pye57.E57(e57_path)
+    assert np.allclose(e57.scan_position(3), np.array([[3.01323456e+05, 5.04260184e+06, 1.56040279e+01]]))

pye57-0.3.1/src/pye57/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.3.1"

pye57-0.3.1/src/pye57/utils.py

@@ -1,21 +0,0 @@
-from pye57 import libe57
-from pye57.libe57 import NodeType
-
-
-def get_fields(node):
-    return [node.get(id_).elementName() for id_ in range(node.childCount())]
-
-
-def get_node(node, name):
-    cast = {
-        NodeType.E57_BLOB: libe57.BlobNode,
-        NodeType.E57_COMPRESSED_VECTOR: libe57.CompressedVectorNode,
-        NodeType.E57_FLOAT: libe57.FloatNode,
-        NodeType.E57_INTEGER: libe57.IntegerNode,
-        NodeType.E57_SCALED_INTEGER: libe57.ScaledIntegerNode,
-        NodeType.E57_STRING: libe57.StringNode,
-        NodeType.E57_STRUCTURE: libe57.StructureNode,
-        NodeType.E57_VECTOR: libe57.VectorNode
-    }
-    n = node.get(name)
-    return cast[n.type()](n)