reverse

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

@@ -1,8 +1,10 @@
 mod anchors;
+mod reverse;
 mod simplify;
 mod smooth;
 mod timestamps;
 
 pub use anchors::*;
+pub use reverse::*;
 pub use simplify::*;
 pub use timestamps::*;

gpx-rs/engine/src/core/algorithm/reverse.rs

@@ -0,0 +1,194 @@
+//! Reversing a path: the order of its trackpoints, and of the segments and tracks that hold them.
+//!
+//! The timestamps are mirrored, so that the reversed path goes through the same period of time:
+//! a trackpoint at time `t` of a part that spans `start..end` ends up at `start + end - t`. When
+//! the part is made of several ones (the segments of a track, the tracks of a file), the gaps
+//! between them are kept: every part comes after the previous one in the new order, as late as the
+//! original one came after the part that followed it.
+
+use crate::{Track, TrackSegment, Trackpoint};
+
+/// The time of the first trackpoint of a segment.
+pub fn start_time(segment: &TrackSegment) -> Option<i64> {
+    segment.iter().next().and_then(|trkpt| trkpt.time)
+}
+
+/// The time of the last trackpoint of a segment.
+pub fn end_time(segment: &TrackSegment) -> Option<i64> {
+    segment.last_index().and_then(|idx| segment[idx].time)
+}
+
+/// The time of the first trackpoint of a track.
+pub fn track_start_time(track: &Track) -> Option<i64> {
+    track.trkseg.first().and_then(start_time)
+}
+
+/// The time of the last trackpoint of a track.
+pub fn track_end_time(track: &Track) -> Option<i64> {
+    track.trkseg.last().and_then(end_time)
+}
+
+/// Reverses the trackpoints of a segment.
+///
+/// `original_next` is the time at which what came after the segment started, and `new_previous`
+/// the time at which what comes before it now ends: the segment is mirrored to start there. Both
+/// are those of the segment itself if the segment is reversed on its own, which are the ones
+/// used when they are missing (`new_previous` is the start of the segment, and `original_next`
+/// follows from the duration of the segment). Without timestamps, the trackpoints are only put
+/// in the opposite order.
+pub fn reverse_segment(
+    segment: &mut TrackSegment,
+    original_next: Option<i64>,
+    new_previous: Option<i64>,
+) {
+    let (original_start, original_end) = (start_time(segment), end_time(segment));
+    let new_previous = new_previous.or(original_start);
+    let original_next = original_next.or_else(|| {
+        // the segment lasts as long as before
+        Some(new_previous? + original_end? - original_start?)
+    });
+
+    let len = segment.len();
+    let mut points: Vec<Trackpoint> = segment.iter().cloned().collect();
+    if let (Some(next), Some(previous), Some(end)) = (original_next, new_previous, original_end) {
+        let new_start = previous + next - end;
+        for point in points.iter_mut() {
+            point.time = point.time.map(|time| new_start + (end - time));
+        }
+    }
+    points.reverse();
+    segment.splice(0, len, points);
+    segment.rev_id = Default::default();
+}
+
+/// Reverses the segments of a track, and their trackpoints: see [`reverse_segment`] for the
+/// meaning of the times, which are the ones of the track as a whole.
+pub fn reverse_segments(
+    segments: &mut [TrackSegment],
+    original_next: Option<i64>,
+    new_previous: Option<i64>,
+) {
+    segments.reverse();
+    let (mut next, mut previous) = (original_next, new_previous);
+    for segment in segments.iter_mut() {
+        // the next one is the one that was before, which started here
+        let original_start = start_time(segment);
+        reverse_segment(segment, next, previous);
+        next = original_start;
+        previous = end_time(segment);
+    }
+}
+
+/// Reverses the tracks of a file, and their segments and trackpoints.
+pub fn reverse_tracks(tracks: &mut [Track], original_next: Option<i64>, new_previous: Option<i64>) {
+    tracks.reverse();
+    let (mut next, mut previous) = (original_next, new_previous);
+    for track in tracks.iter_mut() {
+        let original_start = track_start_time(track);
+        reverse_segments(&mut track.trkseg, next, previous);
+        next = original_start;
+        previous = track_end_time(track);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::LngLat;
+
+    use super::*;
+
+    fn segment(points: &[(f64, Option<i64>)]) -> TrackSegment {
+        let mut segment = TrackSegment::default();
+        let points = points
+            .iter()
+            .map(|(lng, time)| Trackpoint {
+                coordinates: LngLat {
+                    lng: *lng,
+                    lat: 0.0,
+                },
+                time: *time,
+                ..Default::default()
+            })
+            .collect();
+        segment.splice(0, 0, points);
+        segment
+    }
+
+    fn lngs(segment: &TrackSegment) -> Vec<f64> {
+        segment.iter().map(|p| p.coordinates.lng).collect()
+    }
+
+    fn times(segment: &TrackSegment) -> Vec<Option<i64>> {
+        segment.iter().map(|p| p.time).collect()
+    }
+
+    #[test]
+    fn test_a_segment_is_mirrored_in_its_own_time_span() {
+        let mut s = segment(&[(0.0, Some(0)), (1.0, Some(10)), (2.0, Some(40))]);
+        let (start, end) = (start_time(&s), end_time(&s));
+        reverse_segment(&mut s, end, start);
+        assert_eq!(lngs(&s), [2.0, 1.0, 0.0]);
+        // same span, the durations between points follow the points
+        assert_eq!(times(&s), [Some(0), Some(30), Some(40)]);
+    }
+
+    #[test]
+    fn test_reverse_segment_defaults() {
+        // without the times around, the segment is mirrored where it is
+        let mut s = segment(&[(0.0, Some(100)), (1.0, Some(130))]);
+        reverse_segment(&mut s, None, None);
+        assert_eq!(times(&s), [Some(100), Some(130)]);
+        assert_eq!(lngs(&s), [1.0, 0.0]);
+    }
+
+    #[test]
+    fn test_a_segment_without_times_is_only_reversed() {
+        let mut s = segment(&[(0.0, None), (1.0, None), (2.0, None)]);
+        reverse_segment(&mut s, None, None);
+        assert_eq!(lngs(&s), [2.0, 1.0, 0.0]);
+        assert_eq!(times(&s), [None, None, None]);
+    }
+
+    #[test]
+    fn test_segments_keep_the_gaps_between_them() {
+        // 0..20, then 100..120: a gap of 80
+        let mut segments = vec![
+            segment(&[(0.0, Some(0)), (1.0, Some(10)), (2.0, Some(20))]),
+            segment(&[(3.0, Some(100)), (4.0, Some(110)), (5.0, Some(120))]),
+        ];
+        let (end, start) = (end_time(&segments[1]), start_time(&segments[0]));
+        reverse_segments(&mut segments, end, start);
+        assert_eq!(lngs(&segments[0]), [5.0, 4.0, 3.0]);
+        assert_eq!(lngs(&segments[1]), [2.0, 1.0, 0.0]);
+        assert_eq!(times(&segments[0]), [Some(0), Some(10), Some(20)]);
+        // the gap is still 80
+        assert_eq!(times(&segments[1]), [Some(100), Some(110), Some(120)]);
+    }
+
+    #[test]
+    fn test_tracks_are_reversed_like_segments() {
+        let track = |segments: Vec<TrackSegment>| Track {
+            trkseg: segments,
+            ..Default::default()
+        };
+        let mut tracks = vec![
+            track(vec![
+                segment(&[(0.0, Some(0)), (1.0, Some(10))]),
+                segment(&[(2.0, Some(50)), (3.0, Some(60))]),
+            ]),
+            track(vec![segment(&[(4.0, Some(200)), (5.0, Some(230))])]),
+        ];
+        let (end, start) = (track_end_time(&tracks[1]), track_start_time(&tracks[0]));
+        reverse_tracks(&mut tracks, end, start);
+        let all: Vec<f64> = tracks
+            .iter()
+            .flat_map(|t| t.trkseg.iter().flat_map(lngs))
+            .collect();
+        assert_eq!(all, [5.0, 4.0, 3.0, 2.0, 1.0, 0.0]);
+        // 3 segments: durations 10, 10, 30 and gaps 40 and 140 are reversed to 30, 10, 10 and
+        // gaps 140 and 40 (the first part of the time is the longest)
+        assert_eq!(times(&tracks[0].trkseg[0]), [Some(0), Some(30)]);
+        assert_eq!(times(&tracks[1].trkseg[0]), [Some(170), Some(180)]);
+        assert_eq!(times(&tracks[1].trkseg[1]), [Some(220), Some(230)]);
+    }
+}