update to latest (not yet released) geo

NOTE: the test fixture changes appear to be due to georust/geo#1310,
which reversed the Polygon winding on the output from geo::boolean_operations.

Now the exterior is wound counter-clockwise and the interior clockwise.

This output convention matches what's used elsewhere in geo and also in
the geojson spec.

In practice many tools are tolerant of both, but it's probably better to
follow convention here.

Author: michaelkirk

backend/Cargo.lock

@@ -140,7 +140,7 @@ fn floodfill(map: &MapModel, start: RoadID, neighbourhood: &Neighbourhood) -> Ce
                         if interval.start == 0.0 {
                             visited_start = true;
                         }
-                        if interval.end == next_road.linestring.length::<Euclidean>() {
+                        if interval.end == Euclidean.length(&next_road.linestring) {
                             visited_end = true;
                         }
                     }

backend/src/cells.rs

@@ -141,7 +141,7 @@ pub fn bearing_from_endpoint(endpoint: Point, linestring: &LineString) -> f64 {
 pub fn angle_of_pt_on_line(linestring: &LineString, pt: Coord) -> f64 {
     let line = linestring
         .lines()
-        .min_by_key(|line| (Euclidean::distance(line, pt) * 10e9) as usize)
+        .min_by_key(|line| (Euclidean.distance(line, pt) * 10e9) as usize)
         .unwrap();
     angle_of_line(line)
 }
@@ -193,7 +193,7 @@ pub fn make_arrow(line: Line, thickness: f64, double_ended: bool) -> Option<Poly
     let head_size = thickness * 2.0;
     let triangle_height = head_size / 2.0_f64.sqrt();
     let angle = angle_of_line(line);
-    let length = line.length::<Euclidean>();
+    let length = Euclidean.length(&line);
 
     if length < triangle_height * 3.0 {
         return None;

backend/src/geo_helpers/mod.rs

@@ -70,7 +70,7 @@ impl SliceNearestFrechetBoundary for Polygon {
         let mut segment_idx_closest_to_final = 0;
         let mut coord_closest_to_final = coord!(x: 0., y: 0.);
         for (segment_idx, segment) in exterior.lines().enumerate() {
-            let new_first_distance = Euclidean::distance(&segment, first_coord);
+            let new_first_distance = Euclidean.distance(&segment, first_coord);
             if new_first_distance < distance_to_first {
                 distance_to_first = new_first_distance;
                 segment_idx_closest_to_first = segment_idx;
@@ -86,7 +86,7 @@ impl SliceNearestFrechetBoundary for Polygon {
                 };
             }
 
-            let new_final_distance = Euclidean::distance(&segment, final_coord);
+            let new_final_distance = Euclidean.distance(&segment, final_coord);
             if new_final_distance < distance_to_final {
                 distance_to_final = new_final_distance;
                 segment_idx_closest_to_final = segment_idx;

backend/src/geo_helpers/slice_nearest_boundary.rs

@@ -9,8 +9,8 @@ use crate::impact::Impact;
 use crate::Router;
 use anyhow::Result;
 use geo::{
-    Closest, ClosestPoint, Coord, Euclidean, Length, Line, LineInterpolatePoint, LineLocatePoint,
-    LineString, Point, Polygon,
+    Closest, ClosestPoint, Coord, Distance, Euclidean, Length, LineInterpolatePoint,
+    LineLocatePoint, LineString, Point, Polygon,
 };
 use geojson::{Feature, FeatureCollection, GeoJson, Geometry, JsonValue};
 use rstar::{primitives::GeomWithData, RTree, AABB};
@@ -212,7 +212,7 @@ impl MapModel {
                     Closest::SinglePoint(pt) => Some(pt),
                     Closest::Indeterminate => None,
                 } {
-                    let score = Line::new(click_pt, hit_pt.into()).length::<Euclidean>();
+                    let score = Euclidean.distance(click_pt, hit_pt.0);
                     let percent_along = road.linestring.line_locate_point(&hit_pt).unwrap();
                     Some(((score * 100.0) as usize, road.id, percent_along))
                 } else {
@@ -229,16 +229,14 @@ impl MapModel {
         self.roads
             .iter()
             .min_by_key(|r| {
-                let diff1 = Line::new(
+                let diff1 = Euclidean.distance(
                     r.linestring.points().next().unwrap(),
                     linestring.points().next().unwrap(),
-                )
-                .length::<Euclidean>();
-                let diff2 = Line::new(
+                );
+                let diff2 = Euclidean.distance(
                     r.linestring.points().last().unwrap(),
                     linestring.points().last().unwrap(),
-                )
-                .length::<Euclidean>();
+                );
                 ((diff1 + diff2) * 100.0) as usize
             })
             .unwrap()
@@ -703,7 +701,7 @@ impl MapModel {
 impl Road {
     // How long does it take for a car following the speed limit to cross this road?
     pub fn cost_seconds(&self) -> f64 {
-        let meters = self.linestring.length::<Euclidean>();
+        let meters = Euclidean.length(&self.linestring);
         let meters_per_second = (self.speed_mph as f64) * 0.44704;
         meters / meters_per_second
     }

backend/src/map_model.rs

@@ -69,7 +69,7 @@ fn render_arrow(i: IntersectionID, road1: &Road, road2: &Road) -> Polygon {
 fn pt_near_intersection(i: IntersectionID, road: &Road) -> Point {
     // If the road is long enough, offset from the intersection this much
     let distance_away = 10.0;
-    let len = road.linestring.length::<Euclidean>();
+    let len = Euclidean.length(&road.linestring);
 
     if len > distance_away {
         let pct = if road.src_i == i {

backend/src/movements.rs

@@ -344,11 +344,11 @@ fn line_in_polygon(
     let mut sum = 0.0;
     // TODO: update this to use i_overlay impl
     for clipped in clip_linestring_to_polygon(linestring, polygon) {
-        sum += clipped.length::<Euclidean>();
+        sum += Euclidean.length(&clipped);
     }
     // How much of the clipped linestring is inside the boundary? If it's nearly 1, then this
     // road is interior.
-    let ratio_inside = sum / linestring.length::<Euclidean>();
+    let ratio_inside = sum / Euclidean.length(linestring);
     if ratio_inside > 0.99 {
         LineInPolygon::Inside
     } else if ratio_inside < 0.01 {

backend/src/neighbourhood.rs

@@ -57,7 +57,7 @@ impl RenderCells {
                 let road = map.get_r(*r);
                 let slice = slice_linestring(&road.linestring, interval.start, interval.end);
                 // Walk along the center line
-                for pt in slice.densify::<Euclidean>(RESOLUTION_M / 2.0).0 {
+                for pt in Euclidean.densify(&slice, RESOLUTION_M / 2.0).0 {
                     let grid_idx = grid.idx(
                         ((pt.x - bounds.min().x) / RESOLUTION_M) as usize,
                         ((pt.y - bounds.min().y) / RESOLUTION_M) as usize,
@@ -90,9 +90,8 @@ impl RenderCells {
         // the area. The grid covers the rectangular bounds of the polygon. Rather than make an
         // enum with 3 cases, just assign a new index to mean "boundary."
         let boundary_marker = cells.len();
-        for pt in boundary_polygon
-            .exterior()
-            .densify::<Euclidean>(RESOLUTION_M / 2.0)
+        for pt in Euclidean
+            .densify(boundary_polygon.exterior(), RESOLUTION_M / 2.0)
             .0
         {
             // TODO Refactor helpers to transform between map-space and the grid tiles. Possibly

backend/src/render_cells.rs

@@ -171,7 +171,7 @@ impl Route {
         let mut time = 0.0;
         for (r, _) in &self.steps {
             let road = &map.roads[r.0];
-            distance += road.linestring.length::<Euclidean>();
+            distance += Euclidean.length(&road.linestring);
             time += road.cost_seconds();
         }
         (distance, time)

backend/src/route.rs

@@ -69,7 +69,7 @@ impl Shortcuts {
                             let road = map.find_edge(i1, i2);
                             steps.push((road.id, i1, i2));
                             *count_per_road.entry(road.id).or_insert(0) += 1;
-                            shortcut_length += road.linestring.length::<Euclidean>();
+                            shortcut_length += Euclidean.length(&road.linestring);
                         }
 
                         // How long is the shortest route through the original router, using this
@@ -79,7 +79,7 @@ impl Shortcuts {
                             map.get_i(*start).point.into(),
                             map.get_i(*end).point.into(),
                         ) {
-                            Some(route) => route.to_linestring(map).length::<Euclidean>(),
+                            Some(route) => Euclidean.length(&route.to_linestring(map)),
                             None => {
                                 warn!("Found a shortcut from {start} to {end}, but not a route using the whole map");
                                 shortcut_length
@@ -123,7 +123,7 @@ impl Path {
         }
         let linestring = LineString::new(pts);
 
-        let length = linestring.length::<Euclidean>();
+        let length = Euclidean.length(&linestring);
         let mut f = map.mercator.to_wgs84_gj(&linestring);
         f.set_property("directness", self.directness);
         f.set_property("length_meters", length);