routers_realtime 0.4.0

A Demonstration for Real-Time Map Matching
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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

//! The diff emission a matcher publishes per solve: one layer per trip
//! observation, addressable by timestamp, with hop geometry resolved against
//! the matcher's network.

use geo::point;
use routers_network::mock::{MockEntryId, MockNetwork, MockNetworkBuilder};
use routers_realtime::event::MatchedDiff;
use routers_transition::costing::{CostingStrategies, DefaultEmissionCost, DefaultTransitionCost};
use routers_transition::layer::generation::StandardGenerator;
use routers_transition::weigh::AllCompute;
use routers_transition::{Matcher, Origin};

type Costing = CostingStrategies<DefaultEmissionCost, DefaultTransitionCost, MockEntryId>;

/// A staircase road: west, then south, then west again.
fn bent_road() -> MockNetwork {
    MockNetworkBuilder::new()
        .node(1, point!(x: -118.15, y: 34.15))
        .node(2, point!(x: -118.16, y: 34.15))
        .node(3, point!(x: -118.17, y: 34.15))
        .node(4, point!(x: -118.17, y: 34.14))
        .node(5, point!(x: -118.18, y: 34.14))
        .edge(1, 2)
        .edge(2, 3)
        .edge(3, 4)
        .edge(4, 5)
        .build()
}

fn observations() -> Vec<Origin> {
    [
        point!(x: -118.151, y: 34.1503),
        point!(x: -118.155, y: 34.1503),
        point!(x: -118.165, y: 34.1503),
        point!(x: -118.170, y: 34.1490),
        point!(x: -118.172, y: 34.1403),
        point!(x: -118.179, y: 34.1403),
    ]
    .into_iter()
    .enumerate()
    // Realistic supplier stamps: distinct, spaced, non-zero micros.
    .map(|(index, point)| Origin::new(point, 1_775_000_000_000_000 + index as i64 * 5_000_000))
    .collect()
}

#[test]
fn diff_lifts_every_layer_with_its_timestamp() {
    let net = bent_road();
    let costing = Costing::default();
    let generator = StandardGenerator::new(&net, &costing.emission);
    let m = Matcher::new(&net, &costing, generator, AllCompute::default(), &());

    let origins = observations();
    let mut trip = m.begin();
    for &origin in &origins {
        m.push(&mut trip, origin).expect("push must anchor");
    }

    let solution = m.snapshot(&mut trip).expect("trip must solve");
    let diff = MatchedDiff::new(&solution, &origins, &net, 42);

    assert_eq!(diff.revision, 42);
    assert!(!diff.downgraded);
    assert_eq!(
        diff.layers.len(),
        origins.len(),
        "one emitted layer per observation"
    );

    for (layer, origin) in diff.layers.iter().zip(&origins) {
        assert_eq!(
            layer.timestamp, origin.timestamp,
            "layers are addressed by their observation's timestamp"
        );
    }

    assert!(
        diff.layers[0].path.is_empty(),
        "the first layer has no inbound hop"
    );

    // The staircase forces the interpolation through the bend: at least one
    // hop must resolve interior geometry, or the diff carries no more than
    // the raw positions did.
    assert!(
        diff.layers.iter().any(|layer| !layer.path.is_empty()),
        "hop geometry must resolve against the network"
    );
}

#[test]
fn diff_layers_flatten_into_a_connected_trace() {
    let net = bent_road();
    let costing = Costing::default();
    let generator = StandardGenerator::new(&net, &costing.emission);
    let m = Matcher::new(&net, &costing, generator, AllCompute::default(), &());

    let origins = observations();
    let mut trip = m.begin();
    for &origin in &origins {
        m.push(&mut trip, origin).expect("push must anchor");
    }

    let solution = m.snapshot(&mut trip).expect("trip must solve");
    let interpolated = solution.interpolated(&net);

    let diff = MatchedDiff::new(&solution, &origins, &net, 0);

    // Rendering the diff — each layer's path then its position, in timestamp
    // order — must reproduce the solution's own interpolated linestring.
    let rendered: Vec<geo::Point> = diff
        .layers
        .iter()
        .flat_map(|layer| {
            layer
                .path
                .iter()
                .copied()
                .chain(core::iter::once(layer.position))
        })
        .collect();

    let expected: Vec<geo::Point> = interpolated.into_points();
    assert_eq!(
        rendered, expected,
        "the diff must carry exactly the interpolated geometry"
    );
}