pinpointer 0.1.5

Gets provinces and countries from latitudes and longitudes.
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

use std::{net::SocketAddr, path::Path, sync::Arc};

use axum::{extract::Query, routing::get, Router};
use datasets::{
    load_or_compute_country_label_tree, load_or_compute_province_label_tree, lazy_download_map_data,
};
use geo::Point;

mod datasets;
mod labeling;

use serde::Deserialize;

use crate::labeling::LabeledPartitionTree;

#[derive(Deserialize, Debug)]
struct LatLon {
    lat: f64,
    lon: f64,
}

async fn lat_lon_to_label(
    lat_lon: LatLon,
    label_tree: Arc<LabeledPartitionTree<String>>,
) -> String {
    label_tree
        .label(&Point::new(lat_lon.lon, lat_lon.lat))
        .unwrap_or(String::from("-99"))
}

#[tokio::main]
async fn main() {
    lazy_download_map_data().expect("Could not load or download map data.");

    let country_label_tree = load_or_compute_country_label_tree(
        Path::new("data"),
        Path::new("data\\ne_10m_admin_0_countries_lakes.geojson"),
        6
    );
    let country_label_tree_arc = Arc::new(country_label_tree);

    let province_label_tree = load_or_compute_province_label_tree(
        Path::new("data"),
        Path::new("data\\ne_10m_admin_1_states_provinces_lakes.geojson"),
        6
    );
    let province_label_tree_arc = Arc::new(province_label_tree);

    let app = Router::new()
        .route(
            "/lat_lon_to_country",
            get(move |lat_lon: Query<LatLon>| {
                lat_lon_to_label(
                    LatLon {
                        lat: lat_lon.lat,
                        lon: lat_lon.lon,
                    },
                    country_label_tree_arc.clone(),
                )
            }),
        )
        .route(
            "/lat_lon_to_province",
            get(move |lat_lon: Query<LatLon>| {
                lat_lon_to_label(
                    LatLon {
                        lat: lat_lon.lat,
                        lon: lat_lon.lon,
                    },
                    province_label_tree_arc.clone(),
                )
            }),
        );

    let addr = SocketAddr::from(([127, 0, 0, 1], 8000));
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}