Make raycasting code more extensible

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

@@ -0,0 +1,37 @@
+//! Ray casting
+
+mod segment;
+
+pub use self::segment::RaySegmentHit;
+
+use fj_math::Point;
+
+/// Implemented by types that support ray casting
+pub trait CastRay<const D: usize> {
+ /// The type that describes a hit of the ray on the implementing type
+ type Hit;
+
+ /// Cast a ray against `self`
+ fn cast_ray(&self, ray: HorizontalRayToTheRight<D>) -> Option<Self::Hit>;
+}
+
+/// A horizontal ray that goes to the right
+///
+/// For in-kernel use, we don't need anything more flexible, and being exactly
+/// horizontal simplifies some calculations.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct HorizontalRayToTheRight<const D: usize> {
+ /// The point where the ray originates
+ pub origin: Point<D>,
+}
+
+impl<P, const D: usize> From<P> for HorizontalRayToTheRight<D>
+where
+ P: Into<Point<D>>,
+{
+ fn from(point: P) -> Self {
+ Self {
+ origin: point.into(),
+ }
+ }
+}

crates/fj-kernel/src/algorithms/ray_cast.rs → crates/fj-kernel/src/algorithms/cast_ray/segment.rs

@@ -1,39 +1,31 @@
-//! Ray casting
+use fj_math::Segment;
 
-use fj_math::{Point, Segment};
+use super::{CastRay, HorizontalRayToTheRight};
 
-/// A horizontal ray that goes to the right
-///
-/// For in-kernel use, we don't need anything more flexible, and being exactly
-/// horizontal simplifies some calculations.
-pub struct HorizontalRayToTheRight<const D: usize> {
- /// The point where the ray originates
- pub origin: Point<D>,
-}
+impl CastRay<2> for Segment<2> {
+ type Hit = RaySegmentHit;
 
-impl HorizontalRayToTheRight<2> {
- /// Determine whether the ray hits the given line segment
- pub fn hits_segment(
+ fn cast_ray(
  &self,
- segment: impl Into<Segment<2>>,
+ ray: HorizontalRayToTheRight<2>,
  ) -> Option<RaySegmentHit> {
- let [a, b] = segment.into().points();
+ let [a, b] = self.points();
  let [lower, upper] = if a.v <= b.v { [a, b] } else { [b, a] };
  let right = if a.u > b.u { a } else { b };
 
- if self.origin.v > upper.v {
+ if ray.origin.v > upper.v {
  // ray is above segment
  return None;
  }
- if self.origin.v < lower.v {
+ if ray.origin.v < lower.v {
  // ray is below segment
  return None;
  }
 
- if self.origin.v == lower.v && lower.v == upper.v {
+ if ray.origin.v == lower.v && lower.v == upper.v {
  // ray and segment are parallel and at same height
 
- if self.origin.u > right.u {
+ if ray.origin.u > right.u {
  return None;
  }
 
@@ -49,17 +41,17 @@ impl HorizontalRayToTheRight<2> {
  y: upper.v,
  };
  let pc = robust::Coord {
- x: self.origin.u,
- y: self.origin.v,
+ x: ray.origin.u,
+ y: ray.origin.v,
  };
 
  if robust::orient2d(pa, pb, pc) >= 0. {
  // ray starts on the line or left of it
 
- if self.origin.v == upper.v {
+ if ray.origin.v == upper.v {
  return Some(RaySegmentHit::UpperVertex);
  }
- if self.origin.v == lower.v {
+ if ray.origin.v == lower.v {
  return Some(RaySegmentHit::LowerVertex);
  }
 
@@ -70,17 +62,6 @@ impl HorizontalRayToTheRight<2> {
  }
 }
 
-impl<P, const D: usize> From<P> for HorizontalRayToTheRight<D>
-where
- P: Into<Point<D>>,
-{
- fn from(point: P) -> Self {
- Self {
- origin: point.into(),
- }
- }
-}
-
 /// A hit between a ray and a line segment
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum RaySegmentHit {
@@ -99,20 +80,24 @@ pub enum RaySegmentHit {
 
 #[cfg(test)]
 mod tests {
+ use fj_math::Segment;
+
+ use crate::algorithms::cast_ray::CastRay;
+
  use super::{HorizontalRayToTheRight, RaySegmentHit};
 
  #[test]
  fn hits_segment_right() {
  let ray = HorizontalRayToTheRight::from([0., 2.]);
 
- let below = [[1., 0.], [1., 1.]];
- let above = [[1., 3.], [1., 4.]];
- let same_level = [[1., 1.], [1., 3.]];
+ let below = Segment::from([[1., 0.], [1., 1.]]);
+ let above = Segment::from([[1., 3.], [1., 4.]]);
+ let same_level = Segment::from([[1., 1.], [1., 3.]]);
 
- assert!(ray.hits_segment(below).is_none());
- assert!(ray.hits_segment(above).is_none());
+ assert!(below.cast_ray(ray).is_none());
+ assert!(above.cast_ray(ray).is_none());
  assert!(matches!(
- ray.hits_segment(same_level),
+ same_level.cast_ray(ray),
  Some(RaySegmentHit::Segment)
  ));
  }
@@ -121,31 +106,31 @@ mod tests {
  fn hits_segment_left() {
  let ray = HorizontalRayToTheRight::from([1., 2.]);
 
- let same_level = [[0., 1.], [0., 3.]];
- assert!(ray.hits_segment(same_level).is_none());
+ let same_level = Segment::from([[0., 1.], [0., 3.]]);
+ assert!(same_level.cast_ray(ray).is_none());
  }
 
  #[test]
  fn hits_segment_overlapping() {
  let ray = HorizontalRayToTheRight::from([1., 1.]);
 
- let no_hit = [[0., 0.], [2., 3.]];
+ let no_hit = Segment::from([[0., 0.], [2., 3.]]);
 
- let hit_segment = [[0., 0.], [3., 2.]];
- let hit_upper = [[0., 0.], [2., 1.]];
- let hit_lower = [[0., 2.], [2., 1.]];
+ let hit_segment = Segment::from([[0., 0.], [3., 2.]]);
+ let hit_upper = Segment::from([[0., 0.], [2., 1.]]);
+ let hit_lower = Segment::from([[0., 2.], [2., 1.]]);
 
- assert!(ray.hits_segment(no_hit).is_none());
+ assert!(no_hit.cast_ray(ray).is_none());
  assert!(matches!(
- ray.hits_segment(hit_segment),
+ hit_segment.cast_ray(ray),
  Some(RaySegmentHit::Segment)
  ));
  assert!(matches!(
- ray.hits_segment(hit_upper),
+ hit_upper.cast_ray(ray),
  Some(RaySegmentHit::UpperVertex),
  ));
  assert!(matches!(
- ray.hits_segment(hit_lower),
+ hit_lower.cast_ray(ray),
  Some(RaySegmentHit::LowerVertex),
  ));
  }
@@ -154,20 +139,20 @@ mod tests {
  fn hits_segment_on_segment() {
  let ray = HorizontalRayToTheRight::from([1., 1.]);
 
- let hit_segment = [[0., 0.], [2., 2.]];
- let hit_upper = [[0., 0.], [1., 1.]];
- let hit_lower = [[1., 1.], [2., 2.]];
+ let hit_segment = Segment::from([[0., 0.], [2., 2.]]);
+ let hit_upper = Segment::from([[0., 0.], [1., 1.]]);
+ let hit_lower = Segment::from([[1., 1.], [2., 2.]]);
 
  assert!(matches!(
- ray.hits_segment(hit_segment),
+ hit_segment.cast_ray(ray),
  Some(RaySegmentHit::Segment)
  ));
  assert!(matches!(
- ray.hits_segment(hit_upper),
+ hit_upper.cast_ray(ray),
  Some(RaySegmentHit::UpperVertex),
  ));
  assert!(matches!(
- ray.hits_segment(hit_lower),
+ hit_lower.cast_ray(ray),
  Some(RaySegmentHit::LowerVertex),
  ));
  }
@@ -176,18 +161,15 @@ mod tests {
  fn hits_segment_parallel() {
  let ray = HorizontalRayToTheRight::from([2., 0.]);
 
- let left = [[0., 0.], [1., 0.]];
- let overlapping = [[1., 0.], [3., 0.]];
- let right = [[3., 0.], [4., 0.]];
+ let left = Segment::from([[0., 0.], [1., 0.]]);
+ let overlapping = Segment::from([[1., 0.], [3., 0.]]);
+ let right = Segment::from([[3., 0.], [4., 0.]]);
 
- assert!(ray.hits_segment(left).is_none());
- assert!(matches!(
- ray.hits_segment(overlapping),
- Some(RaySegmentHit::Parallel)
- ));
+ assert!(left.cast_ray(ray).is_none());
  assert!(matches!(
- ray.hits_segment(right),
+ overlapping.cast_ray(ray),
  Some(RaySegmentHit::Parallel)
  ));
+ assert!(matches!(right.cast_ray(ray), Some(RaySegmentHit::Parallel)));
  }
 }

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

@@ -9,8 +9,8 @@ mod sweep;
 mod transform;
 mod triangulate;
 
+pub mod cast_ray;
 pub mod intersection;
-pub mod ray_cast;
 
 pub use self::{
  approx::{CycleApprox, FaceApprox, InvalidTolerance, Tolerance},

crates/fj-kernel/src/algorithms/triangulate/polygon.rs

@@ -2,7 +2,7 @@ use fj_interop::debug::{DebugInfo, TriangleEdgeCheck};
 use fj_math::{Point, PolyChain, Segment};
 
 use crate::{
- algorithms::ray_cast::{HorizontalRayToTheRight, RaySegmentHit},
+ algorithms::cast_ray::{CastRay, HorizontalRayToTheRight, RaySegmentHit},
  objects::Surface,
 };
 
@@ -154,13 +154,11 @@ impl Polygon {
  // first segment. The logic in the loop properly takes care of that,
  // as long as we initialize the `previous_hit` variable with the
  // result of the last segment.
- let mut previous_hit = edges
- .last()
- .copied()
- .and_then(|edge| ray.hits_segment(edge));
+ let mut previous_hit =
+ edges.last().copied().and_then(|edge| edge.cast_ray(ray));
 
  for edge in edges {
- let hit = ray.hits_segment(edge);
+ let hit = edge.cast_ray(ray);
 
  let count_hit = match (hit, previous_hit) {
  (Some(RaySegmentHit::Segment), _) => {