Work on cycleway snapping for St George:

- the cycleway itself may be short, ignore it
- the short road between the main road and intersection may have been merged
- Remove connector segments immediately
- Remember to regenerate intersection geometry

osm2streets-js/src/lib.rs

@@ -69,8 +69,8 @@ impl JsStreetNetwork {
  }
  if input.sidepath_zipping_experiment {
  transformations.push(Transformation::ZipSidepaths);
- transformations.push(Transformation::TrimDeadendCycleways);
- transformations.push(Transformation::CollapseDegenerateIntersections);
+ //transformations.push(Transformation::TrimDeadendCycleways);
+ //transformations.push(Transformation::CollapseDegenerateIntersections);
  }
  if input.debug_each_step {
  street_network.apply_transformations_stepwise_debugging(transformations, &mut timer);

osm2streets/src/lib.rs

@@ -177,15 +177,19 @@ impl StreetNetwork {
 
  pub(crate) fn debug_intersection<I: Into<String>>(&mut self, i: IntersectionID, label: I) {
  if let Some(step) = self.debug_steps.last_mut() {
- step.points
- .push((self.intersections[&i].polygon.center(), label.into()));
+ if let Some(intersection) = self.intersections.get(&i) {
+ step.points
+ .push((intersection.polygon.center(), label.into()));
+ }
  }
  }
 
  pub(crate) fn debug_road<I: Into<String>>(&mut self, r: RoadID, label: I) {
  if let Some(step) = self.debug_steps.last_mut() {
- step.polylines
- .push((self.roads[&r].center_line.clone(), label.into()));
+ if let Some(road) = self.roads.get(&r) {
+ step.polylines
+ .push((road.center_line.clone(), label.into()));
+ }
  }
  }
 

osm2streets/src/operations/zip_sidepath.rs

@@ -1,3 +1,5 @@
+use std::collections::BTreeSet;
+
 use geom::{Distance, PolyLine};
 
 use crate::{BufferType, Direction, IntersectionID, LaneSpec, LaneType, RoadID, StreetNetwork};
@@ -22,6 +24,8 @@ pub struct Sidepath {
  main_road_src_i: IntersectionID,
  main_road_dst_i: IntersectionID,
  main_roads: Vec<RoadID>,
+ connector_src_i: Option<RoadID>,
+ connector_dst_i: Option<RoadID>,
 }
 
 impl Sidepath {
@@ -35,12 +39,17 @@ impl Sidepath {
  for i in sidepath_road.endpoints() {
  let mut connector_candidates = Vec::new();
  for road in streets.roads_per_intersection(i) {
- if road.untrimmed_length() < SHORT_ROAD_THRESHOLD {
+ if road.id != sidepath_road.id && road.center_line.length() < SHORT_ROAD_THRESHOLD {
  connector_candidates.push(road.id);
  }
  }
  if connector_candidates.len() == 1 {
- main_road_endpoints.push(streets.roads[&connector_candidates[0]].other_side(i));
+ let connector = connector_candidates[0];
+ main_road_endpoints
+ .push((streets.roads[&connector].other_side(i), Some(connector)));
+ } else if connector_candidates.is_empty() {
+ // Maybe this intersection has been merged already. Use it directly.
+ main_road_endpoints.push((i, None));
  }
  }
 
@@ -50,8 +59,12 @@ impl Sidepath {
 
  // Often the main road parallel to this sidepath segment is just one road, but it might
  // be more.
- let main_road_src_i = main_road_endpoints[0];
- let main_road_dst_i = main_road_endpoints[1];
+ let (main_road_src_i, connector_src_i) = main_road_endpoints[0];
+ let (main_road_dst_i, connector_dst_i) = main_road_endpoints[1];
+ // It may be none at all, when the main road intersection gets merged
+ if main_road_src_i == main_road_dst_i {
+ return None;
+ }
 
  // Find all main road segments "parallel to" this sidepath, by pathfinding between the
  // main road intersections. We don't care about the order, but simple_path does. In
@@ -66,6 +79,8 @@ impl Sidepath {
  main_road_src_i,
  main_road_dst_i,
  main_roads: path.into_iter().map(|(r, _)| r).collect(),
+ connector_src_i,
+ connector_dst_i,
  });
  }
 
@@ -79,10 +94,20 @@ impl Sidepath {
  for x in &self.main_roads {
  streets.debug_road(*x, format!("main road along {label}"));
  }
+ if let Some(r) = self.connector_src_i {
+ streets.debug_road(r, format!("src_i connector of {label}"));
+ }
+ if let Some(r) = self.connector_dst_i {
+ streets.debug_road(r, format!("dst_i connector of {label}"));
+ }
  }
 
  pub fn zip(self, streets: &mut StreetNetwork) {
- assert!(streets.roads.contains_key(&self.sidepath));
+ // The caller may find a bunch of these and zip, which sometimes could delete one of the
+ // located pieces
+ if !streets.roads.contains_key(&self.sidepath) {
+ return;
+ }
 
  // Remove the sidepath, but remember the lanes it contained
  let mut sidepath_lanes = streets.remove_road(self.sidepath).lane_specs_ltr;
@@ -117,6 +142,7 @@ impl Sidepath {
  // - Fixing the direction of the lanes
  // - Appending them on the left or right side (and "inside" the inferred sidewalk on the road)
  // - Inserting the buffer
+ let mut intersections = BTreeSet::new();
  for r in self.main_roads {
  let main_road = &streets.roads[&r];
  // Which side is closer to the sidepath?
@@ -186,11 +212,31 @@ impl Sidepath {
 
  let main_road = streets.roads.get_mut(&r).unwrap();
  splice_in(&mut main_road.lane_specs_ltr, insert_idx, insert_lanes);
+
+ intersections.extend(main_road.endpoints());
+ }
+
+ // Recalculate geometry along all of the main roads we just thickened
+ for i in intersections {
+ streets.update_i(i);
  }
 
  // After this transformation, we should run CollapseDegenerateIntersections to handle the
  // intersection where the side road originally crossed the sidepath, and TrimDeadendCycleways
  // to clean up any small cycle connection roads.
+ //
+ // ALTERNATIVELY, remove the connector segments immediately.
+ if let Some(r) = self.connector_src_i {
+ if streets.roads.contains_key(&r) {
+ // Ignore errors
+ let _ = streets.collapse_short_road(r);
+ }
+ }
+ if let Some(r) = self.connector_dst_i {
+ if streets.roads.contains_key(&r) {
+ let _ = streets.collapse_short_road(r);
+ }
+ }
  }
 }