1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105

//! Natively read and write [ASPRS
//! LAS](https://www.asprs.org/committee-general/laser-las-file-format-exchange-activities.html) data.
//!
//! # Reading
//!
//! `Reader`s can be created from paths:
//!
//! ```
//! 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();
//! ```
//!
//! 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 one-by-one with `read`:
//!
//! ```
//! # use las::Reader;
//! # let mut reader = Reader::from_path("tests/data/autzen.las").unwrap();
//! let point = reader.read().unwrap().unwrap();
//! ```
//!
//! # Writing
//!
//! Create a `Writer` from something that implements `Write` and a `Header`:
//!
//! ```
//! use std::io::Cursor;
//! use las::Writer;
//! let writer = Writer::new(Cursor::new(Vec::new()), Default::default()).unwrap();
//! ```
//!
//! Use the `Header` to customize the output data formats:
//!
//! ```
//! # use std::io::Cursor;
//! # use las::Writer;
//! use las::Header;
//! let header = Header { version: (1, 3), point_format: 2.into(), ..Default::default() };
//! let writer = Writer::new(Cursor::new(Vec::new()), header).unwrap();
//! ```
//!
//! You can also write out to a path (automatically buffered):
//!
//! ```
//! # use las::Writer;
//! let writer = Writer::from_path("/dev/null", Default::default());
//! ```
//!
//! Write points one at a time:
//!
//! ```
//! # use std::io::Cursor;
//! # use las::Writer;
//! # let mut writer = Writer::new(Cursor::new(Vec::new()), Default::default()).unwrap();
//! use las::Point;
//! let point = Point { x: 1., y: 2., z: 3., ..Default::default() };
//! writer.write(&point).unwrap();
//! ```

#![deny(missing_docs,
        missing_debug_implementations, missing_copy_implementations,
        trivial_casts, trivial_numeric_casts,
        unsafe_code,
        unstable_features,
        unused_import_braces, unused_qualifications)]

extern crate byteorder;
extern crate chrono;

pub mod header;
pub mod point;
pub mod reader;
pub mod vlr;

mod bounds;
mod error;
mod transform;
mod utils;
mod vector;
mod writer;

pub use bounds::Bounds;
pub use error::Error;
pub use header::Header;
pub use reader::Reader;
pub use point::Point;
pub use transform::Transform;
pub use vector::Vector;
pub use vlr::Vlr;
pub use writer::Writer;

/// Crate-specific result type.
pub type Result<T> = std::result::Result<T, Error>;