spatialtime 0.1.0

A simple library to lookup longitude + latitude pairs, using flatgeobufs.
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

use anyhow::{anyhow, Result};
use flatgeobuf::{FgbCrs, FgbWriter, FgbWriterOptions, GeometryType};
use geojson::de::{deserialize_feature_collection_to_vec, deserialize_geometry};
use geojson::ser::{serialize_geometry, to_feature_collection_byte_vec};
use geozero::{geojson::GeoJsonReader, GeozeroDatasource};
use serde::{Deserialize, Serialize};
use std::env;
use std::{
    fs::File,
    io::{BufWriter, Read, Write},
};

#[derive(Deserialize, Serialize)]
struct NedGeoJson {
    #[serde(
        serialize_with = "serialize_geometry",
        deserialize_with = "deserialize_geometry"
    )]
    geometry: geo_types::Geometry<f64>,
    #[serde(rename(deserialize = "zone"))]
    offset: f64,
    #[serde(rename(deserialize = "tz_name1st"))]
    tzid: Option<String>,
}

static OSM_ADDRESS: &str = "https://github.com/evansiroky/timezone-boundary-builder/releases/latest/download/timezones-with-oceans-now.geojson.zip";
static NED_ADDRESS: &str = "https://raw.githubusercontent.com/nvkelso/natural-earth-vector/master/geojson/ne_10m_time_zones.geojson";

fn main() -> Result<()> {
    let rebuild_assets = cfg!(feature = "rebuild-assets");
    let cwd = env::current_dir()?;
    let parent_path = cwd
        .parent()
        .ok_or_else(|| anyhow!("Could not get parent path?"))?;
    std::fs::create_dir_all(parent_path.join("assets"))?;

    if cfg!(feature = "ned") {
        let asset_path = parent_path.join("assets").join("timezones_ned.fgb.zst");
        if !asset_path.exists() || rebuild_assets {
            let ned_bytes = get_ned_bytes()?;
            write_fgb(ned_bytes, "timezones_ned.fgb")?;
        }
    }

    if cfg!(feature = "osm") {
        let asset_path = parent_path.join("assets").join("timezones_osm.fgb.zst");
        if !asset_path.exists() || rebuild_assets {
            let osm_bytes = get_osm_bytes()?;
            write_fgb(osm_bytes, "timezones_osm.fgb")?;
        }
    }
    Ok(())
}

fn get_ned_bytes() -> Result<Vec<u8>> {
    let mut response = reqwest::blocking::get(NED_ADDRESS)?;
    let mut input_byte_vec = Vec::new();
    response.read_to_end(&mut input_byte_vec)?;
    let geojson_struct: Vec<NedGeoJson> =
        deserialize_feature_collection_to_vec(input_byte_vec.as_slice())?;
    let output_byte_vec = to_feature_collection_byte_vec(&geojson_struct)?;
    Ok(output_byte_vec)
}

fn get_osm_bytes() -> Result<Vec<u8>> {
    let response = reqwest::blocking::get(OSM_ADDRESS)?;
    let download_bytes = response.bytes()?;
    let mut byte_vec = Vec::new();
    let mut zip = zip::ZipArchive::new(std::io::Cursor::new(download_bytes))?;
    let mut file_input = Vec::new();
    zip.by_index(0)?.read_to_end(&mut file_input)?;
    byte_vec.append(&mut file_input);
    Ok(byte_vec)
}

fn write_fgb(byte_vec: Vec<u8>, file_name: &str) -> Result<()> {
    let mut fgb: FgbWriter = FgbWriter::create_with_options(
        "timezones",
        GeometryType::MultiPolygon,
        FgbWriterOptions {
            write_index: true,
            promote_to_multi: true,
            crs: FgbCrs {
                org: Some("EPSG"),
                code: 4326,
                name: None,
                description: None,
                wkt: None,
                code_string: None,
            },
            ..Default::default()
        },
    )?;

    let mut reader = GeoJsonReader(byte_vec.as_slice());
    reader.process(&mut fgb)?;

    let mut byte_vec: Vec<u8> = Vec::new();
    fgb.write(&mut byte_vec)?;
    /*let fgb_file = File::create(format!("../assets/{}", file_name))?;
    let mut fgb_writer = BufWriter::new(fgb_file);
    fgb_writer.write_all(&byte_vec.as_slice())?;*/
    let zstd_file = File::create(format!("../assets/{}.zst", file_name))?;
    zstd::stream::copy_encode(byte_vec.as_slice(), zstd_file, 22)?;

    Ok(())
}