add robustness to intersection code + PathGradientBrush bencmharks

Author: antonfirsov

src/ImageSharp.Drawing/Utilities/Intersect.cs

@@ -5,17 +5,28 @@ namespace SixLabors.ImageSharp.Drawing.Utilities
 {
     internal static class Intersect
     {
-        public static bool LineSegmentToLineSegment(PointF a0, PointF a1, PointF b0, PointF b1, ref PointF intersectionPoint)
+        private const float Eps = 1e-3f;
+        private const float MinusEps = -Eps;
+        private const float OnePlusEps = 1 + Eps;
+
+        public static bool LineSegmentToLineSegmentIgnoreCollinear(PointF a0, PointF a1, PointF b0, PointF b1, ref PointF intersectionPoint)
         {
             float dax = a1.X - a0.X;
             float day = a1.Y - a0.Y;
             float dbx = b1.X - b0.X;
             float dby = b1.Y - b0.Y;
 
-            float s = ((-day * (a0.X - b0.X)) + (dax * (a0.Y - b0.Y))) / ((-dbx * day) + (dax * dby));
-            float t = ((dbx * (a0.Y - b0.Y)) - (dby * (a0.X - b0.X))) / ((-dbx * day) + (dax * dby));
+            float crossD = (-dbx * day) + (dax * dby);
+
+            if (crossD > MinusEps && crossD < Eps)
+            {
+                return false;
+            }
+
+            float s = ((-day * (a0.X - b0.X)) + (dax * (a0.Y - b0.Y))) / crossD;
+            float t = ((dbx * (a0.Y - b0.Y)) - (dby * (a0.X - b0.X))) / crossD;
 
-            if (s >= 0 && s <= 1 && t >= 0 && t <= 1)
+            if (s > MinusEps && s < OnePlusEps && t > MinusEps && t < OnePlusEps)
             {
                 intersectionPoint.X = a0.X + (t * dax);
                 intersectionPoint.Y = a0.Y + (t * day);

tests/ImageSharp.Drawing.Benchmarks/Drawing/FillPathGradientBrush.cs

@@ -0,0 +1,34 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using BenchmarkDotNet.Attributes;
+using SixLabors.ImageSharp.Drawing.Processing;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing;
+
+namespace SixLabors.ImageSharp.Drawing.Benchmarks
+{
+    public class FillPathGradientBrush
+    {
+        private Image<Rgba32> image;
+
+        [GlobalSetup]
+        public void Setup() => this.image = new Image<Rgba32>(100, 100);
+
+        [GlobalCleanup]
+        public void Cleanup() => this.image.Dispose();
+
+        [Benchmark]
+        public void FillGradientBrush_ImageSharp()
+        {
+            var star = new Star(50, 50, 5, 20, 45);
+            PointF[] points = star.Points.ToArray();
+            Color[] colors = { Color.Red, Color.Yellow, Color.Green, Color.Blue, Color.Purple,
+                Color.Red, Color.Yellow, Color.Green, Color.Blue, Color.Purple };
+
+            var brush = new PathGradientBrush(points, colors, Color.White);
+
+            this.image.Mutate(x => x.Fill(brush));
+        }
+    }
+}

tests/ImageSharp.Drawing.Tests/TestUtilities/ApproximateFloatComparer.cs

@@ -12,6 +12,7 @@ namespace SixLabors.ImageSharp.Drawing.Tests
     internal readonly struct ApproximateFloatComparer :
         IEqualityComparer<float>,
         IEqualityComparer<Vector2>,
+        IEqualityComparer<PointF>,
         IEqualityComparer<Vector4>,
         IEqualityComparer<ColorMatrix>
     {
@@ -35,13 +36,19 @@ public bool Equals(float x, float y)
         public int GetHashCode(float obj) => obj.GetHashCode();
 
         /// <inheritdoc/>
-        public bool Equals(Vector2 x, Vector2 y) => this.Equals(x.X, y.X) && this.Equals(x.Y, y.Y);
+        public bool Equals(Vector2 a, Vector2 b) => this.Equals(a.X, b.X) && this.Equals(a.Y, b.Y);
+
+        /// <inheritdoc/>
+        public bool Equals(PointF a, PointF b) => this.Equals(a.X, b.X) && this.Equals(a.Y, b.Y);
 
         /// <inheritdoc/>
         public int GetHashCode(Vector2 obj) => obj.GetHashCode();
 
         /// <inheritdoc/>
-        public bool Equals(Vector4 x, Vector4 y) => this.Equals(x.X, y.X) && this.Equals(x.Y, y.Y) && this.Equals(x.Z, y.Z) && this.Equals(x.W, y.W);
+        public int GetHashCode(PointF obj) => obj.GetHashCode();
+
+        /// <inheritdoc/>
+        public bool Equals(Vector4 a, Vector4 b) => this.Equals(a.X, b.X) && this.Equals(a.Y, b.Y) && this.Equals(a.Z, b.Z) && this.Equals(a.W, b.W);
 
         /// <inheritdoc/>
         public int GetHashCode(Vector4 obj) => obj.GetHashCode();

tests/ImageSharp.Drawing.Tests/Utilities/IntersectTests.cs

@@ -8,25 +8,39 @@ namespace SixLabors.ImageSharp.Drawing.Tests.Drawing.Utils
 {
     public class IntersectTests
     {
-        public static TheoryData<PointF, PointF, PointF, PointF, PointF?> LineSegmentToLineSegment_Data =
-            new TheoryData<PointF, PointF, PointF, PointF, PointF?>()
+        public static TheoryData<(float x, float y), (float x, float y), (float x, float y), (float x, float y), (float x, float y)?> LineSegmentToLineSegment_Data =
+            new ()
             {
-                { new PointF(0, 0), new PointF(2, 3), new PointF(1, 3), new PointF(1, 0), new PointF(1, 1.5f) },
-                { new PointF(0, 0), new PointF(2, 3), new PointF(1, 3), new PointF(1, 2), null },
+                { (0, 0), (2, 3), (1, 3), (1, 0), (1, 1.5f) },
+                { (3, 1), (3, 3), (3, 2), (4, 2), (3, 2)},
+                { (1, -3), (3, -1), (3, -4), (2, -2), (2, -2)},
+                { (0, 0), (2, 1), (2, 1.0001f), (5, 2), (2, 1)}, // Robust to inaccuracies
+                { (0, 0), (2, 3), (1, 3), (1, 2), null },
+                { (-3, 3), (-1, 3), (-3, 2), (-1, 2), null},
+                { (-4, 3), (-4, 1), (-5, 3), (-5, 1), null},
+                { (0, 0), (4, 1), (4, 1), (8, 2), null}, // Collinear intersections are ignored
+                { (0, 0), (4, 1), (4, 1.0001f), (8, 2), null}, // Collinear intersections are ignored
             };
 
         [Theory]
         [MemberData(nameof(LineSegmentToLineSegment_Data))]
-        public void LineSegmentToLineSegment(PointF a0, PointF a1, PointF b0, PointF b1, PointF? expected)
+        public void LineSegmentToLineSegmentNoCollinear(
+            (float x, float y) a0,
+            (float x, float y) a1,
+            (float x, float y) b0,
+            (float x, float y) b1,
+            (float x, float y)? expected)
         {
             PointF ip = default;
 
-            bool result = Intersect.LineSegmentToLineSegment(a0, a1, b0, b1, ref ip);
+            bool result = Intersect.LineSegmentToLineSegmentIgnoreCollinear(P(a0), P(a1), P(b0), P(b1), ref ip);
             Assert.Equal(result, expected.HasValue);
             if (expected.HasValue)
             {
-                Assert.Equal(expected.Value, ip);
+                Assert.Equal(P(expected.Value), ip, new ApproximateFloatComparer(1e-3f));
             }
+
+            static PointF P((float x, float y) p) => new PointF(p.x, p.y);
         }
     }
 }