Add CurveFaceIntersections

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

@@ -3,95 +3,120 @@ use parry2d_f64::query::{Ray, RayCast};
 
 use crate::objects::{Curve, Face};
 
-/// Determine the intersection between a [`Curve`] and a [`Face`]
-///
-/// Returns a list of intersections in curve coordinates.
-pub fn curve_face(curve: &Curve<2>, face: &Face) -> Vec<[Scalar; 2]> {
- 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().collect();
- edges
- })
- .map(|edge| {
- let line = match edge.curve.local() {
- Curve::Line(line) => line,
- _ => todo!("Curve-face intersection only supports polygons"),
- };
+/// The intersections between a [`Curve`] and a [`Face`], in curve coordinates
+#[derive(Clone, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
+pub struct CurveFaceIntersections(Vec<[Scalar; 2]>);
+
+impl CurveFaceIntersections {
+ /// Create a new instance from the intersection intervals
+ ///
+ /// This method is useful for test code.
+ pub fn from_intervals(
+ intervals: impl IntoIterator<Item = [impl Into<Scalar>; 2]>,
+ ) -> Self {
+ let intervals = intervals
+ .into_iter()
+ .map(|interval| interval.map(Into::into))
+ .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 vertices = match edge.vertices() {
- Some(vertices) => vertices,
- None => todo!(
- "Curve-face intersection does not support faces with \
+ let face_as_polygon = face
+ .exteriors()
+ .chain(face.interiors())
+ .flat_map(|cycle| {
+ let edges: Vec<_> = cycle.edges().collect();
+ edges
+ })
+ .map(|edge| {
+ let line = match edge.curve.local() {
+ Curve::Line(line) => line,
+ _ => {
+ todo!("Curve-face intersection only supports polygons")
+ }
+ };
+
+ let vertices = match edge.vertices() {
+ Some(vertices) => vertices,
+ None => todo!(
+ "Curve-face intersection does not support faces with \
  continuous edges"
- ),
- };
+  ),
+  };
 
- (line, vertices)
- });
+  (line, vertices)
+  });
 
- let mut intersections = Vec::new();
+  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);
+ 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 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));
+ 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));
+ }
  }
- }
 
- assert!(intersections.len() % 2 == 0);
+ assert!(intersections.len() % 2 == 0);
+
+ intersections.sort();
 
- intersections.sort();
+ // Can be cleaned up, once `array_chunks` is stable:
+ // https://doc.rust-lang.org/std/primitive.slice.html#method.array_chunks
+ let intersections = intersections
+ .chunks(2)
+ .map(|chunk| {
+ // Can't panic, as we passed `2` to `windows`.
+ [chunk[0], chunk[1]]
+ })
+ .collect();
 
- // Can be cleaned up, once `array_chunks` is stable:
- // https://doc.rust-lang.org/std/primitive.slice.html#method.array_chunks
- intersections
- .chunks(2)
- .map(|chunk| {
- // Can't panic, as we passed `2` to `windows`.
- [chunk[0], chunk[1]]
- })
- .collect()
+ CurveFaceIntersections(intersections)
+ }
 }
 
 #[cfg(test)]
 mod tests {
- use fj_math::{Line, Point, Scalar, Vector};
+ use fj_math::{Line, Point, Vector};
 
  use crate::objects::{Curve, Face, Surface};
 
+ use super::CurveFaceIntersections;
+
  #[test]
- fn curve_face() {
+ fn compute() {
  let curve = Curve::Line(Line {
  origin: Point::from([-3., 0.]),
  direction: Vector::from([1., 0.]),
@@ -117,10 +142,8 @@ mod tests {
  .with_interior_polygon(interior)
  .build();
 
- let expected: Vec<_> = [[1., 2.], [4., 5.]]
- .into_iter()
- .map(|interval: [f64; 2]| interval.map(Scalar::from))
- .collect();
- assert_eq!(super::curve_face(&curve, &face), expected);
+ let expected =
+ CurveFaceIntersections::from_intervals([[1., 2.], [4., 5.]]);
+ assert_eq!(CurveFaceIntersections::compute(&curve, &face), expected);
  }
 }

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

@@ -5,7 +5,7 @@ mod line_segment;
 mod surface_surface;
 
 pub use self::{
- curve_face::curve_face,
+ curve_face::CurveFaceIntersections,
  line_segment::{line_segment, LineSegmentIntersection},
  surface_surface::surface_surface,
 };