Add special case for a different center color. Fix edge test.

Author: maxvoxel8

src/ImageSharp.Drawing/Processing/PathGradientBrush.cs

@@ -20,14 +20,14 @@ public sealed class PathGradientBrush : IBrush
         private readonly IList<Edge> edges;
 
         private readonly Color centerColor;
+        private readonly bool hasSpecialCenterColor;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="PathGradientBrush"/> class.
         /// </summary>
         /// <param name="points">Points that constitute a polygon that represents the gradient area.</param>
         /// <param name="colors">Array of colors that correspond to each point in the polygon.</param>
-        /// <param name="centerColor">Color at the center of the gradient area to which the other colors converge.</param>
-        public PathGradientBrush(PointF[] points, Color[] colors, Color centerColor)
+        public PathGradientBrush(PointF[] points, Color[] colors)
         {
             if (points == null)
             {
@@ -62,7 +62,7 @@ public PathGradientBrush(PointF[] points, Color[] colors, Color centerColor)
                 lines[i] = new LinearLineSegment(points[i % size], points[(i + 1) % size]);
             }
 
-            this.centerColor = centerColor;
+            this.centerColor = CalculateCenterColor(colors);
 
             Color ColorAt(int index) => colors[index % colors.Length];
 
@@ -75,9 +75,12 @@ public PathGradientBrush(PointF[] points, Color[] colors, Color centerColor)
         /// </summary>
         /// <param name="points">Points that constitute a polygon that represents the gradient area.</param>
         /// <param name="colors">Array of colors that correspond to each point in the polygon.</param>
-        public PathGradientBrush(PointF[] points, Color[] colors)
-            : this(points, colors, CalculateCenterColor(colors))
+        /// <param name="centerColor">Color at the center of the gradient area to which the other colors converge.</param>
+        public PathGradientBrush(PointF[] points, Color[] colors, Color centerColor)
+            : this(points, colors)
         {
+            this.centerColor = centerColor;
+            this.hasSpecialCenterColor = true;
         }
 
         /// <inheritdoc />
@@ -88,7 +91,7 @@ public BrushApplicator<TPixel> CreateApplicator<TPixel>(
             RectangleF region)
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            return new PathGradientBrushApplicator<TPixel>(configuration, options, source, this.edges, this.centerColor);
+            return new PathGradientBrushApplicator<TPixel>(configuration, options, source, this.edges, this.centerColor, this.hasSpecialCenterColor);
         }
 
         private static Color CalculateCenterColor(Color[] colors)
@@ -209,6 +212,8 @@ private class PathGradientBrushApplicator<TPixel> : BrushApplicator<TPixel>
 
             private readonly Vector4 centerColor;
 
+            private readonly bool hasSpecialCenterColor;
+
             private readonly float maxDistance;
 
             private readonly IList<Edge> edges;
@@ -230,14 +235,16 @@ public PathGradientBrushApplicator(
                 GraphicsOptions options,
                 ImageFrame<TPixel> source,
                 IList<Edge> edges,
-                Color centerColor)
+                Color centerColor,
+                bool hasSpecialCenterColor)
                 : base(configuration, options, source)
             {
                 this.edges = edges;
                 PointF[] points = edges.Select(s => s.Start).ToArray();
 
                 this.center = points.Aggregate((p1, p2) => p1 + p2) / edges.Count;
                 this.centerColor = (Vector4)centerColor;
+                this.hasSpecialCenterColor = hasSpecialCenterColor;
                 this.centerPixel = centerColor.ToPixel<TPixel>();
 
                 this.maxDistance = points.Select(p => (Vector2)(p - this.center)).Max(d => d.Length());
@@ -257,7 +264,7 @@ public PathGradientBrushApplicator(
                         return this.centerPixel;
                     }
 
-                    if (this.edges.Count == 3)
+                    if (this.edges.Count == 3 && !this.hasSpecialCenterColor)
                     {
                         if (!FindPointOnTriangle(
                                                       this.edges[0].Start,
@@ -335,7 +342,7 @@ private static bool FindPointOnTriangle(PointF v1, PointF v2, PointF v3, PointF
                 var d2 = Vector3.Cross(new Vector3(e2.X, e2.Y, 0), new Vector3(pv2.X, pv2.Y, 0));
                 var d3 = Vector3.Cross(new Vector3(e3.X, e3.Y, 0), new Vector3(pv3.X, pv3.Y, 0));
 
-                if (Math.Sign(Vector3.Dot(d1, d2)) != Math.Sign(Vector3.Dot(d1, d3)) || Math.Sign(Vector3.Dot(d1, d2)) != Math.Sign(Vector3.Dot(d2, d3)))
+                if (Math.Sign(Vector3.Dot(d1, d2)) * Math.Sign(Vector3.Dot(d1, d3)) == -1 || Math.Sign(Vector3.Dot(d1, d2)) * Math.Sign(Vector3.Dot(d2, d3)) == -1)
                 {
                     u = 0;
                     v = 0;

tests/ImageSharp.Drawing.Tests/Drawing/FillPathGradientBrushTests.cs

@@ -35,15 +35,15 @@ public void FillRectangleWithDifferentColors<TPixel>(TestImageProvider<TPixel> p
         }
 
         [Theory]
-        [WithBlankImages(10, 10, PixelTypes.Rgba32)]
+        [WithBlankImages(20, 20, PixelTypes.Rgba32)]
         public void FillTriangleWithDifferentColors<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             provider.VerifyOperation(
                 TolerantComparer,
                 image =>
                 {
-                    PointF[] points = { new PointF(5, 0), new PointF(10, 10), new PointF(0, 10) };
+                    PointF[] points = { new PointF(10, 0), new PointF(20, 20), new PointF(0, 20) };
                     Color[] colors = { Color.Red, Color.Green, Color.Blue };
 
                     var brush = new PathGradientBrush(points, colors);
@@ -53,6 +53,26 @@ public void FillTriangleWithDifferentColors<TPixel>(TestImageProvider<TPixel> pr
                 });
         }
 
+        [Theory]
+        [WithBlankImages(20, 20, PixelTypes.Rgba32)]
+        public void FillTriangleWithDifferentColorsCenter<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            provider.VerifyOperation(
+                TolerantComparer,
+                image =>
+                {
+                    PointF[] points = { new PointF(10, 0), new PointF(20, 20), new PointF(0, 20) };
+                    Color[] colors = { Color.Red, Color.Green, Color.Blue };
+
+                    var brush = new PathGradientBrush(points, colors, Color.White);
+
+                    image.Mutate(x => x.Fill(brush));
+                    image.DebugSave(provider, appendPixelTypeToFileName: false, appendSourceFileOrDescription: false);
+                });
+        }
+
+
         [Theory]
         [WithBlankImages(10, 10, PixelTypes.Rgba32)]
         public void FillRectangleWithSingleColor<TPixel>(TestImageProvider<TPixel> provider)