#lidar #pointcloud #gis #las #ASPRS

las

Read and write point clouds stored in the ASPRS las file format

19 releases

Uses old Rust 2015

0.7.3 Oct 21, 2020
0.7.1 Mar 10, 2020
0.7.0 Aug 22, 2019
0.6.2 Jul 3, 2019
0.2.0 Jun 25, 2015

#33 in Science

Download history 21/week @ 2020-07-27 11/week @ 2020-08-03 49/week @ 2020-08-10 44/week @ 2020-08-17 33/week @ 2020-08-24 36/week @ 2020-08-31 93/week @ 2020-09-07 20/week @ 2020-09-14 19/week @ 2020-09-21 16/week @ 2020-09-28 42/week @ 2020-10-05 14/week @ 2020-10-12 59/week @ 2020-10-19 23/week @ 2020-10-26 42/week @ 2020-11-02 17/week @ 2020-11-09

140 downloads per month
Used in 2 crates

MIT license

200KB
3.5K SLoC

las-rs

Documentation Build Status

Read and write ASPRS las files natively with rust.

las = "0.7"

lib.rs:

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::{Read, 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::{Read, 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();

If compiled with laz you can compress the data written

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();
// asking to compress data
builder.point_format.is_compressed = true;
let header = builder.into_header().unwrap();

let write = Cursor::new(Vec::new());
let is_compiled_with_laz = cfg!(feature = "laz");


let result =  Writer::new(write, header);
if is_compiled_with_laz {
    assert_eq!(result.is_ok(), true);
} else {
   assert_eq!(result.is_err(), true);
}

The 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

Prefer BufWrite

Just like the Reader, your performance will improve greatly if you use a BufWrite 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();

Dependencies

~1.6–2.3MB
~46K SLoC