deprecate EuclideanDistance

geo/CHANGES.md

@@ -22,27 +22,31 @@
 * Unify various line measurements under new `line_measures::{Bearing, Distance, Destination, InterpolatePoint}` traits
   Before:
   ```
-  use geo::{GeodesicBearing, HaversineBearing, GeodesicDistance, HaversineDistance};
-  GeodesicBearing::geodesic_bearing(p1, p2)
-  HaversineBearing::haversine_bearing(p1, p2)
-  GeodesicDistance::geodesic_distance(p1, p2)
-  HaversineDistance::haversine_distance(p1, p2)
+  use geo::{GeodesicBearing, HaversineBearing, GeodesicDistance, HaversineDistance, EuclideanDistance};
+  p1.geodesic_bearing(p2)
+  p1.haversine_bearing(p2)
+  p1.geodesic_distance(p2)
+  p1.haversine_distance(p2)
+  p1.euclidean_distance(p2)
   ```
 
   After:
   ```
-  use geo::{Geodesic, Haversine, Bearing, Distance};
+  use geo::{Geodesic, Haversine, Euclidean, Bearing, Distance};
   Geodesic::bearing(p1, p2)
   Haversine::bearing(p1, p2)
   Geodesic::distance(p1, p2)
   Haversine::distance(p1, p2)
+  Euclidean::distance(p1, p2)
   ```
   * <https://github.com/georust/geo/pull/1216>
 * Deprecated legacy line measure traits in favor of those added in the previous changelog entry:
   * `GeodesicBearing`, `GeodesicDistance`, `GeodesicDestination`, `GeodesicIntermediate`
   * `RhumbBearing`, `RhumbDistance`, `RhumbDestination`, `RhumbIntermediate`
   * `HaversineBearing`, `HaversineDistance`, `HaversineDestination`, `HaversineIntermediate`
+  * `EuclideanDistance`
   * <https://github.com/georust/geo/pull/1222>
+  * <https://github.com/georust/geo/pull/1232>
 * Deprecated `HaversineLength`, `EuclideanLength`, `RhumbLength`, `GeodesicLength` in favor of new generic `Length` trait.
   ```
   // Before
@@ -77,6 +81,8 @@
   * <https://github.com/georust/geo/pull/1226>
 * Enable i128 geometry types
   * <https://github.com/georust/geo/pull/1230>
+
+
 ## 0.28.0
 
 * BREAKING: The `HasKernel` trait was removed and it's functionality was merged

geo/benches/euclidean_distance.rs

@@ -1,5 +1,5 @@
 use criterion::{criterion_group, criterion_main};
-use geo::algorithm::{ConvexHull, EuclideanDistance};
+use geo::algorithm::{ConvexHull, Distance, Euclidean};
 use geo::{polygon, Polygon};
 
 fn criterion_benchmark(c: &mut criterion::Criterion) {
@@ -37,9 +37,7 @@ fn criterion_benchmark(c: &mut criterion::Criterion) {
             (x: -6.064453, y: 68.49604),
         ];
         bencher.iter(|| {
-            criterion::black_box(
-                criterion::black_box(&poly1).euclidean_distance(criterion::black_box(&poly2)),
-            );
+            criterion::black_box(Euclidean::distance(&poly1, &poly2));
         });
     });
 
@@ -81,9 +79,7 @@ fn criterion_benchmark(c: &mut criterion::Criterion) {
             ]
             .convex_hull();
             bencher.iter(|| {
-                criterion::black_box(
-                    criterion::black_box(&poly1).euclidean_distance(criterion::black_box(&poly2)),
-                );
+                criterion::black_box(Euclidean::distance(&poly1, &poly2));
             });
         },
     );

geo/src/algorithm/concave_hull.rs

@@ -1,8 +1,8 @@
 use crate::convex_hull::qhull;
 use crate::utils::partial_min;
 use crate::{
-    coord, Centroid, Coord, CoordNum, Euclidean, EuclideanDistance, GeoFloat, Length, Line,
-    LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon,
+    coord, Centroid, Coord, CoordNum, Distance, Euclidean, GeoFloat, Length, Line, LineString,
+    MultiLineString, MultiPoint, MultiPolygon, Point, Polygon,
 };
 use rstar::{RTree, RTreeNum};
 use std::collections::VecDeque;
@@ -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 line.euclidean_distance(&acc_point)
-                        > line.euclidean_distance(&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 closest_point.euclidean_distance(&acc)
-                        > closest_point.euclidean_distance(candidate)
+                    if Euclidean::distance(&closest_point, &acc)
+                        > Euclidean::distance(&closest_point, candidate)
                     {
                         *candidate
                     } else {
@@ -164,8 +164,8 @@ where
                 })),
             };
             let decision_distance = partial_min(
-                closest_point.euclidean_distance(&line.start_point()),
-                closest_point.euclidean_distance(&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;