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/bezpath.rs

@@ -1285,6 +1285,7 @@ mod tests {
 
     #[test]
     #[should_panic(expected = "no open subpath")]
+    #[cfg(debug_assertions)] // Only provides proper panic message in debug mode
     fn test_elements_to_segments_starts_on_closepath() {
         let mut path = BezPath::new();
         path.close_path();
@@ -1307,6 +1308,7 @@ mod tests {
 
     #[test]
     #[should_panic(expected = "no open subpath")]
+    #[cfg(debug_assertions)] // Only provides proper panic message in debug mode
     fn test_must_not_start_on_quad() {
         let mut path = BezPath::new();
         path.quad_to((5.0, 5.0), (10.0, 10.0));

src/common.rs

@@ -51,6 +51,8 @@ impl FloatExt<f32> for f32 {
 /// See: <http://mathworld.wolfram.com/CubicFormula.html>
 ///
 /// Return values of x for which c0 + c1 x + c2 x² + c3 x³ = 0.
+///
+/// Note: The input arguments are in increasing exponent order
 pub fn solve_cubic(c0: f64, c1: f64, c2: f64, c3: f64) -> ArrayVec<f64, 3> {
     let mut result = ArrayVec::new();
     let c3_recip = c3.recip();
@@ -103,18 +105,16 @@ pub fn solve_cubic(c0: f64, c1: f64, c2: f64, c3: f64) -> ArrayVec<f64, 3> {
 /// the other root might be out of representable range. In the degenerate
 /// case where all coefficients are zero, so that all values of x satisfy
 /// the equation, a single `0.0` is returned.
+///
+/// Note: The input arguments are in increasing exponent order
 pub fn solve_quadratic(c0: f64, c1: f64, c2: f64) -> ArrayVec<f64, 2> {
     let mut result = ArrayVec::new();
     let sc0 = c0 * c2.recip();
     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 +149,23 @@ 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.
+///
+/// Note: The input arguments are in increasing exponent order
+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, this happens the line is horizontal, hence when c1 == 0.
+        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

@@ -1,13 +1,12 @@
 //! Cubic Bézier segments.
 
+use arrayvec::ArrayVec;
 use std::ops::{Mul, Range};
 
 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, GAUSS_LEGENDRE_COEFFS_9};
 use crate::{
     Affine, Nearest, ParamCurve, ParamCurveArclen, ParamCurveArea, ParamCurveCurvature,
     ParamCurveDeriv, ParamCurveExtrema, ParamCurveNearest, PathEl, Point, QuadBez, Rect, Shape,
@@ -238,7 +237,11 @@ 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
+    ///
+    /// Note: Values returned are in decresing exponent order
+    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();
@@ -310,6 +313,13 @@ impl CubicBez {
         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
+    }
+
     /// Determine the inflection points.
     ///
     /// Return value is t parameter for the inflection points of the curve segment.