osm_graph 0.1.1

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
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

#![allow(dead_code)]

mod graph;
mod isochrone;
mod overpass;
mod utils;
mod cache;

use pyo3::prelude::*;

/// Calculates isochrones from a point
#[pyfunction]
fn calc_isochrones(
    lat: f64,
    lon: f64,
    max_dist: f64,
    time_limits: Vec<f64>,
    network_type: String,
    hull_type: String,
) -> PyResult<Vec<String>> {
    // Convert network_type string to NetworkType enum
    let network_type_enum = match network_type.as_str() {
        "Drive" => overpass::NetworkType::Drive,
        "DriveService" => overpass::NetworkType::DriveService,
        "Walk" => overpass::NetworkType::Walk,
        "Bike" => overpass::NetworkType::Bike,
        "All" => overpass::NetworkType::All,
        "AllPrivate" => overpass::NetworkType::AllPrivate,
        _ => {
            return Err(pyo3::PyErr::new::<pyo3::exceptions::PyValueError, _>(
                "Invalid network type",
            ))
        }
    };

    // Convert hull_type string to HullType enum
    let hull_type_enum = match hull_type.as_str() {
        "Convex" => isochrone::HullType::Convex,
        "FastConcave" => isochrone::HullType::FastConcave,
        "Concave" => isochrone::HullType::Concave,
        _ => {
            return Err(pyo3::PyErr::new::<pyo3::exceptions::PyValueError, _>(
                "Invalid hull type",
            ))
        }
    };

    // Create a new Tokio runtime
    let rt = tokio::runtime::Runtime::new().unwrap();
    let isochrones = rt
        .block_on(isochrone::calculate_isochrones_from_point(
            lat,
            lon,
            max_dist,
            time_limits,
            network_type_enum,
            hull_type_enum,
        ))
        .unwrap();

    // Convert from Geo::Polygon to GeoJSON string
    let mut isochrones_converted = Vec::new();
    for isochrone in isochrones {
        let converted = utils::polygon_to_geojson_string(&isochrone);
        isochrones_converted.push(converted);
    }

    Ok(isochrones_converted)
}

/// Calculates a reverse isochrones from a point
#[pyfunction]
fn calc_reverse_isochrones(
    lat: f64,
    lon: f64,
    max_dist: f64,
    time_limits: Vec<f64>,
    network_type: String,
    hull_type: String,
) -> PyResult<Vec<String>> {
    // Convert network_type string to NetworkType enum
    let network_type_enum = match network_type.as_str() {
        "Drive" => overpass::NetworkType::Drive,
        "DriveService" => overpass::NetworkType::DriveService,
        "Walk" => overpass::NetworkType::Walk,
        "Bike" => overpass::NetworkType::Bike,
        "All" => overpass::NetworkType::All,
        "AllPrivate" => overpass::NetworkType::AllPrivate,
        _ => {
            return Err(pyo3::PyErr::new::<pyo3::exceptions::PyValueError, _>(
                "Invalid network type",
            ))
        }
    };

    // Convert hull_type string to HullType enum
    let hull_type_enum = match hull_type.as_str() {
        "Convex" => isochrone::HullType::Convex,
        "Concave" => isochrone::HullType::Concave,
        _ => {
            return Err(pyo3::PyErr::new::<pyo3::exceptions::PyValueError, _>(
                "Invalid hull type",
            ))
        }
    };

    // Create a new Tokio runtime
    let rt = tokio::runtime::Runtime::new().unwrap();
    let isochrones = rt
        .block_on(isochrone::calculate_reverse_isochrones_from_point(
            lat,
            lon,
            max_dist,
            time_limits,
            network_type_enum,
            hull_type_enum,
        ))
        .unwrap();

    // Convert from Geo::Polygon to GeoJSON string
    let mut isochrones_converted = Vec::new();
    for isochrone in isochrones {
        let converted = utils::polygon_to_geojson_string(&isochrone);
        isochrones_converted.push(converted);
    }

    Ok(isochrones_converted)
}

/// Python module for quickly creating isochrones
#[pymodule]
fn pysochrone(_py: Python, m: &PyModule) -> pyo3::PyResult<()> {
    m.add_function(wrap_pyfunction!(calc_isochrones, m)?)?;
    m.add_function(wrap_pyfunction!(calc_reverse_isochrones, m)?)?;
    Ok(())
}