Skip to main content

qualia_geospatial/raster_m64/
writer.rs

1use super::*;
2use bytemuck::Zeroable;
3use qualia_core_db::q42::m64_matter::{
4    georaster_chunk_hilbert, M64ChunkDirectoryEntry, M64Header, M64StrataColumnRecord, M64_MAGIC,
5    M64_MODE_STRATA,
6};
7
8/// Opt-in developmental v3: exact GRM3 metadata plus raw elevation-only strata.
9/// Elevations remain absolute integer mm in the declared vertical datum; no
10/// frame-base subtraction or addition occurs. Explicit limits, caller output,
11/// no allocation or recursion. Every error and
12/// cancellation check occurs before any output write. The admitted write batch
13/// is non-interruptible and returns success even if cancellation arrives later.
14pub fn compile_raster_to_m64_v3(
15    raster: &ElevationRaster<'_>,
16    frame: &GeodeticFrame,
17    lut_bank_epoch: u16,
18    policy: RasterM64Policy,
19    limits: RasterM64Limits,
20    cancelled: &AtomicBool,
21    out: &mut [u8],
22) -> Result<usize, RasterM64Error> {
23    use RasterM64Error as E;
24    if cancelled.load(Ordering::Relaxed) {
25        return Err(E::Cancelled);
26    }
27    if !cfg!(target_endian = "little") {
28        return Err(E::UnsupportedEndian);
29    }
30    let meta = policy.metadata(raster, frame);
31    let shape = meta.shape().map_err(E::Metadata)?;
32    if shape.width.checked_mul(shape.height) != Some(raster.elevations_mm.len()) {
33        return Err(E::DimensionMismatch);
34    }
35    if shape.chunks > limits.max_chunks {
36        return Err(E::ChunkLimit);
37    }
38    if shape.records > limits.max_records {
39        return Err(E::RecordLimit);
40    }
41    if shape.file_bytes > limits.max_output_bytes {
42        return Err(E::OutputByteLimit);
43    }
44    if out.len() < shape.file_bytes {
45        return Err(E::BufferTooSmall);
46    }
47    let mut block = [0u8; 128];
48    meta.encode(&mut block).map_err(E::Metadata)?;
49    let mut header = M64Header {
50        magic: M64_MAGIC,
51        version: 3,
52        header_size: 192,
53        total_file_size: shape.file_bytes as u64,
54        spatial_origin: [frame.origin_lat_deg as f32, frame.origin_lon_deg as f32],
55        elevation_datum: [frame.origin_elevation_mm as f32 / 1000.0, 1.0],
56        chunk_table_offset: 192,
57        chunk_count: shape.chunks as u64,
58        header_crc32c: 0,
59        container_flags: 0,
60    };
61    header.update_crc();
62    if cancelled.load(Ordering::Relaxed) {
63        return Err(E::Cancelled);
64    }
65    out[..64].copy_from_slice(bytemuck::bytes_of(&header));
66    out[64..192].copy_from_slice(&block);
67    let payload_start = 192 + shape.chunks * 64;
68    for chunk in 0..shape.chunks {
69        let cx = chunk % shape.chunks_x;
70        let cy = chunk / shape.chunks_x;
71        let key = georaster_chunk_hilbert(cx as u32, cy as u32);
72        let start = payload_start + chunk * 4096 * 64;
73        let mut entry = M64ChunkDirectoryEntry {
74            chunk_uuid: [0; 16],
75            spatial_hilbert_index: key,
76            byte_offset: start as u64,
77            byte_length: 4096 * 64,
78            record_count: 4096,
79            srid_geodetic_code: frame.srid,
80            lut_bank_epoch_id: lut_bank_epoch,
81            chunk_record_mode: M64_MODE_STRATA,
82            compression_flags: 0,
83            bao_root_hash_prefix: [0; 12],
84            entry_crc32c: 0,
85        };
86        entry.chunk_uuid[..8].copy_from_slice(&key.to_le_bytes());
87        entry.chunk_uuid[8..].copy_from_slice(&key.to_le_bytes());
88        entry.update_crc();
89        out[192 + chunk * 64..192 + (chunk + 1) * 64].copy_from_slice(bytemuck::bytes_of(&entry));
90        for record in 0..4096 {
91            let x = (cx * 64 + record % 64).min(shape.width - 1);
92            let y = (cy * 64 + record / 64).min(shape.height - 1);
93            // Unpopulated strata fields are not fabricated soil/material values.
94            let mut value = M64StrataColumnRecord::zeroed();
95            value.surface_elevation_mm = raster.elevations_mm[y * shape.width + x];
96            value.update_crc();
97            let offset = start + record * 64;
98            out[offset..offset + 64].copy_from_slice(bytemuck::bytes_of(&value));
99        }
100    }
101    Ok(shape.file_bytes)
102}