utiles-cover 0.8.0

web-map-tile coverage for geojson/geo-types
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

use crate::cover_geojson::geojson2tiles;
use geojson::GeoJson;
use std::collections::HashSet;
use utiles_core::{Tile, parse_textiles};

#[test]
fn cover_geotypes() {
    use crate::cover_geotypes::geometry2tiles;
    let expected = expected_burn_test_tiles();
    let geojson_string = include_str!("./cover-test.geo.json");
    let geojson: GeoJson = geojson_string.parse::<GeoJson>().unwrap();
    let gt_geometry = geo_types::Geometry::<f64>::try_from(geojson).unwrap();
    let tilescoverage = geometry2tiles(&gt_geometry, 9).unwrap();
    let tiles_set: HashSet<Tile> = tilescoverage.into_iter().collect();
    let expected_set: HashSet<Tile> = expected.into_iter().collect();
    for tile in expected_set {
        assert!(
            tiles_set.contains(&tile),
            "Expected tile {tile:?} is not in the tiles set."
        );
    }
}

#[test]
fn cover_geojson() {
    let expected = expected_burn_test_tiles();
    let geojson_string = include_str!("./cover-test.geo.json");
    let geojson: GeoJson = geojson_string.parse::<GeoJson>().unwrap();
    let tilescoverage = geojson2tiles(&geojson, 9).unwrap();
    let tiles_set: HashSet<Tile> = tilescoverage.into_iter().collect();
    let expected_set: HashSet<Tile> = expected.into_iter().collect();

    for tile in expected_set {
        assert!(
            tiles_set.contains(&tile),
            "Expected tile {tile:?} is not in the tiles set."
        );
    }
}

// macro to test expected vs actual tiles from 2 paths:
// - geojson path file
// - tiles jsonl path file

macro_rules! mk_coverage_test {
    ($test_name:ident, $zoom:expr, $geojson_path:expr, $tiles_path:expr) => {
        #[test]
        fn $test_name() {
            let tiles_str = include_str!($tiles_path);
            let expected: Vec<Tile> = parse_textiles(tiles_str);
            let geojson_string = include_str!($geojson_path);
            let geojson: GeoJson = geojson_string.parse::<GeoJson>().unwrap();
            let gt_geometry =
                geo_types::Geometry::<f64>::try_from(geojson.clone()).unwrap();

            let gt_coverage =
                crate::cover_geotypes::geometry2tiles(&gt_geometry, $zoom).unwrap();
            let gt_tiles_set: HashSet<Tile> = gt_coverage.into_iter().collect();

            let tilescoverage = geojson2tiles(&geojson, $zoom).unwrap();
            let tiles_set: HashSet<Tile> = tilescoverage.into_iter().collect();
            let expected_set: HashSet<Tile> = expected.into_iter().collect();

            println!(
                "Expected tiles: {}, Actual tiles: {}",
                expected_set.len(),
                tiles_set.len()
            );
            println!(
                "GT tiles: {}, Actual GT tiles: {}",
                gt_tiles_set.len(),
                tiles_set.len()
            );
            for tile in expected_set {
                assert!(
                    tiles_set.contains(&tile),
                    "Expected tile {tile:?} is not in the tiles set."
                );

                assert!(
                    gt_tiles_set.contains(&tile),
                    "Expected tile {tile:?} is not in the gt tiles set."
                );
            }
        }
    };
}

mk_coverage_test!(
    cover_geotypes_test,
    9,
    "./cover-test.geo.json",
    "./cover-test.tiles.jsonl"
);
mk_coverage_test!(
    cover_geojson_test,
    9,
    "./cover-test.geo.json",
    "./cover-test.tiles.jsonl"
);

mk_coverage_test!(
    blocky,
    6,
    "../../../../test-data/tile-cover/blocky.geojson",
    "../../../../test-data/tile-cover/blocky.tiles.jsonl"
);

mk_coverage_test!(
    donut,
    16,
    "../../../../test-data/tile-cover/donut.geojson",
    "../../../../test-data/tile-cover/donut.tiles.jsonl"
);

fn expected_burn_test_tiles() -> Vec<Tile> {
    let tiles_str = include_str!("./cover-test.tiles.jsonl");
    parse_textiles(tiles_str)
}