Merge pull request #1118 from SixLabors/js/faster-transforms

Faster Transforms

Author: JimBobSquarePants

src/ImageSharp/Common/Helpers/Guard.cs

@@ -0,0 +1,29 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp;
+
+namespace SixLabors
+{
+    internal static partial class Guard
+    {
+        /// <summary>
+        /// Ensures that the value is a value type.
+        /// </summary>
+        /// <param name="value">The target object, which cannot be null.</param>
+        /// <param name="parameterName">The name of the parameter that is to be checked.</param>
+        /// <typeparam name="TValue">The type of the value.</typeparam>
+        /// <exception cref="ArgumentException"><paramref name="value"/> is not a value type.</exception>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public static void MustBeValueType<TValue>(TValue value, string parameterName)
+        {
+            if (!value.GetType().GetTypeInfo().IsValueType)
+            {
+                ThrowArgumentException("Type must be a struct.", parameterName);
+            }
+        }
+    }
+}

src/ImageSharp/Common/Helpers/ImageMaths.cs

@@ -242,40 +242,6 @@ public static float SinC(float f)
             return 1F;
         }
 
-        /// <summary>
-        /// Returns the result of a B-C filter against the given value.
-        /// <see href="http://www.imagemagick.org/Usage/filter/#cubic_bc"/>
-        /// </summary>
-        /// <param name="x">The value to process.</param>
-        /// <param name="b">The B-Spline curve variable.</param>
-        /// <param name="c">The Cardinal curve variable.</param>
-        /// <returns>
-        /// The <see cref="float"/>.
-        /// </returns>
-        [MethodImpl(InliningOptions.ShortMethod)]
-        public static float GetBcValue(float x, float b, float c)
-        {
-            if (x < 0F)
-            {
-                x = -x;
-            }
-
-            float temp = x * x;
-            if (x < 1F)
-            {
-                x = ((12 - (9 * b) - (6 * c)) * (x * temp)) + ((-18 + (12 * b) + (6 * c)) * temp) + (6 - (2 * b));
-                return x / 6F;
-            }
-
-            if (x < 2F)
-            {
-                x = ((-b - (6 * c)) * (x * temp)) + (((6 * b) + (30 * c)) * temp) + (((-12 * b) - (48 * c)) * x) + ((8 * b) + (24 * c));
-                return x / 6F;
-            }
-
-            return 0F;
-        }
-
         /// <summary>
         /// Gets the bounding <see cref="Rectangle"/> from the given points.
         /// </summary>

src/ImageSharp/Processing/AffineTransformBuilder.cs

@@ -31,7 +31,7 @@ public AffineTransformBuilder PrependRotationDegrees(float degrees)
         /// <param name="radians">The amount of rotation, in radians.</param>
         /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
         public AffineTransformBuilder PrependRotationRadians(float radians)
-            => this.Prepend(size => TransformUtils.CreateRotationMatrixRadians(radians, size));
+            => this.Prepend(size => TransformUtilities.CreateRotationMatrixRadians(radians, size));
 
         /// <summary>
         /// Prepends a rotation matrix using the given rotation in degrees at the given origin.
@@ -67,7 +67,7 @@ public AffineTransformBuilder AppendRotationDegrees(float degrees)
         /// <param name="radians">The amount of rotation, in radians.</param>
         /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
         public AffineTransformBuilder AppendRotationRadians(float radians)
-            => this.Append(size => TransformUtils.CreateRotationMatrixRadians(radians, size));
+            => this.Append(size => TransformUtilities.CreateRotationMatrixRadians(radians, size));
 
         /// <summary>
         /// Appends a rotation matrix using the given rotation in degrees at the given origin.
@@ -142,7 +142,7 @@ public AffineTransformBuilder AppendScale(Vector2 scales)
         /// <param name="degreesY">The Y angle, in degrees.</param>
         /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
         public AffineTransformBuilder PrependSkewDegrees(float degreesX, float degreesY)
-            => this.Prepend(size => TransformUtils.CreateSkewMatrixDegrees(degreesX, degreesY, size));
+            => this.Prepend(size => TransformUtilities.CreateSkewMatrixDegrees(degreesX, degreesY, size));
 
         /// <summary>
         /// Prepends a centered skew matrix from the give angles in radians.
@@ -151,7 +151,7 @@ public AffineTransformBuilder PrependSkewDegrees(float degreesX, float degreesY)
         /// <param name="radiansY">The Y angle, in radians.</param>
         /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
         public AffineTransformBuilder PrependSkewRadians(float radiansX, float radiansY)
-            => this.Prepend(size => TransformUtils.CreateSkewMatrixRadians(radiansX, radiansY, size));
+            => this.Prepend(size => TransformUtilities.CreateSkewMatrixRadians(radiansX, radiansY, size));
 
         /// <summary>
         /// Prepends a skew matrix using the given angles in degrees at the given origin.
@@ -180,7 +180,7 @@ public AffineTransformBuilder PrependSkewRadians(float radiansX, float radiansY,
         /// <param name="degreesY">The Y angle, in degrees.</param>
         /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
         public AffineTransformBuilder AppendSkewDegrees(float degreesX, float degreesY)
-            => this.Append(size => TransformUtils.CreateSkewMatrixDegrees(degreesX, degreesY, size));
+            => this.Append(size => TransformUtilities.CreateSkewMatrixDegrees(degreesX, degreesY, size));
 
         /// <summary>
         /// Appends a centered skew matrix from the give angles in radians.
@@ -189,7 +189,7 @@ public AffineTransformBuilder AppendSkewDegrees(float degreesX, float degreesY)
         /// <param name="radiansY">The Y angle, in radians.</param>
         /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
         public AffineTransformBuilder AppendSkewRadians(float radiansX, float radiansY)
-            => this.Append(size => TransformUtils.CreateSkewMatrixRadians(radiansX, radiansY, size));
+            => this.Append(size => TransformUtilities.CreateSkewMatrixRadians(radiansX, radiansY, size));
 
         /// <summary>
         /// Appends a skew matrix using the given angles in degrees at the given origin.

src/ImageSharp/Processing/Extensions/Transforms/TransformExtensions.cs

@@ -52,7 +52,7 @@ public static IImageProcessingContext Transform(
             IResampler sampler)
         {
             Matrix3x2 transform = builder.BuildMatrix(sourceRectangle);
-            Size targetDimensions = TransformUtils.GetTransformedSize(sourceRectangle.Size, transform);
+            Size targetDimensions = TransformUtilities.GetTransformedSize(sourceRectangle.Size, transform);
             return ctx.Transform(sourceRectangle, transform, targetDimensions, sampler);
         }
 
@@ -116,7 +116,7 @@ public static IImageProcessingContext Transform(
             IResampler sampler)
         {
             Matrix4x4 transform = builder.BuildMatrix(sourceRectangle);
-            Size targetDimensions = TransformUtils.GetTransformedSize(sourceRectangle.Size, transform);
+            Size targetDimensions = TransformUtilities.GetTransformedSize(sourceRectangle.Size, transform);
             return ctx.Transform(sourceRectangle, transform, targetDimensions, sampler);
         }
 

src/ImageSharp/Processing/KnownResamplers.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors and contributors.
+// Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
 using SixLabors.ImageSharp.Processing.Processors.Transforms;
@@ -13,86 +13,86 @@ public static class KnownResamplers
         /// <summary>
         /// Gets the Bicubic sampler that implements the bicubic kernel algorithm W(x)
         /// </summary>
-        public static IResampler Bicubic { get; } = new BicubicResampler();
+        public static IResampler Bicubic { get; } = default(BicubicResampler);
 
         /// <summary>
         /// Gets the Box sampler that implements the box algorithm. Similar to nearest neighbor when upscaling.
         /// When downscaling the pixels will average, merging pixels together.
         /// </summary>
-        public static IResampler Box { get; } = new BoxResampler();
+        public static IResampler Box { get; } = default(BoxResampler);
 
         /// <summary>
         /// Gets the Catmull-Rom sampler, a well known standard Cubic Filter often used as a interpolation function
         /// </summary>
-        public static IResampler CatmullRom { get; } = new CatmullRomResampler();
+        public static IResampler CatmullRom { get; } = CubicResampler.CatmullRom;
 
         /// <summary>
         /// Gets the Hermite sampler. A type of smoothed triangular interpolation filter that rounds off strong edges while
         /// preserving flat 'color levels' in the original image.
         /// </summary>
-        public static IResampler Hermite { get; } = new HermiteResampler();
+        public static IResampler Hermite { get; } = CubicResampler.Hermite;
 
         /// <summary>
         /// Gets the Lanczos kernel sampler that implements smooth interpolation with a radius of 2 pixels.
         /// This algorithm provides sharpened results when compared to others when downsampling.
         /// </summary>
-        public static IResampler Lanczos2 { get; } = new Lanczos2Resampler();
+        public static IResampler Lanczos2 { get; } = LanczosResampler.Lanczos2;
 
         /// <summary>
         /// Gets the Lanczos kernel sampler that implements smooth interpolation with a radius of 3 pixels
         /// This algorithm provides sharpened results when compared to others when downsampling.
         /// </summary>
-        public static IResampler Lanczos3 { get; } = new Lanczos3Resampler();
+        public static IResampler Lanczos3 { get; } = LanczosResampler.Lanczos3;
 
         /// <summary>
         /// Gets the Lanczos kernel sampler that implements smooth interpolation with a radius of 5 pixels
         /// This algorithm provides sharpened results when compared to others when downsampling.
         /// </summary>
-        public static IResampler Lanczos5 { get; } = new Lanczos5Resampler();
+        public static IResampler Lanczos5 { get; } = LanczosResampler.Lanczos5;
 
         /// <summary>
         /// Gets the Lanczos kernel sampler that implements smooth interpolation with a radius of 8 pixels
         /// This algorithm provides sharpened results when compared to others when downsampling.
         /// </summary>
-        public static IResampler Lanczos8 { get; } = new Lanczos8Resampler();
+        public static IResampler Lanczos8 { get; } = LanczosResampler.Lanczos8;
 
         /// <summary>
         /// Gets the Mitchell-Netravali sampler. This seperable cubic algorithm yields a very good equilibrium between
         /// detail preservation (sharpness) and smoothness.
         /// </summary>
-        public static IResampler MitchellNetravali { get; } = new MitchellNetravaliResampler();
+        public static IResampler MitchellNetravali { get; } = CubicResampler.MitchellNetravali;
 
         /// <summary>
         /// Gets the Nearest-Neighbour sampler that implements the nearest neighbor algorithm. This uses a very fast, unscaled filter
         /// which will select the closest pixel to the new pixels position.
         /// </summary>
-        public static IResampler NearestNeighbor { get; } = new NearestNeighborResampler();
+        public static IResampler NearestNeighbor { get; } = default(NearestNeighborResampler);
 
         /// <summary>
         /// Gets the Robidoux sampler. This algorithm developed by Nicolas Robidoux providing a very good equilibrium between
         /// detail preservation (sharpness) and smoothness comparable to <see cref="MitchellNetravali"/>.
         /// </summary>
-        public static IResampler Robidoux { get; } = new RobidouxResampler();
+        public static IResampler Robidoux { get; } = CubicResampler.Robidoux;
 
         /// <summary>
         /// Gets the Robidoux Sharp sampler. A sharpened form of the <see cref="Robidoux"/> sampler
         /// </summary>
-        public static IResampler RobidouxSharp { get; } = new RobidouxSharpResampler();
+        public static IResampler RobidouxSharp { get; } = CubicResampler.RobidouxSharp;
 
         /// <summary>
-        /// Gets the Spline sampler. A seperable cubic algorithm similar to <see cref="MitchellNetravali"/> but yielding smoother results.
+        /// Gets the Spline sampler. A separable cubic algorithm similar to <see cref="MitchellNetravali"/> but yielding smoother results.
         /// </summary>
-        public static IResampler Spline { get; } = new SplineResampler();
+        public static IResampler Spline { get; } = CubicResampler.Spline;
 
         /// <summary>
         /// Gets the Triangle sampler, otherwise known as Bilinear. This interpolation algorithm can be used where perfect image transformation
         /// with pixel matching is impossible, so that one can calculate and assign appropriate intensity values to pixels
         /// </summary>
-        public static IResampler Triangle { get; } = new TriangleResampler();
+        public static IResampler Triangle { get; } = default(TriangleResampler);
 
         /// <summary>
         /// Gets the Welch sampler. A high speed algorithm that delivers very sharpened results.
         /// </summary>
-        public static IResampler Welch { get; } = new WelchResampler();
+        public static IResampler Welch { get; } = default(WelchResampler);
     }
-}
+}

src/ImageSharp/Processing/Processors/CloningImageProcessor{TPixel}.cs

@@ -110,10 +110,10 @@ public void Dispose()
         }
 
         /// <summary>
-        /// Gets the size of the target image.
+        /// Gets the size of the destination image.
         /// </summary>
         /// <returns>The <see cref="Size"/>.</returns>
-        protected abstract Size GetTargetSize();
+        protected abstract Size GetDestinationSize();
 
         /// <summary>
         /// This method is called before the process is applied to prepare the processor.
@@ -168,21 +168,21 @@ protected virtual void Dispose(bool disposing)
         private Image<TPixel> CreateTarget()
         {
             Image<TPixel> source = this.Source;
-            Size targetSize = this.GetTargetSize();
+            Size destinationSize = this.GetDestinationSize();
 
             // We will always be creating the clone even for mutate because we may need to resize the canvas.
-            var targetFrames = new ImageFrame<TPixel>[source.Frames.Count];
-            for (int i = 0; i < targetFrames.Length; i++)
+            var destinationFrames = new ImageFrame<TPixel>[source.Frames.Count];
+            for (int i = 0; i < destinationFrames.Length; i++)
             {
-                targetFrames[i] = new ImageFrame<TPixel>(
+                destinationFrames[i] = new ImageFrame<TPixel>(
                     this.Configuration,
-                    targetSize.Width,
-                    targetSize.Height,
+                    destinationSize.Width,
+                    destinationSize.Height,
                     source.Frames[i].Metadata.DeepClone());
             }
 
             // Use the overload to prevent an extra frame being added.
-            return new Image<TPixel>(this.Configuration, source.Metadata.DeepClone(), targetFrames);
+            return new Image<TPixel>(this.Configuration, source.Metadata.DeepClone(), destinationFrames);
         }
 
         private void CheckFrameCount(Image<TPixel> a, Image<TPixel> b)