Store scan angles as lossless F32 degrees and add shared parse limits in copc-core

Author: i-norden

copc-core/src/columns.rs

@@ -16,7 +16,9 @@ pub enum LasDimension {
     Classification,
     ScanDirectionFlag,
     EdgeOfFlightLine,
-    ScanAngleRank,
+    /// Scan angle in degrees. LAS 1.4 stores it as a scaled i16 in 0.006°
+    /// increments; the column carries the decoded degrees losslessly.
+    ScanAngle,
     UserData,
     PointSourceId,
     Synthetic,
@@ -41,8 +43,7 @@ impl LasDimension {
     pub const fn default_scalar(self) -> Option<ScalarType> {
         match self {
             Self::X | Self::Y | Self::Z | Self::GpsTime => Some(ScalarType::F64),
-            Self::WavePacketReturnPointWaveformLocation => Some(ScalarType::F32),
-            Self::ScanAngleRank => Some(ScalarType::I16),
+            Self::ScanAngle | Self::WavePacketReturnPointWaveformLocation => Some(ScalarType::F32),
             Self::WaveformPacketByteOffset => Some(ScalarType::U64),
             Self::Intensity
             | Self::PointSourceId
@@ -94,7 +95,7 @@ impl ColumnSelection {
             LasDimension::Classification,
             LasDimension::ScanDirectionFlag,
             LasDimension::EdgeOfFlightLine,
-            LasDimension::ScanAngleRank,
+            LasDimension::ScanAngle,
             LasDimension::UserData,
             LasDimension::PointSourceId,
             LasDimension::Synthetic,
@@ -433,7 +434,7 @@ pub fn layout_for_las_format(format: LasPointFormat) -> Vec<ColumnSpec> {
             LasDimension::Classification,
             LasDimension::ScanDirectionFlag,
             LasDimension::EdgeOfFlightLine,
-            LasDimension::ScanAngleRank,
+            LasDimension::ScanAngle,
             LasDimension::UserData,
             LasDimension::PointSourceId,
             LasDimension::Synthetic,
@@ -473,12 +474,6 @@ pub fn layout_for_las_format(format: LasPointFormat) -> Vec<ColumnSpec> {
     columns
 }
 
-/// Converts scan angle degrees into the rank-style column used by existing readers.
-pub fn scan_angle_rank_from_degrees(degrees: f32) -> i16 {
-    let scaled = (degrees * 180.0 / 90.0).round() as i32;
-    scaled.clamp(i16::MIN as i32, i16::MAX as i32) as i16
-}
-
 fn push_default_specs<I>(columns: &mut Vec<ColumnSpec>, dims: I)
 where
     I: IntoIterator<Item = LasDimension>,
@@ -575,7 +570,7 @@ mod tests {
             LasDimension::Classification,
             LasDimension::ScanDirectionFlag,
             LasDimension::EdgeOfFlightLine,
-            LasDimension::ScanAngleRank,
+            LasDimension::ScanAngle,
             LasDimension::UserData,
             LasDimension::PointSourceId,
             LasDimension::Synthetic,
@@ -699,11 +694,12 @@ mod tests {
         assert!(ColumnSpec::new(LasDimension::ExtraBytes, ScalarType::U8)
             .validate_default_scalar()
             .is_err());
-        assert!(
-            ColumnSpec::new(LasDimension::ScanAngleRank, ScalarType::F32)
-                .validate_default_scalar()
-                .is_err()
-        );
+        assert!(ColumnSpec::new(LasDimension::ScanAngle, ScalarType::I16)
+            .validate_default_scalar()
+            .is_err());
+        assert!(ColumnSpec::new(LasDimension::ScanAngle, ScalarType::F32)
+            .validate_default_scalar()
+            .is_ok());
     }
 
     #[test]
@@ -733,15 +729,6 @@ mod tests {
         assert!(all.contains(LasDimension::ExtraBytes));
     }
 
-    #[test]
-    fn scan_angle_rank_uses_engine_conversion() {
-        assert_eq!(0, scan_angle_rank_from_degrees(0.0));
-        assert_eq!(91, scan_angle_rank_from_degrees(45.25));
-        assert_eq!(-91, scan_angle_rank_from_degrees(-45.25));
-        assert_eq!(i16::MAX, scan_angle_rank_from_degrees(f32::MAX));
-        assert_eq!(i16::MIN, scan_angle_rank_from_degrees(f32::MIN));
-    }
-
     #[test]
     fn layout_for_format_0_has_core_dimensions() {
         assert_layout_dims(0, base_layout_dims());

copc-core/src/lib.rs

@@ -8,15 +8,19 @@ pub mod columns;
 pub mod error;
 pub mod hierarchy;
 pub mod info;
+pub mod limits;
 pub mod streaming;
 
 pub use bounds::Bounds;
 pub use cancel::{CancelCheck, NeverCancel};
 pub use columns::{
-    layout_for_las_format, scan_angle_rank_from_degrees, ColumnData, ColumnSelection, ColumnSpec,
-    ColumnView, LasColumnBatch, LasDimension, ScalarType,
+    layout_for_las_format, ColumnData, ColumnSelection, ColumnSpec, ColumnView, LasColumnBatch,
+    LasDimension, ScalarType,
 };
 pub use error::{Error, Result};
 pub use hierarchy::{Entry, EntryAvailability, HierarchyPage, VoxelKey, HIERARCHY_ENTRY_BYTES};
 pub use info::CopcInfo;
-pub use streaming::{deserialize_le, serialize_le, LasPointRecord, StreamingLayout};
+pub use limits::{MAX_EVLR_COUNT, MAX_VLR_COUNT};
+pub use streaming::{
+    deserialize_le, deserialize_le_into, serialize_le, LasPointRecord, StreamingLayout,
+};

copc-core/src/limits.rs

@@ -0,0 +1,7 @@
+//! Shared parsing limits applied to untrusted LAS/COPC input.
+
+/// Maximum number of VLRs accepted when parsing LAS/COPC input.
+pub const MAX_VLR_COUNT: u32 = 4_096;
+
+/// Maximum number of EVLRs accepted when parsing LAS/COPC input.
+pub const MAX_EVLR_COUNT: u32 = 4_096;

copc-core/src/streaming.rs

@@ -8,7 +8,7 @@ const LASF_SPEC_USER_ID: &str = "LASF_Spec";
 const EXTRA_BYTES_RECORD_ID: u16 = 4;
 
 /// In-memory representation of one full-fidelity LAS point.
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, Default, PartialEq)]
 pub struct LasPointRecord {
     pub x: f64,
     pub y: f64,
@@ -239,6 +239,17 @@ pub fn serialize_le(
 
 /// Deserialize one record from the little-endian spill bytes.
 pub fn deserialize_le(src: &[u8], layout: &StreamingLayout) -> io::Result<LasPointRecord> {
+    let mut record = LasPointRecord::default();
+    deserialize_le_into(src, layout, &mut record)?;
+    Ok(record)
+}
+
+/// Deserialize one record into `out`, reusing its `extra_bytes` allocation.
+pub fn deserialize_le_into(
+    src: &[u8],
+    layout: &StreamingLayout,
+    out: &mut LasPointRecord,
+) -> io::Result<()> {
     if src.len() != layout.record_width() {
         return Err(io::Error::new(
             io::ErrorKind::InvalidData,
@@ -301,44 +312,40 @@ pub fn deserialize_le(src: &[u8], layout: &StreamingLayout) -> io::Result<LasPoi
     } else {
         (0, 0, 0, 0.0)
     };
-    let extra_bytes = if layout.extra_bytes > 0 {
+    out.extra_bytes.clear();
+    if layout.extra_bytes > 0 {
         let end = offset + usize::from(layout.extra_bytes);
-        let extra_bytes = src[offset..end].to_vec();
+        out.extra_bytes.extend_from_slice(&src[offset..end]);
         offset = end;
-        extra_bytes
-    } else {
-        Vec::new()
-    };
+    }
     debug_assert_eq!(offset, layout.record_width());
-    Ok(LasPointRecord {
-        x,
-        y,
-        z,
-        intensity,
-        return_number,
-        number_of_returns,
-        classification,
-        scan_direction_flag,
-        edge_of_flight_line,
-        scan_angle,
-        user_data,
-        point_source_id,
-        synthetic,
-        key_point,
-        withheld,
-        overlap,
-        scan_channel,
-        gps_time,
-        red,
-        green,
-        blue,
-        nir,
-        wave_packet_descriptor_index,
-        byte_offset_to_waveform_data,
-        waveform_packet_size,
-        return_point_waveform_location,
-        extra_bytes,
-    })
+    out.x = x;
+    out.y = y;
+    out.z = z;
+    out.intensity = intensity;
+    out.return_number = return_number;
+    out.number_of_returns = number_of_returns;
+    out.classification = classification;
+    out.scan_direction_flag = scan_direction_flag;
+    out.edge_of_flight_line = edge_of_flight_line;
+    out.scan_angle = scan_angle;
+    out.user_data = user_data;
+    out.point_source_id = point_source_id;
+    out.synthetic = synthetic;
+    out.key_point = key_point;
+    out.withheld = withheld;
+    out.overlap = overlap;
+    out.scan_channel = scan_channel;
+    out.gps_time = gps_time;
+    out.red = red;
+    out.green = green;
+    out.blue = blue;
+    out.nir = nir;
+    out.wave_packet_descriptor_index = wave_packet_descriptor_index;
+    out.byte_offset_to_waveform_data = byte_offset_to_waveform_data;
+    out.waveform_packet_size = waveform_packet_size;
+    out.return_point_waveform_location = return_point_waveform_location;
+    Ok(())
 }
 
 #[inline]