ferrostar 0.49.0

The core of modern turn-by-turn navigation.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

use crate::{
    deviation_detection::RouteDeviation,
    models::Route,
    navigation_controller::{
        Navigator,
        models::{NavState, TripState},
    },
    navigation_session::NavigationSession,
    simulation::{LocationBias, advance_location_simulation, location_simulation_from_route},
};

pub(crate) fn test_full_route_state_snapshot(
    route: Route,
    session: NavigationSession,
) -> Vec<NavState> {
    let mut simulation_state =
        location_simulation_from_route(&route, Some(10.0), LocationBias::None)
            .expect("Unable to create simulation");

    let mut state = session.get_initial_state(simulation_state.current_location);
    let mut states = vec![state.clone()];
    loop {
        let new_simulation_state = advance_location_simulation(&simulation_state);
        let new_state = session.update_user_location(new_simulation_state.current_location, state);

        match new_state.trip_state() {
            TripState::Idle { .. } => {}
            TripState::Navigating {
                current_step_geometry_index,
                ref remaining_steps,
                ref deviation,
                ..
            } => {
                if let Some(index) = current_step_geometry_index {
                    let geom_length = remaining_steps[0].geometry.len() as u64;
                    // Regression test that the geometry index is valid
                    assert!(
                        index < geom_length,
                        "index = {index}, geom_length = {geom_length}"
                    );
                }

                // Regression test that we are never marked as off the route.
                // We used to encounter this with relative step advance on self-intersecting
                // routes, for example.
                assert_eq!(deviation, &RouteDeviation::NoDeviation);
            }
            TripState::Complete { .. } => {
                states.push(new_state);
                break;
            }
        }

        simulation_state = new_simulation_state;
        state = new_state.clone();
        states.push(new_state);
    }

    states
}