Use dedicated struct to represent boundaries on curves

crates/fj-core/src/algorithms/approx/edge.rs

@@ -10,12 +10,12 @@ use std::collections::BTreeMap;
 use fj_math::Point;
 
 use crate::{
-    geometry::{GlobalPath, SurfacePath},
+    geometry::{BoundaryOnCurve, GlobalPath, SurfacePath},
     objects::{GlobalEdge, HalfEdge, Surface, Vertex},
     storage::{Handle, ObjectId},
 };
 
-use super::{path::RangeOnPath, Approx, ApproxPoint, Tolerance};
+use super::{Approx, ApproxPoint, Tolerance};
 
 impl Approx for (&HalfEdge, &Surface) {
     type Approximation = HalfEdgeApprox;
@@ -28,9 +28,6 @@ impl Approx for (&HalfEdge, &Surface) {
     ) -> Self::Approximation {
         let (half_edge, surface) = self;
 
-        let boundary = half_edge.boundary();
-        let range = RangeOnPath { boundary };
-
         let position_surface = half_edge.start_position();
         let position_global = match cache.get_position(half_edge.start_vertex())
         {
@@ -87,20 +84,22 @@ impl Approx for (&HalfEdge, &Surface) {
             //
             // Only item 2. is something we can do right here. Item 1. requires
             // a change to the object graph.
-            let cached_approx =
-                cache.get_edge(half_edge.global_form().clone(), range);
+            let cached_approx = cache.get_edge(
+                half_edge.global_form().clone(),
+                half_edge.boundary(),
+            );
             let approx = match cached_approx {
                 Some(approx) => approx,
                 None => {
                     let approx = approx_edge(
                         &half_edge.path(),
                         surface,
-                        range,
+                        half_edge.boundary(),
                         tolerance,
                     );
                     cache.insert_edge(
                         half_edge.global_form().clone(),
-                        range,
+                        half_edge.boundary(),
                         approx,
                     )
                 }
@@ -148,7 +147,7 @@ impl HalfEdgeApprox {
 fn approx_edge(
     path: &SurfacePath,
     surface: &Surface,
-    range: RangeOnPath,
+    boundary: BoundaryOnCurve,
     tolerance: impl Into<Tolerance>,
 ) -> GlobalEdgeApprox {
     // There are different cases of varying complexity. Circles are the hard
@@ -164,7 +163,7 @@ fn approx_edge(
             )
         }
         (SurfacePath::Circle(_), GlobalPath::Line(_)) => {
-            (path, range)
+            (path, boundary)
                 .approx_with_cache(tolerance, &mut ())
                 .into_iter()
                 .map(|(point_curve, point_surface)| {
@@ -192,7 +191,7 @@ fn approx_edge(
         }
         (SurfacePath::Line(line), _) => {
             let range_u =
-                RangeOnPath::from(range.boundary.map(|point_curve| {
+                BoundaryOnCurve::from(boundary.inner.map(|point_curve| {
                     [path.point_from_path_coords(point_curve).u]
                 }));
 
@@ -224,7 +223,7 @@ fn approx_edge(
 /// A cache for results of an approximation
 #[derive(Default)]
 pub struct EdgeCache {
-    edge_approx: BTreeMap<(ObjectId, RangeOnPath), GlobalEdgeApprox>,
+    edge_approx: BTreeMap<(ObjectId, BoundaryOnCurve), GlobalEdgeApprox>,
     vertex_approx: BTreeMap<ObjectId, Point<3>>,
 }
 
@@ -238,15 +237,15 @@ impl EdgeCache {
     pub fn get_edge(
         &self,
         handle: Handle<GlobalEdge>,
-        range: RangeOnPath,
+        boundary: BoundaryOnCurve,
     ) -> Option<GlobalEdgeApprox> {
-        if let Some(approx) = self.edge_approx.get(&(handle.id(), range)) {
+        if let Some(approx) = self.edge_approx.get(&(handle.id(), boundary)) {
             return Some(approx.clone());
         }
         if let Some(approx) =
-            self.edge_approx.get(&(handle.id(), range.reverse()))
+            self.edge_approx.get(&(handle.id(), boundary.reverse()))
         {
-            // If we have a cache entry for the reverse range, we need to use
+            // If we have a cache entry for the reverse boundary, we need to use
             // that too!
             return Some(approx.clone().reverse());
         }
@@ -258,11 +257,11 @@ impl EdgeCache {
     pub fn insert_edge(
         &mut self,
         handle: Handle<GlobalEdge>,
-        range: RangeOnPath,
+        boundary: BoundaryOnCurve,
         approx: GlobalEdgeApprox,
     ) -> GlobalEdgeApprox {
         self.edge_approx
-            .insert((handle.id(), range), approx.clone())
+            .insert((handle.id(), boundary), approx.clone())
             .unwrap_or(approx)
     }
 
@@ -303,8 +302,8 @@ mod tests {
     use pretty_assertions::assert_eq;
 
     use crate::{
-        algorithms::approx::{path::RangeOnPath, Approx, ApproxPoint},
-        geometry::{GlobalPath, SurfaceGeometry},
+        algorithms::approx::{Approx, ApproxPoint},
+        geometry::{BoundaryOnCurve, GlobalPath, SurfaceGeometry},
         objects::{HalfEdge, Surface},
         operations::BuildHalfEdge,
         services::Services,
@@ -346,22 +345,22 @@ mod tests {
         let mut services = Services::new();
 
         let path = GlobalPath::circle_from_radius(1.);
-        let range = RangeOnPath::from([[0.], [TAU]]);
+        let boundary = BoundaryOnCurve::from([[0.], [TAU]]);
 
         let surface = Surface::new(SurfaceGeometry {
             u: path,
             v: [0., 0., 1.].into(),
         });
         let half_edge = HalfEdge::line_segment(
             [[0., 1.], [TAU, 1.]],
-            Some(range.boundary),
+            Some(boundary.inner),
             &mut services,
         );
 
         let tolerance = 1.;
         let approx = (&half_edge, &surface).approx(tolerance);
 
-        let expected_approx = (path, range)
+        let expected_approx = (path, boundary)
             .approx(tolerance)
             .into_iter()
             .map(|(point_local, _)| {
@@ -386,7 +385,7 @@ mod tests {
         let approx = (&half_edge, surface.deref()).approx(tolerance);
 
         let expected_approx =
-            (&half_edge.path(), RangeOnPath::from([[0.], [TAU]]))
+            (&half_edge.path(), BoundaryOnCurve::from([[0.], [TAU]]))
                 .approx(tolerance)
                 .into_iter()
                 .map(|(_, point_surface)| {

crates/fj-core/src/algorithms/approx/path.rs

@@ -32,11 +32,11 @@ use std::iter;
 
 use fj_math::{Circle, Point, Scalar, Sign};
 
-use crate::geometry::{GlobalPath, SurfacePath};
+use crate::geometry::{BoundaryOnCurve, GlobalPath, SurfacePath};
 
 use super::{Approx, Tolerance};
 
-impl Approx for (&SurfacePath, RangeOnPath) {
+impl Approx for (&SurfacePath, BoundaryOnCurve) {
     type Approximation = Vec<(Point<1>, Point<2>)>;
     type Cache = ();
 
@@ -56,7 +56,7 @@ impl Approx for (&SurfacePath, RangeOnPath) {
     }
 }
 
-impl Approx for (GlobalPath, RangeOnPath) {
+impl Approx for (GlobalPath, BoundaryOnCurve) {
     type Approximation = Vec<(Point<1>, Point<3>)>;
     type Cache = ();
 
@@ -76,46 +76,21 @@ impl Approx for (GlobalPath, RangeOnPath) {
     }
 }
 
-/// The range on which a path should be approximated
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd)]
-pub struct RangeOnPath {
-    /// The boundary of the range
-    pub boundary: [Point<1>; 2],
-}
-
-impl RangeOnPath {
-    /// Reverse the direction of the range
-    pub fn reverse(self) -> Self {
-        let [a, b] = self.boundary;
-        Self { boundary: [b, a] }
-    }
-}
-
-impl<T> From<[T; 2]> for RangeOnPath
-where
-    T: Into<Point<1>>,
-{
-    fn from(boundary: [T; 2]) -> Self {
-        let boundary = boundary.map(Into::into);
-        Self { boundary }
-    }
-}
-
 /// Approximate a circle
 ///
 /// `tolerance` specifies how much the approximation is allowed to deviate
 /// from the circle.
 fn approx_circle<const D: usize>(
     circle: &Circle<D>,
-    range: impl Into<RangeOnPath>,
+    boundary: impl Into<BoundaryOnCurve>,
     tolerance: Tolerance,
 ) -> Vec<(Point<1>, Point<D>)> {
-    let range = range.into();
+    let boundary = boundary.into();
 
     let params = PathApproxParams::for_circle(circle, tolerance);
     let mut points = Vec::new();
 
-    for point_curve in params.points(range) {
+    for point_curve in params.points(boundary) {
         let point_global = circle.point_from_circle_coords(point_curve);
         points.push((point_curve, point_global));
     }
@@ -152,11 +127,11 @@ impl PathApproxParams {
 
     pub fn points(
         &self,
-        range: impl Into<RangeOnPath>,
+        boundary: impl Into<BoundaryOnCurve>,
     ) -> impl Iterator<Item = Point<1>> + '_ {
-        let range = range.into();
+        let boundary = boundary.into();
 
-        let [a, b] = range.boundary.map(|point| point.t / self.increment());
+        let [a, b] = boundary.inner.map(|point| point.t / self.increment());
         let direction = (b - a).sign();
         let [min, max] = if a < b { [a, b] } else { [b, a] };
 
@@ -195,7 +170,7 @@ mod tests {
 
     use fj_math::{Circle, Point, Scalar};
 
-    use crate::algorithms::approx::{path::RangeOnPath, Tolerance};
+    use crate::algorithms::approx::{path::BoundaryOnCurve, Tolerance};
 
     use super::PathApproxParams;
 
@@ -245,7 +220,7 @@ mod tests {
         test_path([[TAU - 2.], [0.]], [2., 1.]);
 
         fn test_path(
-            range: impl Into<RangeOnPath>,
+            boundary: impl Into<BoundaryOnCurve>,
             expected_coords: impl IntoIterator<Item = impl Into<Scalar>>,
         ) {
             // Choose radius and tolerance such, that we need 4 vertices to
@@ -257,7 +232,7 @@ mod tests {
             let circle = Circle::from_center_and_radius([0., 0.], radius);
             let params = PathApproxParams::for_circle(&circle, tolerance);
 
-            let points = params.points(range).collect::<Vec<_>>();
+            let points = params.points(boundary).collect::<Vec<_>>();
 
             let expected_points = expected_coords
                 .into_iter()

crates/fj-core/src/algorithms/bounding_volume/edge.rs

@@ -18,7 +18,7 @@ impl super::BoundingVolume<2> for HalfEdge {
                 })
             }
             SurfacePath::Line(_) => {
-                let points = self.boundary().map(|point_curve| {
+                let points = self.boundary().inner.map(|point_curve| {
                     self.path().point_from_path_coords(point_curve)
                 });
 

crates/fj-core/src/algorithms/intersect/curve_edge.rs

@@ -44,6 +44,7 @@ impl CurveEdgeIntersection {
 
             let edge_vertices = half_edge
                 .boundary()
+                .inner
                 .map(|point| edge_path_as_line.point_from_line_coords(point));
 
             Segment::from_points(edge_vertices)

crates/fj-core/src/algorithms/intersect/ray_edge.rs

@@ -26,6 +26,7 @@ impl Intersect for (&HorizontalRayToTheRight<2>, &Handle<HalfEdge>) {
 
         let points = edge
             .boundary()
+            .inner
             .map(|point| line.point_from_line_coords(point));
         let segment = Segment::from_points(points);
 

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

@@ -47,7 +47,7 @@ impl Sweep for (&HalfEdge, &Handle<Vertex>, &Surface, Option<Color>) {
 
         // Let's figure out the surface coordinates of the edge vertices.
         let surface_points = {
-            let [a, b] = edge.boundary();
+            let [a, b] = edge.boundary().inner;
 
             [
                 [a.t, Scalar::ZERO],
@@ -65,7 +65,7 @@ impl Sweep for (&HalfEdge, &Handle<Vertex>, &Surface, Option<Color>) {
 
         // Now, the boundaries of each edge.
         let boundaries = {
-            let [a, b] = edge.boundary();
+            let [a, b] = edge.boundary().inner;
             let [c, d] = [0., 1.].map(|coord| Point::from([coord]));
 
             [[a, b], [c, d], [b, a], [d, c]]

crates/fj-core/src/geometry/boundary.rs

@@ -0,0 +1,26 @@
+use fj_math::Point;
+
+/// A boundary on a curve
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
+pub struct BoundaryOnCurve {
+    /// The raw representation of the boundary
+    pub inner: [Point<1>; 2],
+}
+
+impl BoundaryOnCurve {
+    /// Reverse the direction of the boundary
+    pub fn reverse(self) -> Self {
+        let [a, b] = self.inner;
+        Self { inner: [b, a] }
+    }
+}
+
+impl<T> From<[T; 2]> for BoundaryOnCurve
+where
+    T: Into<Point<1>>,
+{
+    fn from(boundary: [T; 2]) -> Self {
+        let inner = boundary.map(Into::into);
+        Self { inner }
+    }
+}

crates/fj-core/src/geometry/mod.rs

@@ -1,9 +1,11 @@
 //! Types that are tied to objects, but aren't objects themselves
 
+mod boundary;
 mod path;
 mod surface;
 
 pub use self::{
+    boundary::BoundaryOnCurve,
     path::{GlobalPath, SurfacePath},
     surface::SurfaceGeometry,
 };

crates/fj-core/src/objects/kinds/cycle.rs

@@ -82,7 +82,7 @@ impl Cycle {
                 .next()
                 .expect("Invalid cycle: expected at least one half-edge");
 
-            let [a, b] = first.boundary();
+            let [a, b] = first.boundary().inner;
             let edge_direction_positive = a < b;
 
             let circle = match first.path() {