try1

Author: el-hult

plotters-backend/src/rasterizer/path.rs

@@ -34,13 +34,7 @@ fn compute_polygon_vertex(triple: &[BackendCoord; 3], d: f64, buf: &mut Vec<Back
         f64::from(triple[1].1) + d * b_n.1,
     );
 
-    // Check if 3 points are colinear. If so, just emit the point.
-    if a_t.1 * b_t.0 == a_t.0 * b_t.1 {
-        buf.push((a_p.0 as i32, a_p.1 as i32));
-        return;
-    }
-
-    // So we are actually computing the intersection of two lines:
+    // We want to compute the intersection of two lines:
     // a_p + u * a_t and b_p + v * b_t.
     // We can solve the following vector equation:
     // u * a_t + a_p = v * b_t + b_p
@@ -61,30 +55,34 @@ fn compute_polygon_vertex(triple: &[BackendCoord; 3], d: f64, buf: &mut Vec<Back
     let b1 = -b_t.1;
     let c1 = b_p.1 - a_p.1;
 
-    let mut x = f64::INFINITY;
-    let mut y = f64::INFINITY;
-
-    // Well if the determinant is not 0, then we can actually get a intersection point.
-    if (a0 * b1 - a1 * b0).abs() > f64::EPSILON {
-        let u = (c0 * b1 - c1 * b0) / (a0 * b1 - a1 * b0);
-
-        x = a_p.0 + u * a_t.0;
-        y = a_p.1 + u * a_t.1;
+    // If the determinant is 0, then we cannot actuall get a intersection point.
+    // n that case, the two lines are parallel and we just emit the point a_p \approx b_p
+    if ( a0 * b1 - a1 * b0).abs() <= f64::EPSILON {
+        buf.push((a_p.0 as i32, a_p.1 as i32));
+        return;
     }
-
-    let cross_product = a_t.0 * b_t.1 - a_t.1 * b_t.0;
-    if (cross_product < 0.0 && d < 0.0) || (cross_product > 0.0 && d > 0.0) {
-        // Then we are at the outer side of the angle, so we need to consider a cap.
-        let dist_square = (x - triple[1].0 as f64).powi(2) + (y - triple[1].1 as f64).powi(2);
-        // If the point is too far away from the line, we need to cap it.
-        if dist_square > d * d * 16.0 {
-            buf.push((a_p.0.round() as i32, a_p.1.round() as i32));
-            buf.push((b_p.0.round() as i32, b_p.1.round() as i32));
-            return;
+    else{
+        let u = (c0 * b1 - c1 * b0) / (a0 * b1 - a1 * b0);
+        let x = a_p.0 + u * a_t.0;
+        let y = a_p.1 + u * a_t.1;
+        
+        let cross_product = a_t.0 * b_t.1 - a_t.1 * b_t.0;
+        if (cross_product < 0.0 && d < 0.0) || (cross_product > 0.0 && d > 0.0) {
+            // Then we are at the outter side of the angle, so we need to consider a cap.
+            let dist_square = (x - triple[1].0 as f64).powi(2) + (y - triple[1].1 as f64).powi(2);
+            // If the point is too far away from the line, we need to cap it.
+            if dist_square > d * d * 16.0 {
+                buf.push((a_p.0.round() as i32, a_p.1.round() as i32));
+                buf.push((b_p.0.round() as i32, b_p.1.round() as i32));
+                return;
+            }
+        } else {
+            // We are at the inner side of the angle, so we just emit the point.
+            buf.push((x.round() as i32, y.round() as i32));
         }
     }
 
-    buf.push((x.round() as i32, y.round() as i32));
+
 }
 
 fn traverse_vertices<'a>(