Curve curve intersection tylers

AUTHORS

@@ -5,3 +5,4 @@
 # of contributors, see the revision history in source control.
 Raph Levien
 Nicolas Silva
+Epilog Laser (Tyler Scott)

Cargo.toml

@@ -15,6 +15,7 @@ features = ["mint", "schemars", "serde"]
 
 [dependencies]
 arrayvec = "0.7.1"
+bitflags = "1.3"
 
 [dependencies.mint]
 version = "0.5.1"

src/common.rs

@@ -109,12 +109,8 @@ pub fn solve_quadratic(c0: f64, c1: f64, c2: f64) -> ArrayVec<f64, 2> {
     let sc1 = c1 * c2.recip();
     if !sc0.is_finite() || !sc1.is_finite() {
         // c2 is zero or very small, treat as linear eqn
-        let root = -c0 / c1;
-        if root.is_finite() {
+        for root in solve_linear(c0, c1) {
             result.push(root);
-        } else if c0 == 0.0 && c1 == 0.0 {
-            // Degenerate case
-            result.push(0.0);
         }
         return result;
     }
@@ -149,6 +145,21 @@ pub fn solve_quadratic(c0: f64, c1: f64, c2: f64) -> ArrayVec<f64, 2> {
     result
 }
 
+/// Find real roots of linear equation.
+///
+/// Return values of x for which c0 + c1 x = 0.
+pub fn solve_linear(c0: f64, c1: f64) -> ArrayVec<[f64; 1]> {
+    let mut result = ArrayVec::new();
+    let root = -c0 / c1;
+    if root.is_finite() {
+        result.push(root);
+    } else if c0 == 0.0 && c1 == 0.0 {
+        // Degenerate case
+        result.push(0.0);
+    }
+    result
+}
+
 /// Solve an arbitrary function for a zero-crossing.
 ///
 /// This uses the [ITP method], as described in the paper

src/cubicbez.rs

@@ -6,11 +6,12 @@ use crate::MAX_EXTREMA;
 use crate::{Line, QuadSpline, Vec2};
 use arrayvec::ArrayVec;
 
-use crate::common::solve_quadratic;
 use crate::common::GAUSS_LEGENDRE_COEFFS_9;
+use crate::common::{solve_quadratic};
 use crate::{
-    Affine, Nearest, ParamCurve, ParamCurveArclen, ParamCurveArea, ParamCurveCurvature,
-    ParamCurveDeriv, ParamCurveExtrema, ParamCurveNearest, PathEl, Point, QuadBez, Rect, Shape,
+    Affine, Nearest, ParamCurve, ParamCurveArclen, ParamCurveArea, ParamCurveBezierClipping,
+    ParamCurveCurvature, ParamCurveDeriv, ParamCurveExtrema, ParamCurveNearest, PathEl, Point,
+    QuadBez, Rect, Shape,
 };
 
 const MAX_SPLINE_SPLIT: usize = 100;
@@ -238,7 +239,9 @@ impl CubicBez {
         })
     }
 
-    fn parameters(&self) -> (Vec2, Vec2, Vec2, Vec2) {
+    /// Get the parameters such that the curve can be represented by the following formula:
+    ///     B(t) = a*t^3 + b*t^2 + c*t + d
+    pub fn parameters(&self) -> (Vec2, Vec2, Vec2, Vec2) {
         let c = (self.p1 - self.p0) * 3.0;
         let b = (self.p2 - self.p1) * 3.0 - c;
         let d = self.p0.to_vec2();
@@ -309,6 +312,13 @@ impl CubicBez {
     pub fn is_nan(&self) -> bool {
         self.p0.is_nan() || self.p1.is_nan() || self.p2.is_nan() || self.p3.is_nan()
     }
+
+    /// Is this cubic Bezier curve a line?
+    #[inline]
+    pub fn is_linear(&self, accuracy: f64) -> bool {
+        self.baseline().nearest(self.p1, accuracy).distance_sq <= accuracy
+            && self.baseline().nearest(self.p2, accuracy).distance_sq <= accuracy
+    }
 }
 
 /// An iterator for cubic beziers.
@@ -598,6 +608,7 @@ mod tests {
         cubics_to_quadratic_splines, Affine, CubicBez, Nearest, ParamCurve, ParamCurveArclen,
         ParamCurveArea, ParamCurveDeriv, ParamCurveExtrema, ParamCurveNearest, Point, QuadBez,
     };
+    use arrayvec::{Array, ArrayVec};
 
     #[test]
     fn cubicbez_deriv() {
@@ -877,4 +888,28 @@ mod tests {
             converted[0].points()[2].distance(Point::new(88639.0 / 90.0, 52584.0 / 90.0)) < 0.0001
         );
     }
+
+    use crate::param_curve::ParamCurveBezierClipping;
+    #[test]
+    fn solve_t_for_xy() {
+        fn verify<T: Array<Item = f64>>(mut roots: ArrayVec<T>, expected: &[f64]) {
+            assert_eq!(expected.len(), roots.len());
+            let epsilon = 1e-6;
+            roots.sort_by(|a, b| a.partial_cmp(b).unwrap());
+
+            for i in 0..expected.len() {
+                assert!((roots[i] - expected[i]).abs() < epsilon);
+            }
+        }
+
+        let curve = CubicBez::new((0.0, 0.0), (0.0, 8.0), (10.0, 8.0), (10.0, 0.0));
+        verify(curve.solve_t_for_x(5.0), &[0.5]);
+        verify(curve.solve_t_for_y(6.0), &[0.5]);
+
+        {
+            let curve = CubicBez::new((0.0, 10.0), (0.0, 10.0), (10.0, 10.0), (10.0, 10.0));
+
+            verify(curve.solve_t_for_y(10.0), &[]);
+        }
+    }
 }