tracematch 0.0.4

High-performance GPS route matching and activity analysis
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
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

//! Tests for heatmap module

use std::collections::HashMap;
use tracematch::heatmap::*;
use tracematch::{Bounds, GpsPoint, RouteSignature};

fn make_signature(id: &str, points: Vec<(f64, f64)>) -> RouteSignature {
    let gps_points: Vec<GpsPoint> = points
        .iter()
        .map(|(lat, lng)| GpsPoint::new(*lat, *lng))
        .collect();

    let min_lat = points
        .iter()
        .map(|(lat, _)| *lat)
        .fold(f64::INFINITY, f64::min);
    let max_lat = points
        .iter()
        .map(|(lat, _)| *lat)
        .fold(f64::NEG_INFINITY, f64::max);
    let min_lng = points
        .iter()
        .map(|(_, lng)| *lng)
        .fold(f64::INFINITY, f64::min);
    let max_lng = points
        .iter()
        .map(|(_, lng)| *lng)
        .fold(f64::NEG_INFINITY, f64::max);

    let center_lat = points.iter().map(|(lat, _)| *lat).sum::<f64>() / points.len() as f64;
    let center_lng = points.iter().map(|(_, lng)| *lng).sum::<f64>() / points.len() as f64;

    RouteSignature {
        activity_id: id.to_string(),
        points: gps_points.clone(),
        total_distance: 1000.0,
        start_point: gps_points
            .first()
            .cloned()
            .unwrap_or(GpsPoint::new(0.0, 0.0)),
        end_point: gps_points
            .last()
            .cloned()
            .unwrap_or(GpsPoint::new(0.0, 0.0)),
        bounds: Bounds {
            min_lat,
            max_lat,
            min_lng,
            max_lng,
        },
        center: GpsPoint::new(center_lat, center_lng),
    }
}

#[test]
fn test_empty_heatmap() {
    let result = generate_heatmap(&[], &HashMap::new(), &HeatmapConfig::default());
    assert!(result.cells.is_empty());
    assert_eq!(result.total_activities, 0);
}

#[test]
fn test_single_activity() {
    let sig = make_signature(
        "act1",
        vec![
            (37.7749, -122.4194),
            (37.7750, -122.4195),
            (37.7751, -122.4196),
        ],
    );

    let mut data = HashMap::new();
    data.insert(
        "act1".to_string(),
        ActivityHeatmapData {
            activity_id: "act1".to_string(),
            route_id: None,
            route_name: None,
            timestamp: Some(1000000),
        },
    );

    let result = generate_heatmap(&[sig], &data, &HeatmapConfig::default());

    assert!(!result.cells.is_empty());
    assert_eq!(result.total_activities, 1);
    assert_eq!(result.total_routes, 0);
}

#[test]
fn test_multiple_activities_same_path() {
    let sig1 = make_signature("act1", vec![(37.7749, -122.4194), (37.7750, -122.4195)]);
    let sig2 = make_signature("act2", vec![(37.7749, -122.4194), (37.7750, -122.4195)]);

    let mut data = HashMap::new();
    data.insert(
        "act1".to_string(),
        ActivityHeatmapData {
            activity_id: "act1".to_string(),
            route_id: Some("route1".to_string()),
            route_name: Some("Morning Run".to_string()),
            timestamp: None,
        },
    );
    data.insert(
        "act2".to_string(),
        ActivityHeatmapData {
            activity_id: "act2".to_string(),
            route_id: Some("route1".to_string()),
            route_name: Some("Morning Run".to_string()),
            timestamp: None,
        },
    );

    let result = generate_heatmap(&[sig1, sig2], &data, &HeatmapConfig::default());

    assert!(!result.cells.is_empty());
    assert_eq!(result.total_activities, 2);
    assert_eq!(result.total_routes, 1);

    // Cells should have higher density due to overlapping paths
    let max_cell = result
        .cells
        .iter()
        .max_by(|a, b| a.visit_count.cmp(&b.visit_count))
        .unwrap();
    assert!(max_cell.visit_count >= 2);
}

#[test]
fn test_common_path_detection() {
    let sig1 = make_signature("act1", vec![(37.7749, -122.4194)]);
    let sig2 = make_signature("act2", vec![(37.7749, -122.4194)]);

    let mut data = HashMap::new();
    data.insert(
        "act1".to_string(),
        ActivityHeatmapData {
            activity_id: "act1".to_string(),
            route_id: Some("route1".to_string()),
            route_name: None,
            timestamp: None,
        },
    );
    data.insert(
        "act2".to_string(),
        ActivityHeatmapData {
            activity_id: "act2".to_string(),
            route_id: Some("route2".to_string()),
            route_name: None,
            timestamp: None,
        },
    );

    let result = generate_heatmap(&[sig1, sig2], &data, &HeatmapConfig::default());

    // Should detect cells where routes overlap
    let common_cells: Vec<_> = result.cells.iter().filter(|c| c.is_common_path).collect();
    assert!(!common_cells.is_empty());
}