Merge pull request #884 from hannobraun/intersection

Implement curve/edge intersection

crates/fj-kernel/src/algorithms/intersection/curve_edge.rs

@@ -0,0 +1,134 @@
+use fj_math::{Point, Segment};
+use parry2d_f64::query::{Ray, RayCast};
+
+use crate::objects::{Curve, Edge};
+
+/// The intersection between a [`Curve`] and an [`Edge`], in curve coordinates
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
+pub struct CurveEdgeIntersection {
+    point_on_curve: Point<1>,
+}
+
+impl CurveEdgeIntersection {
+    /// Construct an instance from a point on a curve
+    pub fn from_point_on_curve(point_on_curve: impl Into<Point<1>>) -> Self {
+        let point_on_curve = point_on_curve.into();
+        Self { point_on_curve }
+    }
+
+    /// Compute the intersection
+    ///
+    /// # Panics
+    ///
+    /// Currently, only intersections between lines and line segments can be
+    /// computed. Panics, if a different type of [`Curve`] or [`Edge`] is
+    /// passed.
+    pub fn compute(curve: &Curve<2>, edge: &Edge) -> Option<Self> {
+        let curve_as_line = match curve {
+            Curve::Line(line) => line,
+            _ => todo!("Curve-edge intersection only supports lines"),
+        };
+
+        let edge_as_segment = {
+            let line = match edge.curve().local_form() {
+                Curve::Line(line) => line,
+                _ => {
+                    todo!("Curve-edge intersection only supports line segments")
+                }
+            };
+
+            let vertices = match edge.vertices().get() {
+                Some(vertices) => vertices.map(|vertex| {
+                    line.point_from_line_coords(vertex.position())
+                }),
+                None => todo!(
+                    "Curve-edge intersection does not support continuous edges"
+                ),
+            };
+
+            Segment::from_points(vertices)
+        };
+
+        let ray = Ray {
+            origin: curve_as_line.origin.to_na(),
+            dir: curve_as_line.direction.to_na(),
+        };
+        let ray_inv = Ray {
+            origin: curve_as_line.origin.to_na(),
+            dir: -curve_as_line.direction.to_na(),
+        };
+
+        let result = edge_as_segment.to_parry().cast_local_ray(
+            &ray,
+            f64::INFINITY,
+            false,
+        );
+        let result_inv = edge_as_segment.to_parry().cast_local_ray(
+            &ray_inv,
+            f64::INFINITY,
+            false,
+        );
+
+        if let Some(result) = result {
+            return Some(Self {
+                point_on_curve: Point::from([result]),
+            });
+        }
+        if let Some(result_inv) = result_inv {
+            return Some(Self {
+                point_on_curve: Point::from([-result_inv]),
+            });
+        }
+
+        None
+    }
+
+    /// Access the intersection point on the curve
+    pub fn point_on_curve(&self) -> Point<1> {
+        self.point_on_curve
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use fj_math::Point;
+
+    use crate::objects::{Curve, Edge, Surface};
+
+    use super::CurveEdgeIntersection;
+
+    #[test]
+    fn compute() {
+        let surface = Surface::xy_plane();
+
+        let curve = Curve::u_axis();
+
+        let edge_left = Edge::build()
+            .line_segment_from_points(&surface, [[-1., -1.], [-1., 1.]]);
+        let edge_right = Edge::build()
+            .line_segment_from_points(&surface, [[1., -1.], [1., 1.]]);
+        let edge_below = Edge::build()
+            .line_segment_from_points(&surface, [[-1., -1.], [1., -1.]]);
+
+        let intersection_with_edge_left =
+            CurveEdgeIntersection::compute(&curve, &edge_left);
+        let intersection_with_edge_right =
+            CurveEdgeIntersection::compute(&curve, &edge_right);
+        let intersection_with_edge_below =
+            CurveEdgeIntersection::compute(&curve, &edge_below);
+
+        assert_eq!(
+            intersection_with_edge_left,
+            Some(CurveEdgeIntersection::from_point_on_curve(Point::from([
+                -1.
+            ])))
+        );
+        assert_eq!(
+            intersection_with_edge_right,
+            Some(CurveEdgeIntersection::from_point_on_curve(Point::from([
+                1.
+            ])))
+        );
+        assert!(intersection_with_edge_below.is_none());
+    }
+}

crates/fj-kernel/src/algorithms/intersection/curve_face.rs

@@ -1,9 +1,11 @@
 use std::vec;
 
-use fj_math::{Scalar, Segment};
-use parry2d_f64::query::{Ray, RayCast};
+use fj_math::Point;
 
-use crate::objects::{Curve, Face};
+use crate::{
+    algorithms::intersection::CurveEdgeIntersection,
+    objects::{Curve, Face},
+};
 
 /// The intersections between a [`Curve`] and a [`Face`], in curve coordinates
 #[derive(Clone, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
@@ -16,80 +18,33 @@ impl CurveFaceIntersectionList {
     ///
     /// This method is useful for test code.
     pub fn from_intervals(
-        intervals: impl IntoIterator<Item = [impl Into<Scalar>; 2]>,
+        intervals: impl IntoIterator<Item = [impl Into<Point<1>>; 2]>,
     ) -> Self {
         let intervals = intervals
             .into_iter()
-            .map(|interval| interval.map(Into::into))
+            .map(|interval| {
+                interval
+                    .map(Into::into)
+                    .map(CurveEdgeIntersection::from_point_on_curve)
+            })
             .collect();
         Self { intervals }
     }
 
     /// Compute the intersections between a [`Curve`] and a [`Face`]
     pub fn compute(curve: &Curve<2>, face: &Face) -> Self {
-        let line = match curve {
-            Curve::Line(line) => line,
-            _ => todo!("Curve-face intersection only supports lines"),
-        };
-
-        let face_as_polygon = face
-            .exteriors()
-            .chain(face.interiors())
-            .flat_map(|cycle| {
-                let edges: Vec<_> = cycle.edges().cloned().collect();
-                edges
-            })
-            .map(|edge| {
-                let line = match edge.curve().local_form() {
-                    Curve::Line(line) => line,
-                    _ => {
-                        todo!("Curve-face intersection only supports polygons")
-                    }
-                };
-
-                let vertices = match edge.vertices().get() {
-                    Some(vertices) => vertices.map(|&vertex| vertex),
-                    None => todo!(
-                        "Curve-face intersection does not support faces with \
-                    continuous edges"
-                    ),
-                };
-
-                (*line, vertices)
-            });
+        let edges = face.all_cycles().flat_map(|cycle| {
+            let edges: Vec<_> = cycle.edges().cloned().collect();
+            edges
+        });
 
         let mut intersections = Vec::new();
 
-        for (edge_line, vertices) in face_as_polygon {
-            let vertices = vertices.map(|vertex| {
-                edge_line.point_from_line_coords(vertex.position())
-            });
-            let segment = Segment::from_points(vertices);
-
-            let ray = Ray {
-                origin: line.origin.to_na(),
-                dir: line.direction.to_na(),
-            };
-            let ray_inv = Ray {
-                origin: line.origin.to_na(),
-                dir: -line.direction.to_na(),
-            };
-
-            let result =
-                segment
-                    .to_parry()
-                    .cast_local_ray(&ray, f64::INFINITY, false);
-            let result_inv = segment.to_parry().cast_local_ray(
-                &ray_inv,
-                f64::INFINITY,
-                false,
-            );
-
-            if let Some(result) = result {
-                intersections.push(Scalar::from(result));
-            }
-            if let Some(result_inv) = result_inv {
-                intersections.push(-Scalar::from(result_inv));
+        for edge in edges {
+            let intersection = CurveEdgeIntersection::compute(curve, &edge);
+
+            if let Some(intersection) = intersection {
+                intersections.push(intersection);
             }
         }
 
@@ -178,7 +133,7 @@ impl IntoIterator for CurveFaceIntersectionList {
 }
 
 /// An intersection between a curve and a face, in curve coordinates
-pub type CurveFaceIntersection = [Scalar; 2];
+pub type CurveFaceIntersection = [CurveEdgeIntersection; 2];
 
 #[cfg(test)]
 mod tests {
@@ -215,77 +170,79 @@ mod tests {
             .polygon_from_points(exterior)
             .with_hole(interior);
 
-        let expected =
-            CurveFaceIntersectionList::from_intervals([[1., 2.], [4., 5.]]);
+        let expected = CurveFaceIntersectionList::from_intervals([
+            [[1.], [2.]],
+            [[4.], [5.]],
+        ]);
         assert_eq!(CurveFaceIntersectionList::compute(&curve, &face), expected);
     }
 
     #[test]
     fn merge() {
         let a = CurveFaceIntersectionList::from_intervals([
-            [0., 1.],   // 1: `a` and `b` are equal
-            [2., 5.],   // 2: `a` contains `b`
-            [7., 8.],   // 3: `b` contains `a`
-            [9., 11.],  // 4: overlap; `a` is left
-            [14., 16.], // 5: overlap; `a` is right
-            [18., 21.], // 6: one of `a` partially overlaps two of `b`
-            [23., 25.], // 7: two of `a` partially overlap one of `b`
-            [26., 28.], // 7
-            [31., 35.], // 8: one of `a` overlaps two of `b`; partial/complete
-            [36., 38.], // 9: two of `a` overlap one of `b`; partial/complete
-            [39., 40.], // 9
-            [41., 45.], // 10: one of `a` overlaps two of `b`; complete/partial
-            [48., 49.], // 11: two of `a` overlap one of `b`; complete/partial
-            [50., 52.], // 11
-            [53., 58.], // 12: one of `a` overlaps two of `b` completely
-            [60., 61.], // 13: one of `b` overlaps two of `a` completely
-            [62., 63.], // 13
-            [65., 66.], // 14: one of `a` with no overlap in `b`
+            [[0.], [1.]],   // 1: `a` and `b` are equal
+            [[2.], [5.]],   // 2: `a` contains `b`
+            [[7.], [8.]],   // 3: `b` contains `a`
+            [[9.], [11.]],  // 4: overlap; `a` is left
+            [[14.], [16.]], // 5: overlap; `a` is right
+            [[18.], [21.]], // 6: one of `a` partially overlaps two of `b`
+            [[23.], [25.]], // 7: two of `a` partially overlap one of `b`
+            [[26.], [28.]], // 7
+            [[31.], [35.]], // 8: partial/complete: one of `a`, two of `b`;
+            [[36.], [38.]], // 9: partial/complete: two of `a`, one of `b`
+            [[39.], [40.]], // 9
+            [[41.], [45.]], // 10: complete/partial: one of `a`, two of `b`
+            [[48.], [49.]], // 11: complete/partial: two of `a`, one of `b`
+            [[50.], [52.]], // 11
+            [[53.], [58.]], // 12: one of `a` overlaps two of `b` completely
+            [[60.], [61.]], // 13: one of `b` overlaps two of `a` completely
+            [[62.], [63.]], // 13
+            [[65.], [66.]], // 14: one of `a` with no overlap in `b`
         ]);
         let b = CurveFaceIntersectionList::from_intervals([
-            [0., 1.],   // 1
-            [3., 4.],   // 2
-            [6., 9.],   // 3
-            [10., 12.], // 4
-            [13., 15.], // 5
-            [17., 19.], // 6
-            [20., 22.], // 6
-            [24., 27.], // 7
-            [30., 32.], // 8
-            [33., 34.], // 8
-            [37., 41.], // 9
-            [42., 43.], // 10
-            [44., 46.], // 10
-            [47., 51.], // 11
-            [54., 55.], // 12
-            [56., 57.], // 12
-            [59., 64.], // 13
+            [[0.], [1.]],   // 1
+            [[3.], [4.]],   // 2
+            [[6.], [9.]],   // 3
+            [[10.], [12.]], // 4
+            [[13.], [15.]], // 5
+            [[17.], [19.]], // 6
+            [[20.], [22.]], // 6
+            [[24.], [27.]], // 7
+            [[30.], [32.]], // 8
+            [[33.], [34.]], // 8
+            [[37.], [41.]], // 9
+            [[42.], [43.]], // 10
+            [[44.], [46.]], // 10
+            [[47.], [51.]], // 11
+            [[54.], [55.]], // 12
+            [[56.], [57.]], // 12
+            [[59.], [64.]], // 13
         ]);
 
         let merged = a.merge(&b);
 
         let expected = CurveFaceIntersectionList::from_intervals([
-            [0., 1.],   // 1
-            [3., 4.],   // 2
-            [7., 8.],   // 3
-            [10., 11.], // 4
-            [14., 15.], // 5
-            [18., 19.], // 6
-            [20., 21.], // 6
-            [24., 25.], // 7
-            [26., 27.], // 7
-            [31., 32.], // 8
-            [33., 34.], // 8
-            [37., 38.], // 9
-            [39., 40.], // 9
-            [42., 43.], // 10
-            [44., 45.], // 10
-            [48., 49.], // 11
-            [50., 51.], // 11
-            [54., 55.], // 12
-            [56., 57.], // 12
-            [60., 61.], // 13
-            [62., 63.], // 13
+            [[0.], [1.]],   // 1
+            [[3.], [4.]],   // 2
+            [[7.], [8.]],   // 3
+            [[10.], [11.]], // 4
+            [[14.], [15.]], // 5
+            [[18.], [19.]], // 6
+            [[20.], [21.]], // 6
+            [[24.], [25.]], // 7
+            [[26.], [27.]], // 7
+            [[31.], [32.]], // 8
+            [[33.], [34.]], // 8
+            [[37.], [38.]], // 9
+            [[39.], [40.]], // 9
+            [[42.], [43.]], // 10
+            [[44.], [45.]], // 10
+            [[48.], [49.]], // 11
+            [[50.], [51.]], // 11
+            [[54.], [55.]], // 12
+            [[56.], [57.]], // 12
+            [[60.], [61.]], // 13
+            [[62.], [63.]], // 13
         ]);
         assert_eq!(merged, expected);
     }