partial revert, making the fix minimal

Author: el-hult

plotters-backend/src/rasterizer/path.rs

@@ -14,23 +14,13 @@ fn get_dir_vector(from: BackendCoord, to: BackendCoord, flag: bool) -> ((f64, f6
     }
 }
 
-/// Consider two line segments between three points: t1-t2-t3
-/// Imagine the line bends to the right, and we run along the line on the right hand side.
-/// In that case, we make an "inside corner" at t2.
-/// This function would compute the point close to t2 that makes the line have thickness `d`
-///
-/// For "outside corners" (the line bends to the left), we sometimes get too pointy corners
-/// if there is just one new point. In that case, we add a cap to make the corner look better.
-/// In that case, the function emits two points.
-///
-/// The function will return values via the `buf` parameter, after clearing it.
-///
-/// d can be negative, this will emit a vertex on the other side of the line.
-///
+// Compute the polygonized vertex of the given angle
+// d is the distance between the polygon edge and the actual line.
+// d can be negative, this will emit a vertex on the other side of the line.
 fn compute_polygon_vertex(triple: &[BackendCoord; 3], d: f64, buf: &mut Vec<BackendCoord>) {
     buf.clear();
 
-    // Compute the tangential and normal vectors of the given straight line.
+    // Compute the tanginal and normal vectors of the given straight line.
     let (a_t, a_n) = get_dir_vector(triple[0], triple[1], false);
     let (b_t, b_n) = get_dir_vector(triple[2], triple[1], true);
 
@@ -44,7 +34,13 @@ fn compute_polygon_vertex(triple: &[BackendCoord; 3], d: f64, buf: &mut Vec<Back
         f64::from(triple[1].1) + d * b_n.1,
     );
 
-    // We want to compute the intersection of two lines:
+    // Check if 3 points are colinear, up to precision. If so, just emit the point.
+    if (a_t.1 * b_t.0 - a_t.0 * b_t.1).abs() <= f64::EPSILON {
+        buf.push((a_p.0 as i32, a_p.1 as i32));
+        return;
+    }
+
+    // So we are actually computing 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
@@ -65,38 +61,24 @@ 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;
 
-    // If the determinant is 0, then we cannot actually get an intersection point.
-    // In that case, the two lines are parallel and we just emit the point a_p, which is
-    // approximately equal to b_p
-    if (a0 * b1 - a1 * b0).abs() <= f64::EPSILON {
-        buf.push((a_p.0 as i32, a_p.1 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;
-        let is_outside_the_angle =
-            (cross_product < 0.0 && d < 0.0) || (cross_product > 0.0 && d > 0.0);
-        if is_outside_the_angle {
-            // 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);
-            let needs_capping = dist_square > d * d * 16.0;
-            if needs_capping {
-                // If the point is too far away from the line, we need to cap it to make it look okay
-                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 outer side of the angle, at an appropriate distance, so we just emit the point.
-                buf.push((x.round() as i32, y.round() as i32));
-            }
-        } 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));
+    // Since the points are not collinear, the determinant is not 0, and we can get a intersection point.
+    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 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;
         }
     }
+
+    buf.push((x.round() as i32, y.round() as i32));
 }
 
 fn traverse_vertices<'a>(
@@ -162,11 +144,11 @@ pub fn polygonize(vertices: &[BackendCoord], stroke_width: u32) -> Vec<BackendCo
     ret
 }
 
-
 #[cfg(test)]
 mod test
 {
     use super::*;
+
     /// Test for regression with respect to https://github.com/plotters-rs/plotters/issues/562
     #[test]
     fn test_no_inf_in_compute_polygon_vertex() {
@@ -177,4 +159,15 @@ mod test
         let nani32 = f64::INFINITY as i32;
         assert!(!buf.iter().any(|&v| v.0 == nani32 || v.1 == nani32));
     }
+
+    /// Correct 90 degree turn to the right
+    #[test]
+    fn standard_corner() {
+        let path = [(10, 10), (20, 10), (20, 20)];
+        let mut buf = Vec::new();
+        compute_polygon_vertex(&path, 2.0, buf.as_mut());
+        assert!(!buf.is_empty());
+        let buf2 = vec![(18, 12)];
+        assert_eq!(buf,buf2);
+    }
 }