Source code for laspy.point.record

""" Contains the classes that manages Las PointRecords
Las PointRecords are represented using Numpy's structured arrays,
The PointRecord classes provide a few extra things to manage these arrays
in the context of Las point data
"""
import logging
from copy import deepcopy
from enum import Enum, auto
from typing import Optional

import numpy as np

from ..point import PointFormat
from . import dims
from .dims import OLD_LASPY_NAMES, ScaledArrayView

logger = logging.getLogger(__name__)


[docs]def scale_dimension(array_dim, scale, offset): return (array_dim * scale) + offset
[docs]def unscale_dimension(array_dim, scale, offset): return np.round((np.array(array_dim) - offset) / scale)
[docs]class DimensionNameValidity(Enum): """Helper class to make the return value of PackedPointRecord.validate_dimentsion_name more expressive. """ # Means the name is valid and supported by the point format Valid = auto() # Means the name is valid but _not_ supported by the point format Unsupported = auto() # The name does not exist in LAS spec Invalid = auto()
[docs]class PackedPointRecord: """ In the PackedPointRecord, fields that are a combinations of many sub-fields (fields stored on less than a byte) are still packed together and are only de-packed and re-packed when accessed. This uses of less memory than if the sub-fields were unpacked >>> #return number is a sub-field >>> from laspy import PointFormat, PackedPointRecord >>> packed_point_record = PackedPointRecord.zeros(10,PointFormat(0)) >>> return_number = packed_point_record['return_number'] >>> return_number <SubFieldView([0 0 0 0 0 0 0 0 0 0])> >>> return_number[:] = 1 >>> np.alltrue(packed_point_record['return_number'] == 1) True """ def __init__(self, data: np.ndarray, point_format: PointFormat): self.__dict__["array"] = data self.__dict__["point_format"] = point_format self.__dict__["sub_fields_dict"] = dims.get_sub_fields_dict(point_format.id) @property def point_size(self): """Returns the point size in bytes taken by each points of the record Returns ------- int The point size in byte """ return self.array.dtype.itemsize
[docs] @staticmethod def zeros(point_count, point_format): """Creates a new point record with all dimensions initialized to zero Parameters ---------- point_format: PointFormat The point format id the point record should have point_count : int The number of point the point record should have Returns ------- PackedPointRecord """ data = np.zeros(point_count, point_format.dtype()) return PackedPointRecord(data, point_format)
[docs] @staticmethod def empty(point_format): """Creates an empty point record. Parameters ---------- point_format: laspy.PointFormat The point format id the point record should have Returns ------- PackedPointRecord """ return PackedPointRecord.zeros(point_count=0, point_format=point_format)
[docs] @classmethod def from_point_record( cls, other_point_record: "PackedPointRecord", new_point_format: PointFormat ) -> "PackedPointRecord": """Construct a new PackedPointRecord from an existing one with the ability to change to point format while doing so """ array = np.zeros_like(other_point_record.array, dtype=new_point_format.dtype()) new_record = cls(array, new_point_format) new_record.copy_fields_from(other_point_record) return new_record
[docs] @classmethod def from_buffer(cls, buffer, point_format, count=-1, offset=0): points_dtype = point_format.dtype() data = np.frombuffer(buffer, dtype=points_dtype, offset=offset, count=count) return cls(data, point_format)
[docs] def copy_fields_from(self, other_record: "PackedPointRecord") -> None: """Tries to copy the values of the current dimensions from other_record""" for dim_name in self.point_format.dimension_names: try: self[dim_name] = np.array(other_record[dim_name]) except ValueError: pass
[docs] def copy(self) -> "PackedPointRecord": return PackedPointRecord(self.array.copy(), deepcopy(self.point_format))
[docs] def memoryview(self) -> memoryview: return memoryview(self.array)
[docs] def resize(self, new_size: int) -> None: size_diff = new_size - len(self.array) if size_diff > 0: self.array = np.append( self.array, np.zeros(size_diff, dtype=self.array.dtype) ) elif size_diff < 0: self.array = self.array[:new_size].copy()
def _append_zeros_if_too_small(self, value): """Appends zeros to the points stored if the value we are trying to fit is bigger """ if len(value) > len(self.array): self.resize(len(value)) def __eq__(self, other): return self.point_format == other.point_format and np.all( self.array == other.array ) def __len__(self): if self.array.ndim == 0: return 1 return self.array.shape[0] def __getitem__(self, item): """Gives access to the underlying numpy array Unpack the dimension if item is the name a sub-field """ if isinstance(item, (int, slice, np.ndarray, list, tuple)): return PackedPointRecord(self.array[item], self.point_format) try: item = OLD_LASPY_NAMES[item] except KeyError: pass # 1) Is it a sub field ? try: composed_dim, sub_field = self.sub_fields_dict[item] return dims.SubFieldView(self.array[composed_dim], sub_field.mask) except KeyError: pass # 2) Is it a Scaled Extra Byte Dimension ? try: dim_info = self.point_format.dimension_by_name(item) if dim_info.is_standard is False and dim_info.is_scaled: assert dim_info.scales is not None and dim_info.offsets is not None return ScaledArrayView( self.array[item], dim_info.scales, dim_info.offsets ) except ValueError: pass return self.array[item] def __setitem__(self, key, value): """Sets elements in the array""" if isinstance(key, (tuple, list)): if not isinstance(value, np.ndarray): value = np.asarray(value) if value.dtype.isbuiltin == 0: # value is most likely a structured array (dtype = [('name1', 'type1'), ...]) # https://numpy.org/devdocs/reference/generated/numpy.dtype.isbuiltin.html for name, v_name in zip(key, value.dtype.names): self[name] = value[v_name] else: if len(key) == 1 and value.ndim == 1: value = value[..., np.newaxis] for i, name in enumerate(key): self[name] = value[..., i] return self._append_zeros_if_too_small(value) if isinstance(key, str): self[key][:] = value else: self.array[key] = value def __getattr__(self, item): try: return self[item] except ValueError: raise AttributeError("{} is not a valid dimension".format(item)) from None
[docs] def validate_dimension_name(self, key: str) -> DimensionNameValidity: """Given a name of a dimension this validates it.""" try: key = OLD_LASPY_NAMES[key] except KeyError: pass if key in self.point_format.dimension_names or key in self.array.dtype.names: return DimensionNameValidity.Valid elif key in dims.DIMENSIONS_TO_TYPE: return DimensionNameValidity.Unsupported else: return DimensionNameValidity.Invalid
def __setattr__(self, key, value): name_validity = self.validate_dimension_name(key) if name_validity == DimensionNameValidity.Valid: self[key] = value elif name_validity == DimensionNameValidity.Unsupported: raise ValueError( f"Point format {self.point_format} does not support {key} dimension" ) else: super().__setattr__(key, value) def __repr__(self): return "<{}(fmt: {}, len: {}, point size: {})>".format( self.__class__.__name__, self.point_format, len(self), self.point_format.size, )
[docs]def apply_new_scaling(record, scales: np.ndarray, offsets: np.ndarray) -> None: record["X"] = unscale_dimension(np.asarray(record.x), scales[0], offsets[0]) record["Y"] = unscale_dimension(np.asarray(record.y), scales[1], offsets[1]) record["Z"] = unscale_dimension(np.asarray(record.z), scales[2], offsets[2])
[docs]class ScaleAwarePointRecord(PackedPointRecord): """A ScaleAwarePointRecord is a point record that knows the scales and offets to use, and is thus able to get and set the scaled x, y, z coordinates To create one, use :meth:`.ScaleAwarePointRecord.zeros` or :meth:`.ScaleAwarePointRecord.empty` """ def __init__(self, array, point_format, scales, offsets): super().__init__(array, point_format) self.scales = np.array(scales) self.offsets = np.array(offsets) if self.scales.shape != (3,): raise ValueError("scales must be an array of 3 elements") if self.offsets.shape != (3,): raise ValueError("offsets must be an array of 3 elements")
[docs] @staticmethod def zeros( point_count, *, point_format=None, scales=None, offsets=None, header=None ): """Creates a new point record with all dimensions initialized to zero Examples -------- >>> record = ScaleAwarePointRecord.zeros( ... 5, point_format=PointFormat(3), scales=[1.0, 1.0, 1.0], offsets=[0.1, 0.5, 17.5]) >>> len(record) 5 >>> import laspy >>> hdr = laspy.LasHeader() >>> record = ScaleAwarePointRecord.zeros(5, header=hdr) >>> len(record) 5 >>> hdr = laspy.LasHeader() >>> record = ScaleAwarePointRecord.zeros(5, header=hdr, scales=[1.0, 1.0, 1.0]) Traceback (most recent call last): ValueError: header argument is mutually exclusive with point_format, scales and offets >>> record = ScaleAwarePointRecord.zeros(5, point_format=PointFormat(3)) Traceback (most recent call last): ValueError: You have to provide all 3: point_format, scale and offsets """ first_set = (point_format, scales, offsets) if header is not None: if any(arg is not None for arg in first_set): raise ValueError( "header argument is mutually exclusive with point_format, scales and offets" ) point_format = header.point_format scales = header.scales offsets = header.offsets else: if any(arg is None for arg in first_set): raise ValueError( "You have to provide all 3: " "point_format, scale and offsets" ) data = np.zeros(point_count, point_format.dtype()) return ScaleAwarePointRecord(data, point_format, scales, offsets)
[docs] @staticmethod def empty(point_format=None, scales=None, offsets=None, header=None): """Creates an empty point record.""" return ScaleAwarePointRecord.zeros( point_count=0, point_format=point_format, scales=scales, offsets=offsets, header=header, )
[docs] def change_scaling(self, scales=None, offsets=None) -> None: """See :meth:`.LasData.change_scaling`""" if scales is None: scales = self.scales if offsets is None: offsets = self.offsets apply_new_scaling(self, scales, offsets) self.scales = scales self.offsets = offsets
def __getitem__(self, item): if isinstance(item, (int, slice, np.ndarray, list, tuple)): if isinstance(item, (list, tuple)): # x, y ,z do not really exists in the array, but they are computed from X, Y, Z item = [ item if item not in ("x", "y", "z") else item.upper() for item in item ] return ScaleAwarePointRecord( self.array[item], self.point_format, self.scales, self.offsets ) if item == "x": return ScaledArrayView(self.array["X"], self.scales[0], self.offsets[0]) elif item == "y": return ScaledArrayView(self.array["Y"], self.scales[1], self.offsets[1]) elif item == "z": return ScaledArrayView(self.array["Z"], self.scales[2], self.offsets[2]) else: return super().__getitem__(item) def __setattr__(self, key, value): if key in ("x", "y", "z"): self[key][:] = value else: return super().__setattr__(key, value)