Faster Transforms

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; } = default(CatmullRomResampler);
 
         /// <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; } = default(HermiteResampler);
 
         /// <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; } = default(Lanczos2Resampler);
 
         /// <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; } = default(Lanczos3Resampler);
 
         /// <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; } = default(Lanczos5Resampler);
 
         /// <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; } = default(Lanczos8Resampler);
 
         /// <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; } = default(MitchellNetravaliResampler);
 
         /// <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; } = default(RobidouxResampler);
 
         /// <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; } = default(RobidouxSharpResampler);
 
         /// <summary>
         /// Gets the Spline sampler. A seperable cubic algorithm similar to <see cref="MitchellNetravali"/> but yielding smoother results.
         /// </summary>
-        public static IResampler Spline { get; } = new SplineResampler();
+        public static IResampler Spline { get; } = default(SplineResampler);
 
         /// <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)

src/ImageSharp/Processing/Processors/Transforms/AffineTransformProcessor.cs

@@ -21,7 +21,7 @@ public AffineTransformProcessor(Matrix3x2 matrix, IResampler sampler, Size targe
             Guard.NotNull(sampler, nameof(sampler));
             this.Sampler = sampler;
             this.TransformMatrix = matrix;
-            this.TargetDimensions = targetDimensions;
+            this.DestinationSize = targetDimensions;
         }
 
         /// <summary>
@@ -35,9 +35,9 @@ public AffineTransformProcessor(Matrix3x2 matrix, IResampler sampler, Size targe
         public Matrix3x2 TransformMatrix { get; }
 
         /// <summary>
-        /// Gets the target dimensions to constrain the transformed image to.
+        /// Gets the destination size to constrain the transformed image to.
         /// </summary>
-        public Size TargetDimensions { get; }
+        public Size DestinationSize { get; }
 
         /// <inheritdoc/>
         public override ICloningImageProcessor<TPixel> CreatePixelSpecificCloningProcessor<TPixel>(Configuration configuration, Image<TPixel> source, Rectangle sourceRectangle)