From d5876b9650cf3f186ca2e1861cc0e19a28197e41 Mon Sep 17 00:00:00 2001
From: Hanno Braun <hanno@braun-odw.eu>
Date: Tue, 22 Mar 2022 15:28:25 +0100
Subject: [PATCH] Simplify `approximate_cycle`

---
 fj-kernel/src/algorithms/approximation.rs | 32 +++++++++++------------
 fj-kernel/src/algorithms/sweep.rs         |  6 +++--
 2 files changed, 20 insertions(+), 18 deletions(-)

diff --git a/fj-kernel/src/algorithms/approximation.rs b/fj-kernel/src/algorithms/approximation.rs
index 97f397731..1d2a57dbc 100644
--- a/fj-kernel/src/algorithms/approximation.rs
+++ b/fj-kernel/src/algorithms/approximation.rs
@@ -46,10 +46,18 @@ impl Approximation {
         let mut segments = HashSet::new();
 
         for cycle in face.cycles() {
-            let approx = approximate_cycle(&cycle, tolerance);
+            let cycle_points = approximate_cycle(&cycle, tolerance);
 
-            points.extend(approx.points);
-            segments.extend(approx.segments);
+            let mut cycle_segments = Vec::new();
+            for segment in cycle_points.windows(2) {
+                let p0 = segment[0];
+                let p1 = segment[1];
+
+                cycle_segments.push(Segment::from([p0, p1]));
+            }
+
+            points.extend(cycle_points);
+            segments.extend(cycle_segments);
         }
 
         Self { points, segments }
@@ -89,9 +97,8 @@ fn approximate_edge(
 ///
 /// `tolerance` defines how far the approximation is allowed to deviate from the
 /// actual cycle.
-pub fn approximate_cycle(cycle: &Cycle, tolerance: Scalar) -> Approximation {
-    let mut points = HashSet::new();
-    let mut segments = HashSet::new();
+pub fn approximate_cycle(cycle: &Cycle, tolerance: Scalar) -> Vec<Point<3>> {
+    let mut points = Vec::new();
 
     for edge in cycle.edges() {
         let mut edge_points = Vec::new();
@@ -99,19 +106,12 @@ pub fn approximate_cycle(cycle: &Cycle, tolerance: Scalar) -> Approximation {
 
         let edge_points = approximate_edge(edge_points, edge.vertices());
 
-        let mut edge_segments = Vec::new();
-        for segment in edge_points.windows(2) {
-            let p0 = segment[0];
-            let p1 = segment[1];
-
-            edge_segments.push(Segment::from([p0, p1]));
-        }
-
         points.extend(edge_points);
-        segments.extend(edge_segments);
     }
 
-    Approximation { points, segments }
+    points.dedup();
+
+    points
 }
 
 #[cfg(test)]
diff --git a/fj-kernel/src/algorithms/sweep.rs b/fj-kernel/src/algorithms/sweep.rs
index 36097998b..425351aa9 100644
--- a/fj-kernel/src/algorithms/sweep.rs
+++ b/fj-kernel/src/algorithms/sweep.rs
@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use fj_math::{Scalar, Transform, Triangle, Vector};
+use fj_math::{Scalar, Segment, Transform, Triangle, Vector};
 
 use crate::{
     geometry::{Surface, SweptCurve},
@@ -147,7 +147,9 @@ pub fn sweep_shape(
             let approx = approximate_cycle(&cycle_source.get(), tolerance);
 
             let mut quads = Vec::new();
-            for segment in approx.segments {
+            for segment in approx.windows(2) {
+                let segment = Segment::from_points([segment[0], segment[1]]);
+
                 let [v0, v1] = segment.points();
                 let [v3, v2] = {
                     let segment = Transform::translation(path)