Rjf/directed graph

configuration/bambam-omf/travel-mode-filter.json

@@ -7,7 +7,7 @@
         { 
           "type": "class", 
           "classes": ["secondary", "tertiary", "residential", "living_street", "unclassified", "service", "pedestrian", "footway", "steps", "path", "track", "bridleway", "unknown"], 
-          "ignore_unset": true,
+          "allow_unset": true,
           "behavior": "include"
         },
         { "type": "access_mode", "modes": ["foot"] }
@@ -20,7 +20,7 @@
         { 
           "type": "class", 
           "classes": ["primary", "secondary", "tertiary", "residential", "living_street", "unclassified", "service", "pedestrian", "path", "track", "cycleway", "bridleway", "unknown"], 
-          "ignore_unset": true,
+          "allow_unset": true,
           "behavior": "include"
         },
         { "type": "access_mode", "modes": ["bicycle"] }
@@ -33,7 +33,7 @@
         { 
           "type": "class", 
           "classes": ["motorway", "trunk", "primary", "secondary", "tertiary", "residential", "living_street", "unclassified", "service", "unknown"], 
-          "ignore_unset": true,
+          "allow_unset": true,
           "behavior": "include"
         },
         { "type": "access_mode", "modes": ["motor_vehicle", "car", "truck", "motorcycle"] }

rust/Cargo.toml

@@ -1,22 +1,24 @@
 [workspace]
 resolver = "2"
-members = ["bambam", "bambam-osm", "bambam-gtfs", "bambam-omf", "bambam-gbfs", "bambam-py"]
+members = [
+    "bambam",
+    "bambam-gbfs",
+    "bambam-gtfs",
+    "bambam-omf",
+    "bambam-osm",
+    "bambam-py",
+]
 
 [workspace.dependencies]
 
+# third party
+arrow = { version = "55.0.0" }
+bamcensus = { version = "0.1.0" }
+bamcensus-acs = { version = "0.1.0" }
+
 # nrel 
 bamcensus-core = { version = "0.1.0" }
-bamcensus-acs = { version = "0.1.0" }
-bamcensus = { version = "0.1.0" }
 bamcensus-lehd = { version = "0.1.0" }
-routee-compass = "0.15.2"
-routee-compass-core = "0.15.2"
-routee-compass-powertrain = "0.15.2"
-routee-compass-py = "0.15.2"
-routee-compass-macros = "0.15.2"
-
-# third party
-arrow = { version = "55.0.0" }
 chrono = { version = "0.4.41", features = ["serde"] }
 clap = { version = "4.3.19", features = ["derive"] }
 config = "0.15.11"
@@ -51,10 +53,16 @@ rand = "0.9.1"
 rayon = "1.10.0"
 regex = { version = "1.11.1" }
 reqwest = { version = "0.12.12", features = ["blocking"] }
+routee-compass = "0.15.2"
+routee-compass-core = "0.15.2"
+routee-compass-macros = "0.15.2"
+routee-compass-powertrain = "0.15.2"
+routee-compass-py = "0.15.2"
 rstar = { version = "0.12.0" }
 serde = { version = "1.0.160", features = ["derive"] }
-serde_json = { version = "1.0" }
 serde_arrow = { version = "0.13.7", features = ["arrow-55"] }
+serde_bytes = { version = "0.11.19" }
+serde_json = { version = "1.0" }
 serde_with = { version = "3.0", features = ["chrono_0_4"] }
 shapefile = { version = "0.7.0", features = ["geo-types"] }
 skiplist = "0.5.1"

rust/bambam-gbfs/Cargo.toml

@@ -6,15 +6,15 @@ license = "BSD-3-Clause"
 description = "GBFS Extensions for The Behavior and Advanced Mobility Big Access Model"
 
 [dependencies]
+chrono = { workspace = true }
+clap = { workspace = true }
 env_logger = { workspace = true }
+geo = { workspace = true }
+humantime = { workspace = true }
+kdam = { workspace = true }
+log = { workspace = true }
+reqwest = { workspace = true }
 routee-compass-core = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 serde_with = { workspace = true }
-chrono = { workspace = true }
-humantime = { workspace = true }
-log = { workspace = true }
-geo = { workspace = true }
-reqwest = { workspace = true }
-clap = { workspace = true }
-kdam = { workspace = true }

rust/bambam-omf/Cargo.toml

@@ -18,15 +18,12 @@ keywords = [
 categories = ["command-line-utilities", "science", "science::geo"]
 
 [dependencies]
-bamcensus-core = { workspace = true }
-bamcensus-acs = { workspace = true }
-bamcensus-lehd = { workspace = true }
-bamcensus = { workspace = true }
-routee-compass = { workspace = true }
-routee-compass-core = { workspace = true }
-routee-compass-powertrain = { workspace = true }
 
 arrow = { workspace = true }
+bamcensus = { workspace = true }
+bamcensus-acs = { workspace = true }
+bamcensus-core = { workspace = true }
+bamcensus-lehd = { workspace = true }
 chrono = { workspace = true }
 clap = { workspace = true }
 config = { workspace = true }
@@ -41,16 +38,20 @@ itertools = { workspace = true }
 kdam = { workspace = true }
 log = { workspace = true }
 object_store = { workspace = true }
-parquet = { workspace = true }
 opening-hours-syntax = { workspace = true }
 ordered-float = { workspace = true }
+parquet = { workspace = true }
 rayon = { workspace = true }
 reqwest = { workspace = true }
+routee-compass = { workspace = true }
+routee-compass-core = { workspace = true }
+routee-compass-powertrain = { workspace = true }
 serde = { workspace = true }
-serde_json = { workspace = true }
 serde_arrow = { workspace = true }
+serde_bytes = { workspace = true }
+serde_json = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true }
 uom = { workspace = true }
-wkt = { workspace = true }
 wkb = { workspace = true }
+wkt = { workspace = true }

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

@@ -6,7 +6,8 @@ use crate::{
     app::CliBoundingBox,
     collection::{
         filter::TravelModeFilter, ObjectStoreSource, OvertureMapsCollectionError,
-        OvertureMapsCollectorConfig, ReleaseVersion, TransportationCollection,
+        OvertureMapsCollectorConfig, ReleaseVersion, SegmentAccessRestrictionWhen,
+        TransportationCollection,
     },
     graph::OmfGraphVectorized,
     util,
@@ -18,6 +19,20 @@ pub struct NetworkEdgeListConfiguration {
     pub filter: Vec<TravelModeFilter>,
 }
 
+impl From<&NetworkEdgeListConfiguration> for SegmentAccessRestrictionWhen {
+    fn from(value: &NetworkEdgeListConfiguration) -> Self {
+        let user_modes_opt = value.filter.iter().find_map(|f| match f {
+            TravelModeFilter::MatchesModeAccess { modes } => Some(modes.clone()),
+            _ => None,
+        });
+        let mut result = SegmentAccessRestrictionWhen::default();
+        if let Some(modes) = user_modes_opt {
+            result.mode = Some(modes);
+        }
+        result
+    }
+}
+
 /// runs an OMF network import using the provided configuration.
 pub fn run(
     bbox: Option<&CliBoundingBox>,

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

@@ -48,6 +48,10 @@ pub enum OvertureMapsCollectionError {
     ReadError { path: PathBuf, message: String },
     #[error("Error writing to '{path}': {message}")]
     WriteError { path: PathBuf, message: String },
+    #[error("Invalid `between` vector: {0}")]
+    InvalidBetweenVector(String),
+    #[error("Required attribute is None: {0}")]
+    MissingAttribute(String),
     #[error("{0}")]
     InternalError(String),
 }

rust/bambam-omf/src/collection/filter/travel_mode_filter.rs

@@ -24,15 +24,15 @@ pub enum TravelModeFilter {
     MatchesClasses {
         classes: HashSet<SegmentClass>,
         behavior: MatchBehavior,
-        ignore_unset: bool,
+        allow_unset: bool,
     },
     /// filter a row based on a class with additional subclass(es). fails if not a match,
     /// and optionally, if 'class' or 'subclass' are unset.
     #[serde(rename = "class_with_subclasses")]
     MatchesClassesWithSubclasses {
         classes: HashMap<SegmentClass, Vec<SegmentSubclass>>,
         behavior: MatchBehavior,
-        ignore_unset: bool,
+        allow_unset: bool,
     },
 
     /// filter a row based on the [SegmentMode].
@@ -145,35 +145,39 @@ impl TravelModeFilter {
     /// returns false if there is no match.
     pub fn matches_filter(&self, segment: &TransportationSegmentRecord) -> bool {
         match self {
+            // subtype matching. default behavior is REJECT
             TravelModeFilter::MatchesSubtype { subtype } => segment
                 .subtype
                 .as_ref()
                 .map(|s| s == subtype)
                 .unwrap_or_default(),
 
+            // class matching. default behavior set by user (allow_unset).
             TravelModeFilter::MatchesClasses {
                 classes,
                 behavior,
-                ignore_unset,
+                allow_unset,
             } => segment
                 .class
                 .as_ref()
                 .map(|c| behavior.apply(classes.contains(c)))
-                .unwrap_or(*ignore_unset),
+                .unwrap_or(*allow_unset),
 
+            // subclass matching. default behavior set by user (allow_unset).
             TravelModeFilter::MatchesClassesWithSubclasses {
                 classes,
                 behavior,
-                ignore_unset,
+                allow_unset,
             } => match (segment.class.as_ref(), segment.subclass.as_ref()) {
                 (Some(cl), None) => behavior.apply(classes.contains_key(cl)),
                 (Some(cl), Some(sc)) => match classes.get(cl) {
-                    None => *ignore_unset,
+                    None => *allow_unset,
                     Some(subclasses) => behavior.apply(subclasses.contains(sc)),
                 },
-                _ => *ignore_unset,
+                _ => *allow_unset,
             },
 
+            // mode matching. default behavior is ALLOW
             TravelModeFilter::MatchesModeAccess { modes } => {
                 let restrictions = segment
                     .access_restrictions

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

@@ -2,12 +2,12 @@ mod collector;
 mod collector_config;
 mod error;
 mod object_source;
-mod record;
 mod taxonomy;
 mod version;
 
 pub mod constants;
 pub mod filter;
+pub mod record;
 
 pub use collector::OvertureMapsCollector;
 pub use collector_config::OvertureMapsCollectorConfig;
@@ -17,7 +17,9 @@ pub use filter::RowFilter;
 pub use filter::RowFilterConfig;
 pub use object_source::ObjectStoreSource;
 pub use record::{
-    BuildingsRecord, OvertureRecord, OvertureRecordType, PlacesRecord, TransportationCollection,
+    BuildingsRecord, OvertureRecord, OvertureRecordType, PlacesRecord,
+    SegmentAccessRestrictionWhen, SegmentClass, SegmentFullType, SegmentSpeedLimit,
+    SegmentSpeedUnit, SegmentSubclass, SegmentSubtype, TransportationCollection,
     TransportationConnectorRecord, TransportationSegmentRecord,
 };
 pub use taxonomy::{TaxonomyModel, TaxonomyModelBuilder};

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

@@ -1,15 +1,15 @@
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Debug, Serialize, Deserialize, Clone, Default)]
 pub struct OvertureMapsBbox {
     xmin: Option<f32>,
     xmax: Option<f32>,
     ymin: Option<f32>,
     ymax: Option<f32>,
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Debug, Serialize, Deserialize, Clone, Default)]
 pub struct OvertureMapsSource {
     property: Option<String>,
     dataset: Option<String>,
@@ -18,14 +18,14 @@ pub struct OvertureMapsSource {
     confidence: Option<f64>,
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Debug, Serialize, Deserialize, Clone, Default)]
 pub struct OvertureMapsNames {
     primary: Option<String>,
     common: Option<HashMap<String, Option<String>>>,
     rules: Option<Vec<OvertureMapsNamesRule>>,
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Debug, Serialize, Deserialize, Clone, Default)]
 struct OvertureMapsNamesRule {
     variant: Option<String>,
     language: Option<String>,

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

@@ -1,13 +1,16 @@
 use geo::{Geometry, MapCoords, TryConvert};
 use geozero::{error::GeozeroError, wkb::Wkb, ToGeo};
 use serde::{Deserialize, Deserializer};
+use serde_bytes;
 
-// Deserialize into an enum that can handle both Vec<u8> and String
+/// Deserialize into an enum that can handle both String and Vec<u8>, in
+/// that order.
 #[derive(Deserialize)]
 #[serde(untagged)]
 enum BytesOrString {
-    Bytes(Vec<u8>),
     String(String),
+    #[serde(with = "serde_bytes")]
+    Bytes(Vec<u8>),
 }
 
 impl std::fmt::Display for BytesOrString {

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

@@ -14,12 +14,14 @@ pub use record_type::OvertureRecordType;
 pub use transportation_collection::TransportationCollection;
 pub use transportation_connector::TransportationConnectorRecord;
 pub use transportation_segment::{
-    SegmentAccessRestriction, SegmentAccessType, SegmentClass, SegmentHeading, SegmentMode,
-    SegmentSubclass, SegmentSubtype, TransportationSegmentRecord,
+    SegmentAccessRestriction, SegmentAccessRestrictionWhen, SegmentAccessType, SegmentClass,
+    SegmentDestination, SegmentFullType, SegmentHeading, SegmentMode, SegmentRecognized,
+    SegmentSpeedLimit, SegmentSpeedUnit, SegmentSubclass, SegmentSubtype, SegmentUsing,
+    TransportationSegmentRecord,
 };
 
 // Common structs and functions for many record types
-use common::OvertureMapsBbox;
-use common::OvertureMapsNames;
-use common::OvertureMapsSource;
+pub use common::OvertureMapsBbox;
+pub use common::OvertureMapsNames;
+pub use common::OvertureMapsSource;
 pub mod geometry_wkb_codec;