las 0.9.3

Reads and writes point clouds stored in the ASPRS las file format.
Documentation 
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
106
107
108
109
110
111
112
113
114
115
116

//! Utility functions for working with laszip compressed data.

use crate::{Error, Header, Result, Vlr};
use laz::{LazItemRecordBuilder, LazItemType, LazVlr};
use std::io::Cursor;

/// Returns true if this [Vlr] is the laszip Vlr.
///
/// # Examples
///
/// ```
/// #[cfg(feature = "laz")]
/// {
/// use las::{laz, Vlr};
///
/// let mut vlr = Vlr::default();
/// assert!(!laz::is_laszip_vlr(&vlr));
/// vlr.user_id = "laszip encoded".to_string();
/// vlr.record_id = 22204;
/// assert!(laz::is_laszip_vlr(&vlr));
/// }
/// ```
pub fn is_laszip_vlr(vlr: &Vlr) -> bool {
    vlr.user_id == LazVlr::USER_ID && vlr.record_id == LazVlr::RECORD_ID
}

impl Header {
    /// Adds a new laszip vlr to this header.
    ///
    /// Ensures that there's only one laszip vlr, as well.
    ///
    /// # Examples
    ///
    /// ```
    /// use las::Header;
    ///
    /// let mut header = Header::default();
    /// #[cfg(feature = "laz")]
    /// header.add_laz_vlr().unwrap();
    /// ```
    pub fn add_laz_vlr(&mut self) -> Result<()> {
        let point_format = self.point_format();
        let mut laz_items = LazItemRecordBuilder::new();
        if !point_format.is_extended {
            let _ = laz_items.add_item(LazItemType::Point10);

            if point_format.has_gps_time {
                let _ = laz_items.add_item(LazItemType::GpsTime);
            }

            if point_format.has_color {
                let _ = laz_items.add_item(LazItemType::RGB12);
            }

            if point_format.extra_bytes > 0 {
                let _ = laz_items.add_item(LazItemType::Byte(point_format.extra_bytes));
            }
        } else {
            let _ = laz_items.add_item(LazItemType::Point14);

            if point_format.has_color {
                // Point format 7 & 8 both have RGB
                if point_format.has_nir {
                    let _ = laz_items.add_item(LazItemType::RGBNIR14);
                } else {
                    let _ = laz_items.add_item(LazItemType::RGB14);
                }
            }
            if point_format.extra_bytes > 0 {
                let _ = laz_items.add_item(LazItemType::Byte14(point_format.extra_bytes));
            }
        }
        let laz_vlr = LazVlr::from_laz_items(laz_items.build());
        let mut cursor = Cursor::new(Vec::<u8>::new());
        laz_vlr.write_to(&mut cursor)?;
        let vlr = Vlr {
            user_id: LazVlr::USER_ID.to_owned(),
            record_id: LazVlr::RECORD_ID,
            description: LazVlr::DESCRIPTION.to_owned(),
            data: cursor.into_inner(),
        };
        self.vlrs.push(vlr);
        Ok(())
    }

    /// Returns header's [LazVlr], or `None` if none is found.
    ///
    /// # Examples
    ///
    /// ```
    /// use las::Header;
    ///
    /// let mut header = Header::default();
    ///
    /// #[cfg(feature = "laz")]
    /// {
    /// assert!(header.laz_vlr().is_none());
    /// header.add_laz_vlr();
    /// assert!(header.laz_vlr().is_some());
    /// }
    /// ```
    pub fn laz_vlr(&self) -> Option<LazVlr> {
        self.vlrs
            .iter()
            .find(|vlr| is_laszip_vlr(vlr))
            .and_then(|vlr| vlr.try_into().ok())
    }
}

impl TryFrom<&Vlr> for LazVlr {
    type Error = Error;

    fn try_from(vlr: &Vlr) -> Result<LazVlr> {
        LazVlr::from_buffer(&vlr.data).map_err(Error::from)
    }
}