Struct MmapTerrain 

pub struct MmapTerrain<'a> { /* private fields */ }

Memory-mappable terrain reader backed by a terrain store byte span.

Scalar and batch terrain lookups return orthometric metres, H, above the EGM96 mean sea level geoid. Use Self::ellipsoidal_height_m or OrthometricHeightM::to_ellipsoidal_height_deg for the explicit h = H + N conversion to WGS84 ellipsoidal height.

Implementations

impl MmapTerrain<'static>

pub fn from_vec(bytes: Vec<u8>) -> Result<Self, TerrainStoreError>

Parse an owned terrain store byte vector.

pub fn from_vec_attested( bytes: Vec<u8>, claimed_checksum64: u64, ) -> Result<Self, TerrainStoreError>

Parse owned terrain store bytes using a caller-attested checksum.

The byte-based counterpart of Self::from_path_attested, for callers that already hold the store bytes (an interface layer, an object-store read) alongside a trustworthy content measurement. Same contract: structural checks run unconditionally, the per-tile payload hashing is replaced by the claim, and the handle reports DigestProvenance::Attested until Self::verify succeeds.

pub fn from_path(path: impl AsRef<Path>) -> Result<Self, TerrainStoreError>

Open and parse a terrain store file.

With the mmap feature the file is memory-mapped read-only and this reader owns the mapping; without it the file is read into memory. The entry point is the same either way, so enabling the feature speeds up every existing caller rather than asking anyone to migrate.

Mapping is what makes a very large store usable at all: construction parses only the header, datum tag, and tile index, and lookups are demand-paged, so a reader querying a geographically local region never faults in the rest of the file.

pub fn from_path_attested( path: impl AsRef<Path>, claimed_checksum64: u64, ) -> Result<Self, TerrainStoreError>

Open a terrain store using a caller-attested full-store checksum.

This performs the same header, index, dimension, length, and tile-bound validation as Self::from_path without hashing tile payloads. Terrain headers do not carry a full-store checksum, so the claim is recorded as supplied and can be checked later with Self::verify. With the mmap feature the file is memory-mapped read-only; without it the file is read into memory.

impl<'a> MmapTerrain<'a>

pub fn from_bytes(bytes: &'a [u8]) -> Result<Self, TerrainStoreError>

Parse a borrowed terrain store byte span.

The reader keeps the byte span in place and indexes posting payloads by offset. Passing an mmap-backed slice gives a zero-copy reader.

pub fn as_bytes(&self) -> &[u8]

Borrow the original terrain store bytes.

pub fn is_memory_mapped(&self) -> bool

Whether this reader is backed by a memory map rather than a copy in process memory.

pub const fn vertical_datum(&self) -> VerticalDatum

Return the store’s file-level vertical datum.

pub fn tile_index(&self) -> &[TerrainStoreTileIndex]

Borrow the parsed tile index records.

pub fn tile_count(&self) -> usize

Return the number of tiles present in this terrain store.

pub fn tile_ids(&self) -> &[TerrainTileId]

Borrow the sorted integer tile ids present in this terrain store.

pub const fn digest_provenance(&self) -> DigestProvenance

Return who computed the checksum carried by this reader.

pub fn checksum64(&self) -> u64

Return the full-store checksum carried by this reader.

Verified readers compute the FNV-1a checksum on demand. Attested readers return the caller’s claim without hashing the byte span.

pub fn verify(&mut self) -> Result<(), TerrainStoreError>

Re-verify tile payloads and any caller-attested full-store checksum.

Successful verification changes the digest provenance to DigestProvenance::Verified.

pub fn to_bytes(&self) -> Vec<u8>

Re-serialize this parsed terrain store into canonical bytes.

A store accepted by Self::from_bytes is already canonical, so this returns bytes identical to Self::as_bytes.

pub fn height_m(&mut self, longitude_deg: f64, latitude_deg: f64) -> Result<f64>

Return the bilinearly interpolated orthometric height H in metres at a longitude-first geodetic position in degrees.

pub fn height_m_with_options( &mut self, longitude_deg: f64, latitude_deg: f64, options: DtedLookupOptions, ) -> Result<f64>

Return the orthometric height H in metres at a longitude-first geodetic position in degrees using explicit lookup options.

pub fn orthometric_height_m( &self, longitude_deg: f64, latitude_deg: f64, ) -> Result<OrthometricHeightM>

Return the bilinearly interpolated orthometric height H in metres as a typed value at a longitude-first geodetic position in degrees.

pub fn orthometric_height_m_with_options( &self, longitude_deg: f64, latitude_deg: f64, options: DtedLookupOptions, ) -> Result<OrthometricHeightM>

Return the orthometric height H in metres as a typed value at a longitude-first geodetic position in degrees using explicit lookup options.

pub fn height_batch( &mut self, points: &[(f64, f64)], options: DtedLookupOptions, ) -> Vec<Result<f64>>

Evaluate (longitude_deg, latitude_deg) points in order as orthometric heights H in metres.

The tuple order is longitude-first, matching Self::height_m. Each output element is independent, so an invalid point or parse failure is returned only for that element.

pub fn orthometric_height_batch( &self, points: &[(f64, f64)], options: DtedLookupOptions, ) -> Vec<Result<OrthometricHeightM>>

Evaluate (longitude_deg, latitude_deg) points in order as typed orthometric heights H in metres.

The tuple order is longitude-first. Each output element is independent, so an invalid point or parse failure is returned only for that element.

pub fn ellipsoidal_height_m( &self, longitude_deg: f64, latitude_deg: f64, ) -> Result<EllipsoidalHeightM, TerrainDatumError>

Return ellipsoidal height h in metres using the embedded EGM96 1-degree grid for h = H + N.

The input position is terrain order (longitude_deg, latitude_deg). Internally, the geoid call is made with (latitude_deg, longitude_deg). The embedded EGM96 1-degree grid agrees with the full EGM96 15-arcminute grid to about 0.4 m RMS.

pub fn ellipsoidal_height_m_with_options( &self, longitude_deg: f64, latitude_deg: f64, options: DtedLookupOptions, ) -> Result<EllipsoidalHeightM, TerrainDatumError>

Return ellipsoidal height h in metres using the embedded EGM96 1-degree grid for h = H + N and explicit terrain lookup options.

The input position is terrain order (longitude_deg, latitude_deg). Internally, the geoid call is made with (latitude_deg, longitude_deg).

pub fn ellipsoidal_height_m_with_model( &self, longitude_deg: f64, latitude_deg: f64, options: DtedLookupOptions, geoid: TerrainGeoidModel<'_>, ) -> Result<EllipsoidalHeightM, TerrainDatumError>

Return ellipsoidal height h in metres using an explicit geoid tier for h = H + N.

The input position is terrain order (longitude_deg, latitude_deg). Internally, the geoid call is made with (latitude_deg, longitude_deg). Choosing TerrainGeoidModel::Egm96FifteenMinute requires a loaded WW15MGH.DAC grid and never falls back to the embedded EGM96 1-degree grid.

Trait Implementations

impl<'a> Clone for MmapTerrain<'a>

fn clone(&self) -> MmapTerrain<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for MmapTerrain<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.