凸包算法

  1. use std::cmp::Ordering::Equal;
  3. fn sort_by_min_angle(pts: &[(f64, f64)], min: &(f64, f64)) -> Vec<(f64, f64)> {
  4.     let mut points: Vec<(f64, f64, (f64, f64))> = pts
  5.         .iter()
  6.         .map(|x| {
  7.             (
  8.                 ((x.1 - min.1) as f64).atan2((x.0 - min.0) as f64),
  9.                 // angle
  10.                 ((x.1 - min.1) as f64).hypot((x.0 - min.0) as f64),
  11.                 // distance (we want the closest to be first)
  12.                 *x,
  13.             )
  14.         })
  15.         .collect();
  16.     points.sort_by(|a, b| a.partial_cmp(b).unwrap_or(Equal));
  17.     points.into_iter().map(|x| x.2).collect()
  18. }
  20. // calculates the z coordinate of the vector product of vectors ab and ac
  21. fn calc_z_coord_vector_product(a: &(f64, f64), b: &(f64, f64), c: &(f64, f64)) -> f64 {
  22.     (b.0 - a.0) * (c.1 - a.1) - (c.0 - a.0) * (b.1 - a.1)
  23. }
  25. /*
  26.     If three points are aligned and are part of the convex hull then the three are kept.
  27.     If one doesn't want to keep those points, it is easy to iterate the answer and remove them.
  28.     The first point is the one with the lowest y-coordinate and the lowest x-coordinate.
  29.     Points are then given counter-clockwise, and the closest one is given first if needed.
  30. */
  31. pub fn convex_hull_graham(pts: &[(f64, f64)]) -> Vec<(f64, f64)> {
  32.     if pts.is_empty() {
  33.         return vec![];
  34.     }
  36.     let mut stack: Vec<(f64, f64)> = vec![];
  37.     let min = pts
  38.         .iter()
  39.         .min_by(|a, b| {
  40.             let ord = a.1.partial_cmp(&b.1).unwrap_or(Equal);
  41.             match ord {
  42.                 Equal => a.0.partial_cmp(&b.0).unwrap_or(Equal),
  43.                 o => o,
  44.             }
  45.         })
  46.         .unwrap();
  47.     let points = sort_by_min_angle(pts, min);
  49.     if points.len() <= 3 {
  50.         return points;
  51.     }
  53.     for point in points {
  54.         while stack.len() > 1
  55.             && calc_z_coord_vector_product(&stack[stack.len() - 2], &stack[stack.len() - 1], &point)
  56.                 < 0.
  57.         {
  58.             stack.pop();
  59.         }
  60.         stack.push(point);
  61.     }
  63.     stack
  64. }
  66. #[cfg(test)]
  67. mod tests {
  68.     use super::*;
  70.     #[test]
  71.     fn empty() {
  72.         assert_eq!(convex_hull_graham(&vec![]), vec![]);
  73.     }
  75.     #[test]
  76.     fn not_enough_points() {
  77.         let list = vec![(0f64, 0f64)];
  78.         assert_eq!(convex_hull_graham(&list), list);
  79.     }
  81.     #[test]
  82.     fn not_enough_points1() {
  83.         let list = vec![(2f64, 2f64), (1f64, 1f64), (0f64, 0f64)];
  84.         let ans = vec![(0f64, 0f64), (1f64, 1f64), (2f64, 2f64)];
  85.         assert_eq!(convex_hull_graham(&list), ans);
  86.     }
  88.     #[test]
  89.     fn not_enough_points2() {
  90.         let list = vec![(2f64, 2f64), (1f64, 2f64), (0f64, 0f64)];
  91.         let ans = vec![(0f64, 0f64), (2f64, 2f64), (1f64, 2f64)];
  92.         assert_eq!(convex_hull_graham(&list), ans);
  93.     }
  95.     #[test]
  96.     // from https://codegolf.stackexchange.com/questions/11035/find-the-convex-hull-of-a-set-of-2d-points
  97.     fn lots_of_points() {
  98.         let list = vec![
  99.             (4.4, 14.),
  100.             (6.7, 15.25),
  101.             (6.9, 12.8),
  102.             (2.1, 11.1),
  103.             (9.5, 14.9),
  104.             (13.2, 11.9),
  105.             (10.3, 12.3),
  106.             (6.8, 9.5),
  107.             (3.3, 7.7),
  108.             (0.6, 5.1),
  109.             (5.3, 2.4),
  110.             (8.45, 4.7),
  111.             (11.5, 9.6),
  112.             (13.8, 7.3),
  113.             (12.9, 3.1),
  114.             (11., 1.1),
  115.         ];
  116.         let ans = vec![
  117.             (11., 1.1),
  118.             (12.9, 3.1),
  119.             (13.8, 7.3),
  120.             (13.2, 11.9),
  121.             (9.5, 14.9),
  122.             (6.7, 15.25),
  123.             (4.4, 14.),
  124.             (2.1, 11.1),
  125.             (0.6, 5.1),
  126.             (5.3, 2.4),
  127.         ];
  129.         assert_eq!(convex_hull_graham(&list), ans);
  130.     }
  132.     #[test]
  133.     // from https://codegolf.stackexchange.com/questions/11035/find-the-convex-hull-of-a-set-of-2d-points
  134.     fn lots_of_points2() {
  135.         let list = vec![
  136.             (1., 0.),
  137.             (1., 1.),
  138.             (1., -1.),
  139.             (0.68957, 0.283647),
  140.             (0.909487, 0.644276),
  141.             (0.0361877, 0.803816),
  142.             (0.583004, 0.91555),
  143.             (-0.748169, 0.210483),
  144.             (-0.553528, -0.967036),
  145.             (0.316709, -0.153861),
  146.             (-0.79267, 0.585945),
  147.             (-0.700164, -0.750994),
  148.             (0.452273, -0.604434),
  149.             (-0.79134, -0.249902),
  150.             (-0.594918, -0.397574),
  151.             (-0.547371, -0.434041),
  152.             (0.958132, -0.499614),
  153.             (0.039941, 0.0990732),
  154.             (-0.891471, -0.464943),
  155.             (0.513187, -0.457062),
  156.             (-0.930053, 0.60341),
  157.             (0.656995, 0.854205),
  158.         ];
  159.         let ans = vec![
  160.             (1., -1.),
  161.             (1., 0.),
  162.             (1., 1.),
  163.             (0.583004, 0.91555),
  164.             (0.0361877, 0.803816),
  165.             (-0.930053, 0.60341),
  166.             (-0.891471, -0.464943),
  167.             (-0.700164, -0.750994),
  168.             (-0.553528, -0.967036),
  169.         ];
  171.         assert_eq!(convex_hull_graham(&list), ans);
  172.     }
  173. }