Start handling highway=crossing nodes

osm2streets/src/intersection.rs

@@ -29,6 +29,8 @@ pub struct Intersection {
     pub roads: Vec<RoadID>,
     pub movements: Vec<Movement>,
 
+    pub crossing: Option<Crossing>,
+
     // true if src_i matches this intersection (or the deleted/consolidated one, whatever)
     // TODO Store start/end trim distance on _every_ road
     #[serde(
@@ -88,6 +90,25 @@ pub enum IntersectionControl {
     Construction,
 }
 
+/// When an Intersection is a pedestrian (and/or bike) crossing, represents details.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Crossing {
+    pub kind: CrossingKind,
+    /// Is there a pedestrian/traffic island/refuge?
+    pub has_island: bool,
+}
+
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
+pub enum CrossingKind {
+    /// Controlled by a traffic signal
+    Signalized,
+    /// Often a zebra crossing. The semantics of which road user has priority is region-specific.
+    Marked,
+    /// No paint markings, but maybe still a de facto crossing due to a nearby curb cut or an
+    /// island on this crossing.
+    Unmarked,
+}
+
 /// The path that some group of adjacent lanes of traffic can take through an intersection.
 pub type Movement = (RoadID, RoadID);
 
@@ -140,6 +161,7 @@ impl StreetNetwork {
                 // Filled out later
                 roads: Vec::new(),
                 movements: Vec::new(),
+                crossing: None,
                 trim_roads_for_merging: BTreeMap::new(),
             },
         );

osm2streets/src/lib.rs

@@ -15,7 +15,8 @@ pub use self::geometry::{intersection_polygon, InputRoad};
 pub(crate) use self::ids::RoadWithEndpoints;
 pub use self::ids::{CommonEndpoint, IntersectionID, LaneID, RoadID};
 pub use self::intersection::{
-    Intersection, IntersectionControl, IntersectionKind, Movement, TrafficConflict,
+    Crossing, CrossingKind, Intersection, IntersectionControl, IntersectionKind, Movement,
+    TrafficConflict,
 };
 pub use self::operations::zip_sidepath::Sidepath;
 pub use self::render::Filter;

osm2streets/src/render/intersection_markings.rs

@@ -1,10 +1,10 @@
 use anyhow::Result;
 use geojson::Feature;
-use geom::{Polygon, Ring};
+use geom::{Distance, Line, PolyLine, Polygon, Ring};
 
 use super::{serialize_features, Filter};
 use crate::road::RoadEdge;
-use crate::{Intersection, LaneType, StreetNetwork};
+use crate::{CrossingKind, Intersection, LaneType, Road, StreetNetwork};
 
 impl StreetNetwork {
     pub fn to_intersection_markings_geojson(&self, filter: &Filter) -> Result<String> {
@@ -15,6 +15,25 @@ impl StreetNetwork {
                 f.set_property("type", "sidewalk corner");
                 features.push(f);
             }
+
+            if let Some(ref crossing) = intersection.crossing {
+                match crossing.kind {
+                    CrossingKind::Signalized | CrossingKind::Marked => {
+                        for polygon in draw_zebra_crossing(self, intersection) {
+                            let mut f = Feature::from(polygon.to_geojson(Some(&self.gps_bounds)));
+                            f.set_property("type", "marked crossing line");
+                            features.push(f);
+                        }
+                    }
+                    CrossingKind::Unmarked => {
+                        for polygon in draw_unmarked_crossing(self, intersection) {
+                            let mut f = Feature::from(polygon.to_geojson(Some(&self.gps_bounds)));
+                            f.set_property("type", "unmarked crossing outline");
+                            features.push(f);
+                        }
+                    }
+                }
+            }
         }
         serialize_features(features)
     }
@@ -109,3 +128,85 @@ fn make_sidewalk_corners(streets: &StreetNetwork, intersection: &Intersection) -
     }
     results
 }
+
+fn get_crossing_line_and_min_width(
+    streets: &StreetNetwork,
+    intersection: &Intersection,
+) -> Option<(PolyLine, Distance)> {
+    // Find the pedestrian roads making up the crossing
+    let mut roads = Vec::new();
+    for r in &intersection.roads {
+        let road = &streets.roads[r];
+        if road.lane_specs_ltr.len() == 1 && road.lane_specs_ltr[0].lt.is_walkable() {
+            roads.push(road);
+        }
+    }
+    // TODO Look for examples
+    if roads.len() != 2 {
+        return None;
+    }
+
+    // Create the line connecting these two roads.
+    // TODO Subset the reference_lines by trim_start/end to get more detail
+    let pl = PolyLine::new(vec![
+        center_line_pointed_at(roads[0], intersection).last_pt(),
+        center_line_pointed_at(roads[1], intersection).last_pt(),
+    ])
+    .ok()?;
+
+    let width = roads[0].total_width().min(roads[1].total_width());
+    Some((pl, width))
+}
+
+fn draw_zebra_crossing(streets: &StreetNetwork, intersection: &Intersection) -> Vec<Polygon> {
+    let mut results = Vec::new();
+    let Some((line, total_width)) = get_crossing_line_and_min_width(streets, intersection) else {
+        return results;
+    };
+
+    // Pretty arbitrary parameters
+    let width = 0.8 * total_width;
+    let thickness = Distance::meters(0.15);
+    let step_size = 3.0 * thickness;
+    let buffer_ends = step_size;
+    for (pt1, angle) in line.step_along(step_size, buffer_ends) {
+        // Project away an arbitrary amount
+        let pt2 = pt1.project_away(Distance::meters(1.0), angle);
+        results.push(perp_line(Line::must_new(pt1, pt2), width).make_polygons(thickness));
+    }
+
+    results
+}
+
+fn draw_unmarked_crossing(streets: &StreetNetwork, intersection: &Intersection) -> Vec<Polygon> {
+    let mut results = Vec::new();
+    let Some((line, total_width)) = get_crossing_line_and_min_width(streets, intersection) else {
+        return results;
+    };
+
+    let width = 0.8 * total_width;
+    let thickness = Distance::meters(0.15);
+
+    for shift in [width / 2.0, -width / 2.0] {
+        if let Ok(pl) = line.shift_either_direction(shift) {
+            results.push(pl.make_polygons(thickness));
+        }
+    }
+
+    results
+}
+
+fn center_line_pointed_at(road: &Road, intersection: &Intersection) -> PolyLine {
+    if road.dst_i == intersection.id {
+        road.center_line.clone()
+    } else {
+        road.center_line.reversed()
+    }
+}
+
+// this always does it at pt1
+fn perp_line(l: Line, length: Distance) -> Line {
+    let pt1 = l.shift_right(length / 2.0).pt1();
+    let pt2 = l.shift_left(length / 2.0).pt1();
+    Line::must_new(pt1, pt2)
+}

osm2streets/src/render/mod.rs

@@ -78,6 +78,7 @@ impl StreetNetwork {
             );
             f.set_property("intersection_kind", format!("{:?}", intersection.kind));
             f.set_property("control", format!("{:?}", intersection.control));
+            f.set_property("crossing", serde_json::to_value(&intersection.crossing)?);
             f.set_property(
                 "movements",
                 Value::Array(

streets_reader/src/extract.rs

@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use abstutil::Tags;
 use geom::{HashablePt2D, Pt2D};
 use osm2streets::osm::{NodeID, OsmID, RelationID, WayID};
-use osm2streets::{osm, Direction, RestrictionType};
+use osm2streets::{osm, Crossing, CrossingKind, Direction, RestrictionType};
 
 use crate::osm_reader::{Node, Relation, Way};
 use crate::MapConfig;
@@ -22,8 +22,7 @@ pub struct OsmExtract {
     /// Traffic signals and bike stop lines, with an optional direction they apply to
     pub traffic_signals: HashMap<HashablePt2D, Option<Direction>>,
     pub cycleway_stop_lines: Vec<(HashablePt2D, Option<Direction>)>,
-    /// Pedestrian crossings with a traffic signal, with unknown direction
-    pub signalized_crossings: Vec<HashablePt2D>,
+    pub crossings: HashMap<HashablePt2D, Crossing>,
 }
 
 impl OsmExtract {
@@ -36,7 +35,7 @@ impl OsmExtract {
 
             traffic_signals: HashMap::new(),
             cycleway_stop_lines: Vec::new(),
-            signalized_crossings: Vec::new(),
+            crossings: HashMap::new(),
         }
     }
 
@@ -53,10 +52,21 @@ impl OsmExtract {
             self.cycleway_stop_lines.push((node.pt.to_hashable(), dir));
         }
 
-        // TODO Maybe restricting to traffic_signals is too much. But we definitely don't want to
-        // use crossing=unmarked to infer stop lines
-        if node.tags.is("highway", "crossing") && node.tags.is("crossing", "traffic_signals") {
-            self.signalized_crossings.push(node.pt.to_hashable());
+        if node.tags.is("highway", "crossing") || node.tags.is("railway", "crossing") {
+            let kind = match node.tags.get("crossing").map(|x| x.as_str()) {
+                Some("traffic_signals") => CrossingKind::Signalized,
+                Some("uncontrolled" | "marked") => CrossingKind::Marked,
+                Some("unmarked") => CrossingKind::Unmarked,
+                // TODO Look into these cases
+                _ => CrossingKind::Unmarked,
+            };
+            self.crossings.insert(
+                node.pt.to_hashable(),
+                Crossing {
+                    kind,
+                    has_island: node.tags.is("crossing:island", "yes"),
+                },
+            );
         }
     }
 

streets_reader/src/split_ways.rs

@@ -286,12 +286,14 @@ pub fn split_up_roads(
         }
     }
 
-    timer.start_iter(
-        "match signalized crossings",
-        input.signalized_crossings.len(),
-    );
-    for pt in input.signalized_crossings {
+    timer.start_iter("match crossings", input.crossings.len());
+    for (pt, crossing) in input.crossings {
         timer.next();
+
+        if let Some(i) = pt_to_intersection_id.get(&pt) {
+            streets.intersections.get_mut(&i).unwrap().crossing = Some(crossing);
+        }
+
         if let Some(road) = pt_to_road.get(&pt).and_then(|r| streets.roads.get_mut(r)) {
             if let Some((dist, _)) = road.reference_line.dist_along_of_point(pt.to_pt2d()) {
                 // We don't know the direction. Arbitrarily snap to the start or end if it's within