tinymvt 0.3.0

A lightweight library for encoding and decoding Mapbox Vector Tiles (MVT)
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

use std::fs;

use prost::Message;
use tinymvt::geometry::GeometryEncoder;
use tinymvt::tag::{TagsEncoder, Value};
use tinymvt::vector_tile::{
    tile::{Feature, GeomType, Layer},
    Tile,
};

#[test]
fn make_tile() {
    let extent = 4096;

    let layer = {
        let mut tags_enc = TagsEncoder::new();

        let points_feature = {
            let mut geom_enc = GeometryEncoder::new();
            geom_enc.add_points([]); // empty
            geom_enc.add_points([
                [300, 300],
                [300, extent - 300],
                [extent - 300, extent - 300],
                [extent - 300, 300],
                [900, 900],
                [900, extent - 900],
                [extent - 900, extent - 900],
                [extent - 900, 900],
            ]);

            tags_enc.add("foo", 10);
            tags_enc.add("bar", 20.5);

            Feature {
                id: Some(1),
                tags: tags_enc.take_tags(),
                r#type: Some(GeomType::Point as i32),
                geometry: geom_enc.into_vec(),
            }
        };

        let line_strings_feature = {
            let mut geom_enc = GeometryEncoder::default();
            geom_enc.add_linestring([]); // empty
            geom_enc.add_linestring([[0, 0], [0, extent], [extent, extent], [extent, 0]]);
            geom_enc.add_linestring([
                [500, 500],
                [500, extent - 500],
                [extent - 500, extent - 500],
                [extent - 500, 500],
            ]);
            geom_enc.add_linestring([
                [700, 700],
                [700, extent - 700],
                [extent - 700, extent - 700],
                [extent - 700, 700],
            ]);

            tags_enc.add("uint", Value::Uint(10));
            tags_enc.add("sint", Value::SInt(-10));
            tags_enc.add("int", Value::Int(10));
            tags_enc.add("string", Value::String("string".to_string()));
            tags_enc.add("float", 10.5f32);
            tags_enc.add("double", 10.5f64);
            tags_enc.add("bool", Value::Bool(true));

            Feature {
                id: Some(2),
                tags: tags_enc.take_tags(),
                r#type: Some(GeomType::Linestring as i32),
                geometry: geom_enc.into_vec(),
            }
        };

        let polygon_feature = {
            let mut geom_enc = GeometryEncoder::new();
            geom_enc.add_ring([]); // empty

            geom_enc.add_ring([[1000, 1000], [1000, 1500], [1500, 1500], [1500, 1000]]);
            geom_enc.add_ring([[1100, 1100], [1200, 1100], [1200, 1200], [1100, 1200]]);
            geom_enc.add_ring([[1200, 1200], [1300, 1200], [1300, 1300], [1200, 1300]]);

            geom_enc.add_ring([[2000, 2000], [2000, 2500], [2500, 2500], [2500, 2000]]);
            geom_enc.add_ring([[2100, 2100], [2200, 2100], [2200, 2200], [2100, 2200]]);
            geom_enc.add_ring([[2200, 2200], [2300, 2200], [2300, 2300], [2200, 2300]]);
            geom_enc.add_ring([[2300, 2300], [2400, 2300], [2400, 2400], [2300, 2400]]);

            tags_enc.add("fizz", 10);
            tags_enc.add("buzz", 20.5);

            Feature {
                id: Some(3),
                tags: tags_enc.take_tags(),
                r#type: Some(GeomType::Polygon as i32),
                geometry: geom_enc.into_vec(),
            }
        };

        let (keys, values) = tags_enc.into_keys_and_values();

        Layer {
            version: 2,
            name: "road".to_string(),
            features: vec![points_feature, line_strings_feature, polygon_feature],
            keys,
            values,
            extent: Some(4096),
        }
    };

    let buf = Tile {
        layers: vec![layer],
    }
    .encode_to_vec();

    let expected = fs::read("tests/fixtures/make_tile.pbf").unwrap();

    assert_eq!(buf, expected);
}