Diagonal filters (#98)

Author: michaelkirk

backend/Cargo.toml

@@ -46,6 +46,9 @@ opt-level = 3
 [[bench]]
 name = "build_neighbourhood"
 harness = false
+[[bench]]
+name = "build_map_model"
+harness = false
 
 [patch.crates-io]
 # use unreleased `geo` and `geo-types` to fix crash: https://github.com/a-b-street/ltn/issues/54

backend/benches/build_map_model.rs

@@ -0,0 +1,28 @@
+use backend::test_fixtures::NeighbourhoodFixture;
+
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+
+fn benchmark_build_map_model(c: &mut Criterion) {
+    for neighbourhood in [
+        NeighbourhoodFixture::BRISTOL_EAST,
+        NeighbourhoodFixture::STRASBOURG,
+    ] {
+        // Do the file i/o (reading OSM.xml) outside of the bench loop
+        let map_model_builder = neighbourhood.map_model_builder().unwrap();
+        c.bench_function(
+            &format!(
+                "build map_model: {name}",
+                name = neighbourhood.study_area_name
+            ),
+            |b| {
+                b.iter(|| {
+                    let map_model = map_model_builder().unwrap();
+                    black_box(map_model);
+                });
+            },
+        );
+    }
+}
+
+criterion_group!(benches, benchmark_build_map_model);
+criterion_main!(benches);

backend/benches/build_neighbourhood.rs

@@ -8,14 +8,14 @@ fn benchmark_build_neighbourhood(c: &mut Criterion) {
         NeighbourhoodFixture::BRISTOL_WEST,
         NeighbourhoodFixture::STRASBOURG,
     ] {
+        let (map, boundary_geo) = neighbourhood.neighbourhood_params().unwrap();
+        let edit_perimeter_roads = false;
         c.bench_function(
             &format!(
                 "build neighbourhood: {name}",
                 name = neighbourhood.savefile_name
             ),
             |b| {
-                let (map, boundary_geo) = neighbourhood.neighbourhood_params().unwrap();
-                let edit_perimeter_roads = false;
                 b.iter(|| {
                     let neighbourhood = Neighbourhood::new(
                         &map,

backend/src/create.rs

@@ -138,19 +138,6 @@ pub fn create_from_osm(
     remove_disconnected_components(&mut graph);
     graph.compact_ids();
 
-    // Copy all the fields
-    let intersections: Vec<Intersection> = graph
-        .intersections
-        .into_values()
-        .map(|i| Intersection {
-            id: IntersectionID(i.id.0),
-            point: i.point,
-            node: i.osm_node,
-            roads: i.edges.into_iter().map(|e| RoadID(e.0)).collect(),
-            turn_restrictions: Vec::new(),
-        })
-        .collect();
-
     // Add in a bit
     let roads: Vec<Road> = graph
         .edges
@@ -166,6 +153,13 @@ pub fn create_from_osm(
         })
         .collect();
 
+    // Copy all the fields
+    let intersections: Vec<Intersection> = graph
+        .intersections
+        .into_values()
+        .map(|i| Intersection::from_graph(i, &roads))
+        .collect();
+
     for ls in &mut osm.railways {
         graph.mercator.to_mercator_in_place(ls);
     }
@@ -213,6 +207,7 @@ pub fn create_from_osm(
 
         original_modal_filters: BTreeMap::new(),
         modal_filters: BTreeMap::new(),
+        diagonal_filters: BTreeMap::new(),
 
         directions,
 

backend/src/geo_helpers/mod.rs

@@ -107,6 +107,37 @@ pub fn angle_of_line(line: Line) -> f64 {
     (line.dy()).atan2(line.dx()).to_degrees()
 }
 
+/// North is 0°
+/// East is 90°
+/// South  is 180°
+/// West is 270°
+pub fn euclidean_bearing(origin: Coord, destination: Coord) -> f64 {
+    (angle_of_line(Line::new(origin, destination)) + 450.0) % 360.0
+}
+
+/// The bearing of the first segment of `linestring` starting from `endpoint`.
+///
+/// precondition: `endpoint` must be either the first or last point in `linestring`
+/// precondition: `linestring` must have at least 2 coordinates
+pub fn bearing_from_endpoint(endpoint: Point, linestring: &LineString) -> f64 {
+    assert!(
+        linestring.0.len() >= 2,
+        "zero length roads should be filtered out"
+    );
+    let next_coord = if endpoint.0 == linestring.0[0] {
+        linestring.0[1]
+    } else if endpoint.0 == linestring.0[linestring.0.len() - 1] {
+        linestring.0[linestring.0.len() - 2]
+    } else {
+        // I'm assuming this won't happen, but maybe it's possible,
+        // e.g. to different rounding schemes.
+        debug_assert!(false, "road does not terminate at intersection");
+        linestring.0[1]
+    };
+
+    euclidean_bearing(endpoint.0, next_coord)
+}
+
 pub fn angle_of_pt_on_line(linestring: &LineString, pt: Coord) -> f64 {
     let line = linestring
         .lines()
@@ -267,3 +298,103 @@ pub fn invert_polygon(wgs84_polygon: Polygon) -> Polygon {
         vec![wgs84_polygon.into_inner().0],
     )
 }
+
+/// The "diagonal line" is an equal angular distance from a and b.
+/// The diagonal bearing is the bearing of this "diagonal line".
+///
+/// That is, given the bearing of a and b, returns the bearing of line c.
+///
+/// ```ignore
+///       a    b
+///        \  /
+///      ∂° \/ ∂°
+///    ------------ c
+/// ```
+pub fn diagonal_bearing(bearing_a: f64, bearing_b: f64) -> f64 {
+    let angle_between = bearing_b - bearing_a;
+    (angle_between / 2.0 + 90.0 + bearing_a) % 360.0
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use approx::assert_relative_eq;
+    use geo::wkt;
+
+    #[test]
+    fn test_line_bearing() {
+        let p1 = Point::new(0.0, 0.0);
+
+        // Due South in our projection
+        assert_relative_eq!(90.0, angle_of_line(Line::new(p1, Point::new(0.0, 1.0))));
+        // East
+        assert_relative_eq!(0.0, angle_of_line(Line::new(p1, Point::new(1.0, 0.0))));
+        // North
+        assert_relative_eq!(-90.0, angle_of_line(Line::new(p1, Point::new(0.0, -1.0))));
+        // West
+        assert_relative_eq!(180.0, angle_of_line(Line::new(p1, Point::new(-1.0, 0.0))));
+    }
+
+    #[test]
+    fn test_bearing_from_endpoint() {
+        let p1 = Point::new(0.0, 0.0);
+
+        // p1 is start point
+
+        // North
+        assert_relative_eq!(
+            0.,
+            bearing_from_endpoint(p1, &wkt!(LINESTRING(0. 0.,0. -1.)))
+        );
+        // East
+        assert_relative_eq!(
+            90.,
+            bearing_from_endpoint(p1, &wkt!(LINESTRING(0. 0.,1. 0.)))
+        );
+        // South
+        assert_relative_eq!(
+            180.,
+            bearing_from_endpoint(p1, &wkt!(LINESTRING(0. 0.,0. 1.)))
+        );
+        // West
+        assert_relative_eq!(
+            270.,
+            bearing_from_endpoint(p1, &wkt!(LINESTRING(0. 0.,-1. 0.)))
+        );
+        // Northwest
+        assert_relative_eq!(
+            315.,
+            bearing_from_endpoint(p1, &wkt!(LINESTRING(0. 0.,-1. -1.)))
+        );
+
+        // Flipped - p1 is now the end point, not the start point
+
+        // North
+        assert_relative_eq!(
+            0.,
+            bearing_from_endpoint(p1, &wkt!(LINESTRING(0. -1.,0. 0.)))
+        );
+        // East
+        assert_relative_eq!(
+            90.,
+            bearing_from_endpoint(p1, &wkt!(LINESTRING(1. 0.,0. 0.)))
+        );
+        // South
+        assert_relative_eq!(
+            180.,
+            bearing_from_endpoint(p1, &wkt!(LINESTRING(0. 1., 0. 0.)))
+        );
+        // West
+        assert_relative_eq!(
+            270.,
+            bearing_from_endpoint(p1, &wkt!(LINESTRING(-1. 0.,0. 0.)))
+        );
+    }
+
+    #[test]
+    fn test_diagonal_angle() {
+        assert_eq!(135.0, diagonal_bearing(0., 90.));
+        assert_eq!(270.0, diagonal_bearing(135., 225.));
+        assert_eq!(270.0, diagonal_bearing(300., 60.));
+    }
+}

backend/src/lib.rs

@@ -225,6 +225,33 @@ impl LTN {
         self.after_edit();
     }
 
+    /// Takes an IntersectionID
+    #[wasm_bindgen(js_name = addDiagonalFilter)]
+    pub fn add_diagonal_filter(&mut self, intersection_id: usize) -> Result<(), JsValue> {
+        self.map
+            .add_diagonal_filter(IntersectionID(intersection_id));
+        self.after_edit();
+        Ok(())
+    }
+
+    /// Takes an IntersectionID
+    #[wasm_bindgen(js_name = rotateDiagonalFilter)]
+    pub fn rotate_diagonal_filter(&mut self, intersection_id: usize) -> Result<(), JsValue> {
+        self.map
+            .rotate_diagonal_filter(IntersectionID(intersection_id));
+        self.after_edit();
+        Ok(())
+    }
+
+    /// Takes an IntersectionID
+    #[wasm_bindgen(js_name = deleteDiagonalFilter)]
+    pub fn delete_diagonal_filter(&mut self, intersection_id: usize) -> Result<(), JsValue> {
+        self.map
+            .delete_diagonal_filter(IntersectionID(intersection_id));
+        self.after_edit();
+        Ok(())
+    }
+
     #[wasm_bindgen(js_name = toggleDirection)]
     pub fn toggle_direction(&mut self, road: usize) {
         self.map.toggle_direction(RoadID(road));
@@ -345,6 +372,7 @@ impl LTN {
                 .map(|i| {
                     let mut f = self.map.mercator.to_wgs84_gj(&i.point);
                     f.set_property("has_turn_restrictions", !i.turn_restrictions.is_empty());
+                    f.set_property("intersection_id", i.id.0);
                     f
                 })
                 .collect::<Vec<_>>(),