osm_pbf2json 0.2.2

A parser/filter/processor for OSM protobuf bundles
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

use super::geo::{BoundaryGeometry, SegmentGeometry};

pub struct AdminBoundary {
    pub name: String,
    pub admin_level: u8,
    pub geometry: BoundaryGeometry,
}

#[derive(Debug, Clone)]
pub struct Street {
    pub name: String,
    pub segments: Vec<Segment>,
    pub boundary: Option<String>,
}

#[derive(Clone, Debug)]
pub struct Segment {
    pub way_id: i64,
    pub geometry: SegmentGeometry,
}

pub enum Object {
    Node(osm::Node),
    Way(osm::Way),
    Relation(osm::Relation),
}

pub mod osm {
    use super::super::geo::{get_geo_info, Bounds, Location};
    use osmpbfreader::objects::Tags;
    use serde::{Deserialize, Serialize};

    #[derive(Serialize, Deserialize)]
    pub struct Node {
        id: i64,
        #[serde(rename = "type")]
        osm_type: &'static str,
        lat: f64,
        lon: f64,
        tags: Tags,
    }

    impl Node {
        pub fn new(id: i64, lat: f64, lon: f64, tags: Tags) -> Self {
            Node {
                id,
                osm_type: "node",
                lat,
                lon,
                tags,
            }
        }
    }

    #[derive(Serialize, Deserialize)]
    pub struct Way {
        id: i64,
        #[serde(rename = "type")]
        osm_type: &'static str,
        tags: Tags,
        centroid: Option<Location>,
        bounds: Option<Bounds>,
    }

    impl Way {
        pub fn new(id: i64, tags: Tags, coordinates: &[(f64, f64)]) -> Self {
            let (centroid, bounds) = get_geo_info(coordinates);
            Way {
                id,
                osm_type: "way",
                tags,
                centroid,
                bounds,
            }
        }
    }

    #[derive(Serialize, Deserialize)]
    pub struct Relation {
        id: i64,
        #[serde(rename = "type")]
        osm_type: &'static str,
        tags: Tags,
        centroid: Option<Location>,
        bounds: Option<Bounds>,
    }

    impl Relation {
        pub fn new(id: i64, tags: Tags, coordinates: &[(f64, f64)]) -> Self {
            let (centroid, bounds) = get_geo_info(coordinates);
            Relation {
                id,
                osm_type: "relation",
                tags,
                centroid,
                bounds,
            }
        }
    }
}