Merge pull request #99 from Voxel8/me/path_gradient_triangle_performance

Improve performance of path gradient brush on triangles.

Author: antonfirsov

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;
@@ -225,19 +230,22 @@ private class PathGradientBrushApplicator<TPixel> : BrushApplicator<TPixel>
             /// <param name="source">The source image.</param>
             /// <param name="edges">Edges of the polygon.</param>
             /// <param name="centerColor">Color at the center of the gradient area to which the other colors converge.</param>
+            /// <param name="hasSpecialCenterColor">Whether the center color is different from a smooth gradient between the edges.</param>
             public PathGradientBrushApplicator(
                 Configuration configuration,
                 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,6 +265,27 @@ public PathGradientBrushApplicator(
                         return this.centerPixel;
                     }
 
+                    if (this.edges.Count == 3 && !this.hasSpecialCenterColor)
+                    {
+                        if (!FindPointOnTriangle(
+                                                      this.edges[0].Start,
+                                                      this.edges[1].Start,
+                                                      this.edges[2].Start,
+                                                      point,
+                                                      out float u,
+                                                      out float v))
+                        {
+                            return this.transparentPixel;
+                        }
+
+                        Vector4 pointColor = ((1 - u - v) * this.edges[0].StartColor) + (u * this.edges[0].EndColor) +
+                                         (v * this.edges[2].StartColor);
+
+                        TPixel px = default;
+                        px.FromScaledVector4(pointColor);
+                        return px;
+                    }
+
                     var direction = Vector2.Normalize(point - this.center);
                     PointF end = point + (PointF)(direction * this.maxDistance);
 
@@ -275,7 +304,9 @@ public PathGradientBrushApplicator(
 
                     var color = Vector4.Lerp(edgeColor, this.centerColor, ratio);
 
-                    return new Color(color).ToPixel<TPixel>();
+                    TPixel pixel = default;
+                    pixel.FromScaledVector4(color);
+                    return pixel;
                 }
             }
 
@@ -301,6 +332,40 @@ public PathGradientBrushApplicator(
 
                 return closest;
             }
+
+            private static bool FindPointOnTriangle(PointF v1, PointF v2, PointF v3, PointF point, out float u, out float v)
+            {
+                Vector2 e1 = v2 - v1;
+                Vector2 e2 = v3 - v2;
+                Vector2 e3 = v1 - v3;
+
+                Vector2 pv1 = point - v1;
+                Vector2 pv2 = point - v2;
+                Vector2 pv3 = point - v3;
+
+                var d1 = Vector3.Cross(new Vector3(e1.X, e1.Y, 0), new Vector3(pv1.X, pv1.Y, 0));
+                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)) == -1 || Math.Sign(Vector3.Dot(d1, d2)) * Math.Sign(Vector3.Dot(d2, d3)) == -1)
+                {
+                    u = 0;
+                    v = 0;
+                    return false;
+                }
+
+                // From Real-Time Collision Detection
+                // https://gamedev.stackexchange.com/questions/23743/whats-the-most-efficient-way-to-find-barycentric-coordinates
+                float d00 = Vector2.Dot(e1, e1);
+                float d01 = -Vector2.Dot(e1, e3);
+                float d11 = Vector2.Dot(e3, e3);
+                float d20 = Vector2.Dot(pv1, e1);
+                float d21 = -Vector2.Dot(pv1, e3);
+                float denominator = (d00 * d11) - (d01 * d01);
+                u = ((d11 * d20) - (d01 * d21)) / denominator;
+                v = ((d00 * d21) - (d01 * d20)) / denominator;
+                return true;
+            }
         }
     }
 }

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,54 @@ public void FillTriangleWithDifferentColors<TPixel>(TestImageProvider<TPixel> pr
                 });
         }
 
+        [Theory]
+        [WithBlankImages(20, 20, PixelTypes.HalfSingle)]
+        public void FillTriangleWithGreyscale<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : unmanaged, IPixel<TPixel>
+        {
+            provider.VerifyOperation(
+                ImageComparer.TolerantPercentage(0.02f),
+                image =>
+                {
+                    PointF[] points = { new PointF(10, 0), new PointF(20, 20), new PointF(0, 20) };
+
+                    var c1 = new Rgba32();
+                    var c2 = new Rgba32();
+                    var c3 = new Rgba32();
+                    new HalfSingle(-1).ToRgba32(ref c1);
+                    new HalfSingle(0).ToRgba32(ref c2);
+                    new HalfSingle(1).ToRgba32(ref c3);
+
+                    Color[] colors = { new Color(c1), new Color(c2), new Color(c3)  };
+                    
+                    var brush = new PathGradientBrush(points, colors);
+
+                    image.Mutate(x => x.Fill(brush));
+                    image.DebugSave(provider, appendPixelTypeToFileName: false, appendSourceFileOrDescription: false);
+                });
+        }
+
+
+        [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)