Implemented PolyBool PR 8 velipso/polybooljs#8

Author: Henry00IS

Scripts/ShapeEditor/Decomposition/PolyBoolCS/Epsilon.cs

@@ -30,33 +30,32 @@ public static bool pointAboveOrOnLine(Point pt, Point left, Point right)
             var Cx = pt.x;
             var Cy = pt.y;
 
-            return (Bx - Ax) * (Cy - Ay) - (By - Ay) * (Cx - Ax) >= -eps;
+            var ABx = Bx - Ax;
+            var ABy = By - Ay;
+            var AB = Math.Sqrt(ABx * ABx + ABy * ABy);
+            // algebraic distance of 'pt' to ('left', 'right') line is:
+            // [ABx * (Cy - Ay) - ABy * (Cx - Ax)] / AB
+            return ABx * (Cy - Ay) - ABy * (Cx - Ax) >= -eps * AB;
         }
 
         public static bool pointBetween(Point pt, Point left, Point right)
         {
             // p must be collinear with left->right
             // returns false if p == left, p == right, or left == right
+            if (pointsSame(pt, left) || pointsSame(pt, right)) return false;
             var d_py_ly = pt.y - left.y;
             var d_rx_lx = right.x - left.x;
             var d_px_lx = pt.x - left.x;
             var d_ry_ly = right.y - left.y;
 
             var dot = d_px_lx * d_rx_lx + d_py_ly * d_ry_ly;
 
-            // if `dot` is 0, then `p` == `left` or `left` == `right` (reject)
-            // if `dot` is less than 0, then `p` is to the left of `left` (reject)
-            if (dot < eps)
-                return false;
-
+            // dot < 0 is p is to the left of 'left'
+            if (dot < 0) return false;
             var sqlen = d_rx_lx * d_rx_lx + d_ry_ly * d_ry_ly;
 
-            // if `dot` > `sqlen`, then `p` is to the right of `right` (reject)
-            // therefore, if `dot - sqlen` is greater than 0, then `p` is to the right of `right` (reject)
-            if (dot - sqlen > -eps)
-                return false;
-
-            return true;
+            // dot <= sqlen is p is to the left of 'right'
+            return dot <= sqlen;
         }
 
         public static bool pointsSameX(Point p1, Point p2)
@@ -95,7 +94,18 @@ public static bool pointsCollinear(Point p1, Point p2, Point p3)
             var dx2 = p2.x - p3.x;
             var dy2 = p2.y - p3.y;
 
-            return Math.Abs(dx1 * dy2 - dx2 * dy1) < eps;
+            var n1 = Math.Sqrt(dx1 * dx1 + dy1 * dy1);
+            var n2 = Math.Sqrt(dx2 * dx2 + dy2 * dy2);
+            // Assuming det(u, v) = 0, we have:
+            // |det(u + u_err, v + v_err)| = |det(u + u_err, v + v_err) - det(u,v)|
+            // =|det(u, v_err) + det(u_err. v) + det(u_err, v_err)|
+            // <= |det(u, v_err)| + |det(u_err, v)| + |det(u_err, v_err)|
+            // <= N(u)N(v_err) + N(u_err)N(v) + N(u_err)N(v_err)
+            // <= eps * (N(u) + N(v) + eps)
+            // We have N(u) ~ N(u + u_err) and N(v) ~ N(v + v_err).
+            // Assuming eps << N(u) and eps << N(v), we end with:
+            // |det(u + u_err, v + v_err)| <= eps * (N(u + u_err) + N(v + v_err))
+            return Math.Abs(dx1 * dy2 - dx2 * dy1) <= eps * (n1 + n2);
         }
 
         public static bool linesIntersect(Point a0, Point a1, Point b0, Point b1, out Intersection intersection)
@@ -125,7 +135,9 @@ public static bool linesIntersect(Point a0, Point a1, Point b0, Point b1, out In
             var bdy = b1.y - b0.y;
 
             var axb = adx * bdy - ady * bdx;
-            if (Math.Abs(axb) < eps)
+            var n1 = Math.Sqrt(adx * adx + ady * ady);
+            var n2 = Math.Sqrt(bdx * bdx + bdy * bdy);
+            if (Math.Abs(axb) <= eps * (n1 + n2))
             {
                 intersection = Intersection.Empty;
                 return false; // lines are coincident
@@ -137,39 +149,37 @@ public static bool linesIntersect(Point a0, Point a1, Point b0, Point b1, out In
             var A = (bdx * dy - bdy * dx) / axb;
             var B = (adx * dy - ady * dx) / axb;
 
+            var pt = new Point()
+            {
+                x = a0.x + A * adx,
+                y = a0.y + A * ady
+            };
+
             intersection = new Intersection()
             {
                 alongA = 0,
                 alongB = 0,
-                pt = new Point()
-                {
-                    x = a0.x + A * adx,
-                    y = a0.y + A * ady
-                }
+                pt = pt
             };
 
             // categorize where intersection point is along A and B
 
-            if (A <= -eps)
-                intersection.alongA = -2;
-            else if (A < eps)
+            if (pointsSame(pt, a0))
                 intersection.alongA = -1;
-            else if (A - 1 <= -eps)
-                intersection.alongA = 0;
-            else if (A - 1 < eps)
+            else if (pointsSame(pt, a1))
                 intersection.alongA = 1;
-            else
+            else if (A < 0)
+                intersection.alongA = -2;
+            else if (A > 1)
                 intersection.alongA = 2;
 
-            if (B <= -eps)
-                intersection.alongB = -2;
-            else if (B < eps)
+            if (pointsSame(pt, b0))
                 intersection.alongB = -1;
-            else if (B - 1 <= -eps)
-                intersection.alongB = 0;
-            else if (B - 1 < eps)
+            else if (pointsSame(pt, b1))
                 intersection.alongB = 1;
-            else
+            else if (B < 0)
+                intersection.alongB = -2;
+            else if (B > 1)
                 intersection.alongB = 2;
 
             return true;