Start calculating Movements and Conflicts

osm2streets-js/src/lib.rs

@@ -96,6 +96,11 @@ impl JsStreetNetwork {
     pub fn debug_clockwise_ordering_geojson(&self) -> String {
         self.inner.debug_clockwise_ordering_geojson().unwrap()
     }
+
+    #[wasm_bindgen(js_name = debugMovementsGeojson)]
+    pub fn debug_movements_geojson(&self) -> String {
+        self.inner.debug_movements_geojson().unwrap()
+    }
 }
 
 #[wasm_bindgen]

osm2streets/src/lib.rs

@@ -20,7 +20,8 @@ pub use self::lanes::{
 };
 pub use self::transform::Transformation;
 pub use self::types::{
-    ControlType, DrivingSide, IntersectionComplexity, MapConfig, NamePerLanguage,
+    ConflictType, ControlType, DrivingSide, IntersectionComplexity, MapConfig, Movement,
+    NamePerLanguage,
 };
 
 mod edit;
@@ -86,21 +87,21 @@ impl StreetNetwork {
         for i in [id.i1, id.i2] {
             self.intersections.get_mut(&i).unwrap().roads.push(id);
             self.sort_roads(i);
+            // Recalculate movements and complexity.
+            self.recalculate_movements(i);
         }
     }
 
     pub fn remove_road(&mut self, id: &OriginalRoad) -> Road {
-        // Since the roads are already sorted, removing doesn't hurt anything
-        self.intersections
-            .get_mut(&id.i1)
-            .unwrap()
-            .roads
-            .retain(|r| r != id);
-        self.intersections
-            .get_mut(&id.i2)
-            .unwrap()
-            .roads
-            .retain(|r| r != id);
+        for i in [id.i1, id.i2] {
+            self.intersections
+                .get_mut(&i)
+                .unwrap()
+                .roads
+                .retain(|r| r != id);
+            // Since the roads are already sorted, removing doesn't break the sort.
+            self.recalculate_movements(i);
+        }
         self.roads.remove(id).unwrap()
     }
 
@@ -260,6 +261,20 @@ impl StreetNetwork {
 
         intersection.roads = road_centers.into_iter().map(|(r, _, _)| r).collect();
     }
+
+    /// Recalculate movements, complexity, and conflict_level of an intersection.
+    fn recalculate_movements(&mut self, i: osm::NodeID) {
+        let (complexity, conflict_level, movements) =
+            crate::transform::classify_intersections::guess_complexity(self, &i);
+        let int = self.intersections.get_mut(&i).unwrap();
+        int.movements = movements;
+        int.conflict_level = conflict_level;
+        // The fact that an intersection represents a road leaving the map bounds is stored in the
+        // complexity field but guess_complexity ignores that. Make sure we don't overwrite it.
+        if int.complexity != IntersectionComplexity::MapEdge {
+            int.complexity = complexity;
+        }
+    }
 }
 
 // Mutations and supporting queries
@@ -548,12 +563,14 @@ pub struct Intersection {
     /// This will be a placeholder until `Transformation::GenerateIntersectionGeometry` runs.
     pub polygon: Polygon,
     pub complexity: IntersectionComplexity,
+    pub conflict_level: ConflictType,
     pub control: ControlType,
     pub elevation: Distance,
 
     /// All roads connected to this intersection. They may be incoming or outgoing relative to this
     /// intersection. They're ordered clockwise aroundd the intersection.
     pub roads: Vec<OriginalRoad>,
+    pub movements: Vec<Movement>,
 
     // true if src_i matches this intersection (or the deleted/consolidated one, whatever)
     pub trim_roads_for_merging: BTreeMap<(osm::WayID, bool), Pt2D>,
@@ -564,16 +581,19 @@ impl Intersection {
         id: osm::NodeID,
         point: Pt2D,
         complexity: IntersectionComplexity,
+        conflict_level: ConflictType,
         control: ControlType,
     ) -> Self {
         Self {
             id,
             point,
             polygon: Polygon::dummy(),
             complexity,
+            conflict_level,
             control,
             // Filled out later
             roads: Vec::new(),
+            movements: Vec::new(),
             elevation: Distance::ZERO,
             trim_roads_for_merging: BTreeMap::new(),
         }

osm2streets/src/render.rs

@@ -1,11 +1,14 @@
+use std::collections::BTreeMap;
 use std::fs::File;
 use std::io::Write;
 use std::path::Path;
 
 use anyhow::Result;
 use geom::{ArrowCap, Distance, Line, PolyLine};
 
-use crate::{DebugStreets, Direction, LaneType, StreetNetwork};
+use crate::{
+    DebugStreets, Direction, DrivingSide, IntersectionComplexity, LaneType, StreetNetwork,
+};
 
 impl StreetNetwork {
     /// Saves the plain GeoJSON rendering to a file.
@@ -45,7 +48,15 @@ impl StreetNetwork {
                     ("osm_node_id", id.0.into()),
                     (
                         "complexity",
-                        format!("{:?}", intersection.complexity).into(),
+                        if intersection.complexity == IntersectionComplexity::MultiConnection {
+                            format!(
+                                "{:?} {:?}",
+                                intersection.complexity, intersection.conflict_level
+                            )
+                        } else {
+                            format!("{:?}", intersection.complexity)
+                        }
+                        .into(),
                     ),
                     ("control", format!("{:?}", intersection.control).into()),
                     ("osm_link", id.to_string().into()),
@@ -240,6 +251,68 @@ impl StreetNetwork {
         let output = serde_json::to_string_pretty(&obj)?;
         Ok(output)
     }
+
+    /// For an intersection, show all the movements.
+    pub fn debug_movements_geojson(&self) -> Result<String> {
+        // Each movement is represented as an arrow from the end of one road to the beginning of
+        // another. To stop arrows overlapping, arrows to/from bidirectional roads are offset from
+        // the center to the appropriate driving side.
+        let arrow_fwd_offset_dist = if self.config.driving_side == DrivingSide::Right {
+            Distance::meters(-1.3)
+        } else {
+            Distance::meters(1.3)
+        };
+
+        let mut pairs = Vec::new();
+
+        for (i, intersection) in &self.intersections {
+            // Find the points where the arrows should (leave, enter) the roads.
+            let road_points: BTreeMap<_, _> = intersection
+                .roads
+                .iter()
+                .map(|r| {
+                    let road = &self.roads[r];
+                    let first_road_segment = if road.id.i1 == *i {
+                        road.trimmed_center_line.first_line()
+                    } else {
+                        road.trimmed_center_line.last_line().reversed()
+                    };
+                    // Offset the arrow start/end points if it is bidirectional.
+                    (
+                        r,
+                        if road.oneway_for_driving().is_some() {
+                            (first_road_segment.pt1(), first_road_segment.pt1())
+                        } else {
+                            (
+                                first_road_segment
+                                    .shift_either_direction(arrow_fwd_offset_dist)
+                                    .pt1(),
+                                first_road_segment
+                                    .shift_either_direction(-arrow_fwd_offset_dist)
+                                    .pt1(),
+                            )
+                        },
+                    )
+                })
+                .collect();
+            for (a, b) in &intersection.movements {
+                if a != b {
+                    if let Ok(line) = Line::new(road_points[a].0, road_points[b].1) {
+                        pairs.push((
+                            line.to_polyline()
+                                .make_arrow(Distance::meters(0.5), ArrowCap::Triangle)
+                                .to_geojson(Some(&self.gps_bounds)),
+                            make_props(&[]),
+                        ))
+                    }
+                }
+            }
+        }
+
+        let obj = geom::geometries_with_properties_to_geojson(pairs);
+        let output = serde_json::to_string_pretty(&obj)?;
+        Ok(output)
+    }
 }
 
 impl DebugStreets {