From 4a84bffab3437db347471ab9068e826d7061d241 Mon Sep 17 00:00:00 2001
From: Sergio Pedri <sergio0694@live.com>
Date: Thu, 6 Feb 2020 19:47:36 +0100
Subject: [PATCH] Refactor ConvolutionProcessor<TPixel>

---
 .../ConvolutionProcessor{TPixel}.cs           | 162 +++++++++++-------
 1 file changed, 98 insertions(+), 64 deletions(-)

diff --git a/src/ImageSharp/Processing/Processors/Convolution/ConvolutionProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Convolution/ConvolutionProcessor{TPixel}.cs
index 33b80688ca..95e5107c76 100644
--- a/src/ImageSharp/Processing/Processors/Convolution/ConvolutionProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Convolution/ConvolutionProcessor{TPixel}.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.Memory;
@@ -50,76 +51,109 @@ namespace SixLabors.ImageSharp.Processing.Processors.Convolution
         /// <inheritdoc/>
         protected override void OnFrameApply(ImageFrame<TPixel> source)
         {
-            DenseMatrix<float> matrix = this.KernelXY;
-            bool preserveAlpha = this.PreserveAlpha;
+            using Buffer2D<TPixel> targetPixels = this.Configuration.MemoryAllocator.Allocate2D<TPixel>(source.Size());
+
+            source.CopyTo(targetPixels);
 
             var interest = Rectangle.Intersect(this.SourceRectangle, source.Bounds());
-            int startY = interest.Y;
-            int endY = interest.Bottom;
-            int startX = interest.X;
-            int endX = interest.Right;
-            int maxY = endY - 1;
-            int maxX = endX - 1;
-
-            using (Buffer2D<TPixel> targetPixels = this.Configuration.MemoryAllocator.Allocate2D<TPixel>(source.Size()))
+
+            ParallelRowIterator.IterateRows<RowIntervalAction, Vector4>(
+                interest,
+                this.Configuration,
+                new RowIntervalAction(interest, targetPixels, source.PixelBuffer, this.KernelXY, this.Configuration, this.PreserveAlpha));
+
+            Buffer2D<TPixel>.SwapOrCopyContent(source.PixelBuffer, targetPixels);
+        }
+
+        /// <summary>
+        /// A <see langword="struct"/> implementing the convolution logic for <see cref="ConvolutionProcessor{T}"/>.
+        /// </summary>
+        private readonly struct RowIntervalAction : IRowIntervalAction<Vector4>
+        {
+            private readonly Rectangle bounds;
+            private readonly Buffer2D<TPixel> targetPixels;
+            private readonly Buffer2D<TPixel> sourcePixels;
+            private readonly DenseMatrix<float> kernel;
+            private readonly Configuration configuration;
+            private readonly bool preserveAlpha;
+
+            /// <summary>
+            /// Initializes a new instance of the <see cref="ConvolutionProcessor{TPixel}.RowIntervalAction"/> struct.
+            /// </summary>
+            /// <param name="bounds">The target processing bounds for the current instance.</param>
+            /// <param name="targetPixels">The target pixel buffer to adjust.</param>
+            /// <param name="sourcePixels">The source pixels. Cannot be null.</param>
+            /// <param name="kernel">The kernel operator.</param>
+            /// <param name="configuration">The <see cref="Configuration"/></param>
+            /// <param name="preserveAlpha">Whether the convolution filter is applied to alpha as well as the color channels.</param>
+            [MethodImpl(InliningOptions.ShortMethod)]
+            public RowIntervalAction(
+                Rectangle bounds,
+                Buffer2D<TPixel> targetPixels,
+                Buffer2D<TPixel> sourcePixels,
+                DenseMatrix<float> kernel,
+                Configuration configuration,
+                bool preserveAlpha)
+            {
+                this.bounds = bounds;
+                this.targetPixels = targetPixels;
+                this.sourcePixels = sourcePixels;
+                this.kernel = kernel;
+                this.configuration = configuration;
+                this.preserveAlpha = preserveAlpha;
+            }
+
+            /// <inheritdoc/>
+            [MethodImpl(InliningOptions.ShortMethod)]
+            public void Invoke(in RowInterval rows, Memory<Vector4> memory)
             {
-                source.CopyTo(targetPixels);
+                Span<Vector4> vectorSpan = memory.Span;
+                int length = vectorSpan.Length;
+                ref Vector4 vectorSpanRef = ref MemoryMarshal.GetReference(vectorSpan);
 
-                var workingRectangle = Rectangle.FromLTRB(startX, startY, endX, endY);
-                int width = workingRectangle.Width;
+                int maxY = this.bounds.Bottom - 1;
+                int maxX = this.bounds.Right - 1;
 
-                ParallelRowIterator.IterateRows<Vector4>(
-                    workingRectangle,
-                    this.Configuration,
-                    (rows, vectorBuffer) =>
+                for (int y = rows.Min; y < rows.Max; y++)
+                {
+                    Span<TPixel> targetRowSpan = this.targetPixels.GetRowSpan(y).Slice(this.bounds.X);
+                    PixelOperations<TPixel>.Instance.ToVector4(this.configuration, targetRowSpan.Slice(0, length), vectorSpan);
+
+                    if (this.preserveAlpha)
+                    {
+                        for (int x = 0; x < this.bounds.Width; x++)
+                        {
+                            DenseMatrixUtils.Convolve3(
+                                in this.kernel,
+                                this.sourcePixels,
+                                ref vectorSpanRef,
+                                y,
+                                x,
+                                this.bounds.Y,
+                                maxY,
+                                this.bounds.X,
+                                maxX);
+                        }
+                    }
+                    else
+                    {
+                        for (int x = 0; x < this.bounds.Width; x++)
                         {
-                            Span<Vector4> vectorSpan = vectorBuffer.Span;
-                            int length = vectorSpan.Length;
-                            ref Vector4 vectorSpanRef = ref MemoryMarshal.GetReference(vectorSpan);
-
-                            for (int y = rows.Min; y < rows.Max; y++)
-                            {
-                                Span<TPixel> targetRowSpan = targetPixels.GetRowSpan(y).Slice(startX);
-                                PixelOperations<TPixel>.Instance.ToVector4(this.Configuration, targetRowSpan.Slice(0, length), vectorSpan);
-
-                                if (preserveAlpha)
-                                {
-                                    for (int x = 0; x < width; x++)
-                                    {
-                                        DenseMatrixUtils.Convolve3(
-                                            in matrix,
-                                            source.PixelBuffer,
-                                            ref vectorSpanRef,
-                                            y,
-                                            x,
-                                            startY,
-                                            maxY,
-                                            startX,
-                                            maxX);
-                                    }
-                                }
-                                else
-                                {
-                                    for (int x = 0; x < width; x++)
-                                    {
-                                        DenseMatrixUtils.Convolve4(
-                                            in matrix,
-                                            source.PixelBuffer,
-                                            ref vectorSpanRef,
-                                            y,
-                                            x,
-                                            startY,
-                                            maxY,
-                                            startX,
-                                            maxX);
-                                    }
-                                }
-
-                                PixelOperations<TPixel>.Instance.FromVector4Destructive(this.Configuration, vectorSpan, targetRowSpan);
-                            }
-                        });
-
-                Buffer2D<TPixel>.SwapOrCopyContent(source.PixelBuffer, targetPixels);
+                            DenseMatrixUtils.Convolve4(
+                                in this.kernel,
+                                this.sourcePixels,
+                                ref vectorSpanRef,
+                                y,
+                                x,
+                                this.bounds.Y,
+                                maxY,
+                                this.bounds.X,
+                                maxX);
+                        }
+                    }
+
+                    PixelOperations<TPixel>.Instance.FromVector4Destructive(this.configuration, vectorSpan, targetRowSpan);
+                }
             }
         }
     }