Bokeh blur implementation

src/ImageSharp/Common/Helpers/DenseMatrixUtils.cs

@@ -1,9 +1,10 @@
-// Copyright (c) Six Labors and contributors.
+// Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
 using System;
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Primitives;
@@ -247,6 +248,91 @@ public static void Convolve4<TPixel>(
             target = vector;
         }
 
+        /// <summary>
+        /// Computes the sum of vectors in <paramref name="targetRow"/> weighted by the kernel weight values.
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="kernel">The 1D convolution kernel.</param>
+        /// <param name="sourcePixels">The source frame.</param>
+        /// <param name="targetRow">The target row.</param>
+        /// <param name="row">The current row.</param>
+        /// <param name="column">The current column.</param>
+        /// <param name="minRow">The minimum working area row.</param>
+        /// <param name="maxRow">The maximum working area row.</param>
+        /// <param name="minColumn">The minimum working area column.</param>
+        /// <param name="maxColumn">The maximum working area column.</param>
+        public static void Convolve1D<TPixel>(
+            Span<Complex64> kernel,
+            Buffer2D<TPixel> sourcePixels,
+            Span<ComplexVector4> targetRow,
+            int row,
+            int column,
+            int minRow,
+            int maxRow,
+            int minColumn,
+            int maxColumn)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            ComplexVector4 vector = default;
+            int kernelLength = kernel.Length;
+            int radiusY = kernelLength >> 1;
+            int sourceOffsetColumnBase = column + minColumn;
+            ref Complex64 baseRef = ref MemoryMarshal.GetReference(kernel);
+
+            for (int i = 0; i < kernelLength; i++)
+            {
+                int offsetY = (row + i - radiusY).Clamp(minRow, maxRow);
+                int offsetX = sourceOffsetColumnBase.Clamp(minColumn, maxColumn);
+                Span<TPixel> sourceRowSpan = sourcePixels.GetRowSpan(offsetY);
+                var currentColor = sourceRowSpan[offsetX].ToVector4();
+
+                vector.Sum(Unsafe.Add(ref baseRef, i) * currentColor);
+            }
+
+            targetRow[column] = vector;
+        }
+
+        /// <summary>
+        /// Computes the sum of vectors in <paramref name="targetRow"/> weighted by the kernel weight values.
+        /// </summary>
+        /// <param name="kernel">The 1D convolution kernel.</param>
+        /// <param name="sourceValues">The source frame.</param>
+        /// <param name="targetRow">The target row.</param>
+        /// <param name="row">The current row.</param>
+        /// <param name="column">The current column.</param>
+        /// <param name="minRow">The minimum working area row.</param>
+        /// <param name="maxRow">The maximum working area row.</param>
+        /// <param name="minColumn">The minimum working area column.</param>
+        /// <param name="maxColumn">The maximum working area column.</param>
+        public static void Convolve1D(
+            Span<Complex64> kernel,
+            Buffer2D<ComplexVector4> sourceValues,
+            Span<ComplexVector4> targetRow,
+            int row,
+            int column,
+            int minRow,
+            int maxRow,
+            int minColumn,
+            int maxColumn)
+        {
+            ComplexVector4 vector = default;
+            int kernelLength = kernel.Length;
+            int radiusX = kernelLength >> 1;
+            int sourceOffsetColumnBase = column + minColumn;
+
+            int offsetY = row.Clamp(minRow, maxRow);
+            ref ComplexVector4 sourceRef = ref MemoryMarshal.GetReference(sourceValues.GetRowSpan(offsetY));
+            ref Complex64 baseRef = ref MemoryMarshal.GetReference(kernel);
+
+            for (int x = 0; x < kernelLength; x++)
+            {
+                int offsetX = (sourceOffsetColumnBase + x - radiusX).Clamp(minColumn, maxColumn);
+                vector.Sum(Unsafe.Add(ref baseRef, x) * Unsafe.Add(ref sourceRef, offsetX));
+            }
+
+            targetRow[column] = vector;
+        }
+
         [MethodImpl(InliningOptions.ShortMethod)]
         private static void ConvolveImpl<TPixel>(
             in DenseMatrix<float> matrix,
@@ -281,4 +367,4 @@ private static void ConvolveImpl<TPixel>(
             }
         }
     }
-}
+}

src/ImageSharp/Primitives/BokehBlurKernelData.cs

@@ -0,0 +1,41 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System.Numerics;
+
+namespace SixLabors.ImageSharp.Primitives
+{
+    /// <summary>
+    /// A <see langword="struct"/> that contains data about a set of bokeh blur kernels
+    /// </summary>
+    internal readonly struct BokehBlurKernelData
+    {
+        /// <summary>
+        /// The kernel parameters to use for the current set of complex kernels
+        /// </summary>
+        public readonly Vector4[] Parameters;
+
+        /// <summary>
+        /// The scaling factor for the kernel values
+        /// </summary>
+        public readonly float Scale;
+
+        /// <summary>
+        /// The kernel components to apply the bokeh blur effect
+        /// </summary>
+        public readonly Complex64[][] Kernels;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BokehBlurKernelData"/> struct.
+        /// </summary>
+        /// <param name="parameters">The kernel parameters</param>
+        /// <param name="scale">The kernel scale factor</param>
+        /// <param name="kernels">The complex kernel components</param>
+        public BokehBlurKernelData(Vector4[] parameters, float scale, Complex64[][] kernels)
+        {
+            this.Parameters = parameters;
+            this.Scale = scale;
+            this.Kernels = kernels;
+        }
+    }
+}

src/ImageSharp/Primitives/BokehBlurParameters.cs

@@ -0,0 +1,32 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Primitives
+{
+    /// <summary>
+    /// A <see langword="struct"/> that contains parameters to apply a bokeh blur filter
+    /// </summary>
+    internal readonly struct BokehBlurParameters
+    {
+        /// <summary>
+        /// The size of the convolution kernel to use when applying the bokeh blur
+        /// </summary>
+        public readonly int Radius;
+
+        /// <summary>
+        /// The number of complex components to use to approximate the bokeh kernel
+        /// </summary>
+        public readonly int Components;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BokehBlurParameters"/> struct.
+        /// </summary>
+        /// <param name="radius">The size of the kernel</param>
+        /// <param name="components">The number of kernel components</param>
+        public BokehBlurParameters(int radius, int components)
+        {
+            this.Radius = radius;
+            this.Components = components;
+        }
+    }
+}

src/ImageSharp/Primitives/Complex64.cs

@@ -0,0 +1,95 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Primitives
+{
+    /// <summary>
+    /// Represents a complex number, where the real and imaginary parts are stored as <see cref="float"/> values.
+    /// </summary>
+    /// <remarks>
+    /// This is a more efficient version of the <see cref="Complex64"/> type.
+    /// </remarks>
+    internal readonly struct Complex64 : IEquatable<Complex64>
+    {
+        /// <summary>
+        /// The real part of the complex number
+        /// </summary>
+        public readonly float Real;
+
+        /// <summary>
+        /// The imaginary part of the complex number
+        /// </summary>
+        public readonly float Imaginary;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Complex64"/> struct.
+        /// </summary>
+        /// <param name="real">The real part in the complex number.</param>
+        /// <param name="imaginary">The imaginary part in the complex number.</param>
+        public Complex64(float real, float imaginary)
+        {
+            this.Real = real;
+            this.Imaginary = imaginary;
+        }
+
+        /// <summary>
+        /// Performs the multiplication operation between a <see cref="Complex64"/> intance and a <see cref="float"/> scalar.
+        /// </summary>
+        /// <param name="value">The <see cref="Complex64"/> value to multiply.</param>
+        /// <param name="scalar">The <see cref="float"/> scalar to use to multiply the <see cref="Complex64"/> value.</param>
+        /// <returns>The <see cref="Complex64"/> result</returns>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public static Complex64 operator *(Complex64 value, float scalar) => new Complex64(value.Real * scalar, value.Imaginary * scalar);
+
+        /// <summary>
+        /// Performs the multiplication operation between a <see cref="Complex64"/> intance and a <see cref="Vector4"/>.
+        /// </summary>
+        /// <param name="value">The <see cref="Complex64"/> value to multiply.</param>
+        /// <param name="vector">The <see cref="Vector4"/> instance to use to multiply the <see cref="Complex64"/> value.</param>
+        /// <returns>The <see cref="Complex64"/> result</returns>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public static ComplexVector4 operator *(Complex64 value, Vector4 vector)
+        {
+            return new ComplexVector4 { Real = vector * value.Real, Imaginary = vector * value.Imaginary };
+        }
+
+        /// <summary>
+        /// Performs the multiplication operation between a <see cref="Complex64"/> intance and a <see cref="ComplexVector4"/>.
+        /// </summary>
+        /// <param name="value">The <see cref="Complex64"/> value to multiply.</param>
+        /// <param name="vector">The <see cref="ComplexVector4"/> instance to use to multiply the <see cref="Complex64"/> value.</param>
+        /// <returns>The <see cref="Complex64"/> result</returns>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public static ComplexVector4 operator *(Complex64 value, ComplexVector4 vector)
+        {
+            Vector4 real = (value.Real * vector.Real) - (value.Imaginary * vector.Imaginary);
+            Vector4 imaginary = (value.Real * vector.Imaginary) + (value.Imaginary * vector.Real);
+            return new ComplexVector4 { Real = real, Imaginary = imaginary };
+        }
+
+        /// <inheritdoc/>
+        public bool Equals(Complex64 other)
+        {
+            return this.Real.Equals(other.Real) && this.Imaginary.Equals(other.Imaginary);
+        }
+
+        /// <inheritdoc/>
+        public override bool Equals(object obj) => obj is Complex64 other && this.Equals(other);
+
+        /// <inheritdoc/>
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return (this.Real.GetHashCode() * 397) ^ this.Imaginary.GetHashCode();
+            }
+        }
+
+        /// <inheritdoc/>
+        public override string ToString() => $"{this.Real}{(this.Imaginary >= 0 ? "+" : string.Empty)}{this.Imaginary}j";
+    }
+}

src/ImageSharp/Primitives/ComplexVector4.cs

@@ -0,0 +1,44 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+namespace SixLabors.ImageSharp.Primitives
+{
+    /// <summary>
+    /// A vector with 4 values of type <see cref="Complex64"/>.
+    /// </summary>
+    internal struct ComplexVector4
+    {
+        /// <summary>
+        /// The real part of the complex vector
+        /// </summary>
+        public Vector4 Real;
+
+        /// <summary>
+        /// The imaginary part of the complex number
+        /// </summary>
+        public Vector4 Imaginary;
+
+        /// <summary>
+        /// Sums the values in the input <see cref="ComplexVector4"/> to the current instance
+        /// </summary>
+        /// <param name="value">The input <see cref="ComplexVector4"/> to sum</param>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public void Sum(in ComplexVector4 value)
+        {
+            this.Real += value.Real;
+            this.Imaginary += value.Imaginary;
+        }
+
+        /// <summary>
+        /// Performs a weighted sum on the current instance according to the given parameters
+        /// </summary>
+        /// <param name="a">The 'a' parameter, for the real component</param>
+        /// <param name="b">The 'b' parameter, for the imaginary component</param>
+        /// <returns>The resulting <see cref="Vector4"/> value</returns>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public Vector4 WeightedSum(float a, float b) => (this.Real * a) + (this.Imaginary * b);
+    }
+}

src/ImageSharp/Processing/Extensions/BokehBlurExtensions.cs

@@ -0,0 +1,58 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using SixLabors.ImageSharp.Processing.Processors.Convolution;
+using SixLabors.Primitives;
+
+namespace SixLabors.ImageSharp.Processing
+{
+    /// <summary>
+    /// Adds bokeh blurring extensions to the <see cref="Image{TPixel}"/> type.
+    /// </summary>
+    public static class BokehBlurExtensions
+    {
+        /// <summary>
+        /// Applies a bokeh blur to the image.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
+        public static IImageProcessingContext BokehBlur(this IImageProcessingContext source)
+            => source.ApplyProcessor(new BokehBlurProcessor());
+
+        /// <summary>
+        /// Applies a bokeh blur to the image.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="radius">The 'radius' value representing the size of the area to sample.</param>
+        /// <param name="components">The 'components' value representing the number of kernels to use to approximate the bokeh effect.</param>
+        /// <param name="gamma">The gamma highlight factor to use to emphasize bright spots in the source image</param>
+        /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
+        public static IImageProcessingContext BokehBlur(this IImageProcessingContext source, int radius, int components, float gamma)
+            => source.ApplyProcessor(new BokehBlurProcessor(radius, components, gamma));
+
+        /// <summary>
+        /// Applies a bokeh blur to the image.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="rectangle">
+        /// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
+        /// </param>
+        /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
+        public static IImageProcessingContext BokehBlur(this IImageProcessingContext source, Rectangle rectangle)
+            => source.ApplyProcessor(new BokehBlurProcessor(), rectangle);
+
+        /// <summary>
+        /// Applies a bokeh blur to the image.
+        /// </summary>
+        /// <param name="source">The image this method extends.</param>
+        /// <param name="radius">The 'radius' value representing the size of the area to sample.</param>
+        /// <param name="components">The 'components' value representing the number of kernels to use to approximate the bokeh effect.</param>
+        /// <param name="gamma">The gamma highlight factor to use to emphasize bright spots in the source image</param>
+        /// <param name="rectangle">
+        /// The <see cref="Rectangle"/> structure that specifies the portion of the image object to alter.
+        /// </param>
+        /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
+        public static IImageProcessingContext BokehBlur(this IImageProcessingContext source, int radius, int components, float gamma, Rectangle rectangle)
+            => source.ApplyProcessor(new BokehBlurProcessor(radius, components, gamma), rectangle);
+    }
+}