binex 0.5.2

BINEX encoder and decoder for real-time GNSS
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use crate::{
    prelude::{Error, Message},
    utils::Utils,
};

use std::str::from_utf8;

#[derive(Debug, Clone, PartialEq)]
pub struct PositionEcef3d {
    /// x coordinate
    pub x_ecef_m: f64,
    /// y coordinate
    pub y_ecef_m: f64,
    /// Z coordinate
    pub z_ecef_m: f64,
    /// Ellpsoid shape
    pub ellipsoid: String,
}

impl PositionEcef3d {
    pub(crate) fn encoding_size(&self) -> usize {
        let mut size = 24;
        if !self.ellipsoid.eq("WGS84") {
            let str_len = self.ellipsoid.len();
            size += Message::bnxi_encoding_size(str_len as u32);
            size += str_len;
        } else {
            size += 1;
        }
        size
    }

    pub(crate) fn encode(&self, big_endian: bool, buf: &mut [u8]) -> Result<usize, Error> {
        let mut ptr = 0;
        let size = self.encoding_size();

        if buf.len() < size {
            return Err(Error::NotEnoughBytes);
        }

        // encode ellipsod
        if self.ellipsoid.eq("WGS84") {
            buf[ptr] = 0;
            ptr += 1;
        } else {
            let str_len = self.ellipsoid.len();

            let size = Message::encode_bnxi(str_len as u32, big_endian, &mut buf[ptr..])?;
            ptr += size;

            buf[ptr..ptr + str_len].copy_from_slice(self.ellipsoid.as_bytes());
            ptr += str_len;
        }

        // encode (x, y, z)
        let bytes = if big_endian {
            self.x_ecef_m.to_be_bytes()
        } else {
            self.x_ecef_m.to_le_bytes()
        };

        buf[ptr..ptr + 8].copy_from_slice(&bytes);

        let bytes = if big_endian {
            self.y_ecef_m.to_be_bytes()
        } else {
            self.y_ecef_m.to_le_bytes()
        };

        buf[ptr + 8..ptr + 16].copy_from_slice(&bytes);

        let bytes = if big_endian {
            self.z_ecef_m.to_be_bytes()
        } else {
            self.z_ecef_m.to_le_bytes()
        };

        buf[ptr + 16..ptr + 24].copy_from_slice(&bytes);
        Ok(size)
    }

    pub(crate) fn decode(big_endian: bool, buf: &[u8]) -> Result<Self, Error> {
        let buf_len = buf.len();
        if buf_len < 2 {
            return Err(Error::NotEnoughBytes);
        }

        let (str_len, mut ptr) = Message::decode_bnxi(buf, big_endian);
        let str_len = str_len as usize;

        let ellipsoid = if str_len == 0 {
            "WGS84".to_string()
        } else {
            let ellipsoid_str =
                from_utf8(&buf[ptr..ptr + str_len]).map_err(|_| Error::Utf8Error)?;

            ellipsoid_str.to_string()
        };

        ptr += str_len;

        if buf_len - str_len < 24 {
            return Err(Error::NotEnoughBytes);
        }

        let x_ecef_m = Utils::decode_f64(big_endian, &buf[ptr..ptr + 8])?;
        let y_ecef_m = Utils::decode_f64(big_endian, &buf[ptr + 8..ptr + 16])?;
        let z_ecef_m = Utils::decode_f64(big_endian, &buf[ptr + 16..ptr + 24])?;

        Ok(Self {
            x_ecef_m,
            y_ecef_m,
            z_ecef_m,
            ellipsoid,
        })
    }

    /// Defines new [PositionEcef3d] expressed in WGS84 ellipsoid.
    pub fn new_wgs84(x_ecef_m: f64, y_ecef_m: f64, z_ecef_m: f64) -> Self {
        Self {
            x_ecef_m,
            y_ecef_m,
            z_ecef_m,
            ellipsoid: "WGS84".to_string(),
        }
    }
}

/// Velocity vector expressed in same ellipsoid that latest [PositionEcef3d].
#[derive(Debug, Clone, PartialEq)]
pub struct Velocity3d {
    /// x component [m/s]
    pub x_m_s: f64,
    /// y c_omponent [m/s]
    pub y_m_s: f64,
    /// z component [m/s]
    pub z_m_s: f64,
}