progress

gpx-rs/src/core/algorithm/anchors.rs

@@ -0,0 +1,112 @@
+use std::f64::consts::PI;
+
+use crate::{
+    TrackSegment, TrackSegmentIndex, core::utils::crossarc_lnglat, ramer_douglas_peucker_by,
+};
+
+/// Highest zoom level of the map at which an anchor can appear.
+pub const MAX_ANCHOR_ZOOM: u8 = 22;
+
+/// Details smaller than this (in meters) do not get an anchor.
+const ANCHOR_EPSILON: f64 = 1.0;
+
+const EARTH_RADIUS_METERS: f64 = 6371008.8;
+
+/// Lowest map zoom level at which an anchor selected at `distance` meters from the line of its
+/// neighbours is worth showing: the smaller the detail, the higher the zoom. The ends of a
+/// segment (no distance) are always shown.
+pub fn anchor_zoom(lat: f64, distance: Option<f64>) -> u8 {
+    let Some(distance) = distance else {
+        return 0;
+    };
+    let width = EARTH_RADIUS_METERS * (lat * PI / 180.0).cos() / distance;
+    width.log2().round().clamp(0.0, MAX_ANCHOR_ZOOM as f64) as u8
+}
+
+/// The anchors of a segment, as `(index, zoom)` sorted by index: the trackpoints kept by the
+/// Ramer-Douglas-Peucker simplification of its path, the ones for smaller details being shown at
+/// higher zoom levels only.
+pub fn compute_anchors(trkseg: &TrackSegment) -> Vec<(usize, u8)> {
+    let measure = |start: TrackSegmentIndex, end: TrackSegmentIndex, idx: TrackSegmentIndex| {
+        crossarc_lnglat(
+            trkseg[start].coordinates,
+            trkseg[end].coordinates,
+            trkseg[idx].coordinates,
+        )
+    };
+    ramer_douglas_peucker_by(trkseg, &measure, ANCHOR_EPSILON)
+        .into_iter()
+        .map(|(idx, distance)| (idx.flat, anchor_zoom(trkseg[idx].coordinates.lat, distance)))
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{LngLat, Trackpoint, TrackpointChunk};
+
+    use super::*;
+
+    fn segment(points: &[(f64, f64)]) -> TrackSegment {
+        let mut trkseg = TrackSegment::default();
+        let mut chunk = TrackpointChunk::default();
+        for (lng, lat) in points {
+            chunk.trkpt.push(Trackpoint {
+                coordinates: LngLat {
+                    lng: *lng,
+                    lat: *lat,
+                },
+                ..Default::default()
+            });
+        }
+        trkseg.push(chunk);
+        trkseg
+    }
+
+    #[test]
+    fn test_zoom_depends_on_the_size_of_the_detail() {
+        assert_eq!(anchor_zoom(45.0, None), 0);
+        // 2^13 meters is close to the radius of the earth divided by 1 km
+        assert_eq!(anchor_zoom(0.0, Some(1_000.0)), 13);
+        assert!(anchor_zoom(0.0, Some(10.0)) > anchor_zoom(0.0, Some(1_000.0)));
+        assert_eq!(anchor_zoom(0.0, Some(1e-9)), MAX_ANCHOR_ZOOM);
+        assert_eq!(anchor_zoom(0.0, Some(1e9)), 0);
+        // the poles do not give NaN or a panic
+        assert_eq!(anchor_zoom(90.0, Some(10.0)), 0);
+    }
+
+    #[test]
+    fn test_anchors_of_a_straight_line_are_its_ends() {
+        let line: Vec<_> = (0..10).map(|i| (i as f64 * 0.001, 0.0)).collect();
+        assert_eq!(compute_anchors(&segment(&line)), vec![(0, 0), (9, 0)]);
+    }
+
+    #[test]
+    fn test_anchors_keep_the_corners() {
+        // a big corner and a small bump
+        let points = [
+            (0.0, 0.0),
+            (0.01, 0.0),
+            (0.02, 0.0),
+            (0.02, 0.01),
+            (0.02, 0.02),
+            (0.02, 0.020005),
+            (0.02, 0.03),
+        ];
+        let anchors = compute_anchors(&segment(&points));
+        let indices: Vec<_> = anchors.iter().map(|(i, _)| *i).collect();
+        assert_eq!(indices, vec![0, 2, 6]);
+        assert_eq!(anchors[0].1, 0);
+        assert_eq!(anchors[2].1, 0);
+        assert!(anchors[1].1 > 0);
+    }
+
+    #[test]
+    fn test_anchors_of_short_segments() {
+        assert!(compute_anchors(&segment(&[])).is_empty());
+        assert_eq!(compute_anchors(&segment(&[(1.0, 2.0)])), vec![(0, 0)]);
+        assert_eq!(
+            compute_anchors(&segment(&[(1.0, 2.0), (1.0, 2.1)])),
+            vec![(0, 0), (1, 0)]
+        );
+    }
+}

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

@@ -0,0 +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/src/core/algorithm/reverse.rs

@@ -0,0 +1,232 @@
+//! 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();
+}
+
+/// Makes a segment go back where it started: a reversed copy of it is added after its last
+/// trackpoint, without the first trackpoint of the copy, which is the last one of the segment.
+///
+/// The timestamps of the copy go on from the end of the segment: it would start at the time of the
+/// last trackpoint, and it lasts as long as the segment. Only the end of the segment changes, so
+/// its other chunks stay shared.
+pub fn round_trip(segment: &mut TrackSegment) {
+    let len = segment.len();
+    let end = end_time(segment);
+    let mut back = segment.clone();
+    reverse_segment(&mut back, end, end);
+    segment.splice(len, len, back.iter().skip(1).cloned().collect());
+    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_round_trip_goes_back_in_time_from_the_end() {
+        let mut s = segment(&[(0.0, Some(0)), (1.0, Some(10)), (2.0, Some(40))]);
+        let first = s.rev_id;
+        round_trip(&mut s);
+        assert_ne!(s.rev_id, first);
+        // the last trackpoint is the turning point, it is not repeated
+        assert_eq!(lngs(&s), [0.0, 1.0, 2.0, 1.0, 0.0]);
+        // the way back lasts as long as the way there, and starts when it ended
+        assert_eq!(times(&s), [Some(0), Some(10), Some(40), Some(70), Some(80)]);
+        // and it is a segment whose ends are anchors
+        assert_eq!(s[0].anchor, Some(0));
+        assert_eq!(s[4].anchor, Some(0));
+    }
+
+    #[test]
+    fn test_round_trip_without_times() {
+        let mut s = segment(&[(0.0, None), (1.0, None)]);
+        round_trip(&mut s);
+        assert_eq!(lngs(&s), [0.0, 1.0, 0.0]);
+        assert_eq!(times(&s), [None; 3]);
+    }
+
+    #[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)]);
+    }
+}

gpx-rs/src/core/algorithm/simplify.rs

@@ -0,0 +1,232 @@
+use crate::{
+    core::gpx::{TrackSegment, TrackSegmentIndex},
+    core::utils::{crossarc, crossarc_lnglat},
+};
+
+pub fn ramer_douglas_peucker<F>(
+    trkseg: &TrackSegment,
+    mapping: &F,
+    epsilon: f64,
+) -> Vec<TrackSegmentIndex>
+where
+    F: Fn(TrackSegmentIndex) -> (f64, f64),
+{
+    let measure = |start, end, idx| {
+        let (start, end, pt) = (mapping(start), mapping(end), mapping(idx));
+        crossarc(start.0, start.1, end.0, end.1, pt.0, pt.1)
+    };
+    ramer_douglas_peucker_by(trkseg, &measure, epsilon)
+        .into_iter()
+        .map(|(idx, _)| idx)
+        .collect()
+}
+
+/// Ramer-Douglas-Peucker with any distance from a point (the last argument) to the line made of
+/// two others (the first ones). Gives the kept points, with the distance at which each of them
+/// was selected (`None` for the ends of the segment, which are always kept).
+pub fn ramer_douglas_peucker_by<M>(
+    trkseg: &TrackSegment,
+    measure: &M,
+    epsilon: f64,
+) -> Vec<(TrackSegmentIndex, Option<f64>)>
+where
+    M: Fn(TrackSegmentIndex, TrackSegmentIndex, TrackSegmentIndex) -> f64,
+{
+    match trkseg.len() {
+        0 => vec![],
+        1 => vec![(trkseg.first_index().unwrap(), None)],
+        2 => vec![
+            (trkseg.first_index().unwrap(), None),
+            (trkseg.last_index().unwrap(), None),
+        ],
+        _ => {
+            let first = trkseg.first_index().unwrap();
+            let last = trkseg.last_index().unwrap();
+
+            let mut kept = vec![(first, None)];
+            ramer_douglas_peucker_helper(trkseg, first, last, measure, epsilon, &mut kept);
+            kept.push((last, None));
+            kept
+        }
+    }
+}
+
+fn ramer_douglas_peucker_helper<M>(
+    trkseg: &TrackSegment,
+    start: TrackSegmentIndex,
+    end: TrackSegmentIndex,
+    measure: &M,
+    epsilon: f64,
+    kept: &mut Vec<(TrackSegmentIndex, Option<f64>)>,
+) where
+    M: Fn(TrackSegmentIndex, TrackSegmentIndex, TrackSegmentIndex) -> f64,
+{
+    let mut max_idx = None;
+    let mut max_dist = 0.0;
+
+    let mut cur = trkseg.next_index(Some(start));
+    while let Some(idx) = cur {
+        if idx == end {
+            break;
+        }
+
+        let dist = measure(start, end, idx);
+        if dist > max_dist {
+            max_idx = Some(idx);
+            max_dist = dist;
+        }
+
+        cur = trkseg.next_index(cur);
+    }
+
+    if let Some(idx) = max_idx.filter(|_| max_dist > epsilon) {
+        ramer_douglas_peucker_helper(trkseg, start, idx, measure, epsilon, kept);
+        kept.push((idx, Some(max_dist)));
+        ramer_douglas_peucker_helper(trkseg, idx, end, measure, epsilon, kept);
+    }
+}
+
+/// Lowest tolerance (in meters) of the reduction of a segment, see [`reduction_distances`].
+pub const MIN_REDUCE_TOLERANCE: f64 = 0.1;
+
+/// The distance (in meters) from a trackpoint to the line between two others of a segment.
+fn lnglat_measure(
+    trkseg: &TrackSegment,
+) -> impl Fn(TrackSegmentIndex, TrackSegmentIndex, TrackSegmentIndex) -> f64 + '_ {
+    move |start, end, idx| {
+        crossarc_lnglat(
+            trkseg[start].coordinates,
+            trkseg[end].coordinates,
+            trkseg[idx].coordinates,
+        )
+    }
+}
+
+/// The indices of the trackpoints of a segment that are kept when it is reduced with `tolerance`
+/// meters (Ramer-Douglas-Peucker), in order. The ends are always kept.
+pub fn reduce_indices(trkseg: &TrackSegment, tolerance: f64) -> Vec<usize> {
+    ramer_douglas_peucker_by(trkseg, &lnglat_measure(trkseg), tolerance)
+        .into_iter()
+        .map(|(idx, _)| idx.flat)
+        .collect()
+}
+
+/// For each trackpoint of a segment, the tolerance (in meters) up to which it is kept by
+/// [`reduce_indices`]: infinite for the ends, which are always kept, zero for the trackpoints that
+/// are not selected even at [`MIN_REDUCE_TOLERANCE`]. A trackpoint is kept with a tolerance if its
+/// value is greater than it.
+///
+/// A trackpoint is only selected if the ones that split the path before it are, so its value is
+/// the smallest distance at which it or one of them was selected.
+pub fn reduction_distances(trkseg: &TrackSegment) -> Vec<f64> {
+    let mut distances = vec![0.0; trkseg.len()];
+    let (Some(first), Some(last)) = (trkseg.first_index(), trkseg.last_index()) else {
+        return distances;
+    };
+    distances[first.flat] = f64::INFINITY;
+    distances[last.flat] = f64::INFINITY;
+    if trkseg.len() > 2 {
+        let measure = lnglat_measure(trkseg);
+        reduction_distances_helper(trkseg, first, last, &measure, f64::INFINITY, &mut distances);
+    }
+    distances
+}
+
+fn reduction_distances_helper<M>(
+    trkseg: &TrackSegment,
+    start: TrackSegmentIndex,
+    end: TrackSegmentIndex,
+    measure: &M,
+    bound: f64,
+    distances: &mut [f64],
+) where
+    M: Fn(TrackSegmentIndex, TrackSegmentIndex, TrackSegmentIndex) -> f64,
+{
+    let mut max_idx = None;
+    let mut max_dist = 0.0;
+    let mut cur = trkseg.next_index(Some(start));
+    while let Some(idx) = cur {
+        if idx == end {
+            break;
+        }
+        let dist = measure(start, end, idx);
+        if dist > max_dist {
+            max_idx = Some(idx);
+            max_dist = dist;
+        }
+        cur = trkseg.next_index(cur);
+    }
+
+    if let Some(idx) = max_idx.filter(|_| max_dist > MIN_REDUCE_TOLERANCE) {
+        let distance = max_dist.min(bound);
+        distances[idx.flat] = distance;
+        reduction_distances_helper(trkseg, start, idx, measure, distance, distances);
+        reduction_distances_helper(trkseg, idx, end, measure, distance, distances);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{Trackpoint, TrackpointChunk};
+
+    use super::*;
+
+    fn segment(eles: &[f64]) -> TrackSegment {
+        let mut trkseg = TrackSegment::default();
+        // several small chunks, to also exercise the chunk boundaries
+        for part in eles.chunks(3) {
+            let mut chunk = TrackpointChunk::default();
+            for ele in part {
+                chunk.trkpt.push(Trackpoint {
+                    ele: *ele,
+                    ..Default::default()
+                });
+            }
+            trkseg.push(chunk);
+        }
+        trkseg
+    }
+
+    fn simplify(eles: &[f64], epsilon: f64) -> Vec<usize> {
+        let trkseg = segment(eles);
+        ramer_douglas_peucker(&trkseg, &|idx| (idx.flat as f64, trkseg[idx].ele), epsilon)
+            .iter()
+            .map(|idx| idx.flat)
+            .collect()
+    }
+
+    #[test]
+    fn test_empty_and_single_point() {
+        assert!(simplify(&[], 1.0).is_empty());
+        assert_eq!(simplify(&[5.0], 1.0), vec![0]);
+    }
+
+    #[test]
+    fn test_collinear_points_are_removed() {
+        let eles: Vec<f64> = (0..20).map(|i| i as f64 * 2.0).collect();
+        assert_eq!(simplify(&eles, 0.1), vec![0, 19]);
+    }
+
+    #[test]
+    fn test_peak_is_kept_when_above_epsilon() {
+        let eles = [0.0, 0.0, 0.0, 10.0, 0.0, 0.0, 0.0];
+        assert_eq!(simplify(&eles, 5.0), vec![0, 3, 6]);
+    }
+
+    #[test]
+    fn test_peak_is_dropped_when_below_epsilon() {
+        let eles = [0.0, 0.0, 0.0, 0.5, 0.0, 0.0, 0.0];
+        assert_eq!(simplify(&eles, 1.0), vec![0, 6]);
+    }
+
+    #[test]
+    fn test_indices_are_sorted_and_keep_extremities() {
+        let eles = [0.0, 5.0, -3.0, 8.0, 1.0, 9.0, -4.0, 2.0, 7.0, 0.0];
+        let kept = simplify(&eles, 0.5);
+        assert_eq!(kept.first(), Some(&0));
+        assert_eq!(kept.last(), Some(&9));
+        assert!(kept.windows(2).all(|w| w[0] < w[1]));
+        // a larger epsilon never keeps more points
+        assert!(simplify(&eles, 5.0).len() <= kept.len());
+    }
+}

gpx-rs/src/core/algorithm/smooth.rs

@@ -0,0 +1,141 @@
+#[macro_export]
+macro_rules! for_each_window {
+    (
+        $trkseg:expr,
+        $left:expr,
+        $right:expr,
+        $window:expr,
+        |$a:ident, $b:ident| $distance:expr,
+        |$i:ident, $l:ident, $r:ident| $body:block,
+    ) => {{
+        let mut window_start = $left.unwrap_or_default();
+        let mut window_center = $left;
+        let mut window_end = $left.unwrap_or_default();
+        while let Some(idx) = window_center {
+            // advance left if needed
+            while window_start != idx && {
+                let $a = window_start;
+                let $b = idx;
+                $distance
+            } > $window {
+                if let Some(next) = $trkseg.next_index(Some(window_start)) {
+                    if next == idx {
+                        break;
+                    }
+                    window_start = next;
+                } else {
+                    break;
+                }
+            }
+            // advance right if needed
+            window_end = window_end.max(idx);
+            while let Some(next) = $trkseg.next_index(Some(window_end)) {
+                if window_end != idx && {
+                    let $a = idx;
+                    let $b = next;
+                    $distance
+                } > $window {
+                    break;
+                }
+                window_end = next;
+            }
+            // apply body
+            let $i = idx;
+            let $l = window_start;
+            let $r = window_end;
+            $body
+            // go next
+            if window_center == $right {
+                break;
+            }
+            window_center = $trkseg.next_index(window_center);
+        }
+    }};
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{TrackSegment, Trackpoint, TrackpointChunk};
+
+    fn segment(eles: &[f64]) -> TrackSegment {
+        let mut trkseg = TrackSegment::default();
+        // several small chunks, to also exercise the chunk boundaries
+        for part in eles.chunks(3) {
+            let mut chunk = TrackpointChunk::default();
+            for ele in part {
+                chunk.trkpt.push(Trackpoint {
+                    ele: *ele,
+                    ..Default::default()
+                });
+            }
+            trkseg.push(chunk);
+        }
+        trkseg
+    }
+
+    /// Returns (center, left, right) flat indices for each visited center.
+    fn windows(len: usize, window: f64) -> Vec<(usize, usize, usize)> {
+        let trkseg = segment(&vec![0.0; len]);
+        let mut visited = vec![];
+        for_each_window!(
+            trkseg,
+            trkseg.first_index(),
+            trkseg.last_index(),
+            window,
+            |a, b| (b.flat - a.flat) as f64,
+            |i, l, r| {
+                visited.push((i.flat, l.flat, r.flat));
+            },
+        );
+        visited
+    }
+
+    #[test]
+    fn test_window_bounds() {
+        let visited = windows(10, 2.0);
+        assert_eq!(visited.len(), 10);
+        for (i, l, r) in visited {
+            assert_eq!(l, i.saturating_sub(2), "left of {i}");
+            assert_eq!(r, (i + 2).min(9), "right of {i}");
+        }
+    }
+
+    #[test]
+    fn test_window_always_includes_neighbours() {
+        for (i, l, r) in windows(6, 0.0) {
+            assert_eq!((l, r), (i.saturating_sub(1), (i + 1).min(5)));
+        }
+    }
+
+    #[test]
+    fn test_window_larger_than_segment() {
+        for (_, l, r) in windows(5, 100.0) {
+            assert_eq!((l, r), (0, 4));
+        }
+    }
+
+    #[test]
+    fn test_window_sub_range() {
+        let trkseg = segment(&[0.0; 10]);
+        let mut centers = vec![];
+        let mut first = trkseg.first_index();
+        for _ in 0..3 {
+            first = trkseg.next_index(first);
+        }
+        let mut last = first;
+        for _ in 0..2 {
+            last = trkseg.next_index(last);
+        }
+        for_each_window!(
+            trkseg,
+            first,
+            last,
+            1.0,
+            |a, b| (b.flat - a.flat) as f64,
+            |i, _l, _r| {
+                centers.push(i.flat);
+            },
+        );
+        assert_eq!(centers, vec![3, 4, 5]);
+    }
+}

gpx-rs/src/core/algorithm/timestamps.rs

@@ -0,0 +1,465 @@
+use crate::{Statistics, TrackSegment, Trackpoint, distance};
+
+/// The new timestamps of the trackpoints of `segments`, one after the other: each segment goes on
+/// from the end of the previous one, the first one starts at `start_time` (in milliseconds).
+///
+/// A segment that has timestamps keeps its durations multiplied by `ratio`; one that has none
+/// (judged by its first trackpoint) follows the previous trackpoint at `speed` (km/h). See
+/// [`shifted_and_compressed`] and [`with_timestamps`].
+pub fn changed_segment_times(
+    segments: &[&TrackSegment],
+    start_time: i64,
+    speed: f64,
+    ratio: f64,
+) -> Vec<Vec<Option<i64>>> {
+    let mut last: Option<Trackpoint> = None;
+    segments
+        .iter()
+        .map(|segment| {
+            let points: Vec<Trackpoint> = segment.iter().cloned().collect();
+            let Some(first) = points.first() else {
+                return vec![];
+            };
+            let start = last.clone().unwrap_or_else(|| {
+                let mut start = first.clone();
+                start.time = Some(start_time);
+                start
+            });
+            let points = if first.time.is_none() {
+                with_timestamps(points, Some(speed), Some(&start), Some(start_time))
+            } else {
+                shifted_and_compressed(points, Some(speed), ratio, &start)
+            };
+            last = points.last().cloned();
+            points.iter().map(|point| point.time).collect()
+        })
+        .collect()
+}
+
+/// Makes up timestamps for the trackpoints of `segments`, one after the other: they start at
+/// `start_time` (in milliseconds) and last `total_time` seconds together, the longer and the
+/// steeper an interval the more of it. Each segment goes on from the end of the previous one.
+pub fn artificial_segment_times(
+    segments: &[&TrackSegment],
+    start_time: i64,
+    total_time: f64,
+) -> Vec<Vec<Option<i64>>> {
+    let mut weights: Vec<Vec<f64>> = segments
+        .iter()
+        .map(|segment| {
+            let points: Vec<Trackpoint> = segment.iter().cloned().collect();
+            let slopes: Vec<f64> = Statistics::compute(segment)
+                .local
+                .iter()
+                .map(|l| l.slope)
+                .collect();
+            artificial_weights(&points, &slopes)
+        })
+        .collect();
+    let mut total: f64 = weights.iter().flatten().sum();
+    if total.is_nan() || total <= 0.0 {
+        // no distance to share the time by: every interval takes as long
+        for weights in &mut weights {
+            weights.iter_mut().for_each(|w| *w = 1.0);
+        }
+        total = weights.iter().map(Vec::len).sum::<usize>() as f64;
+    }
+    let ms_per_weight = if total > 0.0 {
+        total_time * 1000.0 / total
+    } else {
+        0.0
+    };
+
+    let mut start = start_time;
+    segments
+        .iter()
+        .zip(&weights)
+        .map(|(segment, weights)| {
+            let points: Vec<Trackpoint> = segment.iter().cloned().collect();
+            if points.is_empty() {
+                return vec![];
+            }
+            let points = with_artificial_timestamps(points, weights, ms_per_weight, start);
+            // the next segment goes on from the end of this one
+            start = points.last().and_then(|point| point.time).unwrap_or(start);
+            points.iter().map(|point| point.time).collect()
+        })
+        .collect()
+}
+
+/// Replaces the trackpoints `start..end` of `trkpt` by `points`, keeping the timestamps of the
+/// whole path consistent. It is the work of the old `replaceTrackPoints` of the TS library.
+///
+/// The timestamps only matter if the path has some, or if `speed` (in km/h) is given: then the
+/// new points that have none get some (a trackpoint after the previous one at `speed`, or one
+/// second after it without a speed), and so do the points before or after the range if they
+/// had none. `start_time` is the time of the first trackpoint when nothing else gives it.
+/// New points that have timestamps are shifted if they are too early to follow the previous
+/// trackpoint, and so are the points after the range. With `remove_gaps`, the new points are
+/// also brought closer to the previous trackpoint if they come long after it.
+///
+/// Panics if `start..end` is not inside `trkpt`.
+pub fn replace_trackpoints(
+    trkpt: &mut Vec<Trackpoint>,
+    start: usize,
+    end: usize,
+    mut points: Vec<Trackpoint>,
+    speed: Option<f64>,
+    start_time: Option<i64>,
+    remove_gaps: bool,
+) {
+    assert!(start <= end && end <= trkpt.len());
+    let has_times = trkpt.first().is_some_and(|first| first.time.is_some());
+
+    if speed.is_some() || has_times {
+        if start > 0 && trkpt[0].time.is_none() {
+            // the points before the range have no timestamps
+            let before: Vec<_> = trkpt.drain(..start).collect();
+            trkpt.splice(0..0, with_timestamps(before, speed, None, start_time));
+        }
+
+        if !points.is_empty() {
+            let last = start.checked_sub(1).map(|i| &trkpt[i]);
+            let missing =
+                points[0].time.is_none() || points.get(1).is_some_and(|p| p.time.is_none());
+            if missing {
+                points = with_timestamps(points, speed, last, start_time);
+            } else if let Some(last) = last {
+                if is_before(points[0].time, last.time) {
+                    // too early
+                    points = shifted_and_compressed(points, speed, 1.0, last);
+                } else if remove_gaps {
+                    if same_place(&points[0], last) {
+                        // the same place: the new points start at the previous trackpoint, which
+                        // is the new first one
+                        if is_before(last.time, points[0].time) {
+                            points = shifted_and_compressed(points, speed, 1.0, last);
+                            points.remove(0);
+                        }
+                    } else if matches!((points[0].time, last.time), (Some(new), Some(old)) if new - old > 1000)
+                    {
+                        // another place: the new points start one second after the previous one
+                        let mut artificial_last = points[0].clone();
+                        artificial_last.time = last.time.map(|time| time + 1000);
+                        points = shifted_and_compressed(points, speed, 1.0, &artificial_last);
+                    }
+                }
+            }
+        }
+
+        if end < trkpt.len() {
+            // the points after the range
+            let last = points
+                .last()
+                .or_else(|| start.checked_sub(1).map(|i| &trkpt[i]))
+                .cloned();
+            if trkpt[end].time.is_none() {
+                let after: Vec<_> = trkpt.drain(end..).collect();
+                let after = with_timestamps(after, speed, last.as_ref(), start_time);
+                trkpt.extend(after);
+            } else if let Some(last) = last
+                && is_before(trkpt[end].time, last.time)
+            {
+                let after: Vec<_> = trkpt.drain(end..).collect();
+                trkpt.extend(shifted_and_compressed(after, speed, 1.0, &last));
+            }
+        }
+    }
+
+    trkpt.splice(start..end, points);
+}
+
+/// How long each interval between two consecutive trackpoints of a segment should last, relative
+/// to the others, for a made-up pace: the longer the interval, and the steeper it goes up, the
+/// longer. `slopes` has the slope (in %) at each trackpoint.
+pub fn artificial_weights(points: &[Trackpoint], slopes: &[f64]) -> Vec<f64> {
+    points
+        .windows(2)
+        .zip(slopes)
+        .map(|(pair, slope)| {
+            let km = distance(pair[0].coordinates, pair[1].coordinates);
+            km * (0.5 + 1.0 / (1.0 + (-0.2 * slope).exp()))
+        })
+        .collect()
+}
+
+/// `points` with made-up timestamps: the first one is at `start`, and each next one follows the
+/// previous one after `weights[i]` times `ms_per_weight` milliseconds (see [`artificial_weights`]).
+pub fn with_artificial_timestamps(
+    mut points: Vec<Trackpoint>,
+    weights: &[f64],
+    ms_per_weight: f64,
+    start: i64,
+) -> Vec<Trackpoint> {
+    let mut elapsed = 0.0;
+    for (i, point) in points.iter_mut().enumerate() {
+        if i > 0 {
+            elapsed += weights[i - 1] * ms_per_weight;
+        }
+        point.time = Some(start + elapsed as i64);
+    }
+    points
+}
+
+fn same_place(a: &Trackpoint, b: &Trackpoint) -> bool {
+    a.coordinates.lng == b.coordinates.lng && a.coordinates.lat == b.coordinates.lat
+}
+
+/// Whether both times are known and `a` is before `b`.
+fn is_before(a: Option<i64>, b: Option<i64>) -> bool {
+    matches!((a, b), (Some(a), Some(b)) if a < b)
+}
+
+/// The time at which `b` is reached after `a`, at `speed` km/h: one second later without a
+/// speed, unknown if `a` has no time.
+///
+/// The old code gave an invalid date for a null or negative speed: it is as if there was none.
+fn timestamp_after(a: &Trackpoint, b: &Trackpoint, speed: Option<f64>) -> Option<i64> {
+    let time = a.time?;
+    match speed.filter(|speed| speed.is_finite() && *speed > 0.0) {
+        None => Some(time + 1000),
+        Some(speed) => {
+            let km = distance(a.coordinates, b.coordinates);
+            Some(time + (3_600_000.0 * km / speed) as i64)
+        }
+    }
+}
+
+/// `points` with the timestamps that follow `last` (the trackpoint before them), one after the
+/// other. Without `last`, the first one is at `start_time`.
+///
+/// Unlike the old code, a `last` without a time does not get `start_time` itself, only the copy
+/// used here.
+pub fn with_timestamps(
+    points: Vec<Trackpoint>,
+    speed: Option<f64>,
+    last: Option<&Trackpoint>,
+    start_time: Option<i64>,
+) -> Vec<Trackpoint> {
+    let Some(first) = points.first() else {
+        return points;
+    };
+    let mut last = match last {
+        Some(last) if last.time.is_some() => last.clone(),
+        other => {
+            let mut last = other.unwrap_or(first).clone();
+            last.time = start_time;
+            last
+        }
+    };
+    points
+        .into_iter()
+        .map(|mut point| {
+            point.time = timestamp_after(&last, &point, speed);
+            last = point.clone();
+            point
+        })
+        .collect()
+}
+
+/// `points` with their timestamps moved so that the first one follows `last`, and their durations
+/// multiplied by `ratio`. The ones that have no timestamp follow the previous one, as in
+/// [`with_timestamps`]. Without a time for `last`, or for the first point, none is known.
+pub fn shifted_and_compressed(
+    points: Vec<Trackpoint>,
+    speed: Option<f64>,
+    ratio: f64,
+    last: &Trackpoint,
+) -> Vec<Trackpoint> {
+    let Some(first) = points.first() else {
+        return points;
+    };
+    let start = timestamp_after(last, first, speed);
+    let first_time = first.time;
+    let mut previous = first.clone();
+    points
+        .into_iter()
+        .map(|point| {
+            let mut shifted = point.clone();
+            shifted.time = match point.time {
+                None => timestamp_after(&previous, &point, speed),
+                Some(time) => start
+                    .zip(first_time)
+                    .map(|(start, first)| start + (ratio * (time - first) as f64) as i64),
+            };
+            previous = shifted.clone();
+            shifted
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::LngLat;
+
+    use super::*;
+
+    /// A point every 1 km along the equator... about, at 0.009 degrees of longitude.
+    fn point(i: usize, time: Option<i64>) -> Trackpoint {
+        Trackpoint {
+            coordinates: LngLat {
+                lng: i as f64 * 0.009,
+                lat: 0.0,
+            },
+            time,
+            ..Default::default()
+        }
+    }
+
+    fn timed(range: std::ops::Range<usize>, start: i64, step: i64) -> Vec<Trackpoint> {
+        range
+            .map(|i| point(i, Some(start + step * i as i64)))
+            .collect()
+    }
+
+    fn untimed(range: std::ops::Range<usize>) -> Vec<Trackpoint> {
+        range.map(|i| point(i, None)).collect()
+    }
+
+    fn times(trkpt: &[Trackpoint]) -> Vec<Option<i64>> {
+        trkpt.iter().map(|p| p.time).collect()
+    }
+
+    #[test]
+    fn test_without_times_nor_speed_it_is_a_splice() {
+        let mut trkpt = untimed(0..5);
+        replace_trackpoints(&mut trkpt, 1, 3, untimed(10..13), None, None, false);
+        assert_eq!(trkpt.len(), 6);
+        assert!(trkpt.iter().all(|p| p.time.is_none()));
+        assert_eq!(trkpt[1].coordinates.lng, point(10, None).coordinates.lng);
+        assert_eq!(trkpt[4].coordinates.lng, point(3, None).coordinates.lng);
+    }
+
+    #[test]
+    fn test_new_points_follow_the_previous_one_at_the_speed() {
+        // 1 km in 10 s is 360 km/h
+        let mut trkpt = timed(0..4, 0, 10_000);
+        let km = distance(point(0, None).coordinates, point(1, None).coordinates);
+        let speed = 36.0 * km / 0.01; // the time of 1 point to the next is 100 s
+        replace_trackpoints(&mut trkpt, 2, 3, untimed(2..4), Some(speed), None, false);
+        let expected = 10_000 + (3_600_000.0 * km / speed) as i64;
+        assert_eq!(trkpt[2].time, Some(expected));
+        assert!(trkpt[2].time > trkpt[1].time);
+        // the points after follow the new ones, they were not too early
+        assert_eq!(trkpt.len(), 5);
+        assert_eq!(trkpt[4].time, Some(30_000));
+    }
+
+    #[test]
+    fn test_without_a_speed_new_points_are_one_second_apart() {
+        let mut trkpt = timed(0..3, 5_000, 60_000);
+        replace_trackpoints(&mut trkpt, 1, 2, untimed(10..13), None, None, false);
+        assert_eq!(
+            times(&trkpt[..4]),
+            [Some(5_000), Some(6_000), Some(7_000), Some(8_000)]
+        );
+        // what comes after was after, it is kept
+        assert_eq!(trkpt[4].time, Some(125_000));
+    }
+
+    #[test]
+    fn test_the_points_after_are_shifted_if_they_are_too_early() {
+        let mut trkpt = timed(0..4, 0, 10_000);
+        // 30 new points, one second apart: the last one is at 30 s, but the next original
+        // trackpoint is at 20 s
+        replace_trackpoints(&mut trkpt, 1, 2, untimed(10..40), None, None, false);
+        assert_eq!(trkpt.len(), 33);
+        assert_eq!(trkpt[1].time, Some(1_000));
+        assert_eq!(trkpt[30].time, Some(30_000));
+        // the following points keep the duration between them, after the new ones
+        assert_eq!(trkpt[31].time, Some(31_000));
+        assert_eq!(trkpt[32].time, Some(41_000));
+    }
+
+    #[test]
+    fn test_a_path_without_times_gets_them_from_the_speed_and_start_time() {
+        let mut trkpt = untimed(0..4);
+        replace_trackpoints(
+            &mut trkpt,
+            3,
+            4,
+            untimed(3..6),
+            Some(10.0),
+            Some(1_000),
+            false,
+        );
+        let times: Vec<_> = times(&trkpt);
+        assert_eq!(times[0], Some(1_000));
+        assert!(times.iter().all(Option::is_some));
+        assert!(times.windows(2).all(|w| w[0].unwrap() < w[1].unwrap()));
+    }
+
+    #[test]
+    fn test_an_unusable_speed_is_as_if_there_was_none() {
+        for speed in [0.0, -5.0, f64::NAN, f64::INFINITY] {
+            let mut trkpt = timed(0..2, 0, 10_000);
+            replace_trackpoints(&mut trkpt, 2, 2, untimed(2..4), Some(speed), None, false);
+            assert_eq!(
+                times(&trkpt),
+                [Some(0), Some(10_000), Some(11_000), Some(12_000)],
+                "{speed}"
+            );
+        }
+    }
+
+    #[test]
+    fn test_new_points_with_times_that_are_too_early_are_shifted() {
+        let mut trkpt = timed(0..3, 100_000, 10_000);
+        // they are at 0, 5 s: they are moved to follow the trackpoint at 110 s
+        let new = vec![point(5, Some(0)), point(6, Some(5_000))];
+        replace_trackpoints(&mut trkpt, 2, 3, new, None, None, false);
+        // they follow the previous trackpoint after one second, keeping their own durations
+        assert_eq!(trkpt[2].time, Some(111_000));
+        assert_eq!(trkpt[3].time, Some(116_000));
+    }
+
+    #[test]
+    fn test_remove_gaps_at_the_same_place_and_elsewhere() {
+        // same place: the first new point is the previous trackpoint
+        let mut trkpt = timed(0..3, 0, 10_000);
+        let new = vec![point(2, Some(500_000)), point(3, Some(510_000))];
+        replace_trackpoints(&mut trkpt, 3, 3, new.clone(), None, None, true);
+        assert_eq!(trkpt.len(), 4);
+        // without a speed, it is one second after the previous trackpoint, not at its time
+        assert_eq!(trkpt[3].time, Some(31_000));
+        // with a speed, the distance is zero
+        let mut trkpt = timed(0..3, 0, 10_000);
+        replace_trackpoints(&mut trkpt, 3, 3, new, Some(10.0), None, true);
+        assert_eq!(trkpt[3].time, Some(30_000));
+
+        // another place: one second after the previous one
+        let mut trkpt = timed(0..3, 0, 10_000);
+        let new = vec![point(5, Some(500_000)), point(6, Some(510_000))];
+        replace_trackpoints(&mut trkpt, 3, 3, new, None, None, true);
+        assert_eq!(trkpt.len(), 5);
+        // the old code adds the second twice with no speed, see `timestamp_after`
+        assert_eq!(trkpt[3].time, Some(22_000));
+        assert_eq!(trkpt[4].time, Some(32_000));
+
+        // without removing the gaps they stay
+        let mut trkpt = timed(0..3, 0, 10_000);
+        let new = vec![point(5, Some(500_000)), point(6, Some(510_000))];
+        replace_trackpoints(&mut trkpt, 3, 3, new, None, None, false);
+        assert_eq!(trkpt[3].time, Some(500_000));
+    }
+
+    #[test]
+    fn test_removing_points_adapts_nothing_if_the_next_one_is_after() {
+        let mut trkpt = timed(0..5, 0, 10_000);
+        replace_trackpoints(&mut trkpt, 1, 3, vec![], None, None, false);
+        assert_eq!(times(&trkpt), [Some(0), Some(30_000), Some(40_000)]);
+        // from the beginning
+        replace_trackpoints(&mut trkpt, 0, 2, vec![], None, None, false);
+        assert_eq!(times(&trkpt), [Some(40_000)]);
+        replace_trackpoints(&mut trkpt, 0, 1, vec![], None, None, false);
+        assert!(trkpt.is_empty());
+    }
+
+    #[test]
+    fn test_points_without_a_known_previous_time_get_none() {
+        // nothing gives a time to start with
+        let mut trkpt = untimed(0..2);
+        replace_trackpoints(&mut trkpt, 2, 2, untimed(2..4), Some(10.0), None, false);
+        assert!(trkpt.iter().all(|p| p.time.is_none()));
+    }
+}