Make Triangle::from_points fallible; add Line::is_coincident_with

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

@@ -18,6 +18,7 @@ pub fn triangulate(points: Vec<Local<Point<2>>>) -> Vec<[Local<Point<2>>; 3]> {
  *v1.local_form(),
  *v2.local_form(),
  ])
+ .expect("invalid triangle")
  .winding_direction();
 
  let triangle = match orientation {

crates/fj-math/src/line.rs

@@ -1,4 +1,4 @@
-use crate::{Point, Vector};
+use crate::{Point, Triangle, Vector};
 
 /// An n-dimensional line, defined by an origin and a direction
 ///
@@ -33,6 +33,33 @@ impl<const D: usize> Line<D> {
  }
  }
 
+ /// Determine if this line is coincident with another line
+ ///
+ /// # Implementation Note
+ ///
+ /// This method only returns `true`, if the lines are precisely coincident.
+ /// This will probably not be enough going forward, but it'll do for now.
+ pub fn is_coincident_with(&self, other: &Self) -> bool {
+ let other_origin_is_not_on_self = {
+ let a = other.origin;
+ let b = self.origin;
+ let c = self.origin + self.direction;
+
+ // The triangle is valid only, if the three points are not on the
+ // same line.
+ Triangle::from_points([a, b, c]).is_some()
+ };
+
+ if other_origin_is_not_on_self {
+ return false;
+ }
+
+ let d1 = self.direction.normalize();
+ let d2 = other.direction.normalize();
+
+ d1 == d2 || d1 == -d2
+ }
+
  /// Create a new instance that is reversed
  #[must_use]
  pub fn reverse(mut self) -> Self {
@@ -102,6 +129,19 @@ mod tests {
 
  use super::Line;
 
+ #[test]
+ fn is_coincident_with() {
+ let line = Line::from_points([[0., 0.], [1., 0.]]);
+
+ let a = Line::from_points([[0., 0.], [1., 0.]]);
+ let b = Line::from_points([[0., 0.], [-1., 0.]]);
+ let c = Line::from_points([[0., 1.], [1., 1.]]);
+
+ assert!(line.is_coincident_with(&a));
+ assert!(line.is_coincident_with(&b));
+ assert!(!line.is_coincident_with(&c));
+ }
+
  #[test]
  fn convert_point_to_line_coords() {
  let line = Line {

crates/fj-math/src/triangle.rs

@@ -21,7 +21,7 @@ impl<const D: usize> Triangle<D> {
  /// # Panics
  ///
  /// Panics, if the points don't form a triangle.
- pub fn from_points(points: [impl Into<Point<D>>; 3]) -> Self {
+ pub fn from_points(points: [impl Into<Point<D>>; 3]) -> Option<Self> {
  let points = points.map(Into::into);
 
  let area = {
@@ -31,9 +31,9 @@ impl<const D: usize> Triangle<D> {
 
  // A triangle is not valid if it doesn't span any area
  if area != Scalar::from(0.0) {
- Self { points }
+ Some(Self { points })
  } else {
- panic!("Invalid Triangle specified");
+ None
  }
  }
 
@@ -103,7 +103,7 @@ where
  P: Into<Point<D>>,
 {
  fn from(points: [P; 3]) -> Self {
- Self::from_points(points)
+ Self::from_points(points).expect("invalid triangle")
  }
 }