osm-io 0.3.0

Read and write OSM data
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

use crate::osm::model::node::Node;
use crate::osm::pbf::string_table_builder::StringTableBuilder;
use crate::osmpbf::{DenseInfo, DenseNodes, PrimitiveGroup};

pub(crate) struct DenseGroupBuilder {
    granularity: i32,
    date_granularity: i32,
    lat_offset: i64,
    lon_offset: i64,
    dense: Option<DenseNodes>,
    last_id: i64,
    last_lon: i64,
    last_lat: i64,
    last_timestamp: i64,
    last_uid: i32,
    last_changeset: i64,
    last_sid: i32,
}

#[allow(clippy::needless_late_init)]
impl DenseGroupBuilder {
    pub(crate) fn new(
        granularity: i32,
        date_granularity: i32,
        lat_offset: i64,
        lon_offset: i64,
        node: &Node,
        string_table_builder: &mut StringTableBuilder,
    ) -> DenseGroupBuilder {
        let mut dense = Some(DenseNodes::default());
        let last_id;
        let last_lon;
        let last_lat;
        let last_timestamp;
        let last_uid;
        let last_changeset;
        let last_sid;

        last_id = node.id();
        dense.as_mut().unwrap().id.push(last_id);

        last_lon = (node.coordinate().lon() * 1E9f64 / granularity as f64 - lon_offset as f64).round() as i64;
        dense.as_mut().unwrap().lon.push(last_lon);
        last_lat = (node.coordinate().lat() * 1E9f64 / granularity as f64 - lat_offset as f64).round() as i64;
        dense.as_mut().unwrap().lat.push(last_lat);

        dense.as_mut().unwrap().denseinfo = Some(DenseInfo::default());
        dense.as_mut().unwrap().denseinfo.as_mut().unwrap().visible.push(node.visible());

        last_timestamp = node.timestamp() / date_granularity as i64;
        dense.as_mut().unwrap().denseinfo.as_mut().unwrap().timestamp.push(last_timestamp);

        dense.as_mut().unwrap().denseinfo.as_mut().unwrap().version.push(node.version());

        last_uid = node.uid();
        dense.as_mut().unwrap().denseinfo.as_mut().unwrap().uid.push(last_uid);

        last_changeset = node.changeset();
        dense.as_mut().unwrap().denseinfo.as_mut().unwrap().changeset.push(last_changeset);

        last_sid = string_table_builder.add(node.user());
        dense.as_mut().unwrap().denseinfo.as_mut().unwrap().user_sid.push(last_sid);

        for tag in node.tags() {
            let key_index = string_table_builder.add(tag.k());
            let value_index = string_table_builder.add(tag.v());
            dense.as_mut().unwrap().keys_vals.push(key_index);
            dense.as_mut().unwrap().keys_vals.push(value_index);
        }
        dense.as_mut().unwrap().keys_vals.push(0);

        DenseGroupBuilder {
            granularity,
            date_granularity,
            lat_offset,
            lon_offset,
            dense,
            last_id,
            last_lon,
            last_lat,
            last_timestamp,
            last_uid,
            last_changeset,
            last_sid,
        }
    }

    pub(crate) fn add(&mut self, node: &Node, string_table_builder: &mut StringTableBuilder) {
        let current_id = node.id();
        self.dense.as_mut().unwrap().id.push(current_id - self.last_id);
        self.last_id = current_id;

        let current_lon = (node.coordinate().lon() * 1E9f64 / self.granularity as f64 - self.lon_offset as f64).round() as i64;
        self.dense.as_mut().unwrap().lon.push(current_lon - self.last_lon);
        self.last_lon = current_lon;
        let current_lat = (node.coordinate().lat() * 1E9f64 / self.granularity as f64 - self.lat_offset as f64).round() as i64;
        self.dense.as_mut().unwrap().lat.push(current_lat - self.last_lat);
        self.last_lat = current_lat;

        self.dense.as_mut().unwrap().denseinfo.as_mut().unwrap().visible.push(node.visible());

        let current_timestamp = node.timestamp() / self.date_granularity as i64;
        self.dense.as_mut().unwrap().denseinfo.as_mut().unwrap().timestamp.push(current_timestamp - self.last_timestamp);
        self.last_timestamp = current_timestamp;

        self.dense.as_mut().unwrap().denseinfo.as_mut().unwrap().version.push(node.version());

        let current_uid = node.uid();
        self.dense.as_mut().unwrap().denseinfo.as_mut().unwrap().uid.push(current_uid - self.last_uid);
        self.last_uid = current_uid;

        let current_changeset = node.changeset();
        self.dense.as_mut().unwrap().denseinfo.as_mut().unwrap().changeset.push(current_changeset - self.last_changeset);
        self.last_changeset = current_changeset;

        let current_sid = string_table_builder.add(node.user());
        self.dense.as_mut().unwrap().denseinfo.as_mut().unwrap().user_sid.push(current_sid - self.last_sid);
        self.last_sid = current_sid;

        for tag in node.tags() {
            let key_index = string_table_builder.add(tag.k());
            let value_index = string_table_builder.add(tag.v());
            self.dense.as_mut().unwrap().keys_vals.push(key_index);
            self.dense.as_mut().unwrap().keys_vals.push(value_index);
        }
        self.dense.as_mut().unwrap().keys_vals.push(0);
    }

    #[allow(clippy::field_reassign_with_default)]
    pub(crate) fn build(&mut self) -> PrimitiveGroup {
        let mut primitive_group = PrimitiveGroup::default();
        primitive_group.dense = self.dense.replace(DenseNodes::default());
        primitive_group
    }
}