Add Haversine:distance for Line vs. Point (same as CrossTrackDistance)

geo/CHANGES.md

@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+* Add `Haversine:distance` for Line vs. Point (same as CrossTrackDistance)
 
 ## 0.29.0 - 2024.10.30
 

geo/src/algorithm/cross_track_distance.rs

@@ -1,10 +1,15 @@
-use crate::{Bearing, Distance, Haversine, MEAN_EARTH_RADIUS};
-use geo_types::{CoordFloat, Point};
+use crate::Distance;
+use geo_types::{CoordFloat, Line, Point};
 use num_traits::FromPrimitive;
 
 /// Determine the cross track distance (also known as the cross track error) which is the shortest
 /// distance between a point and a continuous line.
-pub trait CrossTrackDistance<T, Rhs = Self> {
+///
+/// Distance is measured in meters, using the Haversine formula.
+pub trait CrossTrackDistance<T, Rhs = Self>
+where
+    T: CoordFloat + FromPrimitive,
+{
     /// Determine the cross track distance between this point and a line
     /// which passes through line_point_a and line_point_b
     ///
@@ -42,20 +47,14 @@ where
     T: CoordFloat + FromPrimitive,
 {
     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_xt: T = (l_delta_13.sin() * (theta_12 - theta_13).sin()).asin();
-        mean_earth_radius * l_delta_xt.abs()
+        crate::Haversine::distance(&Line::new(*line_point_a, *line_point_b), self)
     }
 }
 
 #[cfg(test)]
 mod test {
-    use crate::CrossTrackDistance;
     use crate::Point;
-    use crate::{Distance, Haversine};
+    use crate::{CrossTrackDistance, Distance, Haversine};
 
     #[test]
     fn distance1_test() {
@@ -107,10 +106,7 @@ mod test {
         let line_point_a = Point::new(-80.1918f64, 25.7617f64);
         let line_point_b = Point::new(-120.7401f64, 47.7511f64);
 
-        assert_relative_eq!(
-            p1.cross_track_distance(&line_point_a, &line_point_b),
-            1_547_104.,
-            epsilon = 1.0
-        );
+        let haversine_distance = p1.cross_track_distance(&line_point_a, &line_point_b);
+        assert_relative_eq!(haversine_distance, 1_547_104., epsilon = 1.0);
     }
 }

geo/src/algorithm/line_measures/distance.rs

@@ -10,3 +10,18 @@ pub trait Distance<F, Origin, Destination> {
     /// - returns: depends on the trait implementation.
     fn distance(origin: Origin, destination: Destination) -> F;
 }
+
+// Distance is a symmetric operation, so we can implement it once for both
+macro_rules! symmetric_distance_impl {
+    ($a:ty, $b:ty, for: $metric_space: ty, where: $($bound:tt)+) => {
+        impl<F> $crate::Distance<F, $a, $b> for $metric_space
+        where
+            F: $($bound)+,
+        {
+            fn distance(a: $a, b: $b) -> F {
+                Self::distance(b, a)
+            }
+        }
+    };
+}
+pub(crate) use symmetric_distance_impl;

geo/src/algorithm/line_measures/metric_spaces/euclidean/distance.rs

@@ -2,25 +2,12 @@ use super::{Distance, Euclidean};
 use crate::algorithm::Intersects;
 use crate::coordinate_position::{coord_pos_relative_to_ring, CoordPos};
 use crate::geometry::*;
+use crate::line_measures::distance::symmetric_distance_impl;
 use crate::{CoordFloat, GeoFloat, GeoNum};
 use num_traits::{Bounded, Float};
 use rstar::primitives::CachedEnvelope;
 use rstar::RTree;
 
-// Distance is a symmetric operation, so we can implement it once for both
-macro_rules! symmetric_distance_impl {
-    ($t:ident, $a:ty, $b:ty) => {
-        impl<F> $crate::Distance<F, $a, $b> for Euclidean
-        where
-            F: $t,
-        {
-            fn distance(a: $a, b: $b) -> F {
-                Self::distance(b, a)
-            }
-        }
-    };
-}
-
 // ┌───────────────────────────┐
 // │ Implementations for Coord │
 // └───────────────────────────┘
@@ -124,8 +111,8 @@ impl<F: GeoFloat> Distance<F, &Point<F>, &Polygon<F>> for Euclidean {
 // │ Implementations for Line │
 // └──────────────────────────┘
 
-symmetric_distance_impl!(CoordFloat, &Line<F>, Coord<F>);
-symmetric_distance_impl!(CoordFloat, &Line<F>, &Point<F>);
+symmetric_distance_impl!(&Line<F>, Coord<F>, for: Euclidean, where: CoordFloat);
+symmetric_distance_impl!(&Line<F>, &Point<F>, for: Euclidean, where: CoordFloat);
 
 impl<F: GeoFloat> Distance<F, &Line<F>, &Line<F>> for Euclidean {
     fn distance(line_a: &Line<F>, line_b: &Line<F>) -> F {
@@ -169,8 +156,8 @@ impl<F: GeoFloat> Distance<F, &Line<F>, &Polygon<F>> for Euclidean {
 // │ Implementations for LineString │
 // └────────────────────────────────┘
 
-symmetric_distance_impl!(CoordFloat, &LineString<F>, &Point<F>);
-symmetric_distance_impl!(GeoFloat, &LineString<F>, &Line<F>);
+symmetric_distance_impl!(&LineString<F>, &Point<F>, for: Euclidean, where: CoordFloat);
+symmetric_distance_impl!(&LineString<F>, &Line<F>, for: Euclidean, where: GeoFloat);
 
 impl<F: GeoFloat> Distance<F, &LineString<F>, &LineString<F>> for Euclidean {
     fn distance(line_string_a: &LineString<F>, line_string_b: &LineString<F>) -> F {
@@ -206,9 +193,9 @@ impl<F: GeoFloat> Distance<F, &LineString<F>, &Polygon<F>> for Euclidean {
 // │ Implementations for Polygon │
 // └─────────────────────────────┘
 
-symmetric_distance_impl!(GeoFloat, &Polygon<F>, &Point<F>);
-symmetric_distance_impl!(GeoFloat, &Polygon<F>, &Line<F>);
-symmetric_distance_impl!(GeoFloat, &Polygon<F>, &LineString<F>);
+symmetric_distance_impl!(&Polygon<F>, &Point<F>, for: Euclidean, where: GeoFloat);
+symmetric_distance_impl!(&Polygon<F>, &Line<F>, for: Euclidean, where: GeoFloat);
+symmetric_distance_impl!(&Polygon<F>, &LineString<F>, for: Euclidean, where: GeoFloat);
 impl<F: GeoFloat> Distance<F, &Polygon<F>, &Polygon<F>> for Euclidean {
     fn distance(polygon_a: &Polygon<F>, polygon_b: &Polygon<F>) -> F {
         if polygon_a.intersects(polygon_b) {
@@ -259,7 +246,7 @@ macro_rules! impl_euclidean_distance_for_polygonlike_geometry {
                     Self::distance(&polygonlike.to_polygon(), geometry_b)
               }
           }
-          symmetric_distance_impl!(GeoFloat, $geometry_b, $polygonlike);
+          symmetric_distance_impl!($geometry_b, $polygonlike, for: Euclidean, where: GeoFloat);
       )*
   };
 }
@@ -293,7 +280,7 @@ macro_rules! impl_euclidean_distance_for_iter_geometry {
                         })
                 }
             }
-            symmetric_distance_impl!(GeoFloat, $to_geometry, $iter_geometry);
+            symmetric_distance_impl!($to_geometry, $iter_geometry, for: Euclidean, where: GeoFloat);
         )*
   };
 }
@@ -327,7 +314,7 @@ macro_rules! impl_euclidean_distance_for_geometry_and_variant {
                   }
               }
           }
-          symmetric_distance_impl!(GeoFloat, &Geometry<F>, $target);
+          symmetric_distance_impl!(&Geometry<F>, $target, for: Euclidean, where: GeoFloat);
       )*
   };
 }

geo/src/algorithm/line_measures/metric_spaces/haversine.rs

@@ -1,8 +1,9 @@
 use num_traits::FromPrimitive;
 
 use super::super::{Bearing, Destination, Distance, InterpolatePoint};
+use crate::line_measures::distance::symmetric_distance_impl;
 use crate::utils::normalize_longitude;
-use crate::{CoordFloat, Point, MEAN_EARTH_RADIUS};
+use crate::{CoordFloat, Line, Point, MEAN_EARTH_RADIUS};
 
 /// A spherical model of the earth using the [haversine formula].
 ///
@@ -151,6 +152,18 @@ impl<F: CoordFloat + FromPrimitive> Distance<F, Point<F>, Point<F>> for Haversin
     }
 }
 
+impl<F: CoordFloat + FromPrimitive> Distance<F, &Line<F>, &Point<F>> for Haversine {
+    fn distance(line: &Line<F>, point: &Point<F>) -> F {
+        let mean_earth_radius = F::from(MEAN_EARTH_RADIUS).unwrap();
+        let l_delta_13 = Haversine::distance(line.start_point(), *point) / mean_earth_radius;
+        let theta_13 = Haversine::bearing(line.start_point(), *point).to_radians();
+        let theta_12 = Haversine::bearing(line.start_point(), line.end_point()).to_radians();
+        let l_delta_xt = (l_delta_13.sin() * (theta_12 - theta_13).sin()).asin();
+        mean_earth_radius * l_delta_xt.abs()
+    }
+}
+symmetric_distance_impl!(&Point<F>, &Line<F>, for: Haversine, where: CoordFloat + FromPrimitive);
+
 /// Interpolate Point(s) along a [great circle].
 ///
 /// [great circle]: https://en.wikipedia.org/wiki/Great_circle