[−][src]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::{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();
Re-exports
pub use feature::Feature; |
pub use header::Header; |
pub use point::Point; |
pub use reader::Read; |
pub use reader::Reader; |
pub use vlr::Vlr; |
pub use writer::Write; |
pub use writer::Writer; |
Modules
feature | Programatically determine whether a las version supports a feature. |
header | A |
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. |
Builder | Builds headers. |
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 Definitions
Result | Crate-specific result type. |