Struct TemporalCache 

pub struct TemporalCache { /* private fields */ }

Incrementally-loaded temporal index cache.

Implementations

impl TemporalCache

pub fn new() -> Self

Create an empty temporal cache.

pub async fn from_reader<S: ByteSource>( reader: &CopcStreamingReader<S>, ) -> Result<Option<Self>, TemporalError>

Open the temporal index from a COPC reader.

Loads the temporal header and root page. Returns Ok(None) if no temporal EVLR exists in the file.

pub async fn load_header( &mut self, source: &impl ByteSource, evlr_offset: u64, evlr_count: u32, ) -> Result<bool, TemporalError>

Scan EVLRs to find the temporal EVLR and read its header. Returns false if no temporal EVLR exists.

pub async fn load_root_page( &mut self, source: &impl ByteSource, ) -> Result<(), TemporalError>

Load the root temporal page.

pub async fn load_pages_for_time_range( &mut self, source: &impl ByteSource, start: GpsTime, end: GpsTime, ) -> Result<(), TemporalError>

Load child pages that overlap a time range, pruning by subtree bounds.

pub async fn load_all_pages( &mut self, source: &impl ByteSource, ) -> Result<(), TemporalError>

Load ALL pending pages.

pub async fn query( &mut self, source: &impl ByteSource, start: GpsTime, end: GpsTime, ) -> Result<Vec<&NodeTemporalEntry>, TemporalError>

Load relevant pages and return all nodes that overlap a time range.

This is the primary query method — it ensures the right pages are loaded before returning results. Equivalent to calling load_pages_for_time_range followed by nodes_in_range, but cannot return incomplete results.

pub fn get(&self, key: &VoxelKey) -> Option<&NodeTemporalEntry>

Look up the temporal entry for a node.

pub fn nodes_in_range( &self, start: GpsTime, end: GpsTime, ) -> Vec<&NodeTemporalEntry>

Return all loaded nodes whose time range overlaps [start, end].

pub fn stride(&self) -> u32

The sampling stride (every N-th point is recorded in the index).

pub fn header(&self) -> Option<&TemporalHeader>

The parsed temporal index header, if loaded.

pub fn len(&self) -> usize

Number of loaded node entries.

pub fn is_empty(&self) -> bool

Whether no node entries have been loaded.

pub fn iter(&self) -> impl Iterator<Item = (&VoxelKey, &NodeTemporalEntry)>

Iterate all loaded entries.

pub async fn query_chunks<S: ByteSource>( &mut self, reader: &mut CopcStreamingReader<S>, bounds: &Aabb, start: GpsTime, end: GpsTime, fields: Fields, ) -> Result<Vec<(Chunk, Range<u32>)>, TemporalError>

Query chunks by time range and spatial bounds.

Loads the relevant hierarchy and temporal pages, fetches every matching chunk with the caller’s fields mask, and returns (chunk, candidate_range) pairs. candidate_range is the sub-range of point indices in chunk whose GPS times could possibly fall within [start, end] based on the temporal index stride samples — points outside this range are guaranteed not to match and can be skipped.

The caller is responsible for the exact per-point intersection. Combine with Chunk::indices_in_bounds and indices_in_time_range to compute the precise matching set, then walk column accessors or call Chunk::points_at to materialize owned values.

use copc_streaming::Fields;

let chunks = temporal
    .query_chunks(
        &mut reader,
        &bbox,
        start,
        end,
        Fields::Z | Fields::GPS_TIME,
    )
    .await?;

for (chunk, range) in &chunks {
    let times = chunk.gps_time().unwrap();
    for (i, t) in times.enumerate().skip(range.start as usize)
                                   .take(range.len()) {
        if t >= start.0 && t <= end.0 {
            // ...
        }
    }
}

pub async fn query_chunks_by_time<S: ByteSource>( &mut self, reader: &mut CopcStreamingReader<S>, start: GpsTime, end: GpsTime, fields: Fields, ) -> Result<Vec<(Chunk, Range<u32>)>, TemporalError>

Query chunks by time range only (no spatial filtering).

Like query_chunks but loads the full hierarchy and skips the bounding-box intersection test. Returns every chunk whose node temporal range overlaps [start, end], each paired with its candidate index range.

pub async fn query_points<S: ByteSource>( &mut self, reader: &mut CopcStreamingReader<S>, bounds: &Aabb, start: GpsTime, end: GpsTime, ) -> Result<Vec<Point>, TemporalError>

Query points by time range and spatial bounds.

Loads the relevant hierarchy and temporal pages, fetches matching chunks, and returns only the points that fall inside both the time window and the bounding box.

Thin wrapper over query_chunks with Fields::ALL. Prefer query_chunks when you don’t need every field materialized as las::Point values.

let points = temporal.query_points(
    &mut reader, &query_box, start, end,
).await?;

pub async fn query_points_by_time<S: ByteSource>( &mut self, reader: &mut CopcStreamingReader<S>, start: GpsTime, end: GpsTime, ) -> Result<Vec<Point>, TemporalError>

Query points by time range only (no spatial filtering).

Loads all hierarchy pages and temporal pages that overlap the time range, then returns points within the time window.

Thin wrapper over query_chunks_by_time with Fields::ALL.

Trait Implementations

impl Default for TemporalCache

fn default() -> Self

Returns the “default value” for a type.