editoast: use geojson crate instead of our manual implementation

Author: leovalais

editoast/Cargo.lock

@@ -9,7 +9,6 @@ edition = "2021"
 chrono.workspace = true
 geos.workspace = true
 iso8601 = "0.6.1"
-mvt.workspace = true
 postgis_diesel.workspace = true
 rand.workspace = true
 rangemap.workspace = true

editoast/editoast_common/Cargo.toml

@@ -1,5 +1,4 @@
 pub mod duration;
-pub mod geo_json;
 pub mod geometry;
 mod hash_rounded_float;
 mod identifier;

editoast/editoast_common/src/geo_json.rs

@@ -14,8 +14,10 @@ use diesel::sql_types::Nullable;
 use diesel::sql_types::Text;
 use diesel::QueryableByName;
 use diesel_async::RunQueryDsl;
-use diesel_json::Json as DieselJson;
 use editoast_derive::EditoastError;
+use postgis_diesel::sql_types::Geometry;
+use postgis_diesel::types::GeometryContainer;
+use postgis_diesel::types::Point;
 use serde::Deserialize;
 use serde::Serialize;
 use serde_json::Value as JsonValue;
@@ -25,7 +27,6 @@ use crate::error::Result;
 use crate::modelsv2::get_geometry_layer_table;
 use crate::modelsv2::get_table;
 use crate::DbPool;
-use editoast_common::geo_json::GeoJson;
 use editoast_schemas::primitives::ObjectType;
 
 /// Return `/infra/<infra_id>/objects` routes
@@ -53,10 +54,10 @@ struct ObjectQueryable {
     obj_id: String,
     #[diesel(sql_type = Jsonb)]
     railjson: JsonValue,
-    #[diesel(sql_type = Nullable<Jsonb>)]
-    geographic: Option<DieselJson<GeoJson>>,
-    #[diesel(sql_type = Nullable<Jsonb>)]
-    schematic: Option<DieselJson<GeoJson>>,
+    #[diesel(sql_type = Nullable<Geometry>)]
+    geographic: Option<GeometryContainer<Point>>,
+    #[diesel(sql_type = Nullable<Geometry>)]
+    schematic: Option<GeometryContainer<Point>>,
 }
 
 /// Return the railjson list of a specific OSRD object
@@ -75,16 +76,16 @@ async fn get_objects(
     let query = if [ObjectType::SwitchType, ObjectType::Route].contains(&obj_type) {
         format!(
             "SELECT obj_id as obj_id, data as railjson, NULL as geographic, NULL as schematic
-                FROM {} WHERE infra_id = $1 AND obj_id = ANY($2) ",
+                FROM {} WHERE infra_id = $1 AND obj_id = ANY($2)",
             get_table(&obj_type)
         )
     } else {
         format!("
             SELECT
                 object_table.obj_id as obj_id,
                 object_table.data as railjson,
-                ST_AsGeoJSON(ST_Transform(geographic, 4326))::jsonb as geographic,
-                ST_AsGeoJSON(ST_Transform(schematic, 4326))::jsonb as schematic
+                ST_Transform(geographic, 4326) as geographic,
+                ST_Transform(schematic, 4326) as schematic
             FROM {} AS object_table
             LEFT JOIN {} AS geometry_table ON object_table.obj_id = geometry_table.obj_id AND object_table.infra_id = geometry_table.infra_id
             WHERE object_table.infra_id = $1 AND object_table.obj_id = ANY($2)

editoast/editoast_common/src/lib.rs

@@ -1,15 +1,17 @@
 use diesel::sql_types::Jsonb;
 use diesel::sql_types::Text;
+use geos::geojson::Geometry;
+use geos::geojson::Value as GeoJsonValue;
 use mvt::Feature;
 use mvt::GeomData;
 use mvt::GeomEncoder;
+use mvt::GeomType;
 use mvt::Tile as MvtTile;
 use serde::Deserialize;
 use serde::Serialize;
 use serde_json::Value as JsonValue;
 
 use crate::map::View;
-use editoast_common::geo_json::GeoJson;
 
 #[derive(Clone, QueryableByName, Queryable, Debug, Serialize, Deserialize)]
 pub struct GeoJsonAndData {
@@ -19,33 +21,45 @@ pub struct GeoJsonAndData {
     pub data: JsonValue,
 }
 
+fn geometry_into_mvt_geom_type(geometry: &Geometry) -> GeomType {
+    match geometry.value {
+        GeoJsonValue::Point { .. } => GeomType::Point,
+        GeoJsonValue::MultiPoint { .. } => GeomType::Point,
+        GeoJsonValue::LineString { .. } => GeomType::Linestring,
+        GeoJsonValue::MultiLineString { .. } => GeomType::Linestring,
+        _ => panic!("geometry type unsupported by editoast tiling system"),
+    }
+}
+
 impl GeoJsonAndData {
     /// Converts GeoJsonAndData as mvt GeomData
     pub fn as_geom_data(&self) -> GeomData {
-        let geo_json = serde_json::from_str::<GeoJson>(&self.geo_json).unwrap();
-        let mut encoder = GeomEncoder::new(geo_json.get_geom_type());
-        match geo_json {
-            GeoJson::Point { coordinates } => {
-                encoder.add_point(coordinates.0, coordinates.1).unwrap();
+        let geo_json = serde_json::from_str::<Geometry>(&self.geo_json).unwrap();
+        let geom_type = geometry_into_mvt_geom_type(&geo_json);
+        let mut encoder = GeomEncoder::new(geom_type);
+        match geo_json.value {
+            GeoJsonValue::Point(point) => {
+                encoder.add_point(point[0], point[1]).unwrap();
             }
-            GeoJson::MultiPoint { coordinates } => {
-                for (x, y) in coordinates {
-                    encoder.add_point(x, y).unwrap();
+            GeoJsonValue::MultiPoint(points) => {
+                for point in points {
+                    encoder.add_point(point[0], point[1]).unwrap();
                 }
             }
-            GeoJson::LineString { coordinates } => {
-                for (x, y) in coordinates {
-                    encoder.add_point(x, y).unwrap();
+            GeoJsonValue::LineString(linestring) => {
+                for point in linestring {
+                    encoder.add_point(point[0], point[1]).unwrap();
                 }
             }
-            GeoJson::MultiLineString { coordinates } => {
-                for line in coordinates {
-                    for (x, y) in line.iter() {
-                        encoder.add_point(*x, *y).unwrap();
+            GeoJsonValue::MultiLineString(linestrings) => {
+                for linestring in linestrings {
+                    for point in linestring.iter() {
+                        encoder.add_point(point[0], point[1]).unwrap();
                     }
                     encoder.complete_geom().unwrap();
                 }
             }
+            _ => panic!("geometry type unsupported by editoast tiling system"),
         };
         encoder.complete().unwrap().encode().unwrap()
     }