Merge pull request #39 from roteiro-gis/ian/dev

Add CRS WKT override hook

Author: i-norden

CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## Unreleased
 
+## 0.4.2 - 2026-07-05
+
+- add a proj-free CRS WKT override hook for LAS/LAZ-to-COPC streaming
+  conversion, allowing downstream engines to resolve GeoTIFF-only CRS metadata
+  externally and have `copc-writer` emit the resulting WKT CRS VLR
+- keep GeoTIFF-only CRS inputs rejected with the specific unsupported
+  conversion error when no WKT CRS record or WKT override is supplied
+
 ## 0.4.1 - 2026-07-04
 
 - preserve source EVLRs when converting from COPC/LAZ inputs whose EVLR list

Cargo.lock

@@ -3,7 +3,7 @@ members = ["copc-core", "copc-reader", "copc-writer"]
 resolver = "2"
 
 [workspace.package]
-version = "0.4.1"
+version = "0.4.2"
 edition = "2021"
 rust-version = "1.77"
 license = "MIT OR Apache-2.0"

Cargo.toml

@@ -72,6 +72,10 @@ convert_las_to_copc_streaming(
 )?;
 ```
 
+For GeoTIFF-only CRS inputs, resolve CRS externally and call
+`convert_las_to_copc_streaming_with_crs_wkt_override` with `Some(wkt)`; the
+writer emits the supplied WKT CRS VLR without depending on a geodesy library.
+
 ## Column Ownership Model
 
 `copc-core` owns the LAS/COPC-native column model: `LasDimension`,
@@ -106,14 +110,16 @@ behind a future optional feature.
 - Streaming LAS/LAZ-to-COPC conversion through a disk-backed mmap spill
 - Streaming conversion preserves WKT CRS records, LAS Extra Bytes payloads and
   descriptors, and source non-CRS VLRs/EVLRs
+- Streaming conversion can accept caller-resolved WKT for GeoTIFF-only CRS
+  inputs without adding a geodesy dependency to `copc-writer`
 - LAS 1.4 point formats 6 and 7 with LAZ variable-size chunks
 - Interior-node representative points for native LOD reads
 
 ## Not Yet Supported
 
 - Zero-copy column views directly over compressed COPC/LAZ point data
 - Built-in Arrow or DataFusion conversion
-- GeoTIFF-only CRS conversion to WKT during LAS/LAZ-to-COPC conversion
+- Built-in GeoTIFF-only CRS conversion to WKT during LAS/LAZ-to-COPC conversion
 
 ## Testing
 

README.md

@@ -18,6 +18,6 @@ exclude = [
 
 [dependencies]
 byteorder = { workspace = true }
-copc-core = { version = "0.4.1", path = "../copc-core" }
+copc-core = { version = "0.4.2", path = "../copc-core" }
 las = { workspace = true }
 laz = { workspace = true }

copc-reader/Cargo.toml

@@ -14,11 +14,11 @@ categories = ["science", "encoding"]
 
 [dependencies]
 byteorder = { workspace = true }
-copc-core = { version = "0.4.1", path = "../copc-core" }
+copc-core = { version = "0.4.2", path = "../copc-core" }
 las = { workspace = true }
 laz = { workspace = true }
 memmap2 = { workspace = true }
 tempfile = { version = "3", default-features = false }
 
 [dev-dependencies]
-copc-reader = { version = "0.4.1", path = "../copc-reader" }
+copc-reader = { version = "0.4.2", path = "../copc-reader" }

copc-writer/Cargo.toml

@@ -5,7 +5,7 @@ mod writer;
 
 pub use spill::{SpillReader, SpillWriter};
 pub use writer::{
-    convert_las_to_copc_streaming, write_source, write_source_with_cancel,
-    write_streaming_with_cancel, ColumnBatchSource, CopcPointFields, CopcPointSource,
-    CopcWriterParams,
+    convert_las_to_copc_streaming, convert_las_to_copc_streaming_with_crs_wkt_override,
+    write_source, write_source_with_cancel, write_streaming_with_cancel, ColumnBatchSource,
+    CopcPointFields, CopcPointSource, CopcWriterParams,
 };

copc-writer/src/lib.rs

@@ -475,12 +475,21 @@ impl Default for OutputLasMetadata {
 }
 
 impl OutputLasMetadata {
-    fn from_las_header(header: &las::Header, source_evlrs: &[las::Vlr]) -> Self {
+    fn from_las_header(
+        header: &las::Header,
+        source_evlrs: &[las::Vlr],
+        crs_wkt_override: Option<&str>,
+    ) -> Self {
         let mut global_encoding = u16::from(header.gps_time_type());
         if header.has_synthetic_return_numbers() {
             global_encoding |= 8;
         }
-        let crs_records = extract_source_wkt_crs_records(header, source_evlrs);
+        let mut crs_records = extract_source_wkt_crs_records(header, source_evlrs);
+        if crs_records.is_empty() && has_geotiff_crs_record(header, source_evlrs) {
+            if let Some(crs_wkt) = normalized_crs_wkt_override(crs_wkt_override) {
+                crs_records.push(wkt_override_crs_record(crs_wkt));
+            }
+        }
         if !crs_records.is_empty() {
             global_encoding |= WKT_GLOBAL_ENCODING_BIT;
         }
@@ -678,14 +687,46 @@ pub fn convert_las_to_copc_streaming(
     params: &CopcWriterParams,
     spill_dir: &Path,
     cancel: &dyn CancelCheck,
+) -> Result<()> {
+    convert_las_to_copc_streaming_inner(las_path, copc_path, params, spill_dir, cancel, None)
+}
+
+/// Converts LAS/LAZ to COPC and emits `crs_wkt_override` as a WKT CRS VLR
+/// when the source has GeoTIFF CRS records but no WKT CRS record.
+pub fn convert_las_to_copc_streaming_with_crs_wkt_override(
+    las_path: &Path,
+    copc_path: &Path,
+    params: &CopcWriterParams,
+    spill_dir: &Path,
+    cancel: &dyn CancelCheck,
+    crs_wkt_override: Option<&str>,
+) -> Result<()> {
+    convert_las_to_copc_streaming_inner(
+        las_path,
+        copc_path,
+        params,
+        spill_dir,
+        cancel,
+        crs_wkt_override,
+    )
+}
+
+fn convert_las_to_copc_streaming_inner(
+    las_path: &Path,
+    copc_path: &Path,
+    params: &CopcWriterParams,
+    spill_dir: &Path,
+    cancel: &dyn CancelCheck,
+    crs_wkt_override: Option<&str>,
 ) -> Result<()> {
     cancel.check()?;
     let las_file = File::open(las_path).map_err(|e| Error::io("open source LAS/LAZ", e))?;
     let mut reader = las::Reader::new(BufReader::with_capacity(LAS_INPUT_BUFFER_BYTES, las_file))
         .map_err(|e| Error::Las(e.to_string()))?;
     let source_evlrs = read_all_source_evlrs(las_path)?;
-    validate_las_conversion_supported(reader.header(), &source_evlrs)?;
-    let output_metadata = OutputLasMetadata::from_las_header(reader.header(), &source_evlrs);
+    validate_las_conversion_supported(reader.header(), &source_evlrs, crs_wkt_override)?;
+    let output_metadata =
+        OutputLasMetadata::from_las_header(reader.header(), &source_evlrs, crs_wkt_override);
     let layout = StreamingLayout::from_las_header(reader.header());
     let mut spill = SpillWriter::create(spill_dir, layout)?;
     for (index, result) in reader.points().enumerate() {
@@ -745,6 +786,7 @@ fn validate_streaming_layout_supported(layout: &StreamingLayout) -> Result<()> {
 fn validate_las_conversion_supported(
     header: &las::Header,
     source_evlrs: &[las::Vlr],
+    crs_wkt_override: Option<&str>,
 ) -> Result<()> {
     let mut unsupported = Vec::new();
     let format = header.point_format();
@@ -755,14 +797,15 @@ fn validate_las_conversion_supported(
         unsupported.push("waveform point data".to_string());
     }
     let source_has_wkt_crs_record = has_wkt_crs_record(header, source_evlrs);
+    let has_crs_wkt_override = normalized_crs_wkt_override(crs_wkt_override).is_some();
     let mut geotiff_crs_record_count = 0usize;
     for vlr in header.vlrs() {
-        if is_geotiff_crs_vlr(vlr) && !source_has_wkt_crs_record {
+        if is_geotiff_crs_vlr(vlr) && !source_has_wkt_crs_record && !has_crs_wkt_override {
             geotiff_crs_record_count += 1;
         }
     }
     for evlr in source_evlrs {
-        if is_geotiff_crs_vlr(evlr) && !source_has_wkt_crs_record {
+        if is_geotiff_crs_vlr(evlr) && !source_has_wkt_crs_record && !has_crs_wkt_override {
             geotiff_crs_record_count += 1;
         }
     }
@@ -808,6 +851,10 @@ fn is_geotiff_crs_vlr(vlr: &las::Vlr) -> bool {
         )
 }
 
+fn normalized_crs_wkt_override(crs_wkt_override: Option<&str>) -> Option<&str> {
+    crs_wkt_override.filter(|crs_wkt| !crs_wkt.trim().is_empty())
+}
+
 fn is_extra_bytes_descriptor_vlr(vlr: &las::Vlr) -> bool {
     vlr.user_id == LASF_SPEC_USER_ID && vlr.record_id == EXTRA_BYTES_RECORD_ID
 }
@@ -816,6 +863,10 @@ fn has_wkt_crs_record(header: &las::Header, source_evlrs: &[las::Vlr]) -> bool {
     header.vlrs().iter().any(is_wkt_crs_vlr) || source_evlrs.iter().any(is_wkt_crs_vlr)
 }
 
+fn has_geotiff_crs_record(header: &las::Header, source_evlrs: &[las::Vlr]) -> bool {
+    header.vlrs().iter().any(is_geotiff_crs_vlr) || source_evlrs.iter().any(is_geotiff_crs_vlr)
+}
+
 fn extract_source_wkt_crs_records(
     header: &las::Header,
     source_evlrs: &[las::Vlr],
@@ -840,6 +891,18 @@ fn extract_source_wkt_crs_records(
     records
 }
 
+fn wkt_override_crs_record(crs_wkt: &str) -> OutputCrsRecord {
+    OutputCrsRecord {
+        vlr: las::Vlr {
+            user_id: LASF_PROJECTION_USER_ID.to_string(),
+            record_id: WKT_CRS_RECORD_ID,
+            description: "OGC WKT CRS".to_string(),
+            data: crs_wkt.as_bytes().to_vec(),
+        },
+        is_extended: false,
+    }
+}
+
 fn extract_pass_through_vlrs(header: &las::Header) -> Vec<las::Vlr> {
     header
         .vlrs()

copc-writer/src/writer.rs

@@ -2,8 +2,8 @@ use byteorder::{LittleEndian, ReadBytesExt};
 use copc_core::{Bounds, NeverCancel, StreamingLayout};
 use copc_reader::{BoundsSelection, CopcFile, CopcReader, LodSelection};
 use copc_writer::{
-    convert_las_to_copc_streaming, write_source, write_streaming_with_cancel, CopcPointFields,
-    CopcPointSource, CopcWriterParams,
+    convert_las_to_copc_streaming, convert_las_to_copc_streaming_with_crs_wkt_override,
+    write_source, write_streaming_with_cancel, CopcPointFields, CopcPointSource, CopcWriterParams,
 };
 use las::point::ScanDirection;
 use las::{Color, Point};
@@ -1105,6 +1105,66 @@ fn streaming_conversion_rejects_geotiff_only_crs_with_specific_error() {
     assert!(!message.contains("1 VLR(s)"));
 }
 
+#[test]
+fn streaming_conversion_uses_crs_wkt_override_for_geotiff_only_crs() {
+    let dir = tempfile::tempdir().unwrap();
+    let las_path = dir.path().join("geotiff-crs-override.las");
+    let copc_path = dir.path().join("geotiff-crs-override.copc.laz");
+    let spill_dir = dir.path().join("spill");
+    std::fs::create_dir(&spill_dir).unwrap();
+
+    let crs_wkt = "GEOGCS[\"WGS 84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.257223563]],PRIMEM[\"Greenwich\",0],UNIT[\"degree\",0.0174532925199433],AUTHORITY[\"EPSG\",\"4326\"]]";
+    let mut builder = las::Builder::from((1, 4));
+    builder.point_format = las::point::Format::new(6).unwrap();
+    builder.vlrs.push(las::Vlr {
+        user_id: "LASF_Projection".to_string(),
+        record_id: 34735,
+        description: "GeoTIFF GeoKeyDirectoryTag".to_string(),
+        data: vec![1, 1, 0, 0],
+    });
+    let mut writer = las::Writer::from_path(&las_path, builder.into_header().unwrap()).unwrap();
+    writer
+        .write(las::Point {
+            x: 1.0,
+            y: 2.0,
+            z: 3.0,
+            return_number: 1,
+            number_of_returns: 1,
+            gps_time: Some(1.0),
+            ..Default::default()
+        })
+        .unwrap();
+    writer.close().unwrap();
+
+    convert_las_to_copc_streaming_with_crs_wkt_override(
+        &las_path,
+        &copc_path,
+        &CopcWriterParams::default(),
+        &spill_dir,
+        &NeverCancel,
+        Some(crs_wkt),
+    )
+    .unwrap();
+
+    let header = read_las_header_prefix(&copc_path);
+    assert_eq!(3, header.number_of_vlrs);
+    assert_eq!(16, header.global_encoding & 16);
+
+    let reader = las::Reader::from_path(&copc_path).unwrap();
+    assert!(reader.header().has_wkt_crs());
+    let crs_records: Vec<_> = reader
+        .header()
+        .all_vlrs()
+        .filter(|vlr| vlr.user_id == "LASF_Projection" && vlr.record_id == 2112)
+        .collect();
+    assert_eq!(1, crs_records.len());
+    assert_eq!(crs_wkt.as_bytes(), crs_records[0].data.as_slice());
+    assert!(!reader
+        .header()
+        .all_vlrs()
+        .any(|vlr| vlr.user_id == "LASF_Projection" && vlr.record_id == 34735));
+}
+
 #[test]
 fn streaming_conversion_allows_source_laszip_vlr() {
     let dir = tempfile::tempdir().unwrap();