progress

gpx-rs/src/engine/command/tools/route.rs

@@ -0,0 +1,810 @@
+use std::rc::Rc;
+
+use crate::{
+    Apply, Categories, CommandError, FileId, SegmentLocation, Selection, State, Statistics, Track,
+    TrackSegment, Trackpoint, distance, replace_trackpoints,
+};
+
+/// The values of an OSM attribute (surface, highway...) of the new trackpoints of a [`Route`], as
+/// the intervals of consecutive trackpoints that share one: `starts[i]` is the index of the first
+/// trackpoint of the interval `i`, and `values[i]` its value, 0 when unknown, else 1 + the index
+/// of its name in `names`. No intervals means that the attribute is unknown everywhere.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct RouteCategory<'a> {
+    pub starts: &'a [u32],
+    pub values: &'a [u8],
+    pub names: &'a [String],
+}
+
+impl RouteCategory<'_> {
+    /// The code in `categories` of the value of each of the `len` new trackpoints. A name is
+    /// added to the table of the categories if it is new.
+    fn codes(
+        &self,
+        categories: &mut Categories,
+        len: usize,
+    ) -> Result<Vec<Option<u8>>, CommandError> {
+        if self.starts.len() != self.values.len() {
+            return Err(invalid("intervals of different lengths"));
+        }
+        let mut codes = vec![None; len];
+        for (i, (start, value)) in self.starts.iter().zip(self.values).enumerate() {
+            let end = self.starts.get(i + 1).map_or(len, |end| *end as usize);
+            let start = *start as usize;
+            if start > end || end > len {
+                return Err(invalid("intervals out of the trackpoints"));
+            }
+            if *value == 0 {
+                continue;
+            }
+            let name = self
+                .names
+                .get(usize::from(*value) - 1)
+                .ok_or_else(|| invalid("unknown name of category"))?;
+            codes[start..end].fill(categories.code(name));
+        }
+        Ok(codes)
+    }
+}
+
+/// Replaces the trackpoints `start..end` of a segment of the selection by the given ones (a pure
+/// insertion when `start == end`, a pure removal when there are no new points). It is how the
+/// routing tool reroutes a part of a segment, extends it, or removes the end of it.
+///
+/// `start` and `end` are indices in the trackpoints of the selection (see `RoutingBuffer`): the
+/// range has to be in a single segment, and `start == end == the number of trackpoints` appends
+/// to the last one. If the selection has no trackpoints at all, they go to its last segment, which
+/// is created if needed (in the last track, or in a new one, of the last selected file).
+///
+/// The timestamps follow: the new points get some if the segment has, at the speed it had on the
+/// replaced part (see [`replace_trackpoints`]).
+///
+/// The new points listed in `anchors` become anchors of the routing tool, shown at every zoom
+/// level. The anchors of the segment out of the range are kept, and the ends of the segment are
+/// anchors anyway. The ones right before and after the range, between which the route goes, become
+/// shown at every zoom level as well.
+#[derive(Debug)]
+pub struct Route<'a> {
+    pub start: u32,
+    pub end: u32,
+    pub lng: &'a [f64],
+    pub lat: &'a [f64],
+    pub ele: &'a [f64],
+    pub surface: RouteCategory<'a>,
+    pub highway: RouteCategory<'a>,
+    pub sac_scale: RouteCategory<'a>,
+    pub mtb_scale: RouteCategory<'a>,
+    /// Indices among the new trackpoints.
+    pub anchors: &'a [u32],
+}
+
+fn invalid(message: &str) -> CommandError {
+    CommandError::InvalidData(message.into())
+}
+
+/// A segment of the selection, and the range of its trackpoints that is concerned.
+pub(super) struct Target {
+    pub location: SegmentLocation,
+    pub start: usize,
+    pub end: usize,
+}
+
+impl Apply for Route<'_> {
+    fn apply(self, state: &mut State) -> Result<(), CommandError> {
+        let (start, end) = (self.start as usize, self.end as usize);
+        let len = self.lng.len();
+        if start > end || self.lat.len() != len || self.ele.len() != len {
+            return Err(invalid("invalid trackpoints range"));
+        }
+        if self.anchors.iter().any(|anchor| *anchor as usize >= len) {
+            return Err(invalid("anchor out of the new trackpoints"));
+        }
+        if start == end && len == 0 {
+            return Err(CommandError::NothingToDo);
+        }
+
+        let categories = &mut *state.categories;
+        let surface = self.surface.codes(&mut categories.surface, len)?;
+        let highway = self.highway.codes(&mut categories.highway, len)?;
+        let sac_scale = self.sac_scale.codes(&mut categories.sac_scale, len)?;
+        let mtb_scale = self.mtb_scale.codes(&mut categories.mtb_scale, len)?;
+        let points: Vec<Trackpoint> = (0..len)
+            .map(|i| Trackpoint {
+                coordinates: crate::LngLat {
+                    lng: self.lng[i],
+                    lat: self.lat[i],
+                },
+                ele: self.ele[i],
+                surface: surface[i],
+                highway: highway[i],
+                sac_scale: sac_scale[i],
+                mtb_scale: mtb_scale[i],
+                ..Default::default()
+            })
+            .collect();
+        let mut points = points;
+        for anchor in self.anchors {
+            points[*anchor as usize].anchor = Some(0);
+        }
+
+        let mut file;
+        let target = match find_target(state, start, end)? {
+            Some(target) => {
+                file = (*state.files[&target.location.file_id]).clone();
+                target
+            }
+            None => {
+                let (file_id, trk) = container(state).ok_or(CommandError::NothingToDo)?;
+                if start != 0 || end != 0 {
+                    return Err(invalid("trackpoints range out of bounds"));
+                }
+                file = (*state.files[&file_id]).clone();
+                // the segment of the last track, which may be new
+                let trk = match trk.or_else(|| file.trk.len().checked_sub(1)) {
+                    Some(trk) => trk,
+                    None => {
+                        file.trk.push(Track::default());
+                        file.trk.len() - 1
+                    }
+                };
+                if file.trk[trk].trkseg.is_empty() {
+                    file.trk[trk].trkseg.push(TrackSegment::default());
+                }
+                let seg = file.trk[trk].trkseg.len() - 1;
+                Target {
+                    location: SegmentLocation { file_id, trk, seg },
+                    start: 0,
+                    end: 0,
+                }
+            }
+        };
+
+        let segment = &mut file.trk[target.location.trk].trkseg[target.location.seg];
+        let new_len = points.len();
+        let (speed, start_time) = speed_and_start_time(segment, &target, &points);
+        let has_times = !segment.is_empty() && segment[0].time.is_some();
+        if speed.is_some() || has_times {
+            // the timestamps of the whole segment can change
+            let mut all: Vec<Trackpoint> = segment.iter().cloned().collect();
+            let old_len = all.len();
+            replace_trackpoints(
+                &mut all,
+                target.start,
+                target.end,
+                points,
+                speed,
+                start_time,
+                false,
+            );
+            segment.splice(0, old_len, all);
+        } else {
+            segment.splice(target.start, target.end, points);
+        }
+        // the anchors next to the new points are the ones that were moved or removed around:
+        // they become permanent
+        for index in [target.start.checked_sub(1), Some(target.start + new_len)]
+            .into_iter()
+            .flatten()
+        {
+            if index < segment.len() && segment[index].anchor.is_some_and(|zoom| zoom != 0) {
+                segment.set_anchor(index, 0);
+            }
+        }
+        segment.rev_id = Default::default();
+        state.files.insert(target.location.file_id, Rc::new(file));
+        Ok(())
+    }
+}
+
+/// The segment of the trackpoints `start..end` of the selection.
+pub(super) fn find_target(
+    state: &State,
+    start: usize,
+    end: usize,
+) -> Result<Option<Target>, CommandError> {
+    let locations = state
+        .selection
+        .segment_locations(state.files, &state.order.0);
+    let segments: Vec<(SegmentLocation, usize)> = locations
+        .into_iter()
+        .map(|location| {
+            let segment = &state.files[&location.file_id].trk[location.trk].trkseg[location.seg];
+            (location, segment.len())
+        })
+        .collect();
+    let total: usize = segments.iter().map(|(_, len)| len).sum();
+
+    if total == 0 {
+        // an empty segment of the selection, if there is one
+        return match segments.last() {
+            Some((location, _)) if start == 0 && end == 0 => Ok(Some(Target {
+                location: *location,
+                start: 0,
+                end: 0,
+            })),
+            Some(_) => Err(invalid("trackpoints range out of bounds")),
+            None => Ok(None),
+        };
+    }
+
+    let mut offset = 0;
+    for (location, len) in segments.iter().filter(|(_, len)| *len > 0) {
+        // appending to the selection is appending to its last segment
+        let appends = offset + len == total && start == total;
+        if start >= offset && (start < offset + len || appends) {
+            if end > offset + len {
+                return Err(invalid("trackpoints range over several segments"));
+            }
+            return Ok(Some(Target {
+                location: *location,
+                start: start - offset,
+                end: end - offset,
+            }));
+        }
+        offset += len;
+    }
+    Err(invalid("trackpoints range out of bounds"))
+}
+
+/// The file, and the track (if the selection is one), where to create a segment in a selection
+/// that has none.
+fn container(state: &State) -> Option<(FileId, Option<usize>)> {
+    match &*state.selection {
+        Selection::File { file_ids } => {
+            let id = state
+                .order
+                .0
+                .iter()
+                .rev()
+                .find(|id| file_ids.contains(id))
+                .or_else(|| file_ids.iter().next())?;
+            state.files.contains_key(id).then_some((*id, None))
+        }
+        Selection::Track { file_id, trk_ids } => {
+            let trk = state
+                .files
+                .get(file_id)?
+                .trk
+                .iter()
+                .rposition(|trk| trk_ids.contains(&trk.id))?;
+            Some((*file_id, Some(trk)))
+        }
+        _ => None,
+    }
+}
+
+/// The speed at which the new points are reached and the time of the first one, when the segment
+/// has times to keep consistent: the speed is the one that the segment had on the part that is
+/// replaced, adjusted so that the moving speed of the whole segment stays what it was.
+///
+/// The replaced part goes from the trackpoint before the range (the anchor that stays) to the one
+/// after it, or to the ends of the segment: the new points are the route between them.
+///
+/// This is what the routing tool computed from the statistics of the segment before.
+fn speed_and_start_time(
+    segment: &TrackSegment,
+    target: &Target,
+    points: &[Trackpoint],
+) -> (Option<f64>, Option<i64>) {
+    let time_at = |index: usize| {
+        (index < segment.len())
+            .then(|| segment[index].time)
+            .flatten()
+    };
+    let start_time = time_at(target.start);
+    if points.is_empty() || segment.is_empty() {
+        return (None, start_time);
+    }
+    let stats = Statistics::compute(segment);
+    let Some(moving_speed) = stats.global.moving_speed().filter(|speed| *speed > 0.0) else {
+        return (None, start_time);
+    };
+
+    // the statistics where the replaced part starts and ends
+    let first_index = target.start.saturating_sub(1);
+    let last_index = target.end.min(segment.len() - 1);
+    let (first, last) = (&stats.local[first_index], &stats.local[last_index]);
+    let moving_distance =
+        |stats: &crate::TrackpointStatistics| stats.moving_distance.unwrap_or(0.0);
+    let moving_time = |stats: &crate::TrackpointStatistics| stats.moving_time.unwrap_or(0);
+    let total_time = |stats: &crate::TrackpointStatistics| stats.total_time.unwrap_or(0);
+
+    let replacing_distance: f64 = points
+        .windows(2)
+        .map(|pair| distance(pair[0].coordinates, pair[1].coordinates))
+        .sum();
+    let replaced_distance = moving_distance(last) - moving_distance(first);
+    let global_moving_distance = stats.global.moving_distance.unwrap_or(0.0);
+    let new_distance = global_moving_distance + replacing_distance - replaced_distance;
+    // in milliseconds
+    let new_time = new_distance / moving_speed * 3_600_000.0;
+    let remaining_time = stats.global.moving_time.unwrap_or(0) as f64
+        - (moving_time(last) - moving_time(first)) as f64;
+    let mut replacing_time = new_time - remaining_time;
+    if replacing_time <= 0.0 {
+        // fall back to the time that the replaced part took
+        replacing_time = (total_time(last) - total_time(first)) as f64;
+    }
+    let speed = replacing_distance / (replacing_time / 3_600_000.0);
+
+    let start_time = start_time.or_else(|| {
+        // The first trackpoint has no time: the new points end when the last replaced one did,
+        // after the time they take and the time that the segment was not moving until then.
+        // (Suspicious: without a time for the last one either, it is "0", the year 1970.)
+        let end_time = time_at(last_index);
+        let stopped = (total_time(last) - moving_time(last)) as f64;
+        Some(end_time.unwrap_or(0) - (replacing_time + stopped) as i64)
+    });
+    (Some(speed), start_time)
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashSet;
+
+    use crate::{File, Load, TrackSegmentId, engine::command::fixture::Fixture};
+
+    use super::*;
+
+    fn load(fx: &mut Fixture, path: &str) -> FileId {
+        let data = std::fs::read(path).unwrap();
+        Load {
+            data: &data,
+            name: "file",
+        }
+        .apply(&mut fx.state())
+        .unwrap();
+        *fx.order.0.last().unwrap()
+    }
+
+    fn select_file(fx: &mut Fixture, id: FileId) {
+        fx.selection = Selection::File {
+            file_ids: HashSet::from([id]),
+        };
+    }
+
+    /// The first segment of the file with segments, selected.
+    fn loaded() -> (Fixture, FileId) {
+        let mut fx = Fixture::default();
+        let id = load(&mut fx, "data/with_tracks_and_segments.gpx");
+        let trk = &fx.files[&id].trk[0];
+        fx.selection = Selection::TrackSegment {
+            file_id: id,
+            trk_id: trk.id,
+            trkseg_ids: HashSet::from([trk.trkseg[0].id]),
+        };
+        (fx, id)
+    }
+
+    fn route<'a>(
+        start: u32,
+        end: u32,
+        lng: &'a [f64],
+        lat: &'a [f64],
+        ele: &'a [f64],
+    ) -> Route<'a> {
+        Route {
+            start,
+            end,
+            lng,
+            lat,
+            ele,
+            surface: Default::default(),
+            highway: Default::default(),
+            sac_scale: Default::default(),
+            mtb_scale: Default::default(),
+            anchors: &[],
+        }
+    }
+
+    fn segment(fx: &Fixture, id: FileId, trk: usize, seg: usize) -> &TrackSegment {
+        &fx.files[&id].trk[trk].trkseg[seg]
+    }
+
+    #[test]
+    fn test_route_replaces_points_of_the_selected_segment_only() {
+        let (mut fx, id) = loaded();
+        let before = fx.files[&id].clone();
+        let len = before.trk[0].trkseg[0].len();
+        assert!(len >= 3);
+
+        route(1, 3, &[1.0, 2.0, 3.0], &[4.0, 5.0, 6.0], &[7.0, 8.0, 9.0])
+            .apply(&mut fx.state())
+            .unwrap();
+
+        let after = &fx.files[&id];
+        let (old, new) = (&before.trk[0].trkseg[0], &after.trk[0].trkseg[0]);
+        assert_eq!(new.len(), len + 1);
+        assert_eq!(new[0].coordinates.lng, old[0].coordinates.lng);
+        assert_eq!(new[1].coordinates.lng, 1.0);
+        assert_eq!(new[3].coordinates.lat, 6.0);
+        assert_eq!(new[3].ele, 9.0);
+        assert_eq!(new[4].coordinates.lng, old[3].coordinates.lng);
+        assert_ne!(new.rev_id, old.rev_id);
+        assert_eq!(new.id, old.id);
+        // other segments and tracks keep their revision
+        for (b, a) in before.trk.iter().zip(&after.trk) {
+            for (b, a) in b.trkseg.iter().zip(&a.trkseg) {
+                if a.id != new.id {
+                    assert_eq!(a.rev_id, b.rev_id);
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_route_append_and_remove() {
+        let (mut fx, id) = loaded();
+        let len = fx.files[&id].trk[0].trkseg[0].len() as u32;
+        route(len, len, &[1.0], &[2.0], &[3.0])
+            .apply(&mut fx.state())
+            .unwrap();
+        let seg = segment(&fx, id, 0, 0);
+        assert_eq!(seg.len(), len as usize + 1);
+        assert_eq!(seg[len as usize].ele, 3.0);
+
+        route(0, len + 1, &[], &[], &[])
+            .apply(&mut fx.state())
+            .unwrap();
+        assert_eq!(segment(&fx, id, 0, 0).len(), 0);
+    }
+
+    #[test]
+    fn test_route_invalid_arguments_change_nothing() {
+        let (mut fx, id) = loaded();
+        let before = fx.files[&id].clone();
+        let len = before.trk[0].trkseg[0].len() as u32;
+        let results = [
+            route(2, 1, &[], &[], &[]).apply(&mut fx.state()),
+            route(0, 0, &[1.0], &[], &[]).apply(&mut fx.state()),
+            route(0, len + 1, &[], &[], &[]).apply(&mut fx.state()),
+            route(len + 1, len + 1, &[1.0], &[1.0], &[1.0]).apply(&mut fx.state()),
+            Route {
+                anchors: &[1],
+                ..route(0, 0, &[1.0], &[1.0], &[1.0])
+            }
+            .apply(&mut fx.state()),
+        ];
+        assert!(
+            results
+                .iter()
+                .all(|r| matches!(r, Err(CommandError::InvalidData(_)))),
+            "{results:?}"
+        );
+        assert_eq!(
+            route(0, 0, &[], &[], &[]).apply(&mut fx.state()),
+            Err(CommandError::NothingToDo)
+        );
+        assert!(Rc::ptr_eq(&fx.files[&id], &before));
+    }
+
+    #[test]
+    fn test_route_needs_a_selection_with_a_file() {
+        let (mut fx, _) = loaded();
+        fx.selection = Selection::Empty;
+        assert_eq!(
+            route(0, 0, &[1.0], &[1.0], &[1.0]).apply(&mut fx.state()),
+            Err(CommandError::NothingToDo)
+        );
+    }
+
+    #[test]
+    fn test_route_indices_are_in_the_selection() {
+        let (mut fx, id) = loaded();
+        let file = fx.files[&id].clone();
+        select_file(&mut fx, id);
+        let lens: Vec<_> = file
+            .trk
+            .iter()
+            .flat_map(|trk| trk.trkseg.iter().map(|segment| segment.len()))
+            .collect();
+        assert!(lens.len() >= 2);
+
+        // inside the second segment
+        let second = lens[0] as u32;
+        route(second + 1, second + 2, &[1.0], &[2.0], &[3.0])
+            .apply(&mut fx.state())
+            .unwrap();
+        let (trk, seg) = (0, 1);
+        let segments_before: Vec<_> = file.trk.iter().flat_map(|t| &t.trkseg).collect();
+        let files = fx.files[&id].clone();
+        let segments_after: Vec<_> = files.trk.iter().flat_map(|t| &t.trkseg).collect();
+        for (i, (b, a)) in segments_before.iter().zip(&segments_after).enumerate() {
+            assert_eq!(a.rev_id != b.rev_id, i == 1, "segment {i}");
+        }
+        assert_eq!(segment(&fx, id, trk, seg)[1].coordinates.lng, 1.0);
+
+        // a range over two segments
+        let total: usize = lens.iter().sum();
+        assert!(matches!(
+            route(second - 1, second + 1, &[], &[], &[]).apply(&mut fx.state()),
+            Err(CommandError::InvalidData(_))
+        ));
+        // after the last point: the last segment
+        let before = segments_after.last().unwrap().len();
+        let total = total as u32;
+        route(total, total, &[1.0], &[2.0], &[3.0])
+            .apply(&mut fx.state())
+            .unwrap();
+        let last = fx.files[&id].trk.last().unwrap().trkseg.last().unwrap();
+        assert_eq!(last.len(), before + 1);
+    }
+
+    #[test]
+    fn test_route_creates_the_segment_of_a_selection_that_has_none() {
+        let mut fx = Fixture::default();
+        let file = File::default();
+        let id = file.id;
+        fx.files.insert(id, Rc::new(file));
+        fx.order.0.push(id);
+        select_file(&mut fx, id);
+
+        route(0, 0, &[1.0, 2.0], &[1.0, 2.0], &[3.0, 4.0])
+            .apply(&mut fx.state())
+            .unwrap();
+        assert_eq!(fx.files[&id].trk.len(), 1);
+        assert_eq!(segment(&fx, id, 0, 0).len(), 2);
+        // the ends are anchors
+        assert_eq!(segment(&fx, id, 0, 0)[0].anchor, Some(0));
+        assert_eq!(segment(&fx, id, 0, 0)[1].anchor, Some(0));
+
+        // a track with no segments
+        let mut file = (*fx.files[&id]).clone();
+        file.trk[0].trkseg.clear();
+        let trk_id = file.trk[0].id;
+        fx.files.insert(id, Rc::new(file));
+        fx.selection = Selection::Track {
+            file_id: id,
+            trk_ids: HashSet::from([trk_id]),
+        };
+        route(0, 0, &[5.0], &[5.0], &[5.0])
+            .apply(&mut fx.state())
+            .unwrap();
+        assert_eq!(fx.files[&id].trk.len(), 1);
+        assert_eq!(segment(&fx, id, 0, 0).len(), 1);
+
+        // an empty segment is the target as well
+        let mut file = (*fx.files[&id]).clone();
+        file.trk[0].trkseg[0] = TrackSegment::default();
+        let seg_id: TrackSegmentId = file.trk[0].trkseg[0].id;
+        fx.files.insert(id, Rc::new(file));
+        fx.selection = Selection::TrackSegment {
+            file_id: id,
+            trk_id,
+            trkseg_ids: HashSet::from([seg_id]),
+        };
+        route(0, 0, &[6.0], &[6.0], &[6.0])
+            .apply(&mut fx.state())
+            .unwrap();
+        assert_eq!(segment(&fx, id, 0, 0).len(), 1);
+        assert_eq!(fx.files[&id].trk[0].trkseg.len(), 1);
+    }
+
+    #[test]
+    fn test_route_anchors() {
+        let (mut fx, id) = loaded();
+        let len = segment(&fx, id, 0, 0).len();
+        assert!(len > 4);
+        let anchors_before: Vec<_> = segment(&fx, id, 0, 0).iter().map(|p| p.anchor).collect();
+
+        // 5 new points replacing the 2 in the middle, two of them are anchors
+        let (lng, lat, ele) = ([1.0; 5], [2.0; 5], [3.0; 5]);
+        Route {
+            anchors: &[1, 3],
+            ..route(1, 3, &lng, &lat, &ele)
+        }
+        .apply(&mut fx.state())
+        .unwrap();
+        let anchors: Vec<_> = segment(&fx, id, 0, 0).iter().map(|p| p.anchor).collect();
+        assert_eq!(anchors.len(), len + 3);
+        assert_eq!(anchors[2], Some(0));
+        assert_eq!(anchors[4], Some(0));
+        assert_eq!(anchors[1], None);
+        assert_eq!(anchors[3], None);
+        assert_eq!(anchors[5], None);
+        // the others stay as they were, the ends are always anchors
+        assert_eq!(anchors[0], Some(0));
+        assert_eq!(anchors[len + 2], Some(0));
+        assert_eq!(anchors[len + 2 - 1], anchors_before[len - 2]);
+    }
+
+    #[test]
+    fn test_route_makes_the_anchors_around_the_range_permanent() {
+        let (mut fx, id) = loaded();
+        let mut file = (*fx.files[&id]).clone();
+        let len = file.trk[0].trkseg[0].len();
+        assert!(len > 8);
+        // anchors shown from different zoom levels, around and away from the range 4..6
+        for (index, zoom) in [(1, 7), (3, 9), (6, 12), (8, 14)] {
+            file.trk[0].trkseg[0].set_anchor(index, zoom);
+        }
+        fx.files.insert(id, Rc::new(file));
+
+        route(4, 6, &[1.0, 2.0], &[3.0, 4.0], &[5.0, 6.0])
+            .apply(&mut fx.state())
+            .unwrap();
+        let anchors: Vec<_> = segment(&fx, id, 0, 0).iter().map(|p| p.anchor).collect();
+        assert_eq!(anchors.len(), len);
+        // right before and after the new points: permanent
+        assert_eq!(anchors[3], Some(0));
+        assert_eq!(anchors[6], Some(0));
+        // the others are as they were
+        assert_eq!(anchors[1], Some(7));
+        assert_eq!(anchors[8], Some(14));
+    }
+
+    #[test]
+    fn test_route_categories() {
+        let (mut fx, id) = loaded();
+        let names = ["asphalt".to_string(), "gravel".to_string()];
+        let (lng, lat, ele) = ([1.0; 4], [2.0; 4], [3.0; 4]);
+        // asphalt, asphalt, unknown, gravel
+        Route {
+            surface: RouteCategory {
+                starts: &[0, 2, 3],
+                values: &[1, 0, 2],
+                names: &names,
+            },
+            highway: RouteCategory {
+                starts: &[0],
+                values: &[1],
+                names: &["track".to_string()],
+            },
+            ..route(0, 0, &lng, &lat, &ele)
+        }
+        .apply(&mut fx.state())
+        .unwrap();
+        let file = fx.files[&id].clone();
+        let seg = &file.trk[0].trkseg[0];
+        let asphalt = fx.categories.surface.code("asphalt");
+        let gravel = fx.categories.surface.code("gravel");
+        let surfaces: Vec<_> = (0..4).map(|i| seg[i].surface).collect();
+        assert_eq!(surfaces, [asphalt, asphalt, None, gravel]);
+        let track = fx.categories.highway.code("track");
+        assert!((0..4).all(|i| seg[i].highway == track));
+        assert!((0..4).all(|i| seg[i].sac_scale.is_none() && seg[i].mtb_scale.is_none()));
+
+        // broken intervals or names
+        let broken = [
+            RouteCategory {
+                starts: &[0, 1],
+                values: &[1],
+                names: &names,
+            },
+            RouteCategory {
+                starts: &[5],
+                values: &[1],
+                names: &names,
+            },
+            RouteCategory {
+                starts: &[0],
+                values: &[3],
+                names: &names,
+            },
+        ];
+        for surface in broken {
+            let result = Route {
+                surface,
+                ..route(0, 0, &lng, &lat, &ele)
+            }
+            .apply(&mut fx.state());
+            assert!(matches!(result, Err(CommandError::InvalidData(_))));
+        }
+    }
+
+    /// A segment of `data/with_time.gpx`, selected: 80 trackpoints at 20 km/h.
+    fn timed() -> (Fixture, FileId) {
+        let mut fx = Fixture::default();
+        let id = load(&mut fx, "data/with_time.gpx");
+        select_file(&mut fx, id);
+        (fx, id)
+    }
+
+    fn times(seg: &TrackSegment) -> Vec<i64> {
+        seg.iter().map(|p| p.time.unwrap()).collect()
+    }
+
+    #[test]
+    fn test_route_gives_times_to_the_new_points() {
+        let (mut fx, id) = timed();
+        let seg = segment(&fx, id, 0, 0);
+        let (n, before) = (seg.len(), times(seg));
+        let duration = before[n - 1] - before[0];
+
+        // replace the points 20..40 by the straight line between them, with 5 points
+        let (a, b) = (seg[20].coordinates, seg[39].coordinates);
+        let at = |t: f64| (a.lng + t * (b.lng - a.lng), a.lat + t * (b.lat - a.lat));
+        let positions: Vec<_> = (0..5).map(|i| at(i as f64 / 4.0)).collect();
+        let lng: Vec<_> = positions.iter().map(|p| p.0).collect();
+        let lat: Vec<_> = positions.iter().map(|p| p.1).collect();
+        route(20, 40, &lng, &lat, &[0.0; 5])
+            .apply(&mut fx.state())
+            .unwrap();
+
+        let seg = segment(&fx, id, 0, 0);
+        assert_eq!(seg.len(), n - 15);
+        let after = times(seg);
+        assert!(after.windows(2).all(|w| w[0] < w[1]), "{after:?}");
+        // the points before are untouched
+        assert_eq!(after[..20], before[..20]);
+        // the speed of the replaced part is the one of the segment: the duration of the segment
+        // is about the same as on the same distance
+        let stats = Statistics::compute(seg);
+        let speed = stats.global.moving_speed().unwrap();
+        assert!((speed - 20.0).abs() < 1.0, "{speed}");
+        assert!(after[after.len() - 1] - after[0] <= duration);
+    }
+
+    #[test]
+    fn test_route_between_anchors_that_stay_keeps_them_untouched() {
+        let (mut fx, id) = timed();
+        let seg = segment(&fx, id, 0, 0);
+        let (n, before) = (seg.len(), times(seg));
+        let (a, b) = (seg[20].clone(), seg[39].clone());
+        // 5 points on the line between the anchors 20 and 39, which are not replaced
+        let at = |t: f64| {
+            (
+                a.coordinates.lng + t * (b.coordinates.lng - a.coordinates.lng),
+                a.coordinates.lat + t * (b.coordinates.lat - a.coordinates.lat),
+            )
+        };
+        let positions: Vec<_> = (1..=5).map(|i| at(i as f64 / 6.0)).collect();
+        let lng: Vec<_> = positions.iter().map(|p| p.0).collect();
+        let lat: Vec<_> = positions.iter().map(|p| p.1).collect();
+        route(21, 39, &lng, &lat, &[0.0; 5])
+            .apply(&mut fx.state())
+            .unwrap();
+
+        let seg = segment(&fx, id, 0, 0);
+        assert_eq!(seg.len(), n - 18 + 5);
+        let after = times(seg);
+        assert!(after.windows(2).all(|w| w[0] < w[1]), "{after:?}");
+        // the anchors keep their coordinates and times, and what is before them
+        assert_eq!(after[..=20], before[..=20]);
+        assert_eq!(seg[26].coordinates.lng, b.coordinates.lng);
+        assert_eq!(after[26], before[39]);
+        // and what comes after is unchanged as well
+        assert_eq!(after[27..], before[40..]);
+        let speed = Statistics::compute(seg).global.moving_speed().unwrap();
+        assert!((speed - 20.0).abs() < 1.0, "{speed}");
+    }
+
+    #[test]
+    fn test_route_appending_to_a_segment_with_times() {
+        let (mut fx, id) = timed();
+        let seg = segment(&fx, id, 0, 0);
+        let n = seg.len();
+        let last = seg[n - 1].clone();
+        // replace the last point and go 1 km further east
+        let lng = [last.coordinates.lng, last.coordinates.lng + 0.009];
+        let lat = [last.coordinates.lat; 2];
+        route(n as u32 - 1, n as u32, &lng, &lat, &[0.0; 2])
+            .apply(&mut fx.state())
+            .unwrap();
+        let seg = segment(&fx, id, 0, 0);
+        assert_eq!(seg.len(), n + 1);
+        // the replaced point is reached at the speed of the segment: about at its time
+        assert!((seg[n - 1].time.unwrap() - last.time.unwrap()).abs() < 1000);
+        let (a, b) = (seg[n - 1].time.unwrap(), seg[n].time.unwrap());
+        // the new point is reached at about 20 km/h
+        let km = distance(seg[n - 1].coordinates, seg[n].coordinates);
+        let seconds = (b - a) as f64 / 1000.0;
+        let expected = 3600.0 * km / 20.0;
+        assert!(
+            (seconds - expected).abs() < 0.1 * expected,
+            "{seconds} {expected}"
+        );
+    }
+
+    #[test]
+    fn test_route_does_not_invent_times() {
+        let mut fx = Fixture::default();
+        let id = load(&mut fx, "data/simple.gpx");
+        select_file(&mut fx, id);
+        assert!(segment(&fx, id, 0, 0).iter().all(|p| p.time.is_none()));
+        route(0, 2, &[1.0, 2.0], &[3.0, 4.0], &[5.0, 6.0])
+            .apply(&mut fx.state())
+            .unwrap();
+        assert!(segment(&fx, id, 0, 0).iter().all(|p| p.time.is_none()));
+    }
+}