pye57 0.4.19__cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl

pye57/__init__.py

@@ -0,0 +1,3 @@
+from pye57 import libe57
+from pye57.scan_header import ScanHeader
+from pye57.e57 import E57

pye57/__version__.py

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

pye57/e57.py

@@ -0,0 +1,438 @@
+import uuid
+import os
+from typing import Dict
+from enum import Enum
+
+import numpy as np
+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
+except ImportError:
+    class WindowsError(OSError):
+        pass
+
+
+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",
+    "colorBlue": "B",
+    "rowIndex": "H",
+    "columnIndex": "H",
+    "cartesianInvalidState": "b",
+    "sphericalInvalidState": "b",
+}
+
+
+class E57:
+    def __init__(self, path, mode="r"):
+        if mode not in "rw":
+            raise ValueError("Only 'r' and 'w' modes are supported")
+        self.path = path
+        try:
+            self.image_file = libe57.ImageFile(path, mode)
+            if mode == "w":
+                self.write_default_header()
+        except Exception as e:
+            try:
+                self.image_file.close()
+                os.remove(path)
+            except (AttributeError, WindowsError, PermissionError):
+                pass
+            raise e
+
+    def __del__(self):
+        self.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def close(self):
+        if hasattr(self, "image_file"):
+            self.image_file.close()
+
+    @property
+    def root(self):
+        return self.image_file.root()
+
+    @property
+    def data3d(self):
+        return self.root["data3D"]
+
+    @property
+    def scan_count(self):
+        return len(self.data3d)
+
+    def get_header(self, index):
+        return ScanHeader(self.data3d[index])
+
+    def write_default_header(self):
+        imf = self.image_file
+        imf.extensionsAdd("", libe57.E57_V1_0_URI)
+        self.root.set("formatName", libe57.StringNode(imf, "ASTM E57 3D Imaging Data File"))
+        self.root.set("guid", libe57.StringNode(imf, "{%s}" % uuid.uuid4()))
+        self.root.set("versionMajor", libe57.IntegerNode(imf, libe57.E57_FORMAT_MAJOR))
+        self.root.set("versionMinor", libe57.IntegerNode(imf, libe57.E57_FORMAT_MINOR))
+        self.root.set("e57LibraryVersion", libe57.StringNode(imf, libe57.E57_LIBRARY_ID))
+        self.root.set("coordinateMetadata", libe57.StringNode(imf, ""))
+        creation_date_time = libe57.StructureNode(imf)
+        creation_date_time.set("dateTimeValue", libe57.FloatNode(imf, 0.0))
+        creation_date_time.set("isAtomicClockReferenced", libe57.IntegerNode(imf, 0))
+        self.root.set("creationDateTime", creation_date_time)
+        self.root.set("data3D", libe57.VectorNode(imf, True))
+        self.root.set("images2D", libe57.VectorNode(imf, True))
+
+    def make_buffer(self, field_name, capacity, do_conversion=True, do_scaling=True):
+        # now this exception should never get hit through read_scan or read_scan_raw
+        # for read_scan, the headers are constructed, so they should all be supported
+        # for read_scan_raw, it now filters out the unsupported headers
+        # however, if make_buffer or make_buffers gets called, an unsupported field name could be passed in directly
+        # if we don't want users calling them, maybe we could make them private, and this would be an assertion
+        if field_name not in SUPPORTED_POINT_FIELDS:
+            raise ValueError("Unsupported point field: %s" % field_name)
+
+        np_array = np.empty(capacity, SUPPORTED_POINT_FIELDS[field_name])
+        buffer = libe57.SourceDestBuffer(self.image_file,
+                                         field_name,
+                                         np_array,
+                                         capacity,
+                                         do_conversion,
+                                         do_scaling)
+        return np_array, buffer
+
+    def make_buffers(self, field_names, capacity, do_conversion=True, do_scaling=True):
+        data = {}
+        buffers = libe57.VectorSourceDestBuffer()
+        for field in field_names:
+            d, b = self.make_buffer(field, capacity, do_conversion=do_conversion, do_scaling=do_scaling)
+            data[field] = d
+            buffers.append(b)
+        return data, buffers
+
+    def read_scan_raw(self, index, ignore_unsupported_fields=False) -> Dict:
+        header = self.get_header(index)
+        supported_point_fields = []
+        unsupported_point_fields = []
+        for field in header.point_fields:
+            if field in SUPPORTED_POINT_FIELDS:
+                supported_point_fields.append(field)
+            else:
+                unsupported_point_fields.append(field)
+        if unsupported_point_fields != [] and not ignore_unsupported_fields:
+            raise ValueError("Unsupported point fields: %s.\n"
+                            "Consider using 'ignore_unsupported_fields' to skip them." % unsupported_point_fields)
+        # could it call make_buffers instead, it looks like the code's identical
+        data = {}
+        buffers = libe57.VectorSourceDestBuffer()
+        for field in supported_point_fields:
+            np_array, buffer = self.make_buffer(field, header.point_count)
+            data[field] = np_array
+            buffers.append(buffer)
+
+        header.points.reader(buffers).read()
+
+        return data
+
+    def scan_position(self, index):
+        pt = np.array([[0, 0, 0]])
+        header = self.get_header(index)
+        return self.to_global(pt, header.rotation, header.translation)
+
+    @staticmethod
+    def to_global(points, rotation, translation):
+        rotation_matrix = Quaternion(rotation).rotation_matrix
+        return (np.dot(rotation_matrix, points.T) + translation.reshape(3, 1)).T
+
+    def read_scan(self,
+                  index,
+                  *,
+                  intensity=False,
+                  colors=False,
+                  row_column=False,
+                  transform=True,
+                  ignore_missing_fields=False) -> Dict:
+        header = self.get_header(index)
+        n_points = header.point_count
+
+        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:
+            fields.append("colorRed")
+            fields.append("colorGreen")
+            fields.append("colorBlue")
+        if row_column:
+            fields.append("rowIndex")
+            fields.append("columnIndex")
+        fields.append(validState)
+
+        for field in fields[:]:
+            if field not in header.point_fields:
+                if ignore_missing_fields:
+                    fields.remove(field)
+                else:
+                    raise ValueError("Requested to read a field (%s) with is absent from the e57 file. "
+                                     "Consider using 'ignore_missing_fields' to skip it." % field)
+
+        data, buffers = self.make_buffers(fields, n_points)
+        header.points.reader(buffers).read()
+
+        if validState in data:
+            valid = ~data[validState].astype("?")
+
+            for field in data:
+                data[field] = data[field][valid]
+
+            del data[validState]
+
+        if transform:
+            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):
+        for field in data.keys():
+            if field not in SUPPORTED_POINT_FIELDS:
+                raise ValueError("Unsupported point field: %s" % field)
+
+        if rotation is None:
+            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]))
+
+        if name is None:
+            name = getattr(scan_header, "name", "Scan %s" % len(self.data3d))
+
+        temperature = getattr(scan_header, "temperature", 0)
+        relativeHumidity = getattr(scan_header, "relativeHumidity", 0)
+        atmosphericPressure = getattr(scan_header, "atmosphericPressure", 0)
+
+        scan_node = libe57.StructureNode(self.image_file)
+        scan_node.set("guid", libe57.StringNode(self.image_file, "{%s}" % uuid.uuid4()))
+        scan_node.set("name", libe57.StringNode(self.image_file, name))
+        scan_node.set("temperature", libe57.FloatNode(self.image_file, temperature))
+        scan_node.set("relativeHumidity", libe57.FloatNode(self.image_file, relativeHumidity))
+        scan_node.set("atmosphericPressure", libe57.FloatNode(self.image_file, atmosphericPressure))
+        scan_node.set("description", libe57.StringNode(self.image_file, "pye57 v%s" % __version__))
+
+        n_points = data["cartesianX"].shape[0]
+
+        ibox = libe57.StructureNode(self.image_file)
+        if "rowIndex" in data and "columnIndex" in data:
+            min_row = np.min(data["rowIndex"])
+            max_row = np.max(data["rowIndex"])
+            min_col = np.min(data["columnIndex"])
+            max_col = np.max(data["columnIndex"])
+            ibox.set("rowMinimum", libe57.IntegerNode(self.image_file, min_row))
+            ibox.set("rowMaximum", libe57.IntegerNode(self.image_file, max_row))
+            ibox.set("columnMinimum", libe57.IntegerNode(self.image_file, min_col))
+            ibox.set("columnMaximum", libe57.IntegerNode(self.image_file, max_col))
+        else:
+            ibox.set("rowMinimum", libe57.IntegerNode(self.image_file, 0))
+            ibox.set("rowMaximum", libe57.IntegerNode(self.image_file, n_points - 1))
+            ibox.set("columnMinimum", libe57.IntegerNode(self.image_file, 0))
+            ibox.set("columnMaximum", libe57.IntegerNode(self.image_file, 0))
+        ibox.set("returnMinimum", libe57.IntegerNode(self.image_file, 0))
+        ibox.set("returnMaximum", libe57.IntegerNode(self.image_file, 0))
+        scan_node.set("indexBounds", ibox)
+
+        if "intensity" in data:
+            int_min = getattr(scan_header, "intensityMinimum", np.min(data["intensity"]))
+            int_max = getattr(scan_header, "intensityMaximum", np.max(data["intensity"]))
+            intbox = libe57.StructureNode(self.image_file)
+            intbox.set("intensityMinimum", libe57.FloatNode(self.image_file, int_min))
+            intbox.set("intensityMaximum", libe57.FloatNode(self.image_file, int_max))
+            scan_node.set("intensityLimits", intbox)
+
+        color = all(c in data for c in ["colorRed", "colorGreen", "colorBlue"])
+        if color:
+            colorbox = libe57.StructureNode(self.image_file)
+            colorbox.set("colorRedMinimum", libe57.IntegerNode(self.image_file, 0))
+            colorbox.set("colorRedMaximum", libe57.IntegerNode(self.image_file, 255))
+            colorbox.set("colorGreenMinimum", libe57.IntegerNode(self.image_file, 0))
+            colorbox.set("colorGreenMaximum", libe57.IntegerNode(self.image_file, 255))
+            colorbox.set("colorBlueMinimum", libe57.IntegerNode(self.image_file, 0))
+            colorbox.set("colorBlueMaximum", libe57.IntegerNode(self.image_file, 255))
+            scan_node.set("colorLimits", colorbox)
+
+        bbox_node = libe57.StructureNode(self.image_file)
+        x, y, z = data["cartesianX"], data["cartesianY"], data["cartesianZ"]
+        valid = None
+        if "cartesianInvalidState" in data:
+            valid = ~data["cartesianInvalidState"].astype("?")
+            x, y, z = x[valid], y[valid], z[valid]
+        bb_min = np.array([x.min(), y.min(), z.min()])
+        bb_max = np.array([x.max(), y.max(), z.max()])
+        del valid, x, y, z
+
+        if scan_header is not None:
+            bb_min_scaled = np.array([scan_header.xMinimum, scan_header.yMinimum, scan_header.zMinimum])
+            bb_max_scaled = np.array([scan_header.xMaximum, scan_header.yMaximum, scan_header.zMaximum])
+        else:
+            bb_min_scaled = self.to_global(bb_min.reshape(-1, 3), rotation, translation)[0]
+            bb_max_scaled = self.to_global(bb_max.reshape(-1, 3), rotation, translation)[0]
+
+        bbox_node.set("xMinimum", libe57.FloatNode(self.image_file, bb_min_scaled[0]))
+        bbox_node.set("xMaximum", libe57.FloatNode(self.image_file, bb_max_scaled[0]))
+        bbox_node.set("yMinimum", libe57.FloatNode(self.image_file, bb_min_scaled[1]))
+        bbox_node.set("yMaximum", libe57.FloatNode(self.image_file, bb_max_scaled[1]))
+        bbox_node.set("zMinimum", libe57.FloatNode(self.image_file, bb_min_scaled[2]))
+        bbox_node.set("zMaximum", libe57.FloatNode(self.image_file, bb_max_scaled[2]))
+        scan_node.set("cartesianBounds", bbox_node)
+
+        if rotation is not None and translation is not None:
+            pose_node = libe57.StructureNode(self.image_file)
+            scan_node.set("pose", pose_node)
+            rotation_node = libe57.StructureNode(self.image_file)
+            rotation_node.set("w", libe57.FloatNode(self.image_file, rotation[0]))
+            rotation_node.set("x", libe57.FloatNode(self.image_file, rotation[1]))
+            rotation_node.set("y", libe57.FloatNode(self.image_file, rotation[2]))
+            rotation_node.set("z", libe57.FloatNode(self.image_file, rotation[3]))
+            pose_node.set("rotation", rotation_node)
+            translation_node = libe57.StructureNode(self.image_file)
+            translation_node.set("x", libe57.FloatNode(self.image_file, translation[0]))
+            translation_node.set("y", libe57.FloatNode(self.image_file, translation[1]))
+            translation_node.set("z", libe57.FloatNode(self.image_file, translation[2]))
+            pose_node.set("translation", translation_node)
+
+        start_datetime = getattr(scan_header, "acquisitionStart_dateTimeValue", 0)
+        start_atomic = getattr(scan_header, "acquisitionStart_isAtomicClockReferenced", False)
+        end_datetime = getattr(scan_header, "acquisitionEnd_dateTimeValue", 0)
+        end_atomic = getattr(scan_header, "acquisitionEnd_isAtomicClockReferenced", False)
+        acquisition_start = libe57.StructureNode(self.image_file)
+        scan_node.set("acquisitionStart", acquisition_start)
+        acquisition_start.set("dateTimeValue", libe57.FloatNode(self.image_file, start_datetime))
+        acquisition_start.set("isAtomicClockReferenced", libe57.IntegerNode(self.image_file, start_atomic))
+        acquisition_end = libe57.StructureNode(self.image_file)
+        scan_node.set("acquisitionEnd", acquisition_end)
+        acquisition_end.set("dateTimeValue", libe57.FloatNode(self.image_file, end_datetime))
+        acquisition_end.set("isAtomicClockReferenced", libe57.IntegerNode(self.image_file, end_atomic))
+
+        # todo: pointGroupingSchemes
+
+        points_prototype = libe57.StructureNode(self.image_file)
+
+        is_scaled = False
+        precision = libe57.E57_DOUBLE if is_scaled else libe57.E57_SINGLE
+
+        center = (bb_max + bb_min) / 2
+
+        chunk_size = 5000000
+
+        x_node = libe57.FloatNode(self.image_file, center[0], precision, bb_min[0], bb_max[0])
+        y_node = libe57.FloatNode(self.image_file, center[1], precision, bb_min[1], bb_max[1])
+        z_node = libe57.FloatNode(self.image_file, center[2], precision, bb_min[2], bb_max[2])
+        points_prototype.set("cartesianX", x_node)
+        points_prototype.set("cartesianY", y_node)
+        points_prototype.set("cartesianZ", z_node)
+
+        field_names = ["cartesianX", "cartesianY", "cartesianZ"]
+
+        if "intensity" in data:
+            intensity_min = np.min(data["intensity"])
+            intensity_max = np.max(data["intensity"])
+            intensity_node = libe57.FloatNode(self.image_file, intensity_min, precision, intensity_min, intensity_max)
+            points_prototype.set("intensity", intensity_node)
+            field_names.append("intensity")
+
+        if all(color in data for color in ["colorRed", "colorGreen", "colorBlue"]):
+            points_prototype.set("colorRed", libe57.IntegerNode(self.image_file, 0, 0, 255))
+            points_prototype.set("colorGreen", libe57.IntegerNode(self.image_file, 0, 0, 255))
+            points_prototype.set("colorBlue", libe57.IntegerNode(self.image_file, 0, 0, 255))
+            field_names.append("colorRed")
+            field_names.append("colorGreen")
+            field_names.append("colorBlue")
+
+        if "rowIndex" in data and "columnIndex" in data:
+            min_row = np.min(data["rowIndex"])
+            max_row = np.max(data["rowIndex"])
+            min_col = np.min(data["columnIndex"])
+            max_col = np.max(data["columnIndex"])
+            points_prototype.set("rowIndex", libe57.IntegerNode(self.image_file, min_row, min_row, max_row))
+            field_names.append("rowIndex")
+            points_prototype.set("columnIndex", libe57.IntegerNode(self.image_file, min_col, min_col, max_col))
+            field_names.append("columnIndex")
+
+        if "cartesianInvalidState" in data:
+            min_state = np.min(data["cartesianInvalidState"])
+            max_state = np.max(data["cartesianInvalidState"])
+            points_prototype.set("cartesianInvalidState", libe57.IntegerNode(self.image_file, 0, min_state, max_state))
+            field_names.append("cartesianInvalidState")
+
+        # other fields
+        # // "sphericalRange"
+        # // "sphericalAzimuth"
+        # // "sphericalElevation"
+        # // "timeStamp"
+        # // "sphericalInvalidState"
+        # // "isColorInvalid"
+        # // "isIntensityInvalid"
+        # // "isTimeStampInvalid"
+
+        arrays, buffers = self.make_buffers(field_names, chunk_size)
+
+        codecs = libe57.VectorNode(self.image_file, True)
+        points = libe57.CompressedVectorNode(self.image_file, points_prototype, codecs)
+        scan_node.set("points", points)
+
+        self.data3d.append(scan_node)
+
+        writer = points.writer(buffers)
+
+        current_index = 0
+        while current_index != n_points:
+            current_chunk = min(n_points - current_index, chunk_size)
+
+            for type_ in SUPPORTED_POINT_FIELDS:
+                if type_ in arrays:
+                    arrays[type_][:current_chunk] = data[type_][current_index:current_index + current_chunk]
+
+            writer.write(current_chunk)
+
+            current_index += current_chunk
+
+        writer.close()

pye57/exception.py

@@ -0,0 +1,4 @@
+
+
+class PyE57Exception(BaseException):
+    pass

pye57/scan_header.py

@@ -0,0 +1,227 @@
+import numpy as np
+from pyquaternion import Quaternion
+
+from pye57 import libe57
+from pye57.utils import get_fields, get_node
+
+class ScanHeader:
+    """Provides summary statistics for an individual lidar scan in an E57 file.
+
+    Including the number of points, bounds and pose of the scan.
+    """
+    def __init__(self, scan_node):
+        self.node = scan_node
+        points = self.node["points"]
+        self.point_fields = get_fields(libe57.StructureNode(points.prototype()))
+        self.scan_fields = get_fields(self.node)
+
+    @classmethod
+    def from_data3d(cls, data3d):
+        return [cls(scan) for scan in data3d]
+
+    def has_pose(self):
+        return self.node.isDefined("pose")
+
+    @property
+    def point_count(self):
+        return self.points.childCount()
+
+    @property
+    def rotation_matrix(self) -> np.array:
+        try:
+            rotation = self.node["pose"]["rotation"]
+            q = Quaternion([e.value() for e in rotation])
+        except libe57.E57Exception:
+            q = Quaternion()
+        return q.rotation_matrix
+
+    @property
+    def rotation(self) -> np.array:
+        try:
+            rotation = self.node["pose"]["rotation"]
+            q = Quaternion([e.value() for e in rotation])
+        except libe57.E57Exception:
+            q = Quaternion()
+        return q.elements
+
+    @property
+    def translation(self):
+        try:
+            translation_values = [e.value() for e in self.node["pose"]["translation"]]
+        except libe57.E57Exception:
+            translation_values = [0] * 3
+        return np.array(translation_values)
+
+    def pretty_print(self, node=None, indent=""):
+        if node is None:
+            node = self.node
+        lines = []
+        for field in get_fields(node):
+            child_node = node[field]
+            value = ""
+            if hasattr(child_node, "value"):
+                value = ": %s" % child_node.value()
+            lines.append(indent + str(child_node) + value)
+            if isinstance(child_node, libe57.StructureNode):
+                lines += self.pretty_print(child_node, indent + "    ")
+        return lines
+
+    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):
+        return self["guid"].value()
+
+    @property
+    def temperature(self):
+        return self["temperature"].value()
+
+    @property
+    def relativeHumidity(self):
+        return self["relativeHumidity"].value()
+
+    @property
+    def atmosphericPressure(self):
+        return self["atmosphericPressure"].value()
+
+    @property
+    def indexBounds(self):
+        return self["indexBounds"]
+
+    @property
+    def rowMinimum(self):
+        return self.indexBounds["rowMinimum"].value()
+
+    @property
+    def rowMaximum(self):
+        return self.indexBounds["rowMaximum"].value()
+
+    @property
+    def columnMinimum(self):
+        return self.indexBounds["columnMinimum"].value()
+
+    @property
+    def columnMaximum(self):
+        return self.indexBounds["columnMaximum"].value()
+
+    @property
+    def returnMinimum(self):
+        return self.indexBounds["returnMinimum"].value()
+
+    @property
+    def returnMaximum(self):
+        return self.indexBounds["returnMaximum"].value()
+
+    @property
+    def intensityLimits(self):
+        return self["intensityLimits"]
+
+    @property
+    def intensityMinimum(self):
+        return self.intensityLimits["intensityMinimum"].value()
+
+    @property
+    def intensityMaximum(self):
+        return self.intensityLimits["intensityMaximum"].value()
+
+    @property
+    def cartesianBounds(self):
+        return self["cartesianBounds"]
+
+    @property
+    def xMinimum(self):
+        return self.cartesianBounds["xMinimum"].value()
+
+    @property
+    def xMaximum(self):
+        return self.cartesianBounds["xMaximum"].value()
+
+    @property
+    def yMinimum(self):
+        return self.cartesianBounds["yMinimum"].value()
+
+    @property
+    def yMaximum(self):
+        return self.cartesianBounds["yMaximum"].value()
+
+    @property
+    def zMinimum(self):
+        return self.cartesianBounds["zMinimum"].value()
+
+    @property
+    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"]
+
+    @property
+    def acquisitionStart(self):
+        return self["acquisitionStart"]
+
+    @property
+    def acquisitionStart_dateTimeValue(self):
+        return self.acquisitionStart["dateTimeValue"].value()
+
+    @property
+    def acquisitionStart_isAtomicClockReferenced(self):
+        return self.acquisitionStart["isAtomicClockReferenced"].value()
+
+    @property
+    def acquisitionEnd(self):
+        return self["acquisitionEnd"]
+
+    @property
+    def acquisitionEnd_dateTimeValue(self):
+        return self.acquisitionEnd["dateTimeValue"].value()
+
+    @property
+    def acquisitionEnd_isAtomicClockReferenced(self):
+        return self.acquisitionEnd["isAtomicClockReferenced"].value()
+
+    @property
+    def pointGroupingSchemes(self):
+        return self["pointGroupingSchemes"]
+
+    @property
+    def points(self):
+        return self["points"]

pye57/utils.py

@@ -0,0 +1,117 @@
+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)
+
+
+def copy_node(node, dest_image):
+    compressed_node_pairs = []
+    blob_node_pairs = []
+
+    out_node = None
+    # 'Element' Types
+    if (isinstance(node, libe57.FloatNode)):
+        out_node = libe57.FloatNode(
+            dest_image,
+            value=node.value(),
+            precision=node.precision(),
+            minimum=node.minimum(),
+            maximum=node.maximum())
+
+    elif (isinstance(node, libe57.IntegerNode)):
+        out_node = libe57.IntegerNode(
+            dest_image,
+            value=node.value(),
+            minimum=node.minimum(),
+            maximum=node.maximum())
+
+    elif (isinstance(node, libe57.ScaledIntegerNode)):
+        out_node = libe57.ScaledIntegerNode(
+            dest_image,
+            node.rawValue(),
+            minimum=node.minimum(),
+            maximum=node.maximum(),
+            scale=node.scale(),
+            offset=node.offset())
+
+    elif (isinstance(node, libe57.StringNode)):
+        out_node = libe57.StringNode(
+            dest_image,
+            node.value())
+
+    elif (isinstance(node, libe57.BlobNode)):
+        out_node = libe57.BlobNode(dest_image, node.byteCount())
+        blob_node_pairs.append({ 'in': node, 'out': out_node })
+
+    # 'Container' Types
+    elif (isinstance(node, libe57.CompressedVectorNode)):
+        in_prototype = libe57.StructureNode(node.prototype())
+        out_prototype, _, _  = copy_node(in_prototype, dest_image)
+        out_codecs, _, _ = copy_node(node.codecs(), dest_image)
+
+        out_node = libe57.CompressedVectorNode(dest_image, out_prototype, out_codecs)
+
+        compressed_node_pairs.append({
+            'in': node,
+            'out': out_node
+        })
+
+    elif isinstance(node, libe57.StructureNode):
+        out_node = libe57.StructureNode(dest_image)
+        for i in range(node.childCount()):
+            in_child = get_node(node, i)
+            in_child_name = in_child.elementName()
+            out_child, out_child_compressed_node_pairs, out_child_blob_node_pairs = copy_node(in_child, dest_image)
+
+            out_node.set(in_child_name, out_child)
+            compressed_node_pairs.extend(out_child_compressed_node_pairs)
+            blob_node_pairs.extend(out_child_blob_node_pairs)
+
+    elif isinstance(node, libe57.VectorNode):
+        out_node = libe57.VectorNode(dest_image, allowHeteroChildren=node.allowHeteroChildren())
+        for i in range(node.childCount()):
+            in_child = get_node(node, i)
+            in_child_name = f'{i}'
+            out_child, out_child_compressed_node_pairs, out_child_blob_node_pairs = copy_node(in_child, dest_image)
+
+            out_node.append(out_child)
+            compressed_node_pairs.extend(out_child_compressed_node_pairs)
+            blob_node_pairs.extend(out_child_blob_node_pairs)
+
+    return out_node, compressed_node_pairs, blob_node_pairs

pye57-0.4.19.dist-info/METADATA

@@ -0,0 +1,166 @@
+Metadata-Version: 2.4
+Name: pye57
+Version: 0.4.19
+Summary: Python .e57 files reader/writer
+Home-page: https://www.github.com/davidcaron/pye57
+Author: David Caron
+Author-email: dcaron05@gmail.com
+Maintainer: Graham Knapp
+Maintainer-email: graham.knapp@gmail.com
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+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 :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pyquaternion
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: maintainer
+Dynamic: maintainer-email
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+# 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
+with pye57.E57("e57_file_write.e57", mode='w') as e57_write:
+    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
+
+On linux, Windows or Apple Silicon:
+
+`python -m pip install pye57`
+
+On macOS with Intel CPU you can try to build from source (advanced users):
+
+## Building from source (for developers)
+
+### Cloning the repository with required submodule
+
+Clone a new repository along with the libe57Format submodule
+
+`git clone https://github.com/davidcaron/pye57.git --recursive`
+
+If the repository has already been previously cloned, but without the --recursive flag
+
+```Bash
+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`
+
+### Dependencies on MacOS
+
+To get xerces-c, run:
+
+`bash ./scripts/install_xerces_c.sh`
+
+### Run `pip install` from the repo source
+
+```Bash
+cd pye57
+python -m pip install .
+```
+
+### Uninstalling
+
+Use pip again
+
+```Bash
+python -m pip uninstall pye57
+```

pye57-0.4.19.dist-info/RECORD

@@ -0,0 +1,13 @@
+pye57/__init__.py,sha256=p-yo66Eblp6mIVKaupuS1E3BQGCNZrI96ApqoFusOi8,92
+pye57/__version__.py,sha256=mfToEOXd_f_mFG0ts1iWNTvKhsjPQqwRFaAmcx61xJo,23
+pye57/e57.py,sha256=iW8gC3N_4KFsYJtBDrSci7sl4VgO0p8eg9sv0AlMA6U,19674
+pye57/exception.py,sha256=hjNBnDf-PJrBLU7E8aAlWll0aovVITwjJoN9ex4Lx3o,47
+pye57/libe57.cpython-312-x86_64-linux-gnu.so,sha256=gpeASmLyKlNhNgskdzpnWpybJePubeYs369RrYwcUag,34329377
+pye57/scan_header.py,sha256=5L9gexIEob94UsDQdNd3cBYn745mbMVQwK4MhTCopqY,6349
+pye57/utils.py,sha256=LvBz7-LW3E9WNGu7c2aurqrXi-iCdorY-VLAEcTKGbU,4181
+pye57.libs/libxerces-c-3-252602d7.2.so,sha256=SfneBo9MezKlqkb-Bnkopuf_A9cqfgFtsdWTEswL9TQ,27006257
+pye57-0.4.19.dist-info/METADATA,sha256=Rk9fVBrgWOHq9ftuM0S-IlSaZiCR0alYOvoD93okmfU,4783
+pye57-0.4.19.dist-info/WHEEL,sha256=1crAxrAH5rUbvWUY1UR0ly3o7KnT1jo0_98V8RY5-FM,152
+pye57-0.4.19.dist-info/top_level.txt,sha256=xD9HDzQ3BfGMuz1kI2uNKUR0KXcR-RtNEKigrkh48Nk,6
+pye57-0.4.19.dist-info/RECORD,,
+pye57-0.4.19.dist-info/licenses/LICENSE,sha256=fk66gXDC1OVruix0TJ6tGGH6vaP_VOzBPETZ3xxnMsY,1050

pye57-0.4.19.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp312-cp312-manylinux_2_27_x86_64
+Tag: cp312-cp312-manylinux_2_28_x86_64
+

pye57-0.4.19.dist-info/licenses/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2018 David Caron
+
+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.

pye57-0.4.19.dist-info/top_level.txt

@@ -0,0 +1 @@
+pye57