refactoring

gpx-rs/engine/src/core/gpx/chunk.rs

@@ -0,0 +1,61 @@
+use uuid::Uuid;
+
+use crate::{Trackpoint, Waypoint};
+
+static MAX_TRKPT_CHUNK_SIZE: usize = 4096;
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct TrackpointChunkId(Uuid);
+
+impl Default for TrackpointChunkId {
+    fn default() -> Self {
+        Self(Uuid::new_v4())
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct TrackpointChunk {
+    pub id: TrackpointChunkId,
+    pub trkpt: Vec<Trackpoint>,
+}
+
+impl PartialEq for TrackpointChunk {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+    }
+}
+
+impl TrackpointChunk {
+    pub fn is_full(&self) -> bool {
+        self.trkpt.len() == MAX_TRKPT_CHUNK_SIZE
+    }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct WaypointChunkId(Uuid);
+
+impl Default for WaypointChunkId {
+    fn default() -> Self {
+        Self(Uuid::new_v4())
+    }
+}
+
+static MAX_WPT_CHUNK_SIZE: usize = 128;
+
+#[derive(Debug, Default)]
+pub struct WaypointChunk {
+    pub id: WaypointChunkId,
+    pub wpt: Vec<Waypoint>,
+}
+
+impl PartialEq for WaypointChunk {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+    }
+}
+
+impl WaypointChunk {
+    pub fn is_full(&self) -> bool {
+        self.wpt.len() == MAX_WPT_CHUNK_SIZE
+    }
+}

gpx-rs/engine/src/core/gpx/common.rs

@@ -0,0 +1,48 @@
+#[derive(Debug, Default, PartialEq, Eq)]
+pub struct Link {
+    pub href: String,
+    pub text: Option<String>,
+}
+
+#[derive(Debug, Default, Clone, Copy)]
+pub struct LngLat {
+    pub lng: f64,
+    pub lat: f64,
+}
+
+#[derive(Debug)]
+pub struct LngLatBounds {
+    pub sw: LngLat,
+    pub ne: LngLat,
+}
+
+impl Default for LngLatBounds {
+    fn default() -> Self {
+        Self {
+            sw: LngLat {
+                lng: 180.0,
+                lat: 90.0,
+            },
+            ne: LngLat {
+                lng: -180.0,
+                lat: -90.0,
+            },
+        }
+    }
+}
+
+impl LngLatBounds {
+    pub fn extend(&mut self, coordinates: LngLat) {
+        self.sw.lng = self.sw.lng.min(coordinates.lng);
+        self.sw.lat = self.sw.lat.min(coordinates.lat);
+        self.ne.lng = self.ne.lng.max(coordinates.lng);
+        self.ne.lat = self.ne.lat.max(coordinates.lat);
+    }
+
+    pub fn merge(&mut self, other: &LngLatBounds) {
+        self.sw.lng = self.sw.lng.min(other.sw.lng);
+        self.sw.lat = self.sw.lat.min(other.sw.lat);
+        self.ne.lng = self.ne.lng.max(other.ne.lng);
+        self.ne.lat = self.ne.lat.max(other.ne.lat);
+    }
+}

gpx-rs/engine/src/core/gpx/file.rs

@@ -0,0 +1,39 @@
+use std::rc::Rc;
+
+use uuid::Uuid;
+
+use crate::{Link, Track, WaypointChunk};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct FileId(pub Uuid);
+
+impl Default for FileId {
+    fn default() -> Self {
+        Self(Uuid::new_v4())
+    }
+}
+
+#[derive(Debug, Default, PartialEq)]
+pub struct File {
+    pub id: FileId,
+    pub info: FileInfo,
+    pub trk: Vec<Track>,
+    pub wpt: Vec<Rc<WaypointChunk>>,
+    // TODO routes
+}
+
+#[derive(Debug, Default, PartialEq)]
+pub struct FileInfo {
+    pub name: String,
+    pub desc: Option<String>,
+    pub author: Option<Author>,
+    pub link: Option<Link>,
+    pub time: Option<i64>,
+}
+
+#[derive(Debug, Default, PartialEq)]
+pub struct Author {
+    pub name: Option<String>,
+    pub email: Option<String>,
+    pub link: Option<Link>,
+}

gpx-rs/engine/src/core/gpx/mod.rs

@@ -0,0 +1,15 @@
+mod chunk;
+mod common;
+mod file;
+mod segment;
+mod track;
+mod trackpoint;
+mod waypoint;
+
+pub use chunk::*;
+pub use common::*;
+pub use file::*;
+pub use segment::*;
+pub use track::*;
+pub use trackpoint::*;
+pub use waypoint::*;

gpx-rs/engine/src/core/gpx/segment.rs

@@ -0,0 +1,271 @@
+use std::{ops::Index, rc::Rc};
+
+use uuid::Uuid;
+
+use crate::{Trackpoint, TrackpointChunk};
+
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub struct TrackSegmentId(Uuid);
+
+impl Default for TrackSegmentId {
+    fn default() -> Self {
+        Self(Uuid::new_v4())
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct TrackSegmentRevisionId(Uuid);
+
+impl Default for TrackSegmentRevisionId {
+    fn default() -> Self {
+        Self(Uuid::new_v4())
+    }
+}
+
+#[derive(Debug, Default, PartialEq)]
+pub struct TrackSegment {
+    pub id: TrackSegmentId,
+    pub rev_id: TrackSegmentRevisionId,
+    chunks: Vec<Rc<TrackpointChunk>>,
+    cumul_length: Vec<usize>,
+}
+
+impl TrackSegment {
+    pub fn push(&mut self, chunk: TrackpointChunk) {
+        if chunk.trkpt.is_empty() {
+            return;
+        }
+        self.cumul_length
+            .push(self.cumul_length.last().copied().unwrap_or_default() + chunk.trkpt.len());
+        self.chunks.push(Rc::new(chunk));
+    }
+
+    pub fn len(&self) -> usize {
+        self.cumul_length.last().copied().unwrap_or_default()
+    }
+
+    pub fn iter(&self) -> TrackSegmentIterator<'_> {
+        TrackSegmentIterator::new(self)
+    }
+
+    pub fn first_index(&self) -> Option<TrackSegmentIndex> {
+        self.next_index(None)
+    }
+
+    pub fn last_index(&self) -> Option<TrackSegmentIndex> {
+        self.prev_index(None)
+    }
+
+    pub fn next_index(&self, cur: Option<TrackSegmentIndex>) -> Option<TrackSegmentIndex> {
+        let mut next = cur.map_or_default(|idx| TrackSegmentIndex {
+            chunk: idx.chunk,
+            pos: idx.pos + 1,
+            flat: idx.flat + 1,
+        });
+        loop {
+            if next.chunk >= self.chunks.len() {
+                return None;
+            }
+            if next.pos == self.chunks[next.chunk].trkpt.len() {
+                next.chunk += 1;
+                next.pos = 0;
+            } else {
+                return Some(next);
+            }
+        }
+    }
+
+    pub fn prev_index(&self, cur: Option<TrackSegmentIndex>) -> Option<TrackSegmentIndex> {
+        let mut prev = cur.unwrap_or(TrackSegmentIndex {
+            chunk: self.chunks.len(),
+            pos: 0,
+            flat: self.cumul_length.last().copied().unwrap_or_default(),
+        });
+        loop {
+            if prev.pos == 0 {
+                if prev.chunk == 0 {
+                    return None;
+                }
+                prev.chunk -= 1;
+                prev.pos = self.chunks[prev.chunk].trkpt.len();
+                prev.flat -= 1;
+            } else {
+                prev.pos -= 1;
+                prev.flat -= 1;
+                return Some(prev);
+            }
+        }
+    }
+
+    fn locate(&self, idx: usize) -> Option<TrackSegmentIndex> {
+        let chunk = self.cumul_length.partition_point(|l| idx >= *l);
+        if chunk >= self.chunks.len() {
+            return None;
+        }
+        let pos = if chunk > 0 {
+            idx - self.cumul_length[chunk - 1]
+        } else {
+            idx
+        };
+        if pos >= self.chunks[chunk].trkpt.len() {
+            None
+        } else {
+            Some(TrackSegmentIndex {
+                chunk,
+                pos,
+                flat: idx,
+            })
+        }
+    }
+}
+
+impl Index<TrackSegmentIndex> for TrackSegment {
+    type Output = Trackpoint;
+
+    fn index(&self, idx: TrackSegmentIndex) -> &Self::Output {
+        &self.chunks[idx.chunk].trkpt[idx.pos]
+    }
+}
+
+impl Index<usize> for TrackSegment {
+    type Output = Trackpoint;
+
+    fn index(&self, idx: usize) -> &Self::Output {
+        &self[self.locate(idx).unwrap()]
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, PartialOrd, Ord)]
+pub struct TrackSegmentIndex {
+    pub chunk: usize,
+    pub pos: usize,
+    pub flat: usize,
+}
+
+#[derive(Debug, Clone)]
+pub struct TrackSegmentIterator<'a> {
+    trkseg: &'a TrackSegment,
+    idx: Option<TrackSegmentIndex>,
+}
+
+impl<'a> TrackSegmentIterator<'a> {
+    pub fn new(trkseg: &'a TrackSegment) -> Self {
+        Self {
+            trkseg,
+            idx: Default::default(),
+        }
+    }
+}
+
+impl<'a> Iterator for TrackSegmentIterator<'a> {
+    type Item = &'a Trackpoint;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.idx = self.trkseg.next_index(self.idx);
+        self.idx.map(|idx| &self.trkseg[idx])
+    }
+
+    fn nth(&mut self, n: usize) -> Option<Self::Item> {
+        let idx = self.idx.map_or_default(|idx| idx.flat) + n;
+        self.idx = self.trkseg.locate(idx);
+        self.idx.map(|idx| &self.trkseg[idx])
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn create_track_segment(nb_chunks: usize) -> TrackSegment {
+        let mut trkseg = TrackSegment::default();
+        let mut count = 0;
+        for n in 1..=nb_chunks {
+            let mut chunk = TrackpointChunk::default();
+            for _ in 0..n {
+                let mut trkpt = Trackpoint::default();
+                trkpt.ele = count as f64;
+                chunk.trkpt.push(trkpt);
+                count += 1;
+            }
+            trkseg.push(chunk);
+        }
+        trkseg
+    }
+
+    #[test]
+    fn test_len() {
+        let nb_chunks = 10;
+        let trkseg = create_track_segment(nb_chunks);
+        assert_eq!(trkseg.len(), nb_chunks * (nb_chunks + 1) / 2);
+    }
+
+    #[test]
+    fn test_locate() {
+        let nb_chunks = 10;
+        let trkseg = create_track_segment(nb_chunks);
+        for i in 0..trkseg.len() {
+            let idx = trkseg.locate(i);
+            assert!(idx.is_some());
+            assert_eq!(trkseg[idx.unwrap()].ele, i as f64);
+        }
+
+        assert!(trkseg.locate(trkseg.len()).is_none());
+    }
+
+    #[test]
+    fn test_index() {
+        let nb_chunks = 10;
+        let trkseg = create_track_segment(nb_chunks);
+        for i in 0..trkseg.len() {
+            assert_eq!(trkseg[i].ele, i as f64);
+        }
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_index_out_of_bounds_1() {
+        let nb_chunks = 10;
+        let trkseg = create_track_segment(nb_chunks);
+        trkseg[trkseg.len()].ele;
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_index_out_of_bounds_2() {
+        let nb_chunks = 10;
+        let trkseg = create_track_segment(nb_chunks);
+        trkseg[TrackSegmentIndex {
+            chunk: trkseg.chunks.len(),
+            pos: 0,
+            flat: 0,
+        }]
+        .ele;
+    }
+
+    #[test]
+    fn test_iter() {
+        let nb_chunks = 10;
+        let trkseg = create_track_segment(nb_chunks);
+        for (i, trkpt) in trkseg.iter().enumerate() {
+            assert!(std::ptr::eq(&trkseg[i], trkpt));
+        }
+    }
+
+    #[test]
+    fn test_iter_nth() {
+        let nb_chunks = 10;
+        let trkseg = create_track_segment(nb_chunks);
+        let tenth = trkseg.iter().nth(10);
+        assert!(tenth.is_some());
+        assert!(std::ptr::eq(&trkseg[10], tenth.unwrap()));
+    }
+
+    #[test]
+    fn test_iter_skip() {
+        let nb_chunks = 10;
+        let trkseg = create_track_segment(nb_chunks);
+        for (i, trkpt) in trkseg.iter().enumerate().skip(5) {
+            assert!(std::ptr::eq(&trkseg[i], trkpt));
+        }
+    }
+}

gpx-rs/engine/src/core/gpx/track.rs

@@ -0,0 +1,32 @@
+use uuid::Uuid;
+
+use crate::{Link, TrackSegment};
+
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub struct TrackId(Uuid);
+
+impl Default for TrackId {
+    fn default() -> Self {
+        Self(Uuid::new_v4())
+    }
+}
+
+#[derive(Debug, Default, PartialEq)]
+pub struct Track {
+    pub id: TrackId,
+    pub info: TrackInfo,
+    pub trkseg: Vec<TrackSegment>,
+}
+
+#[derive(Debug, Default, PartialEq)]
+pub struct TrackInfo {
+    pub name: Option<String>,
+    pub cmt: Option<String>,
+    pub desc: Option<String>,
+    pub src: Option<String>,
+    pub link: Option<Link>,
+    pub type_: Option<String>,
+    pub color: Option<String>,
+    pub opacity: Option<f64>,
+    pub width: Option<f64>,
+}

gpx-rs/engine/src/core/gpx/trackpoint.rs

@@ -0,0 +1,13 @@
+use crate::LngLat;
+
+#[derive(Debug, Default)]
+pub struct Trackpoint {
+    pub coordinates: LngLat,
+    pub ele: f64,
+    pub time: Option<i64>,
+    pub atemp: Option<i16>,
+    pub hr: Option<u16>,
+    pub cad: Option<u16>,
+    pub power: Option<u16>,
+    // TODO OSM data? or store intervals at a higher level?
+}

gpx-rs/engine/src/core/gpx/waypoint.rs

@@ -0,0 +1,26 @@
+use uuid::Uuid;
+
+use crate::{Link, LngLat};
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct WaypointId(Uuid);
+
+impl Default for WaypointId {
+    fn default() -> Self {
+        Self(Uuid::new_v4())
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct Waypoint {
+    pub id: WaypointId,
+    pub coordinates: LngLat,
+    pub ele: f64,
+    pub time: Option<i64>,
+    pub name: Option<String>,
+    pub cmt: Option<String>,
+    pub desc: Option<String>,
+    pub link: Option<Link>,
+    pub sym: Option<String>,
+    pub type_: Option<String>,
+}