Merge pull request #282 from SixLabors/js/clipper-upstream-fixes

Clipper upstream fixes

Author: JimBobSquarePants

src/ImageSharp.Drawing/Processing/PathGradientBrush.cs

@@ -349,7 +349,7 @@ protected override void Dispose(bool disposing)
                 Vector2 ip = default;
                 Vector2 closestIntersection = default;
                 Edge closestEdge = null;
-                float minDistance = float.MaxValue;
+                const float minDistance = float.MaxValue;
                 foreach (Edge edge in this.edges)
                 {
                     if (!edge.Intersect(start, end, ref ip))

src/ImageSharp.Drawing/Shapes/PolygonClipper/BoundsF.cs

@@ -52,38 +52,38 @@ public BoundsF(bool isValid)
 
         public float Width
         {
-            get => this.Right - this.Left;
+            readonly get => this.Right - this.Left;
             set => this.Right = this.Left + value;
         }
 
         public float Height
         {
-            get => this.Bottom - this.Top;
+            readonly get => this.Bottom - this.Top;
             set => this.Bottom = this.Top + value;
         }
 
-        public bool IsEmpty()
+        public readonly bool IsEmpty()
             => this.Bottom <= this.Top || this.Right <= this.Left;
 
-        public Vector2 MidPoint()
+        public readonly Vector2 MidPoint()
             => new Vector2(this.Left + this.Right, this.Top + this.Bottom) * .5F;
 
-        public bool Contains(Vector2 pt)
+        public readonly bool Contains(Vector2 pt)
             => pt.X > this.Left
             && pt.X < this.Right
             && pt.Y > this.Top && pt.Y < this.Bottom;
 
-        public bool Contains(BoundsF bounds)
+        public readonly bool Contains(BoundsF bounds)
             => bounds.Left >= this.Left
             && bounds.Right <= this.Right
             && bounds.Top >= this.Top
             && bounds.Bottom <= this.Bottom;
 
-        public bool Intersects(BoundsF bounds)
+        public readonly bool Intersects(BoundsF bounds)
             => (Math.Max(this.Left, bounds.Left) < Math.Min(this.Right, bounds.Right))
             && (Math.Max(this.Top, bounds.Top) < Math.Min(this.Bottom, bounds.Bottom));
 
-        public PathF AsPath()
+        public readonly PathF AsPath()
             => new(4)
             {
                 new Vector2(this.Left, this.Top),

src/ImageSharp.Drawing/Shapes/PolygonClipper/ClipperUtils.cs

@@ -184,17 +184,27 @@ public static bool GetIntersectPoint(Vector2 ln1a, Vector2 ln1b, Vector2 ln2a, V
         {
             Vector2 dxy1 = ln1b - ln1a;
             Vector2 dxy2 = ln2b - ln2a;
-            float cp = CrossProduct(dxy1, dxy2);
-            if (cp == 0F)
+            float det = CrossProduct(dxy1, dxy2);
+            if (det == 0F)
             {
                 ip = default;
                 return false;
             }
 
-            float q1 = CrossProduct(dxy1, ln1a);
-            float q2 = CrossProduct(dxy2, ln2a);
+            float t = (((ln1a.X - ln2a.X) * dxy2.Y) - ((ln1a.Y - ln2a.Y) * dxy2.X)) / det;
+            if (t <= 0F)
+            {
+                ip = ln1a;
+            }
+            else if (t >= 1F)
+            {
+                ip = ln1b;
+            }
+            else
+            {
+                ip = ln1a + (t * dxy1);
+            }
 
-            ip = ((dxy2 * q1) - (dxy1 * q2)) / cp;
             return true;
         }
 

src/ImageSharp.Drawing/Shapes/PolygonClipper/PolygonClipper.cs

@@ -333,13 +333,9 @@ private void ConvertHorzSegsToJoins()
                 for (int j = i + 1; j < k; j++)
                 {
                     HorzSegment hs2 = this.horzSegList[j];
-                    if (hs2.LeftOp.Point.X >= hs1.RightOp.Point.X)
-                    {
-                        break;
-                    }
-
-                    if (hs2.LeftToRight == hs1.LeftToRight ||
-                      (hs2.RightOp.Point.X <= hs1.LeftOp.Point.X))
+                    if ((hs2.LeftOp.Point.X >= hs1.RightOp.Point.X) ||
+                        (hs2.LeftToRight == hs1.LeftToRight) ||
+                        (hs2.RightOp.Point.X <= hs1.LeftOp.Point.X))
                     {
                         continue;
                     }
@@ -674,7 +670,7 @@ private void DoHorizontal(Active horz)
 
             if (IsHotEdge(horz))
             {
-                AddOutPt(horz, horz.Top);
+                this.AddToHorzSegList(AddOutPt(horz, horz.Top));
             }
 
             this.UpdateEdgeIntoAEL(horz); // this is the end of an intermediate horiz.
@@ -929,190 +925,6 @@ private static OutPt DisposeOutPt(OutPt op)
             return result;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static BoundsF GetBounds(OutPt op)
-        {
-            BoundsF result = new(op.Point.X, op.Point.Y, op.Point.X, op.Point.Y);
-            OutPt op2 = op.Next;
-            while (op2 != op)
-            {
-                if (op2.Point.X < result.Left)
-                {
-                    result.Left = op2.Point.X;
-                }
-                else if (op2.Point.X > result.Right)
-                {
-                    result.Right = op2.Point.X;
-                }
-
-                if (op2.Point.Y < result.Top)
-                {
-                    result.Top = op2.Point.Y;
-                }
-                else if (op2.Point.Y > result.Bottom)
-                {
-                    result.Bottom = op2.Point.Y;
-                }
-
-                op2 = op2.Next;
-            }
-
-            return result;
-        }
-
-        private static PointInPolygonResult PointInOpPolygon(Vector2 pt, OutPt op)
-        {
-            if (op == op.Next || op.Prev == op.Next)
-            {
-                return PointInPolygonResult.IsOutside;
-            }
-
-            OutPt op2 = op;
-            do
-            {
-                if (op.Point.Y != pt.Y)
-                {
-                    break;
-                }
-
-                op = op.Next;
-            }
-            while (op != op2);
-
-            // not a proper polygon
-            if (op.Point.Y == pt.Y)
-            {
-                return PointInPolygonResult.IsOutside;
-            }
-
-            // must be above or below to get here
-            bool isAbove = op.Point.Y < pt.Y, startingAbove = isAbove;
-            int val = 0;
-
-            op2 = op.Next;
-            while (op2 != op)
-            {
-                if (isAbove)
-                {
-                    while (op2 != op && op2.Point.Y < pt.Y)
-                    {
-                        op2 = op2.Next;
-                    }
-                }
-                else
-                {
-                    while (op2 != op && op2.Point.Y > pt.Y)
-                    {
-                        op2 = op2.Next;
-                    }
-                }
-
-                if (op2 == op)
-                {
-                    break;
-                }
-
-                // must have touched or crossed the pt.Y horizonal
-                // and this must happen an even number of times
-                // touching the horizontal
-                if (op2.Point.Y == pt.Y)
-                {
-                    if (op2.Point.X == pt.X || (op2.Point.Y == op2.Prev.Point.Y
-                        && (pt.X < op2.Prev.Point.X) != (pt.X < op2.Point.X)))
-                    {
-                        return PointInPolygonResult.IsOn;
-                    }
-
-                    op2 = op2.Next;
-                    if (op2 == op)
-                    {
-                        break;
-                    }
-
-                    continue;
-                }
-
-                if (op2.Point.X <= pt.X || op2.Prev.Point.X <= pt.X)
-                {
-                    if (op2.Prev.Point.X < pt.X && op2.Point.X < pt.X)
-                    {
-                        val = 1 - val; // toggle val
-                    }
-                    else
-                    {
-                        float d = ClipperUtils.CrossProduct(op2.Prev.Point, op2.Point, pt);
-                        if (d == 0)
-                        {
-                            return PointInPolygonResult.IsOn;
-                        }
-
-                        if ((d < 0) == isAbove)
-                        {
-                            val = 1 - val;
-                        }
-                    }
-                }
-
-                isAbove = !isAbove;
-                op2 = op2.Next;
-            }
-
-            if (isAbove != startingAbove)
-            {
-                float d = ClipperUtils.CrossProduct(op2.Prev.Point, op2.Point, pt);
-                if (d == 0)
-                {
-                    return PointInPolygonResult.IsOn;
-                }
-
-                if ((d < 0) == isAbove)
-                {
-                    val = 1 - val;
-                }
-            }
-
-            if (val == 0)
-            {
-                return PointInPolygonResult.IsOutside;
-            }
-            else
-            {
-                return PointInPolygonResult.IsInside;
-            }
-        }
-
-        private static bool Path1InsidePath2(OutPt op1, OutPt op2)
-        {
-            // we need to make some accommodation for rounding errors
-            // so we won't jump if the first vertex is found outside
-            int outside_cnt = 0;
-            OutPt op = op1;
-            do
-            {
-                PointInPolygonResult result = PointInOpPolygon(op.Point, op2);
-                if (result == PointInPolygonResult.IsOutside)
-                {
-                    ++outside_cnt;
-                }
-                else if (result == PointInPolygonResult.IsInside)
-                {
-                    --outside_cnt;
-                }
-
-                op = op.Next;
-            }
-            while (op != op1 && Math.Abs(outside_cnt) < 2);
-
-            if (Math.Abs(outside_cnt) > 1)
-            {
-                return outside_cnt < 0;
-            }
-
-            // since path1's location is still equivocal, check its midpoint
-            Vector2 mp = GetBounds(op).MidPoint();
-            return PointInOpPolygon(mp, op2) == PointInPolygonResult.IsInside;
-        }
-
         private void ProcessHorzJoins()
         {
             foreach (HorzJoin j in this.horzJoinList)
@@ -1127,6 +939,7 @@ private void ProcessHorzJoins()
                 op1b.Prev = op2b;
                 op2b.Next = op1b;
 
+                // 'join' is really a split
                 if (or1 == or2)
                 {
                     or2 = new OutRec
@@ -1215,7 +1028,6 @@ private void DoSplitOp(OutRec outrec, OutPt splitOp)
             OutPt prevOp = splitOp.Prev;
             OutPt nextNextOp = splitOp.Next.Next;
             outrec.Pts = prevOp;
-            OutPt result = prevOp;
 
             ClipperUtils.GetIntersectPoint(
                 prevOp.Point, splitOp.Point, splitOp.Next.Point, nextNextOp.Point, out Vector2 ip);
@@ -1229,11 +1041,6 @@ private void DoSplitOp(OutRec outrec, OutPt splitOp)
                 return;
             }
 
-            // nb: area1 is the path's area *before* splitting, whereas area2 is
-            // the area of the triangle containing splitOp & splitOp.next.
-            // So the only way for these areas to have the same sign is if
-            // the split triangle is larger than the path containing prevOp or
-            // if there's more than one self=intersection.
             float area2 = AreaTriangle(ip, splitOp.Point, splitOp.Next.Point);
             float absArea2 = Math.Abs(area2);
 
@@ -1256,6 +1063,11 @@ private void DoSplitOp(OutRec outrec, OutPt splitOp)
                 prevOp.Next = newOp2;
             }
 
+            // nb: area1 is the path's area *before* splitting, whereas area2 is
+            // the area of the triangle containing splitOp & splitOp.next.
+            // So the only way for these areas to have the same sign is if
+            // the split triangle is larger than the path containing prevOp or
+            // if there's more than one self=intersection.
             if (absArea2 > 1 && (absArea2 > absArea1 || ((area2 > 0) == (area1 > 0))))
             {
                 OutRec newOutRec = this.NewOutRec();
@@ -3312,7 +3124,7 @@ private static bool IsFront(Active ae)
 
         private struct LocMinSorter : IComparer<LocalMinima>
         {
-            public int Compare(LocalMinima locMin1, LocalMinima locMin2)
+            public readonly int Compare(LocalMinima locMin1, LocalMinima locMin2)
                 => locMin2.Vertex.Point.Y.CompareTo(locMin1.Vertex.Point.Y);
         }
 
@@ -3363,7 +3175,7 @@ public IntersectNode(Vector2 pt, Active edge1, Active edge2)
 
         private struct HorzSegSorter : IComparer<HorzSegment>
         {
-            public int Compare(HorzSegment hs1, HorzSegment hs2)
+            public readonly int Compare(HorzSegment hs1, HorzSegment hs2)
             {
                 if (hs1 == null || hs2 == null)
                 {
@@ -3387,7 +3199,7 @@ public int Compare(HorzSegment hs1, HorzSegment hs2)
 
         private struct IntersectListSort : IComparer<IntersectNode>
         {
-            public int Compare(IntersectNode a, IntersectNode b)
+            public readonly int Compare(IntersectNode a, IntersectNode b)
             {
                 if (a.Point.Y == b.Point.Y)
                 {