fill in vector_layer field in TileJSON, use geojson_to_tile for tiling

GeoJSON

Author: styrowolf

martin/src/geojson/mod.rs

@@ -1,15 +1,14 @@
+use std::collections::BTreeMap;
 use std::fmt::{Debug, Formatter};
 use std::path::PathBuf;
 use std::sync::Arc;
 
 use async_trait::async_trait;
-use geojson_vt_rs::{GeoJSONVT, Options};
 use geozero::mvt::Message as _;
 use martin_tile_utils::{Format, TileCoord, TileInfo};
 use std::fs::File;
 use tilejson::TileJSON;
 use tilejson::tilejson;
-use tokio::sync::RwLock;
 
 use crate::file_config::FileError;
 use crate::file_config::FileResult;
@@ -22,10 +21,11 @@ mod mvt;
 
 pub use config::GeoJsonConfig;
 
+#[derive(Clone)]
 pub struct GeoJsonSource {
     id: String,
     path: PathBuf,
-    inner: Arc<RwLock<GeoJSONVT>>,
+    geojson: Arc<geojson::GeoJson>,
     tilejson: TileJSON,
     tile_info: TileInfo,
 }
@@ -49,19 +49,18 @@ impl GeoJsonSource {
         let geojson = geojson::GeoJson::from_reader(geojson_file)
             .map_err(|e| FileError::InvalidFilePath(path.clone()))?;
 
-        // TODO: see if options default is goood enough
-        let inner = GeoJSONVT::from_geojson(&geojson, &Options::default());
-
+        // TODO: vector layers
         let tilejson = tilejson! {
             tiles: vec![],
+            vector_layers: geojson_to_vector_layer(&id, &geojson),
             minzoom: 0,
             maxzoom: 18,
         };
 
         return Ok(Self {
             id,
             path,
-            inner: Arc::new(RwLock::new(inner)),
+            geojson: Arc::new(geojson),
             tilejson,
             tile_info,
         });
@@ -83,8 +82,7 @@ impl Source for GeoJsonSource {
     }
 
     fn clone_source(&self) -> TileInfoSource {
-        // TODO: implement clone for GeoJsonSource (GeoJSONVT is not cloneable, which is a blocker)
-        Box::new(Self::new(self.id.clone(), self.path.clone()).unwrap())
+        Box::new(self.clone())
     }
 
     fn benefits_from_concurrent_scraping(&self) -> bool {
@@ -97,11 +95,17 @@ impl Source for GeoJsonSource {
         xyz: TileCoord,
         _url_query: Option<&UrlQuery>,
     ) -> MartinResult<TileData> {
-        let tile;
-        {
-            let mut guard = self.inner.write().await;
-            tile = guard.get_tile(xyz.z, xyz.x, xyz.y).clone();
-        }
+        // TODO: get from source (self)
+        let options = geojson_vt_rs::TileOptions::default();
+        let tile = geojson_vt_rs::geojson_to_tile(
+            &self.geojson,
+            xyz.z,
+            xyz.x,
+            xyz.y,
+            &options,
+            true,
+            true,
+        );
         let mut builder = LayerBuilder::new(self.id.clone(), 4096);
         for feature in &tile.features.features {
             builder.add_feature(feature);
@@ -112,3 +116,70 @@ impl Source for GeoJsonSource {
         Ok(mvt_tile.encode_to_vec())
     }
 }
+
+// TODO: maybe break down fields subroutine into a function
+fn geojson_to_vector_layer(
+    layer_name: &str,
+    geojson: &geojson::GeoJson,
+) -> Vec<tilejson::VectorLayer> {
+    let mut fields = BTreeMap::new();
+    match geojson {
+        geojson::GeoJson::Geometry(_geometry) => {
+            vec![tilejson::VectorLayer::new(layer_name.to_string(), fields)]
+        }
+        geojson::GeoJson::Feature(feature) => {
+            if let Some(properties) = feature.properties.as_ref() {
+                properties.iter().for_each(|(key, value)| {
+                    // should be in sync with mvt::tilevalue_from_json
+                    let val_type = match value {
+                        serde_json::Value::String(_) => "string",
+                        serde_json::Value::Number(n) => {
+                            if n.is_f64() {
+                                "double"
+                            } else if n.is_i64() {
+                                "signed integer"
+                            } else if n.is_u64() {
+                                "unsigned integer"
+                            } else {
+                                // TODO: check
+                                unreachable!()
+                            }
+                        }
+                        serde_json::Value::Bool(_) => "boolean",
+                        _ => "string",
+                    };
+                    fields.insert(key.to_string(), val_type.to_string());
+                });
+            }
+            vec![tilejson::VectorLayer::new(layer_name.to_string(), fields)]
+        }
+        geojson::GeoJson::FeatureCollection(feature_collection) => {
+            for feature in &feature_collection.features {
+                if let Some(properties) = feature.properties.as_ref() {
+                    properties.iter().for_each(|(key, value)| {
+                        // should be in sync with mvt::tilevalue_from_json
+                        let val_type = match value {
+                            serde_json::Value::String(_) => "string",
+                            serde_json::Value::Number(n) => {
+                                if n.is_f64() {
+                                    "double"
+                                } else if n.is_i64() {
+                                    "signed integer"
+                                } else if n.is_u64() {
+                                    "unsigned integer"
+                                } else {
+                                    // TODO: check
+                                    unreachable!()
+                                }
+                            }
+                            serde_json::Value::Bool(_) => "boolean",
+                            _ => "string",
+                        };
+                        fields.insert(key.to_string(), val_type.to_string());
+                    });
+                }
+            }
+            vec![tilejson::VectorLayer::new(layer_name.to_string(), fields)]
+        }
+    }
+}