Merge pull request #1006 from hannobraun/approx

Add support for arcs to low-level circle approximation code

crates/fj-kernel/src/algorithms/approx/curve.rs

@@ -28,16 +28,12 @@ impl Approx for GlobalCurve {
     /// To support that, we will need additional information here, to define
     /// between which points the curve needs to be approximated.
     fn approx(&self, tolerance: Tolerance) -> Self::Approximation {
-        let mut points = Vec::new();
-
         match self.kind() {
             CurveKind::Circle(curve) => {
-                approx_circle(curve, tolerance, &mut points)
+                approx_circle(curve, [[Scalar::ZERO], [Scalar::TAU]], tolerance)
             }
-            CurveKind::Line(_) => {}
+            CurveKind::Line(_) => Vec::new(),
         }
-
-        points
     }
 }
 
@@ -47,28 +43,40 @@ impl Approx for GlobalCurve {
 /// from the circle.
 pub fn approx_circle(
     circle: &Circle<3>,
+    between: [impl Into<Point<1>>; 2],
     tolerance: Tolerance,
-    out: &mut Vec<Local<Point<1>>>,
-) {
+) -> Vec<Local<Point<1>>> {
+    let mut points = Vec::new();
+
     let radius = circle.a().magnitude();
 
+    let [start, end] = between.map(Into::into);
+    let range = (end - start).t;
+
     // To approximate the circle, we use a regular polygon for which
     // the circle is the circumscribed circle. The `tolerance`
     // parameter is the maximum allowed distance between the polygon
     // and the circle. This is the same as the difference between
     // the circumscribed circle and the incircle.
 
-    let n = number_of_vertices_for_circle(tolerance, radius);
+    let n = number_of_vertices_for_circle(tolerance, radius, range.abs());
 
     for i in 0..n {
-        let angle = Scalar::TAU / n as f64 * i as f64;
+        let angle =
+            start.t + (Scalar::TAU / n as f64 * i as f64) * range.sign();
         let point = circle.point_from_circle_coords([angle]);
-        out.push(Local::new([angle], point));
+        points.push(Local::new([angle], point));
     }
+
+    points
 }
 
-fn number_of_vertices_for_circle(tolerance: Tolerance, radius: Scalar) -> u64 {
-    let n = (Scalar::PI / (Scalar::ONE - (tolerance.inner() / radius)).acos())
+fn number_of_vertices_for_circle(
+    tolerance: Tolerance,
+    radius: Scalar,
+    range: Scalar,
+) -> u64 {
+    let n = (range / (Scalar::ONE - (tolerance.inner() / radius)).acos() / 2.)
         .ceil()
         .into_u64();
 
@@ -83,31 +91,38 @@ mod tests {
 
     #[test]
     fn number_of_vertices_for_circle() {
-        verify_result(50., 100., 3);
-        verify_result(10., 100., 7);
-        verify_result(1., 100., 23);
+        verify_result(50., 100., Scalar::TAU, 3);
+        verify_result(50., 100., Scalar::PI, 3);
+        verify_result(10., 100., Scalar::TAU, 7);
+        verify_result(10., 100., Scalar::PI, 4);
+        verify_result(1., 100., Scalar::TAU, 23);
+        verify_result(1., 100., Scalar::PI, 12);
 
         fn verify_result(
             tolerance: impl Into<Tolerance>,
             radius: impl Into<Scalar>,
+            range: impl Into<Scalar>,
             n: u64,
         ) {
             let tolerance = tolerance.into();
             let radius = radius.into();
+            let range = range.into();
 
             assert_eq!(
                 n,
-                super::number_of_vertices_for_circle(tolerance, radius)
+                super::number_of_vertices_for_circle(tolerance, radius, range)
             );
 
-            assert!(calculate_error(radius, n) <= tolerance.inner());
+            assert!(calculate_error(radius, range, n) <= tolerance.inner());
             if n > 3 {
-                assert!(calculate_error(radius, n - 1) >= tolerance.inner());
+                assert!(
+                    calculate_error(radius, range, n - 1) >= tolerance.inner()
+                );
             }
         }
 
-        fn calculate_error(radius: Scalar, n: u64) -> Scalar {
-            radius - radius * (Scalar::PI / Scalar::from_u64(n)).cos()
+        fn calculate_error(radius: Scalar, range: Scalar, n: u64) -> Scalar {
+            radius - radius * (range / Scalar::from_u64(n) / 2.).cos()
         }
     }
 }