Merge pull request #71 from NREL/rjf/omf-edges

Rjf/omf edges

Author: robfitzgerald

rust/Cargo.toml

@@ -42,6 +42,7 @@ kdam = "0.6.2"
 log = "0.4.19"
 num-traits = "0.2.19"
 object_store = { "version" = "0.12.0", features = ["aws"] }
+ordered-float = { version = "5.1.0", features = ["serde"] }
 osmio = "0.14.0"
 osmpbf = "0.3.4"
 parquet = { version = "55.0.0", features = ["snap", "async", "object_store"] }

rust/bambam-omf/Cargo.toml

@@ -41,6 +41,7 @@ kdam = { workspace = true }
 log = { workspace = true }
 object_store = { workspace = true }
 parquet = { workspace = true }
+ordered-float = { workspace = true }
 rayon = { workspace = true }
 reqwest = { workspace = true }
 serde = { workspace = true }

rust/bambam-omf/src/app/omf_app.rs

@@ -1,6 +1,7 @@
 use std::path::Path;
 
 use clap::{Parser, Subcommand};
+use routee_compass_core::model::network::EdgeListId;
 use serde::{Deserialize, Serialize};
 
 use crate::{
@@ -23,13 +24,18 @@ pub struct OmfApp {
 #[derive(Debug, Clone, Serialize, Deserialize, Subcommand)]
 pub enum OmfOperation {
     /// download all of the OMF transportation data
-    Download,
+    Download {
+        /// location on disk to write output files. if not provided,
+        /// use the current working directory.
+        #[arg(short, long)]
+        output_directory: Option<String>,
+    },
 }
 
 impl OmfOperation {
-    pub fn run(self) -> Result<(), OvertureMapsCollectionError> {
+    pub fn run(&self) -> Result<(), OvertureMapsCollectionError> {
         match self {
-            OmfOperation::Download => {
+            OmfOperation::Download { output_directory } => {
                 let collector =
                     OvertureMapsCollectorConfig::new(ObjectStoreSource::AmazonS3, 128).build()?;
                 let release = ReleaseVersion::Latest;
@@ -45,8 +51,12 @@ impl OmfOperation {
                     release,
                     Some(row_filter_config),
                 )?;
-                let vectorized_graph = OmfGraphVectorized::try_from_collection(collection, 0)?;
-                vectorized_graph.write_compass(Path::new("./"), true)?;
+                let vectorized_graph = OmfGraphVectorized::new(collection, EdgeListId(0))?;
+                let output_path = match output_directory {
+                    Some(o) => Path::new(o),
+                    None => Path::new(""),
+                };
+                vectorized_graph.write_compass(output_path, true)?;
 
                 Ok(())
             }

rust/bambam-omf/src/collection/error.rs

@@ -34,8 +34,12 @@ pub enum OvertureMapsCollectionError {
     SerializationError(String),
     #[error("Segment connectors vector is invalid or not specified: {0}")]
     InvalidSegmentConnectors(String),
+    #[error("linear reference {0} must be in range [0, 1]")]
+    InvalidLinearReference(f64),
     #[error("Invalid or empty geometry: {0}")]
     InvalidGeometry(String),
     #[error("Error writing to csv: {0}")]
     CsvWriteError(String),
+    #[error("{0}")]
+    InternalError(String),
 }

rust/bambam-omf/src/collection/record/building.rs

@@ -9,7 +9,7 @@ use crate::collection::OvertureMapsCollectionError;
 pub struct BuildingsRecord {
     id: Option<String>,
     #[serde(deserialize_with = "deserialize_geometry")]
-    geometry: Option<Geometry>,
+    geometry: Option<Geometry<f32>>,
     bbox: OvertureMapsBbox,
     version: i32,
     sources: Option<Vec<Option<OvertureMapsSource>>>,
@@ -38,7 +38,7 @@ impl BuildingsRecord {
         self.class.clone()
     }
 
-    pub fn get_geometry(&self) -> Option<Geometry> {
+    pub fn get_geometry(&self) -> Option<Geometry<f32>> {
         self.geometry.clone()
     }
 }

rust/bambam-omf/src/collection/record/common.rs

@@ -1,19 +1,31 @@
 use geo::Geometry;
+use geo::MapCoords;
+use geozero::error::GeozeroError;
 use geozero::{wkb::Wkb, ToGeo};
 use serde::de::Deserializer;
 use serde::de::Error;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
-pub fn deserialize_geometry<'de, D>(deserializer: D) -> Result<Option<Geometry>, D::Error>
+pub fn deserialize_geometry<'de, D>(deserializer: D) -> Result<Option<Geometry<f32>>, D::Error>
 where
     D: Deserializer<'de>,
 {
-    // Assumption that this data is binary and not string
+    // Assumption that this data is binary and not string.
+    // convert here at the boundary of the program into f32 values.
     Option::<Vec<u8>>::deserialize(deserializer)?
-        .map(|v| Wkb(v).to_geo())
+        .map(|v| {
+            let g = Wkb(v).to_geo()?;
+
+            g.try_map_coords(|geo::Coord { x, y }| {
+                Ok(geo::Coord {
+                    x: x as f32,
+                    y: y as f32,
+                })
+            })
+        })
         .transpose()
-        .map_err(|e| D::Error::custom(format!("Could not decode wkb: {e}")))
+        .map_err(|e: GeozeroError| D::Error::custom(format!("Could not decode wkb: {e}")))
 }
 
 #[derive(Debug, Serialize, Deserialize)]

rust/bambam-omf/src/collection/record/place.rs

@@ -11,7 +11,7 @@ use crate::collection::OvertureMapsCollectionError;
 #[derive(Debug, Serialize, Deserialize)]
 pub struct PlacesRecord {
     #[serde(deserialize_with = "deserialize_geometry")]
-    geometry: Option<Geometry>,
+    geometry: Option<Geometry<f32>>,
     categories: Option<OvertureMapsPlacesCategories>,
     id: Option<String>,
     bbox: OvertureMapsBbox,
@@ -63,7 +63,7 @@ impl PlacesRecord {
         }
     }
 
-    pub fn get_geometry(&self) -> Option<Geometry> {
+    pub fn get_geometry(&self) -> Option<Geometry<f32>> {
         self.geometry.clone()
     }
 }

rust/bambam-omf/src/collection/record/transportation_connector.rs

@@ -13,7 +13,7 @@ use serde::{Deserialize, Serialize};
 pub struct TransportationConnectorRecord {
     pub id: String,
     #[serde(deserialize_with = "deserialize_geometry")]
-    geometry: Option<Geometry>,
+    geometry: Option<Geometry<f32>>,
     bbox: OvertureMapsBbox,
     version: i32,
     sources: Option<Vec<Option<OvertureMapsSource>>>,
@@ -33,7 +33,7 @@ impl TryFrom<OvertureRecord> for TransportationConnectorRecord {
 }
 
 impl TransportationConnectorRecord {
-    pub fn get_geometry(&self) -> Option<&Geometry> {
+    pub fn get_geometry(&self) -> Option<&Geometry<f32>> {
         self.geometry.as_ref()
     }
 
@@ -52,6 +52,6 @@ impl TransportationConnectorRecord {
             ))),
         }?;
 
-        Ok(Vertex::new(idx, x as f32, y as f32))
+        Ok(Vertex::new(idx, x, y))
     }
 }

rust/bambam-omf/src/collection/record/transportation_segment.rs

@@ -1,4 +1,4 @@
-use geo::{Geometry, Haversine, Length};
+use geo::{Coord, Geometry, Haversine, InterpolatableLine, Length, LineString};
 use serde::{Deserialize, Serialize};
 
 use crate::collection::{OvertureMapsCollectionError, OvertureRecord};
@@ -12,9 +12,10 @@ use super::{OvertureMapsBbox, OvertureMapsNames, OvertureMapsSource};
 /// and other attributes relevant to routing and mapping.
 #[derive(Debug, Serialize, Deserialize)]
 pub struct TransportationSegmentRecord {
+    /// GERS identifier for this segment record
     pub id: String,
     #[serde(deserialize_with = "deserialize_geometry")]
-    pub geometry: Option<Geometry>,
+    pub geometry: Option<Geometry<f32>>,
     bbox: OvertureMapsBbox,
     version: i32,
     sources: Option<Vec<Option<OvertureMapsSource>>>,
@@ -50,21 +51,43 @@ impl TryFrom<OvertureRecord> for TransportationSegmentRecord {
 }
 
 impl TransportationSegmentRecord {
-    pub fn get_distance_at(&self, at: f64) -> Result<f64, OvertureMapsCollectionError> {
-        let geometry =
-            self.geometry
-                .as_ref()
-                .ok_or(OvertureMapsCollectionError::InvalidGeometry(
-                    "empty geometry".to_string(),
-                ))?;
-
+    pub fn get_linestring(&self) -> Result<&LineString<f32>, OvertureMapsCollectionError> {
+        let geometry = self.geometry.as_ref().ok_or_else(|| {
+            OvertureMapsCollectionError::InvalidGeometry("empty geometry".to_string())
+        })?;
         match geometry {
-            Geometry::LineString(line_string) => Ok(Haversine.length(line_string) * at),
+            Geometry::LineString(line_string) => Ok(line_string),
             _ => Err(OvertureMapsCollectionError::InvalidGeometry(format!(
                 "geometry was not a linestring {geometry:?}"
             ))),
         }
     }
+
+    pub fn get_distance_at(&self, at: f64) -> Result<f32, OvertureMapsCollectionError> {
+        if !(0.0..=1.0).contains(&at) {
+            return Err(OvertureMapsCollectionError::InvalidLinearReference(at));
+        }
+        let linestring = self.get_linestring()?;
+        Ok(Haversine.length(linestring) * at as f32)
+    }
+
+    /// gets a coordinate from this linestring at some linear reference.
+    pub fn get_coord_at(&self, at: f64) -> Result<Coord<f32>, OvertureMapsCollectionError> {
+        if !(0.0..=1.0).contains(&at) {
+            return Err(OvertureMapsCollectionError::InvalidLinearReference(at));
+        }
+        let linestring = self.get_linestring()?;
+        match linestring.point_at_ratio_from_start(&Haversine, at as f32) {
+            Some(pt) => Ok(pt.0),
+            None => {
+                let msg = format!(
+                    "unexpected error getting point for segment {} at {at}",
+                    self.id
+                );
+                Err(OvertureMapsCollectionError::InternalError(msg))
+            }
+        }
+    }
 }
 
 #[derive(Debug, Serialize, Deserialize)]

rust/bambam-omf/src/graph/connector_in_segment.rs

@@ -0,0 +1,35 @@
+use ordered_float::OrderedFloat;
+use serde::{Deserialize, Serialize};
+
+/// represents a connector found within a segment
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ConnectorInSegment {
+    pub segment_id: String,
+    pub connector_id: String,
+    pub linear_reference: OrderedFloat<f64>,
+}
+
+impl ConnectorInSegment {
+    /// records an existing connector record as a connector within a segment.
+    pub fn new(segment_id: String, connector_id: String, linear_reference: f64) -> Self {
+        Self {
+            segment_id,
+            connector_id,
+            linear_reference: OrderedFloat(linear_reference),
+        }
+    }
+
+    /// creates a new connector within a segment by concatenating its segment id and reference.
+    ///
+    /// this follows the pattern described by OvertureMaps when assigning unique
+    /// identifiers to sub-segments by their segment id along with linear reference ranges.
+    /// see <https://docs.overturemaps.org/guides/transportation/#transportation-splitter>
+    pub fn new_without_connector_id(segment_id: String, linear_reference: f64) -> Self {
+        let connector_id = format!("{}@{}", segment_id, linear_reference);
+        Self {
+            segment_id,
+            connector_id,
+            linear_reference: OrderedFloat(linear_reference),
+        }
+    }
+}