Crate las

Read and write ASPRS LAS point cloud data.

Reading

Create a Reader from a Path:

use las::Reader;
let reader = Reader::from_path("tests/data/autzen.las").unwrap();

Or anything that implements Read:

use std::io::BufReader;
use std::fs::File;
use las::Reader;
let read = BufReader::new(File::open("tests/data/autzen.las").unwrap());
let reader = Reader::new(read).unwrap();

Prefer BufRead

Your performance will be better if your Read is actually a BufRead. Reader::from_path takes care of this for you, but Reader::new doesn’t.

Read points

Read points one-by-one with Reader::read:

use las::Reader;
let mut reader = Reader::from_path("tests/data/autzen.las").unwrap();
let point = reader.read().unwrap().unwrap();

Or iterate over all points with Reader::points:

use las::Reader;
let mut reader = Reader::from_path("tests/data/autzen.las").unwrap();
for wrapped_point in reader.points() {
    let point = wrapped_point.unwrap();
    println!("Point coordinates: ({}, {}, {})", point.x, point.y, point.z);
    if let Some(color) = point.color {
        println!("Point color: red={}, green={}, blue={}",
            color.red,
            color.green,
            color.blue,
        );
    }
}

Writing

Create a Writer from a Write and a Header:

use std::io::Cursor;
use las::{Writer, Header};
let write = Cursor::new(Vec::new());
let header = Header::default();
let writer = Writer::new(write, header).unwrap();

You can also write out to a path (automatically buffered with BufWriter):

use las::Writer;
let writer = Writer::from_path("/dev/null", Default::default());

Use a Builder to customize the las data:

use std::io::Cursor;
use las::{Writer, Builder};
use las::point::Format;

let mut builder = Builder::from((1, 4));
builder.point_format = Format::new(2).unwrap();
let header = builder.into_header().unwrap();

let write = Cursor::new(Vec::new());
let writer = Writer::new(write, header).unwrap();

Prefer BufWriter

Just like the Reader, your performance will improve greatly if you use a BufWriter instead of just a Write.

Write points

Write points one at a time:

use std::io::Cursor;
use las::{Write, Writer, Point};
let mut writer = Writer::default();
let point = Point { x: 1., y: 2., z: 3., ..Default::default() };
writer.write(point).unwrap();

Compression

The laz compression format is the de-facto standard for compression las data. To enable laz support, enable the laz or laz-parallel feature:

[dependencies]
las = { version = "0.9", features = ["laz"] }  # or laz-parallel

Then, you can compress the data when writing:

use std::io::Cursor;
use las::{Writer, Builder};
use las::point::Format;

let mut builder = Builder::from((1, 4));
builder.point_format = Format::new(2).unwrap();
builder.point_format.is_compressed = true;
let header = builder.into_header().unwrap();
let write = Cursor::new(Vec::new());
let result =  Writer::new(write, header);
if cfg!(feature = "laz") {
    assert!(result.is_ok());
} else {
    assert!(result.is_err());
}

Writer::from_path will use the extension of the output file to determine wether the data should be compressed or not:

• .laz: compressed
• .las: not compressed

Re-exports

pub use crate::copc::CopcEntryReader;laz

pub use crate::feature::Feature;

pub use crate::header::Builder;

pub use crate::header::Header;

pub use crate::point::Point;

pub use crate::reader::Reader;

pub use crate::vlr::Vlr;

pub use crate::writer::Writer;

pub use reader::Read;Deprecated

pub use writer::Write;Deprecated

Modules

copclaz

COPC header data

feature

Programmatically determine whether a las version supports a feature.

header

A Header describes the configuration and properties of las data.

lazlaz

Utility functions for working with laszip compressed data.

point

Attributed three-dimensional points.

raw

Raw structures that map directly to their definitions in the las format specifications.

reader

Read las points.

vlr

Variable length records are used to store additional metadata not defined in the header.

writer

Write las points.

Structs

Bounds

Minimum and maximum bounds in three dimensions.

Color

A RGB color value.

Transform

A scale and an offset that transforms xyz coordinates.

Vector

An xyz collection.

Version

LAS version.

Enums

Error

Crate-specific error enum.

GpsTimeType

The meaning of GPS time in the point records.

Type Aliases

Result

Crate-specific result type.