Remove per pixel allocation in PathGradientBrushApplicator

Author: JimBobSquarePants

src/ImageSharp.Drawing/Processing/GradientBrush.cs

@@ -129,6 +129,7 @@ public override void Apply(Span<float> scanline, int x, int y)
                 MemoryAllocator memoryAllocator = this.Configuration.MemoryAllocator;
                 using IMemoryOwner<float> amountBuffer = memoryAllocator.Allocate<float>(scanline.Length);
                 using IMemoryOwner<TPixel> overlay = memoryAllocator.Allocate<TPixel>(scanline.Length);
+
                 Span<float> amountSpan = amountBuffer.Memory.Span;
                 Span<TPixel> overlaySpan = overlay.Memory.Span;
                 float blendPercentage = this.Options.BlendPercentage;

src/ImageSharp.Drawing/Processing/PathGradientBrush.cs

@@ -160,9 +160,17 @@ public Edge(Path path, Color startColor, Color endColor)
 
             public Vector4 EndColor { get; }
 
-            public Intersection? FindIntersection(PointF start, PointF end, Span<PointF> intersections)
+            public Intersection? FindIntersection(
+                PointF start,
+                PointF end,
+                Span<PointF> intersections,
+                Span<PointOrientation> orientations)
             {
-                int pathIntersections = this.Path.FindIntersections(start, end, intersections.Slice(0, this.Path.MaxIntersections));
+                int pathIntersections = this.Path.FindIntersections(
+                    start,
+                    end,
+                    intersections.Slice(0, this.Path.MaxIntersections),
+                    orientations.Slice(0, this.Path.MaxIntersections));
 
                 if (pathIntersections == 0)
                 {
@@ -211,14 +219,14 @@ private class PathGradientBrushApplicator<TPixel> : BrushApplicator<TPixel>
 
             private readonly float maxDistance;
 
+            private readonly int maxIntersections;
+
             private readonly IList<Edge> edges;
 
             private readonly TPixel centerPixel;
 
             private readonly TPixel transparentPixel;
 
-            private readonly int maxIntersections;
-
             /// <summary>
             /// Initializes a new instance of the <see cref="PathGradientBrushApplicator{TPixel}"/> class.
             /// </summary>
@@ -249,7 +257,7 @@ public PathGradientBrushApplicator(
                 this.transparentPixel = Color.Transparent.ToPixel<TPixel>();
             }
 
-            internal TPixel this[int x, int y, Span<PointF> intersections]
+            internal TPixel this[int x, int y, Span<PointF> intersections, Span<PointOrientation> orientations]
             {
                 get
                 {
@@ -285,7 +293,7 @@ public PathGradientBrushApplicator(
                     var direction = Vector2.Normalize(point - this.center);
                     PointF end = point + (PointF)(direction * this.maxDistance);
 
-                    (Edge edge, Intersection? info) = this.FindIntersection(point, end, intersections);
+                    (Edge edge, Intersection? info) = this.FindIntersection(point, end, intersections, orientations);
 
                     if (!info.HasValue)
                     {
@@ -311,12 +319,14 @@ public override void Apply(Span<float> scanline, int x, int y)
             {
                 MemoryAllocator memoryAllocator = this.Configuration.MemoryAllocator;
                 using IMemoryOwner<float> amountBuffer = memoryAllocator.Allocate<float>(scanline.Length);
-                using IMemoryOwner<TPixel> overlay = memoryAllocator.Allocate<TPixel>(scanline.Length);
+                using IMemoryOwner<TPixel> overlayBuffer = memoryAllocator.Allocate<TPixel>(scanline.Length);
                 using IMemoryOwner<PointF> intersectionsBuffer = memoryAllocator.Allocate<PointF>(this.maxIntersections);
+                using IMemoryOwner<PointOrientation> orientationsBuffer = memoryAllocator.Allocate<PointOrientation>(this.maxIntersections);
 
                 Span<float> amountSpan = amountBuffer.Memory.Span;
-                Span<TPixel> overlaySpan = overlay.Memory.Span;
+                Span<TPixel> overlaySpan = overlayBuffer.Memory.Span;
                 Span<PointF> intersectionsSpan = intersectionsBuffer.Memory.Span;
+                Span<PointOrientation> orientationsSpan = orientationsBuffer.Memory.Span;
                 float blendPercentage = this.Options.BlendPercentage;
 
                 // TODO: Remove bounds checks.
@@ -325,29 +335,33 @@ public override void Apply(Span<float> scanline, int x, int y)
                     for (int i = 0; i < scanline.Length; i++)
                     {
                         amountSpan[i] = scanline[i] * blendPercentage;
-                        overlaySpan[i] = this[x + i, y, intersectionsSpan];
+                        overlaySpan[i] = this[x + i, y, intersectionsSpan, orientationsSpan];
                     }
                 }
                 else
                 {
                     for (int i = 0; i < scanline.Length; i++)
                     {
                         amountSpan[i] = scanline[i];
-                        overlaySpan[i] = this[x + i, y, intersectionsSpan];
+                        overlaySpan[i] = this[x + i, y, intersectionsSpan, orientationsSpan];
                     }
                 }
 
                 Span<TPixel> destinationRow = this.Target.GetPixelRowSpan(y).Slice(x, scanline.Length);
                 this.Blender.Blend(this.Configuration, destinationRow, destinationRow, overlaySpan, amountSpan);
             }
 
-            private (Edge edge, Intersection? info) FindIntersection(PointF start, PointF end, Span<PointF> intersections)
+            private (Edge edge, Intersection? info) FindIntersection(
+                PointF start,
+                PointF end,
+                Span<PointF> intersections,
+                Span<PointOrientation> orientations)
             {
                 (Edge edge, Intersection? info) closest = default;
 
                 foreach (Edge edge in this.edges)
                 {
-                    Intersection? intersection = edge.FindIntersection(start, end, intersections);
+                    Intersection? intersection = edge.FindIntersection(start, end, intersections, orientations);
 
                     if (!intersection.HasValue)
                     {

src/ImageSharp.Drawing/Shapes/ComplexPolygon.cs

@@ -120,7 +120,7 @@ public ComplexPolygon(params IPath[] paths)
         public int MaxIntersections { get; }
 
         /// <summary>
-        /// the distance of the point from the outline of the shape, if the value is negative it is inside the polygon bounds
+        /// The distance of the point from the outline of the shape, if the value is negative it is inside the polygon bounds
         /// </summary>
         /// <param name="point">The point.</param>
         /// <returns>
@@ -162,81 +162,43 @@ public PointInfo Distance(PointF point)
             return pointInfo;
         }
 
-        /// <summary>
-        /// Based on a line described by <paramref name="start"/> and <paramref name="end"/>
-        /// populate a buffer for all points on all the polygons, that make up this complex shape,
-        /// that the line intersects.
-        /// </summary>
-        /// <param name="start">The start point of the line.</param>
-        /// <param name="end">The end point of the line.</param>
-        /// <param name="buffer">The buffer that will be populated with intersections.</param>
-        /// <param name="offset">The offset within the buffer</param>
-        /// <returns>
-        /// The number of intersections populated into the buffer.
-        /// </returns>
-        public int FindIntersections(PointF start, PointF end, PointF[] buffer, int offset)
-            => this.FindIntersections(start, end, buffer, offset, IntersectionRule.OddEven);
-
         /// <inheritdoc />
-        public int FindIntersections(PointF start, PointF end, Span<PointF> buffer)
-            => this.FindIntersections(start, end, buffer, IntersectionRule.OddEven);
-
-        /// <summary>
-        /// Based on a line described by <paramref name="start"/> and <paramref name="end"/>
-        /// populate a buffer for all points on all the polygons, that make up this complex shape,
-        /// that the line intersects.
-        /// </summary>
-        /// <param name="start">The start point of the line.</param>
-        /// <param name="end">The end point of the line.</param>
-        /// <param name="buffer">The buffer that will be populated with intersections.</param>
-        /// <param name="offset">The offset within the buffer</param>
-        /// <param name="intersectionRule">The intersection rule to use</param>
-        /// <returns>
-        /// The number of intersections populated into the buffer.
-        /// </returns>
-        public int FindIntersections(PointF start, PointF end, PointF[] buffer, int offset, IntersectionRule intersectionRule)
-        {
-            Span<PointF> subBuffer = buffer.AsSpan(offset);
-            return this.FindIntersections(start, end, subBuffer, intersectionRule);
-        }
+        public int FindIntersections(PointF start, PointF end, Span<PointF> intersections, Span<PointOrientation> orientations)
+            => this.FindIntersections(start, end, intersections, orientations, IntersectionRule.OddEven);
 
         /// <inheritdoc />
-        public int FindIntersections(PointF start, PointF end, Span<PointF> buffer, IntersectionRule intersectionRule)
+        public int FindIntersections(
+            PointF start,
+            PointF end,
+            Span<PointF> intersections,
+            Span<PointOrientation> orientations,
+            IntersectionRule intersectionRule)
         {
             this.EnsureInternalPathsInitalized();
 
             int totalAdded = 0;
-            InternalPath.PointOrientation[] orientations = ArrayPool<InternalPath.PointOrientation>.Shared.Rent(buffer.Length); // the largest number of intersections of any sub path of the set is the max size with need for this buffer.
-            Span<InternalPath.PointOrientation> orientationsSpan = orientations;
-            try
+            foreach (InternalPath ip in this.internalPaths)
             {
-                foreach (var ip in this.internalPaths)
-                {
-                    Span<PointF> subBuffer = buffer.Slice(totalAdded);
-                    Span<InternalPath.PointOrientation> subOrientationsSpan = orientationsSpan.Slice(totalAdded);
+                Span<PointF> subBuffer = intersections.Slice(totalAdded);
+                Span<PointOrientation> subOrientationsSpan = orientations.Slice(totalAdded);
 
-                    var position = ip.FindIntersectionsWithOrientation(start, end, subBuffer, subOrientationsSpan);
-                    totalAdded += position;
-                }
+                int position = ip.FindIntersectionsWithOrientation(start, end, subBuffer, subOrientationsSpan);
+                totalAdded += position;
+            }
 
-                Span<float> distances = stackalloc float[totalAdded];
-                for (int i = 0; i < totalAdded; i++)
-                {
-                    distances[i] = Vector2.DistanceSquared(start, buffer[i]);
-                }
+            Span<float> distances = stackalloc float[totalAdded];
+            for (int i = 0; i < totalAdded; i++)
+            {
+                distances[i] = Vector2.DistanceSquared(start, intersections[i]);
+            }
 
-                var activeBuffer = buffer.Slice(0, totalAdded);
-                var activeOrientationsSpan = orientationsSpan.Slice(0, totalAdded);
-                SortUtility.Sort(distances, activeBuffer, activeOrientationsSpan);
+            Span<PointF> activeIntersections = intersections.Slice(0, totalAdded);
+            Span<PointOrientation> activeOrientations = orientations.Slice(0, totalAdded);
+            SortUtility.Sort(distances, activeIntersections, activeOrientations);
 
-                if (intersectionRule == IntersectionRule.Nonzero)
-                {
-                    totalAdded = InternalPath.ApplyNonZeroIntersectionRules(activeBuffer, activeOrientationsSpan);
-                }
-            }
-            finally
+            if (intersectionRule == IntersectionRule.Nonzero)
             {
-                ArrayPool<InternalPath.PointOrientation>.Shared.Return(orientations);
+                totalAdded = InternalPath.ApplyNonZeroIntersectionRules(activeIntersections, activeOrientations);
             }
 
             return totalAdded;
@@ -252,9 +214,9 @@ private void EnsureInternalPathsInitalized()
                     {
                         this.internalPaths = new List<InternalPath>(this.paths.Length);
 
-                        foreach (var p in this.paths)
+                        foreach (IPath p in this.paths)
                         {
-                            foreach (var s in p.Flatten())
+                            foreach (ISimplePath s in p.Flatten())
                             {
                                 var ip = new InternalPath(s.Points, s.IsClosed);
                                 this.internalPaths.Add(ip);
@@ -361,7 +323,7 @@ public IPath AsClosedPath()
         /// </returns>
         public SegmentInfo PointAlongPath(float distanceAlongPath)
         {
-            distanceAlongPath = distanceAlongPath % this.Length;
+            distanceAlongPath %= this.Length;
 
             foreach (IPath p in this.Paths)
             {

src/ImageSharp.Drawing/Shapes/EllipsePolygon.cs

@@ -8,7 +8,7 @@
 namespace SixLabors.ImageSharp.Drawing
 {
     /// <summary>
-    /// A shape made up of a single path made up of one of more <see cref="ILineSegment"/>s
+    /// An elliptical shape made up of a single path made up of one of more <see cref="ILineSegment"/>s.
     /// </summary>
     public class EllipsePolygon : IPath, ISimplePath, IInternalPathOwner
     {
@@ -110,12 +110,9 @@ public PointInfo Distance(PointF point)
         /// <returns>
         /// A new path with the matrix applied to it.
         /// </returns>
-        public EllipsePolygon Transform(Matrix3x2 matrix)
-        {
-            return matrix.IsIdentity
+        public EllipsePolygon Transform(Matrix3x2 matrix) => matrix.IsIdentity
                 ? this
                 : new EllipsePolygon(this.segment.Transform(matrix));
-        }
 
         /// <summary>
         /// Transforms the path using the specified matrix.
@@ -133,7 +130,7 @@ public EllipsePolygon Transform(Matrix3x2 matrix)
         IPath IPath.AsClosedPath() => this;
 
         /// <summary>
-        /// Converts the <see cref="IPath" /> into a simple linear path..
+        /// Converts the <see cref="IPath" /> into a simple linear path.
         /// </summary>
         /// <returns>
         /// Returns the current <see cref="IPath" /> as simple linear path.
@@ -144,30 +141,17 @@ public IEnumerable<ISimplePath> Flatten()
         }
 
         /// <inheritdoc/>
-        int IPath.FindIntersections(PointF start, PointF end, PointF[] buffer, int offset, IntersectionRule intersectionRule)
-        {
-            Span<PointF> subBuffer = buffer.AsSpan(offset);
-            return this.innerPath.FindIntersections(start, end, subBuffer, intersectionRule);
-        }
-
-        /// <inheritdoc/>
-        int IPath.FindIntersections(PointF start, PointF end, Span<PointF> buffer, IntersectionRule intersectionRule)
-        {
-            return this.innerPath.FindIntersections(start, end, buffer, intersectionRule);
-        }
+        int IPath.FindIntersections(PointF start, PointF end, Span<PointF> intersections, Span<PointOrientation> orientations)
+            => this.innerPath.FindIntersections(start, end, intersections, orientations, IntersectionRule.OddEven);
 
         /// <inheritdoc/>
-        int IPath.FindIntersections(PointF start, PointF end, PointF[] buffer, int offset)
-        {
-            Span<PointF> subBuffer = buffer.AsSpan(offset);
-            return this.innerPath.FindIntersections(start, end, subBuffer, IntersectionRule.OddEven);
-        }
-
-        /// <inheritdoc/>
-        int IPath.FindIntersections(PointF start, PointF end, Span<PointF> buffer)
-        {
-            return this.innerPath.FindIntersections(start, end, buffer, IntersectionRule.OddEven);
-        }
+        int IPath.FindIntersections(
+            PointF start,
+            PointF end,
+            Span<PointF> intersections,
+            Span<PointOrientation> orientations,
+            IntersectionRule intersectionRule)
+            => this.innerPath.FindIntersections(start, end, intersections, orientations, intersectionRule);
 
         /// <summary>
         /// Determines whether the <see cref="IPath" /> contains the specified point
@@ -176,17 +160,13 @@ int IPath.FindIntersections(PointF start, PointF end, Span<PointF> buffer)
         /// <returns>
         ///   <c>true</c> if the <see cref="IPath" /> contains the specified point; otherwise, <c>false</c>.
         /// </returns>
-        public bool Contains(PointF point)
-        {
-            return this.innerPath.PointInPolygon(point);
-        }
+        public bool Contains(PointF point) => this.innerPath.PointInPolygon(point);
 
         /// <inheritdoc />
-        public SegmentInfo PointAlongPath(float distanceAlongPath)
-        {
-            // TODO switch this out to a calculated algorithum
-            return this.innerPath.PointAlongPath(distanceAlongPath);
-        }
+        public SegmentInfo PointAlongPath(float distanceAlongPath) =>
+
+            // TODO switch this out to a calculated algorithm
+            this.innerPath.PointAlongPath(distanceAlongPath);
 
         private static CubicBezierLineSegment CreateSegment(Vector2 location, SizeF size)
         {