Clean up approx module

crates/fj-app/src/args.rs

@@ -2,7 +2,7 @@ use std::{path::PathBuf, str::FromStr as _};
 
 use anyhow::anyhow;
 use fj_host::Parameters;
-use fj_kernel::algorithms::Tolerance;
+use fj_kernel::algorithms::approx::Tolerance;
 use fj_math::Scalar;
 
 /// Fornjot - Experimental CAD System

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

@@ -2,36 +2,46 @@ use std::cmp::max;
 
 use fj_math::{Circle, Point, Scalar};
 
-use crate::objects::{CurveKind, GlobalCurve};
+use crate::objects::{Curve, CurveKind, GlobalCurve};
 
-use super::{Local, Tolerance};
+use super::{Approx, Local, Tolerance};
 
-/// Compute an approximation of the curve
-///
-/// `tolerance` defines how far the approximation is allowed to deviate from the
-/// actual edge.
-///
-/// # Implementation Note
-///
-/// This only works as it is, because edges are severely limited and don't
-/// define which section of the curve they inhabit. Once they do that, we need
-/// an `approximate_between(a, b)` method instead, where `a` and `b` are the
-/// vertices that bound the edge on the curve.
-///
-/// The `approximate_between` methods of the curves then need to make sure to
-/// only return points in between those vertices, not the vertices themselves.
-pub fn approx_curve(
-    curve: &GlobalCurve,
-    tolerance: Tolerance,
-    out: &mut Vec<Local<Point<1>>>,
-) {
-    match curve.kind() {
-        CurveKind::Circle(curve) => approx_circle(curve, tolerance, out),
-        CurveKind::Line(_) => {}
+impl Approx for Curve {
+    type Approximation = Vec<Local<Point<1>>>;
+
+    fn approx(&self, tolerance: Tolerance) -> Self::Approximation {
+        self.global().approx(tolerance)
+    }
+}
+
+impl Approx for GlobalCurve {
+    type Approximation = Vec<Local<Point<1>>>;
+
+    /// Approximate the global curve
+    ///
+    /// # Implementation Note
+    ///
+    /// This only works as-is, because only circles need to be approximated
+    /// right now and because only edges that are full circles are supported, as
+    /// opposed to edges that only inhabit part of the circle.
+    ///
+    /// 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)
+            }
+            CurveKind::Line(_) => {}
+        }
+
+        points
     }
 }
 
-/// Approximate the circle
+/// Approximate a circle
 ///
 /// `tolerance` specifies how much the approximation is allowed to deviate
 /// from the circle.
@@ -69,7 +79,7 @@ fn number_of_vertices_for_circle(tolerance: Tolerance, radius: Scalar) -> u64 {
 mod tests {
     use fj_math::Scalar;
 
-    use crate::algorithms::Tolerance;
+    use crate::algorithms::approx::Tolerance;
 
     #[test]
     fn number_of_vertices_for_circle() {

crates/fj-kernel/src/algorithms/approx/cycles.rs → crates/fj-kernel/src/algorithms/approx/cycle.rs

@@ -2,27 +2,16 @@ use fj_math::{Point, Segment};
 
 use crate::objects::Cycle;
 
-use super::{curves::approx_curve, edges::approx_edge, Local, Tolerance};
+use super::{Approx, Local, Tolerance};
 
-/// An approximation of a [`Cycle`]
-#[derive(Debug, Eq, PartialEq, Hash)]
-pub struct CycleApprox {
-    /// The points that approximate the cycle
-    pub points: Vec<Local<Point<2>>>,
-}
+impl Approx for Cycle {
+    type Approximation = CycleApprox;
 
-impl CycleApprox {
-    /// Compute the approximation of a cycle
-    ///
-    /// `tolerance` defines how far the approximation is allowed to deviate from
-    /// the actual face.
-    pub fn new(cycle: &Cycle, tolerance: Tolerance) -> Self {
+    fn approx(&self, tolerance: Tolerance) -> Self::Approximation {
         let mut points = Vec::new();
 
-        for edge in cycle.edges() {
-            let mut edge_points = Vec::new();
-            approx_curve(edge.curve().global(), tolerance, &mut edge_points);
-            approx_edge(*edge.vertices(), &mut edge_points);
+        for edge in self.edges() {
+            let edge_points = edge.approx(tolerance);
 
             points.extend(edge_points.into_iter().map(|point| {
                 let local = edge
@@ -37,9 +26,18 @@ impl CycleApprox {
         // could lead to subtly different surface coordinates.
         points.dedup_by(|a, b| a.global_form() == b.global_form());
 
-        Self { points }
+        CycleApprox { points }
     }
+}
 
+/// An approximation of a [`Cycle`]
+#[derive(Debug, Eq, PartialEq, Hash)]
+pub struct CycleApprox {
+    /// The points that approximate the cycle
+    pub points: Vec<Local<Point<2>>>,
+}
+
+impl CycleApprox {
     /// Construct the segments that approximate the cycle
     pub fn segments(&self) -> Vec<Segment<3>> {
         let mut segments = Vec::new();

crates/fj-kernel/src/algorithms/approx/edges.rs → crates/fj-kernel/src/algorithms/approx/edge.rs

@@ -1,8 +1,19 @@
 use fj_math::Point;
 
-use crate::objects::{Vertex, VerticesOfEdge};
+use crate::objects::{Edge, Vertex, VerticesOfEdge};
 
-use super::Local;
+use super::{Approx, Local};
+
+impl Approx for Edge {
+    type Approximation = Vec<Local<Point<1>>>;
+
+    fn approx(&self, tolerance: super::Tolerance) -> Self::Approximation {
+        let mut points = self.curve().approx(tolerance);
+        approx_edge(*self.vertices(), &mut points);
+
+        points
+    }
+}
 
 pub fn approx_edge(
     vertices: VerticesOfEdge<Vertex>,

crates/fj-kernel/src/algorithms/approx/faces.rs → crates/fj-kernel/src/algorithms/approx/face.rs

@@ -4,30 +4,12 @@ use fj_math::Point;
 
 use crate::objects::Face;
 
-use super::{CycleApprox, Local, Tolerance};
+use super::{Approx, CycleApprox, Local, Tolerance};
 
-/// An approximation of a [`Face`]
-#[derive(Debug, Eq, PartialEq)]
-pub struct FaceApprox {
-    /// All points that make up the approximation
-    ///
-    /// These could be actual vertices from the model, points that approximate
-    /// an edge, or points that approximate a face.
-    pub points: HashSet<Local<Point<2>>>,
+impl Approx for Face {
+    type Approximation = FaceApprox;
 
-    /// Approximation of the exterior cycle
-    pub exterior: CycleApprox,
-
-    /// Approximations of the interior cycles
-    pub interiors: HashSet<CycleApprox>,
-}
-
-impl FaceApprox {
-    /// Compute the approximation of a face
-    ///
-    /// `tolerance` defines how far the approximation is allowed to deviate from
-    /// the actual face.
-    pub fn new(face: &Face, tolerance: Tolerance) -> Self {
+    fn approx(&self, tolerance: Tolerance) -> Self::Approximation {
         // Curved faces whose curvature is not fully defined by their edges
         // are not supported yet. For that reason, we can fully ignore `face`'s
         // `surface` field and just pass the edges to `Self::for_edges`.
@@ -45,14 +27,14 @@ impl FaceApprox {
         let mut exteriors = Vec::new();
         let mut interiors = HashSet::new();
 
-        for cycle in face.exteriors() {
-            let cycle = CycleApprox::new(cycle, tolerance);
+        for cycle in self.exteriors() {
+            let cycle = cycle.approx(tolerance);
 
             points.extend(cycle.points.iter().copied());
             exteriors.push(cycle);
         }
-        for cycle in face.interiors() {
-            let cycle = CycleApprox::new(cycle, tolerance);
+        for cycle in self.interiors() {
+            let cycle = cycle.approx(tolerance);
 
             points.extend(cycle.points.iter().copied());
             interiors.insert(cycle);
@@ -70,21 +52,37 @@ impl FaceApprox {
             "Approximation only supports faces with one exterior cycle",
         );
 
-        Self {
+        FaceApprox {
             points,
             exterior,
             interiors,
         }
     }
 }
 
+/// An approximation of a [`Face`]
+#[derive(Debug, Eq, PartialEq)]
+pub struct FaceApprox {
+    /// All points that make up the approximation
+    ///
+    /// These could be actual vertices from the model, points that approximate
+    /// an edge, or points that approximate a face.
+    pub points: HashSet<Local<Point<2>>>,
+
+    /// Approximation of the exterior cycle
+    pub exterior: CycleApprox,
+
+    /// Approximations of the interior cycles
+    pub interiors: HashSet<CycleApprox>,
+}
+
 #[cfg(test)]
 mod tests {
     use fj_math::{Point, Scalar};
     use map_macro::set;
 
     use crate::{
-        algorithms::approx::Local,
+        algorithms::approx::{Approx, Local},
         objects::{Face, Surface},
     };
 
@@ -120,7 +118,7 @@ mod tests {
         let g = Local::new(g, g.to_xyz());
         let h = Local::new(h, h.to_xyz());
 
-        let approx = FaceApprox::new(&face, tolerance);
+        let approx = face.approx(tolerance);
         let expected = FaceApprox {
             points: set![a, b, c, d, e, f, g, h],
             exterior: CycleApprox {

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

@@ -1,13 +1,27 @@
-mod curves;
-mod cycles;
-mod edges;
-mod faces;
+//! Approximation of objects
+
+mod curve;
+mod cycle;
+mod edge;
+mod face;
 mod local;
 mod tolerance;
 
 pub use self::{
-    cycles::CycleApprox,
-    faces::FaceApprox,
+    cycle::CycleApprox,
+    face::FaceApprox,
     local::{Local, LocalForm},
     tolerance::{InvalidTolerance, Tolerance},
 };
+
+/// Approximate an object
+pub trait Approx {
+    /// The approximation of the object
+    type Approximation;
+
+    /// Approximate the object
+    ///
+    /// `tolerance` defines how far the approximation is allowed to deviate from
+    /// the actual object.
+    fn approx(&self, tolerance: Tolerance) -> Self::Approximation;
+}

crates/fj-kernel/src/algorithms/mod.rs

@@ -3,16 +3,15 @@
 //! Algorithmic code is collected in this module, to keep other modules focused
 //! on their respective purpose.
 
-mod approx;
 mod reverse;
 mod transform;
 mod triangulate;
 
+pub mod approx;
 pub mod intersect;
 pub mod sweep;
 
 pub use self::{
-    approx::{CycleApprox, FaceApprox, InvalidTolerance, Tolerance},
     reverse::reverse_face,
     transform::{transform_faces, TransformObject},
     triangulate::triangulate,

crates/fj-kernel/src/algorithms/sweep/edge.rs

@@ -2,7 +2,7 @@ use fj_interop::mesh::Color;
 use fj_math::{Point, Transform, Triangle};
 
 use crate::{
-    algorithms::{CycleApprox, Tolerance},
+    algorithms::approx::{Approx, Tolerance},
     objects::{
         Curve, CurveKind, Cycle, Edge, Face, GlobalCurve, GlobalVertex,
         Surface, Vertex, VerticesOfEdge,
@@ -119,7 +119,7 @@ fn create_continuous_side_face(
     let placeholder = Surface::xy_plane();
 
     let cycle = Cycle::new(placeholder).with_edges([edge]);
-    let approx = CycleApprox::new(&cycle, tolerance);
+    let approx = cycle.approx(tolerance);
 
     let mut quads = Vec::new();
     for segment in approx.segments() {

crates/fj-kernel/src/algorithms/sweep/face.rs

@@ -1,7 +1,7 @@
 use fj_interop::mesh::Color;
 
 use crate::{
-    algorithms::{reverse_face, Tolerance, TransformObject},
+    algorithms::{approx::Tolerance, reverse_face, TransformObject},
     objects::{Face, Shell},
 };
 

crates/fj-kernel/src/algorithms/sweep/mod.rs

@@ -7,7 +7,7 @@ mod sketch;
 use fj_interop::mesh::Color;
 use fj_math::{Scalar, Vector};
 
-use super::Tolerance;
+use super::approx::Tolerance;
 
 /// Sweep an object along a path to create another object
 pub trait Sweep {

crates/fj-kernel/src/algorithms/sweep/sketch.rs

@@ -1,7 +1,7 @@
 use fj_interop::mesh::Color;
 
 use crate::{
-    algorithms::Tolerance,
+    algorithms::approx::Tolerance,
     objects::{Sketch, Solid},
 };
 
@@ -35,7 +35,7 @@ mod tests {
     use fj_math::{Point, Scalar, Vector};
 
     use crate::{
-        algorithms::Tolerance,
+        algorithms::approx::Tolerance,
         iter::ObjectIters,
         objects::{Face, Sketch, Surface},
     };