Remove references in function params for Copy types.

Author: frewsxcv

geo-types/src/algorithms.rs

@@ -8,22 +8,22 @@ pub trait EuclideanDistance<T, Rhs = Self> {
     fn euclidean_distance(&self, rhs: &Rhs) -> T;
 }
 
-fn line_segment_distance<T>(point: &Point<T>, start: &Point<T>, end: &Point<T>) -> T
+fn line_segment_distance<T>(point: Point<T>, start: Point<T>, end: Point<T>) -> T
 where
     T: Float + ToPrimitive,
 {
     if start == end {
-        return point.euclidean_distance(start);
+        return point.euclidean_distance(&start);
     }
     let dx = end.x() - start.x();
     let dy = end.y() - start.y();
     let r =
         ((point.x() - start.x()) * dx + (point.y() - start.y()) * dy) / (dx.powi(2) + dy.powi(2));
     if r <= T::zero() {
-        return point.euclidean_distance(start);
+        return point.euclidean_distance(&start);
     }
     if r >= T::one() {
-        return point.euclidean_distance(end);
+        return point.euclidean_distance(&end);
     }
     let s = ((start.y() - point.y()) * dx - (start.x() - point.x()) * dy) / (dx * dx + dy * dy);
     s.abs() * (dx * dx + dy * dy).sqrt()
@@ -44,7 +44,7 @@ where
     T: Float,
 {
     fn euclidean_distance(&self, point: &Point<T>) -> T {
-        line_segment_distance(point, &self.start, &self.end)
+        line_segment_distance(*point, self.start, self.end)
     }
 }
 

geo-types/src/point.rs

@@ -129,7 +129,7 @@ where
     ///
     /// assert_eq!(p.lng(), 1.234);
     /// ```
-    pub fn lng(&self) -> T {
+    pub fn lng(self) -> T {
         self.x()
     }
 
@@ -160,7 +160,7 @@ where
     ///
     /// assert_eq!(p.lat(), 2.345);
     /// ```
-    pub fn lat(&self) -> T {
+    pub fn lat(self) -> T {
         self.y()
     }
 
@@ -189,11 +189,11 @@ where
     /// use geo_types::Point;
     ///
     /// let p = Point::new(1.5, 0.5);
-    /// let dot = p.dot(&Point::new(2.0, 4.5));
+    /// let dot = p.dot(Point::new(2.0, 4.5));
     ///
     /// assert_eq!(dot, 5.25);
     /// ```
-    pub fn dot(&self, point: &Point<T>) -> T {
+    pub fn dot(self, point: Point<T>) -> T {
         self.x() * point.x() + self.y() * point.y()
     }
 
@@ -210,11 +210,11 @@ where
     /// let p_b = Point::new(3.0,5.0);
     /// let p_c = Point::new(7.0,12.0);
     ///
-    /// let cross = p_a.cross_prod(&p_b, &p_c);
+    /// let cross = p_a.cross_prod(p_b, p_c);
     ///
     /// assert_eq!(cross, 2.0)
     /// ```
-    pub fn cross_prod(&self, point_b: &Point<T>, point_c: &Point<T>) -> T
+    pub fn cross_prod(self, point_b: Point<T>, point_c: Point<T>) -> T
     where
         T: Float,
     {

geo-types/src/polygon.rs

@@ -89,8 +89,8 @@ where
                 let prev_1 = self.previous_vertex(&idx);
                 let prev_2 = self.previous_vertex(&prev_1);
                 self.exterior.0[prev_2].cross_prod(
-                    &self.exterior.0[prev_1],
-                    &self.exterior.0[idx]
+                    self.exterior.0[prev_1],
+                    self.exterior.0[idx]
                 )
             })
             // accumulate and check cross-product result signs in a single pass

geo/src/algorithm/closest_point.rs

@@ -64,7 +64,7 @@ impl<F: Float> ClosestPoint<F> for Line<F> {
         let direction_vector = self.end - self.start;
         let to_p = *p - self.start;
 
-        let t = to_p.dot(&direction_vector) / direction_vector.dot(&direction_vector);
+        let t = to_p.dot(direction_vector) / direction_vector.dot(direction_vector);
 
         // check the cases where the closest point is "outside" the line
         if t < F::zero() {
@@ -91,7 +91,7 @@ impl<F: Float> ClosestPoint<F> for Line<F> {
 /// the `Closest::SinglePoint` which is closest to `p`.
 ///
 /// If the iterator is empty, we get `Closest::Indeterminate`.
-fn closest_of<C, F, I>(iter: I, p: &Point<F>) -> Closest<F>
+fn closest_of<C, F, I>(iter: I, p: Point<F>) -> Closest<F>
 where
     F: Float,
     I: IntoIterator<Item = C>,
@@ -100,7 +100,7 @@ where
     let mut best = Closest::Indeterminate;
 
     for line_segment in iter {
-        let got = line_segment.closest_point(p);
+        let got = line_segment.closest_point(&p);
         best = got.best_of_two(&best, p);
     }
 
@@ -109,32 +109,32 @@ where
 
 impl<F: Float> ClosestPoint<F> for LineString<F> {
     fn closest_point(&self, p: &Point<F>) -> Closest<F> {
-        closest_of(self.lines(), p)
+        closest_of(self.lines(), *p)
     }
 }
 
 impl<F: Float> ClosestPoint<F> for Polygon<F> {
     fn closest_point(&self, p: &Point<F>) -> Closest<F> {
         let prospectives = self.interiors.iter().chain(iter::once(&self.exterior));
-        closest_of(prospectives, p)
+        closest_of(prospectives, *p)
     }
 }
 
 impl<F: Float> ClosestPoint<F> for MultiPolygon<F> {
     fn closest_point(&self, p: &Point<F>) -> Closest<F> {
-        closest_of(self.0.iter(), p)
+        closest_of(self.0.iter(), *p)
     }
 }
 
 impl<F: Float> ClosestPoint<F> for MultiPoint<F> {
     fn closest_point(&self, p: &Point<F>) -> Closest<F> {
-        closest_of(self.0.iter(), p)
+        closest_of(self.0.iter(), *p)
     }
 }
 
 impl<F: Float> ClosestPoint<F> for MultiLineString<F> {
     fn closest_point(&self, p: &Point<F>) -> Closest<F> {
-        closest_of(self.0.iter(), p)
+        closest_of(self.0.iter(), *p)
     }
 }
 

geo/src/algorithm/contains.rs

@@ -144,7 +144,7 @@ pub(crate) enum PositionPoint {
 }
 
 /// Calculate the position of `Point` p relative to a linestring
-pub(crate) fn get_position<T>(p: &Point<T>, linestring: &LineString<T>) -> PositionPoint
+pub(crate) fn get_position<T>(p: Point<T>, linestring: &LineString<T>) -> PositionPoint
 where
     T: Float,
 {
@@ -157,7 +157,7 @@ where
         return PositionPoint::Outside;
     }
     // Point is on linestring
-    if linestring.contains(p) {
+    if linestring.contains(&p) {
         return PositionPoint::OnBoundary;
     }
 
@@ -188,11 +188,11 @@ where
     T: Float,
 {
     fn contains(&self, p: &Point<T>) -> bool {
-        match get_position(p, &self.exterior) {
+        match get_position(*p, &self.exterior) {
             PositionPoint::OnBoundary | PositionPoint::Outside => false,
             _ => self.interiors
                 .iter()
-                .all(|ls| get_position(p, ls) == PositionPoint::Outside),
+                .all(|ls| get_position(*p, ls) == PositionPoint::Outside),
         }
     }
 }

geo/src/algorithm/convexhull.rs

@@ -49,7 +49,7 @@ fn partition<T, F: FnMut(&T) -> bool>(mut slice: &mut [T], mut pred: F) -> usize
 // we can compute the cross product AB x AC and check its sign:
 // If it's negative, it will be on the "right" side of AB
 // (when standing on A and looking towards B). If positive, it will be on the left side
-fn point_location<T>(p_a: &Point<T>, p_b: &Point<T>, p_c: &Point<T>) -> bool
+fn point_location<T>(p_a: Point<T>, p_b: Point<T>, p_c: Point<T>) -> bool
 where
     T: Float,
 {
@@ -79,11 +79,11 @@ where
             mem::swap(point, max);
         }
     }
-    let last = partition(&mut points, |p| point_location(max, min, p));
-    hull_set(max, min, &mut points[..last], &mut hull);
+    let last = partition(&mut points, |p| point_location(*max, *min, *p));
+    hull_set(*max, *min, &mut points[..last], &mut hull);
     hull.push(*max);
-    let last = partition(&mut points, |p| point_location(min, max, p));
-    hull_set(min, max, &mut points[..last], &mut hull);
+    let last = partition(&mut points, |p| point_location(*min, *max, *p));
+    hull_set(*min, *max, &mut points[..last], &mut hull);
     hull.push(*min);
     // close the polygon
     let final_element = *hull.first().unwrap();
@@ -92,7 +92,7 @@ where
 }
 
 // recursively calculate the convex hull of a subset of points
-fn hull_set<T>(p_a: &Point<T>, p_b: &Point<T>, mut set: &mut [Point<T>], hull: &mut Vec<Point<T>>)
+fn hull_set<T>(p_a: Point<T>, p_b: Point<T>, mut set: &mut [Point<T>], hull: &mut Vec<Point<T>>)
 where
     T: Float,
 {
@@ -107,7 +107,7 @@ where
     let mut furthest_idx = 0;
     for (idx, point) in set.iter().enumerate() {
         // let current_distance = pseudo_distance(p_a, p_b, point);
-        let current_distance = point.euclidean_distance(&Line::new(*p_a, *p_b));
+        let current_distance = point.euclidean_distance(&Line::new(p_a, p_b));
         if current_distance > furthest_distance {
             furthest_distance = current_distance;
             furthest_idx = idx
@@ -116,12 +116,12 @@ where
     // move Point at furthest_point from set into hull
     let furthest_point = swap_remove_to_first(&mut set, furthest_idx);
     // points over PB
-    let last = partition(set, |p| point_location(furthest_point, p_b, p));
-    hull_set(furthest_point, p_b, &mut set[..last], hull);
+    let last = partition(set, |p| point_location(*furthest_point, p_b, *p));
+    hull_set(*furthest_point, p_b, &mut set[..last], hull);
     hull.push(*furthest_point);
     // points over AP
-    let last = partition(set, |p| point_location(p_a, furthest_point, p));
-    hull_set(p_a, furthest_point, &mut set[..last], hull);
+    let last = partition(set, |p| point_location(p_a, *furthest_point, *p));
+    hull_set(p_a, *furthest_point, &mut set[..last], hull);
 }
 
 pub trait ConvexHull<T> {

geo/src/algorithm/euclidean_distance.rs

@@ -75,22 +75,22 @@ pub trait EuclideanDistance<T, Rhs = Self> {
 /// Minimum distance between a Point and a Line segment
 /// This is a helper for Point-to-LineString and Point-to-Polygon distance
 /// Adapted from https://github.com/OSGeo/geos/blob/master/src/algorithm/CGAlgorithms.cpp#L191
-fn line_segment_distance<T>(point: &Point<T>, start: &Point<T>, end: &Point<T>) -> T
+fn line_segment_distance<T>(point: Point<T>, start: Point<T>, end: Point<T>) -> T
 where
     T: Float + ToPrimitive,
 {
     if start == end {
-        return point.euclidean_distance(start);
+        return point.euclidean_distance(&start);
     }
     let dx = end.x() - start.x();
     let dy = end.y() - start.y();
     let r =
         ((point.x() - start.x()) * dx + (point.y() - start.y()) * dy) / (dx.powi(2) + dy.powi(2));
     if r <= T::zero() {
-        return point.euclidean_distance(start);
+        return point.euclidean_distance(&start);
     }
     if r >= T::one() {
-        return point.euclidean_distance(end);
+        return point.euclidean_distance(&end);
     }
     let s = ((start.y() - point.y()) * dx - (start.x() - point.x()) * dy) / (dx * dx + dy * dy);
     s.abs() * dx.hypot(dy)
@@ -151,7 +151,7 @@ where
                 polygon
                     .exterior
                     .lines()
-                    .map(|line| line_segment_distance(self, &line.start, &line.end))
+                    .map(|line| line_segment_distance(*self, line.start, line.end))
                     .fold(T::max_value(), |accum, val| accum.min(val)),
             )
     }
@@ -226,7 +226,7 @@ where
         }
         linestring
             .lines()
-            .map(|line| line_segment_distance(self, &line.start, &line.end))
+            .map(|line| line_segment_distance(*self, line.start, line.end))
             .fold(T::max_value(), |accum, val| accum.min(val))
     }
 }
@@ -247,7 +247,7 @@ where
 {
     /// Minimum distance from a Line to a Point
     fn euclidean_distance(&self, point: &Point<T>) -> T {
-        line_segment_distance(point, &self.start, &self.end)
+        line_segment_distance(*point, self.start, self.end)
     }
 }
 
@@ -279,7 +279,7 @@ where
 /// is disjoint because it's contained in the inner ring
 /// we work around this by checking that Polygons with inner rings don't
 /// contain a point from the candidate Polygon's outer shell in their simple representations
-fn ring_contains_point<T>(poly: &Polygon<T>, p: &Point<T>) -> bool
+fn ring_contains_point<T>(poly: &Polygon<T>, p: Point<T>) -> bool
 where
     T: Float,
 {
@@ -319,7 +319,7 @@ where
     fn euclidean_distance(&self, other: &Polygon<T>) -> T {
         if self.intersects(other) || other.contains(self) {
             T::zero()
-        } else if !other.interiors.is_empty() && ring_contains_point(other, &self.0[0]) {
+        } else if !other.interiors.is_empty() && ring_contains_point(other, self.0[0]) {
             // check each ring distance, returning the minimum
             let mut mindist: T = Float::max_value();
             for ring in &other.interiors {
@@ -434,14 +434,14 @@ where
             return T::zero();
         }
         // Containment check
-        if !self.interiors.is_empty() && ring_contains_point(self, &poly2.exterior.0[0]) {
+        if !self.interiors.is_empty() && ring_contains_point(self, poly2.exterior.0[0]) {
             // check each ring distance, returning the minimum
             let mut mindist: T = Float::max_value();
             for ring in &self.interiors {
                 mindist = mindist.min(nearest_neighbour_distance(&poly2.exterior, ring))
             }
             return mindist;
-        } else if !poly2.interiors.is_empty() && ring_contains_point(poly2, &self.exterior.0[0]) {
+        } else if !poly2.interiors.is_empty() && ring_contains_point(poly2, self.exterior.0[0]) {
             let mut mindist: T = Float::max_value();
             for ring in &poly2.interiors {
                 mindist = mindist.min(nearest_neighbour_distance(&self.exterior, ring))
@@ -495,17 +495,17 @@ mod test {
         let p1 = Point::new(7.2, 2.0);
         let p2 = Point::new(6.0, 1.0);
 
-        let dist = line_segment_distance(&o1, &p1, &p2);
-        let dist2 = line_segment_distance(&o2, &p1, &p2);
-        let dist3 = line_segment_distance(&o3, &p1, &p2);
-        let dist4 = line_segment_distance(&o4, &p1, &p2);
+        let dist = line_segment_distance(o1, p1, p2);
+        let dist2 = line_segment_distance(o2, p1, p2);
+        let dist3 = line_segment_distance(o3, p1, p2);
+        let dist4 = line_segment_distance(o4, p1, p2);
         // Results agree with Shapely
         assert_relative_eq!(dist, 2.0485900789263356);
         assert_relative_eq!(dist2, 1.118033988749895);
         assert_relative_eq!(dist3, 1.4142135623730951);
         assert_relative_eq!(dist4, 1.5811388300841898);
         // Point is on the line
-        let zero_dist = line_segment_distance(&p1, &p1, &p2);
+        let zero_dist = line_segment_distance(p1, p1, p2);
         assert_relative_eq!(zero_dist, 0.0);
     }
     #[test]