Merge pull request #1298 from georust/mkirk/customizable-metric-space

Customizable metric space for line measures

Author: michaelkirk

geo/CHANGES.md

@@ -2,8 +2,34 @@
 
 ## Unreleased
 
+- BREAKING: `Densify` and `Length` are now defined on the metric space, rather than a generic method on the geometry.
+  - <https://github.com/georust/geo/pull/1298>
+  ```rust
+  // before
+  line_string.length::<Euclidean>()
+  line_string.densify::<Euclidean>()
+  line_string.densify::<Haversine>()
+
+  // after
+  Euclidean.length(&line_string)
+  Euclidean.densify(&line_string)
+  Haversine.densify(&line_string)
+  ```
+- Add configurable `HaversineMeasure` for doing calculations on a custom sphere. Use `Haversine` for the default earth radius.
+  - <https://github.com/georust/geo/pull/1298>
+  ```rust
+  // before
+  Haversine::distance(point1, point2)
+
+  // after
+  Haversine.distance(point1, point2)
+  
+  // For custom earth (or non-earth!) radius
+  HaversineMeasure::new(3_389_500.0).distance(point1, point2)
+  ```
 - Rename `triangulate_spade` and `TriangulateSpade` to `triangulate_delaunay` and `TriangulateDelaunay`
 - Docs: Fix page location of citation for mean earth radius used in Haversine calculations
+  - <https://github.com/georust/geo/pull/1297>
 - Docs: Add top-level doc link for `InteriorPoint`
 - Add Unary Union algorithm for fast union ops on adjacent / overlapping geometries
   - <https://github.com/georust/geo/pull/1246>

geo/benches/euclidean_distance.rs

@@ -37,7 +37,7 @@ fn criterion_benchmark(c: &mut criterion::Criterion) {
             (x: -6.064453, y: 68.49604),
         ];
         bencher.iter(|| {
-            criterion::black_box(Euclidean::distance(&poly1, &poly2));
+            criterion::black_box(Euclidean.distance(&poly1, &poly2));
         });
     });
 
@@ -79,7 +79,7 @@ fn criterion_benchmark(c: &mut criterion::Criterion) {
             ]
             .convex_hull();
             bencher.iter(|| {
-                criterion::black_box(Euclidean::distance(&poly1, &poly2));
+                criterion::black_box(Euclidean.distance(&poly1, &poly2));
             });
         },
     );

geo/benches/geodesic_distance.rs

@@ -7,7 +7,7 @@ fn criterion_benchmark(c: &mut criterion::Criterion) {
         let b = geo::Point::new(16.372477, 48.208810);
 
         bencher.iter(|| {
-            criterion::black_box(criterion::black_box(Geodesic::distance(a, b)));
+            criterion::black_box(criterion::black_box(Geodesic.distance(a, b)));
         });
     });
 }

geo/parcels.wkt

@@ -465,11 +465,9 @@ impl<T: GeoFloat> CentroidOperation<T> {
     fn add_line(&mut self, line: &Line<T>) {
         match line.dimensions() {
             ZeroDimensional => self.add_coord(line.start),
-            OneDimensional => self.add_centroid(
-                OneDimensional,
-                line.centroid().0,
-                line.length::<Euclidean>(),
-            ),
+            OneDimensional => {
+                self.add_centroid(OneDimensional, line.centroid().0, Euclidean.length(line))
+            }
             _ => unreachable!("Line must be zero or one dimensional"),
         }
     }

geo/src/algorithm/centroid.rs

@@ -52,7 +52,7 @@ impl<F: GeoFloat> ClosestPoint<F> for Point<F> {
 #[allow(clippy::many_single_char_names)]
 impl<F: GeoFloat> ClosestPoint<F> for Line<F> {
     fn closest_point(&self, p: &Point<F>) -> Closest<F> {
-        let line_length = self.length::<Euclidean>();
+        let line_length = Euclidean.length(self);
         if line_length == F::zero() {
             // if we've got a zero length line, technically the entire line
             // is the closest point...

geo/src/algorithm/closest_point.rs

@@ -116,7 +116,7 @@ where
     T: GeoFloat + RTreeNum,
 {
     let h = max_dist + max_dist;
-    let w = line.length::<Euclidean>() + h;
+    let w = Euclidean.length(&line) + h;
     let two = T::add(T::one(), T::one());
     let search_dist = T::div(T::sqrt(T::powi(w, 2) + T::powi(h, 2)), two);
     let centroid = line.centroid();
@@ -134,8 +134,8 @@ where
             let closest_point =
                 candidates.fold(Point::new(point.x, point.y), |acc_point, candidate| {
                     let candidate_point = Point::new(candidate.x, candidate.y);
-                    if Euclidean::distance(&line, &acc_point)
-                        > Euclidean::distance(&line, &candidate_point)
+                    if Euclidean.distance(&line, &acc_point)
+                        > Euclidean.distance(&line, &candidate_point)
                     {
                         candidate_point
                     } else {
@@ -154,8 +154,8 @@ where
             let closest_edge_option = match peeked_edge {
                 None => None,
                 Some(&edge) => Some(edges_nearby_point.fold(*edge, |acc, candidate| {
-                    if Euclidean::distance(&closest_point, &acc)
-                        > Euclidean::distance(&closest_point, candidate)
+                    if Euclidean.distance(&closest_point, &acc)
+                        > Euclidean.distance(&closest_point, candidate)
                     {
                         *candidate
                     } else {
@@ -164,8 +164,8 @@ where
                 })),
             };
             let decision_distance = partial_min(
-                Euclidean::distance(&closest_point, &line.start_point()),
-                Euclidean::distance(&closest_point, &line.end_point()),
+                Euclidean.distance(&closest_point, &line.start_point()),
+                Euclidean.distance(&closest_point, &line.end_point()),
             );
             if let Some(closest_edge) = closest_edge_option {
                 let far_enough = edge_length / decision_distance > concavity;
@@ -217,7 +217,7 @@ where
         line_tree.insert(line);
     }
     while let Some(line) = line_queue.pop_front() {
-        let edge_length = line.length::<Euclidean>();
+        let edge_length = Euclidean.length(&line);
         let dist = edge_length / concavity;
         let possible_closest_point = find_point_closest_to_line(
             &interior_points_tree,

geo/src/algorithm/concave_hull.rs

@@ -43,9 +43,9 @@ where
 {
     fn cross_track_distance(&self, line_point_a: &Point<T>, line_point_b: &Point<T>) -> T {
         let mean_earth_radius = T::from(MEAN_EARTH_RADIUS).unwrap();
-        let l_delta_13: T = Haversine::distance(*line_point_a, *self) / mean_earth_radius;
-        let theta_13: T = Haversine::bearing(*line_point_a, *self).to_radians();
-        let theta_12: T = Haversine::bearing(*line_point_a, *line_point_b).to_radians();
+        let l_delta_13: T = Haversine.distance(*line_point_a, *self) / mean_earth_radius;
+        let theta_13: T = Haversine.bearing(*line_point_a, *self).to_radians();
+        let theta_12: T = Haversine.bearing(*line_point_a, *line_point_b).to_radians();
         let l_delta_xt: T = (l_delta_13.sin() * (theta_12 - theta_13).sin()).asin();
         mean_earth_radius * l_delta_xt.abs()
     }
@@ -90,13 +90,13 @@ mod test {
 
         assert_relative_eq!(
             p.cross_track_distance(&line_point_a, &line_point_b),
-            Haversine::distance(p, Point::new(1., 0.)),
+            Haversine.distance(p, Point::new(1., 0.)),
             epsilon = 1.0e-6
         );
 
         assert_relative_eq!(
             p.cross_track_distance(&line_point_b, &line_point_a),
-            Haversine::distance(p, Point::new(1., 0.)),
+            Haversine.distance(p, Point::new(1., 0.)),
             epsilon = 1.0e-6
         );
     }

geo/src/algorithm/cross_track_distance.rs

@@ -10,7 +10,7 @@ use crate::{
 
 #[deprecated(
     since = "0.29.0",
-    note = "Please use the `line.densify::<Haversine>()` via the `Densify` trait instead."
+    note = "Please use the `Haversine.densify(&line)` via the `Densify` trait instead."
 )]
 /// Returns a new spherical geometry containing both existing and new interpolated coordinates with
 /// a maximum distance of `max_distance` between them.
@@ -50,7 +50,7 @@ where
     type Output = MultiPolygon<T>;
 
     fn densify_haversine(&self, max_distance: T) -> Self::Output {
-        self.densify::<Haversine>(max_distance)
+        Haversine.densify(self, max_distance)
     }
 }
 
@@ -64,7 +64,7 @@ where
     type Output = Polygon<T>;
 
     fn densify_haversine(&self, max_distance: T) -> Self::Output {
-        self.densify::<Haversine>(max_distance)
+        Haversine.densify(self, max_distance)
     }
 }
 
@@ -78,7 +78,7 @@ where
     type Output = MultiLineString<T>;
 
     fn densify_haversine(&self, max_distance: T) -> Self::Output {
-        self.densify::<Haversine>(max_distance)
+        Haversine.densify(self, max_distance)
     }
 }
 
@@ -92,7 +92,7 @@ where
     type Output = LineString<T>;
 
     fn densify_haversine(&self, max_distance: T) -> Self::Output {
-        self.densify::<Haversine>(max_distance)
+        Haversine.densify(self, max_distance)
     }
 }
 
@@ -106,7 +106,7 @@ where
     type Output = LineString<T>;
 
     fn densify_haversine(&self, max_distance: T) -> Self::Output {
-        self.densify::<Haversine>(max_distance)
+        Haversine.densify(self, max_distance)
     }
 }
 
@@ -120,7 +120,7 @@ where
     type Output = Polygon<T>;
 
     fn densify_haversine(&self, max_distance: T) -> Self::Output {
-        self.densify::<Haversine>(max_distance)
+        Haversine.densify(self, max_distance)
     }
 }
 
@@ -134,7 +134,7 @@ where
     type Output = Polygon<T>;
 
     fn densify_haversine(&self, max_distance: T) -> Self::Output {
-        self.densify::<Haversine>(max_distance)
+        Haversine.densify(self, max_distance)
     }
 }