Struct laz::laszip::parallel::ParLasZipCompressor

pub struct ParLasZipCompressor<W> { /* private fields */ }

LasZip compressor that compresses using multiple threads

This supports both variable-size and fixed-size chunks. The method you need to call in order to compress data depends on which type of sized chunks you want to write.

It’s the LazVlr that controls which type of chunks you want to write.

You must call done when you have compressed all the points you wanted.

Fixed-Size

Use compress_many

This works by forming complete chunks of points with the points data passed when compress_many is called. These complete chunks are compressed & written right away and points that are ‘leftovers’ are kept until the next call to compress_many or done.

Variable-Size

Use compress_chunks

Implementations

impl<W: Write + Seek + Send> ParLasZipCompressor<W>

pub fn new(dest: W, vlr: LazVlr) -> Result<Self>

Creates a new ParLasZipCompressor

No i/o operation are performed

pub fn reserve_offset_to_chunk_table(&mut self) -> Result<()>

Reserves and prepares the offset to chunk table that will be updated when done is called.

This method will automatically be called on the first point(s) being compressed, but for some scenarios, manually calling this might be useful as it allow storing the position where the chunk table offset is.

pub fn compress_many(&mut self, points: &[u8]) -> Result<()>

Compresses many points using multiple threads.

Important

This must be called only when writing fixed-size chunks. This will panic otherwise.

Note

For this function to actually use multiple threads, the points buffer shall hold more points that the vlr’s chunk_size.

pub fn compress_chunks<Chunks, Item>(&mut self, chunks: Chunks) -> Result<()>

where Item: AsRef<[u8]> + Send, Chunks: IntoParallelIterator<Item = Item>,

Compresses multiple chunks using multiple threads.

Important

This must be called only when writing variable-size chunks. This will panic otherwise.

Note

For this function to actually use multiple threads, their should be more that one chunk. buffer shall hold more points that the vlr’s chunk_size.

pub fn done(&mut self) -> Result<()>

Tells the compressor that no more points will be compressed

• Compresses & writes the rest of the points to form the last chunk
• Writes the chunk table
• update the offset to the chunk_table

pub fn vlr(&self) -> &LazVlr

pub fn into_inner(self) -> W

pub fn get_mut(&mut self) -> &mut W

pub fn get(&self) -> &W

Trait Implementations

impl<W: Write + Seek + Send> LazCompressor for ParLasZipCompressor<W>

fn compress_one(&mut self, point: &[u8]) -> Result<()>

fn compress_many(&mut self, points: &[u8]) -> Result<()>

fn reserve_offset_to_chunk_table(&mut self) -> Result<()>

fn done(&mut self) -> Result<()>