minigps 0.1.3

Library for MiniGPS file format support
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

//! Working with TRAIL.DAT file
use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
use std::io::{self, Read, Write};

/// TRAIL structure
///
/// Contains timestamp, two coordinates, and elevation as IEEE754 doubles
/// Layout in file:
/// - `_:     u64` - zeros, padding?
/// - `lat:   f64` - latitude of last track point
/// - `lon:   f64` - longtitude of last track point
/// - `_:     u32` - zero padding
/// = `points:u32` - number of track points?
/// - `dist:  f64` - distance in meters
/// - `time:  u32` - seconds that path took
/// - `speed: f32` - Looks like speed, but not sure if average or just in the last track point
#[derive(Debug, Clone, Copy)]
pub struct Trail {
    /// Latitude
    lat: f64,
    /// Longtitude
    lon: f64,
    /// Distance
    dist: f64,
    /// Points
    points: u32,
    /// Time
    time: u32,
    /// Speed
    speed: f32,
}

impl Trail {
    pub fn deserialize(rdr: &mut impl Read) -> io::Result<Self> {
        rdr.read_u64::<LittleEndian>()?; // Padding?
        let lat = rdr.read_f64::<LittleEndian>()?;
        let lon = rdr.read_f64::<LittleEndian>()?;
        rdr.read_u32::<LittleEndian>()?; // Padding?
        let points = rdr.read_u32::<LittleEndian>()?;
        let dist = rdr.read_f64::<LittleEndian>()?;
        let time = rdr.read_u32::<LittleEndian>()?;
        let speed = rdr.read_f32::<LittleEndian>()?; // Padding?

        Ok(Trail {
            lat,
            lon,
            dist,
            points,
            time,
            speed,
        })
    }

    pub fn serialize(self, wr: &mut impl Write) -> io::Result<()> {
        wr.write_u64::<LittleEndian>(0)?;
        wr.write_f64::<LittleEndian>(self.lat)?;
        wr.write_f64::<LittleEndian>(self.lon)?;
        wr.write_u32::<LittleEndian>(0)?;
        wr.write_u32::<LittleEndian>(self.points)?;
        wr.write_f64::<LittleEndian>(self.dist)?;
        wr.write_u32::<LittleEndian>(self.time)?;
        wr.write_f32::<LittleEndian>(self.speed)?;
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use assert_approx_eq::assert_approx_eq;
    use std::fs::File;
    use std::io::BufWriter;
    use std::path::PathBuf;

    #[test]
    fn test_deserialize() -> Result<(), io::Error> {
        let mut d = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
        d.push("resources/testdata/TRAIL.DAT");
        let mut f = File::open(&d)?;
        let v = Trail::deserialize(&mut f)?;
        assert_approx_eq!(v.lat, 55.7880, 0.001);
        assert_approx_eq!(v.lon, 37.5388, 0.001);
        assert_approx_eq!(v.dist, 3011.489, 0.001);
        assert_eq!(v.time, 1983);
        Ok(())
    }

    #[test]
    fn test_serialize() -> Result<(), io::Error> {
        let testtrail = Trail {
            lat: 55.788067,
            lon: 37.538875833333336,
            points: 1972,
            dist: 3011.489339109006,
            time: 1983,
            speed: 3.57,
        };
        let refbytes: [u8; 48] = [
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x07, 0x24, 0x61, 0xdf, 0xe4,
            0x4b, 0x40, 0xbe, 0x62, 0x20, 0xe2, 0xf9, 0xc4, 0x42, 0x40, 0x00, 0x00, 0x00, 0x00,
            0xb4, 0x07, 0x00, 0x00, 0xab, 0xdb, 0xa7, 0x8a, 0xfa, 0x86, 0xa7, 0x40, 0xbf, 0x07,
            0x00, 0x00, 0xe1, 0x7a, 0x64, 0x40,
            // 0xe1, 0x7a, 0x64, 0x40, - last bytes
        ];
        let mut bytes = [0; 48];
        {
            let bytes_ref: &mut [u8] = &mut bytes;
            let mut writer = BufWriter::new(bytes_ref);
            testtrail.serialize(&mut writer)?;
        }
        assert_eq!(bytes, refbytes);

        Ok(())
    }
}