osm_graph 0.1.2

This library provides a set of tools for generating isochrones from geographic coordinates. It leverages OpenStreetMap data to construct road networks and calculate areas accessible within specified time limits. The library is designed for both Rust and Python, offering high performance and easy integration into data science workflows.
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

#![allow(dead_code)]

mod graph;
mod isochrone;
mod overpass;
mod utils;
mod cache;
mod simplify;
mod error;
mod tests;

use std::time::Instant;
use error::OsmGraphError;

#[tokio::main]
async fn main() -> Result<(), OsmGraphError> {
    let lat = 48.123456;
    let lon = 11.123456;
    let max_dist = 10_000.0;
    let time_limits = vec![300.0, 600.0, 900.0, 1_200.0, 1_500.0, 1_800.0];
    let network_type = overpass::NetworkType::Drive;
    let hull_type = isochrone::HullType::Convex;

    // --- Run WITHOUT simplification ---
    println!("Running WITHOUT simplification...");
    let start = Instant::now();
    let (_, unsimplified_sg) = isochrone::calculate_isochrones_from_point(
        lat, lon, max_dist,
        time_limits.clone(),
        network_type,
        hull_type,
        true,
    )
    .await?;
    let unsimplified_duration = start.elapsed();
    println!(
        "  Nodes: {}, Edges: {}, Time: {:.2?}",
        unsimplified_sg.graph.node_count(),
        unsimplified_sg.graph.edge_count(),
        unsimplified_duration
    );

    cache::clear_cache()?;

    println!("Running WITH simplification...");
    let start = Instant::now();
    let (_, simplified_sg) = isochrone::calculate_isochrones_from_point(
        lat, lon, max_dist,
        time_limits.clone(),
        network_type,
        hull_type,
        false,
    )
    .await?;
    let simplified_duration = start.elapsed();
    println!(
        "  Nodes: {}, Edges: {}, Time: {:.2?}",
        simplified_sg.graph.node_count(),
        simplified_sg.graph.edge_count(),
        simplified_duration
    );

    println!(
        "\nNode reduction:  {} -> {} ({:.1}% fewer)",
        unsimplified_sg.graph.node_count(),
        simplified_sg.graph.node_count(),
        (1.0 - simplified_sg.graph.node_count() as f64 / unsimplified_sg.graph.node_count() as f64) * 100.0
    );
    println!(
        "Edge reduction:  {} -> {} ({:.1}% fewer)",
        unsimplified_sg.graph.edge_count(),
        simplified_sg.graph.edge_count(),
        (1.0 - simplified_sg.graph.edge_count() as f64 / unsimplified_sg.graph.edge_count() as f64) * 100.0
    );
    println!(
        "Time difference: {:.2?} vs {:.2?}",
        unsimplified_duration, simplified_duration
    );

    Ok(())
}