Merge pull request #775 from SixLabors/js/better-transforms

Improve the Transform API

src/ImageSharp.Drawing/ImageSharp.Drawing.csproj

@@ -38,8 +38,8 @@
     </ItemGroup>
     <ItemGroup>
         <AdditionalFiles Include="..\..\stylecop.json" />
-        <PackageReference Include="SixLabors.Fonts" Version="1.0.0-beta0007" />
+        <PackageReference Include="SixLabors.Fonts" Version="1.0.0-dev000119" />
-        <PackageReference Include="SixLabors.Shapes" Version="1.0.0-beta0007" />
+        <PackageReference Include="SixLabors.Shapes" Version="1.0.0-dev000102" />
         <PackageReference Include="StyleCop.Analyzers" Version="1.1.0-beta007">
             <PrivateAssets>All</PrivateAssets>
         </PackageReference>

src/ImageSharp/ColorSpaces/Conversion/Implementation/Converters/CIeLchToCieLabConverter.cs

@@ -22,7 +22,7 @@ namespace SixLabors.ImageSharp.ColorSpaces.Conversion.Implementation
             // Conversion algorithm described here:
             // https://en.wikipedia.org/wiki/Lab_color_space#Cylindrical_representation:_CIELCh_or_CIEHLC
             float l = input.L, c = input.C, hDegrees = input.H;
-            float hRadians = MathFExtensions.DegreeToRadian(hDegrees);
+            float hRadians = GeometryUtilities.DegreeToRadian(hDegrees);
 
             float a = c * MathF.Cos(hRadians);
             float b = c * MathF.Sin(hRadians);

src/ImageSharp/ColorSpaces/Conversion/Implementation/Converters/CieLabToCieLchConverter.cs

@@ -24,7 +24,7 @@ namespace SixLabors.ImageSharp.ColorSpaces.Conversion.Implementation
             float l = input.L, a = input.A, b = input.B;
             float c = MathF.Sqrt((a * a) + (b * b));
             float hRadians = MathF.Atan2(b, a);
-            float hDegrees = MathFExtensions.RadianToDegree(hRadians);
+            float hDegrees = GeometryUtilities.RadianToDegree(hRadians);
 
             // Wrap the angle round at 360.
             hDegrees %= 360;

src/ImageSharp/ColorSpaces/Conversion/Implementation/Converters/CieLchuvToCieLuvConverter.cs

@@ -22,7 +22,7 @@ namespace SixLabors.ImageSharp.ColorSpaces.Conversion.Implementation
             // Conversion algorithm described here:
             // https://en.wikipedia.org/wiki/CIELUV#Cylindrical_representation_.28CIELCH.29
             float l = input.L, c = input.C, hDegrees = input.H;
-            float hRadians = MathFExtensions.DegreeToRadian(hDegrees);
+            float hRadians = GeometryUtilities.DegreeToRadian(hDegrees);
 
             float u = c * MathF.Cos(hRadians);
             float v = c * MathF.Sin(hRadians);

src/ImageSharp/ColorSpaces/Conversion/Implementation/Converters/CieLuvToCieLchuvConverter.cs

@@ -24,7 +24,7 @@ namespace SixLabors.ImageSharp.ColorSpaces.Conversion.Implementation
             float l = input.L, a = input.U, b = input.V;
             float c = MathF.Sqrt((a * a) + (b * b));
             float hRadians = MathF.Atan2(b, a);
-            float hDegrees = MathFExtensions.RadianToDegree(hRadians);
+            float hDegrees = GeometryUtilities.RadianToDegree(hRadians);
 
             // Wrap the angle round at 360.
             hDegrees %= 360;

src/ImageSharp/Common/Helpers/ImageMaths.cs

@@ -22,7 +22,8 @@ namespace SixLabors.ImageSharp
         /// <param name="b">The blue component.</param>
         /// <returns>The <see cref="byte"/>.</returns>
         [MethodImpl(InliningOptions.ShortMethod)]
-        public static byte Get8BitBT709Luminance(byte r, byte g, byte b) => (byte)((r * .2126F) + (g * .7152F) + (b * .0722F) + 0.5f);
+        public static byte Get8BitBT709Luminance(byte r, byte g, byte b) =>
+            (byte)((r * .2126F) + (g * .7152F) + (b * .0722F) + 0.5f);
 
         /// <summary>
         /// Gets the luminance from the rgb components using the formula as specified by ITU-R Recommendation BT.709.
@@ -32,7 +33,8 @@ namespace SixLabors.ImageSharp
         /// <param name="b">The blue component.</param>
         /// <returns>The <see cref="ushort"/>.</returns>
         [MethodImpl(InliningOptions.ShortMethod)]
-        public static ushort Get16BitBT709Luminance(ushort r, ushort g, ushort b) => (ushort)((r * .2126F) + (g * .7152F) + (b * .0722F));
+        public static ushort Get16BitBT709Luminance(ushort r, ushort g, ushort b) =>
+            (ushort)((r * .2126F) + (g * .7152F) + (b * .0722F));
 
         /// <summary>
         /// Scales a value from a 16 bit <see cref="ushort"/> to it's 8 bit <see cref="byte"/> equivalent.
@@ -123,10 +125,7 @@ namespace SixLabors.ImageSharp
         /// <paramref name="m"/> should be power of 2.
         /// </summary>
         [MethodImpl(InliningOptions.ShortMethod)]
-        public static int ModuloP2(int x, int m)
+        public static int ModuloP2(int x, int m) => x & (m - 1);
-        {
-            return x & (m - 1);
-        }
 
         /// <summary>
         /// Returns the absolute value of a 32-bit signed integer. Uses bit shifting to speed up the operation.

src/ImageSharp/ImageSharp.csproj

@@ -42,7 +42,7 @@
   
   <ItemGroup>
     <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="4.5.1" />
-    <PackageReference Include="SixLabors.Core" Version="1.0.0-beta0006" />
+    <PackageReference Include="SixLabors.Core" Version="1.0.0-dev000089" />
     <AdditionalFiles Include="..\..\stylecop.json" />
     <PackageReference Include="StyleCop.Analyzers" Version="1.1.0-beta007">
       <PrivateAssets>All</PrivateAssets>

src/ImageSharp/Processing/AffineTransformBuilder.cs

@@ -0,0 +1,303 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Collections.Generic;
+using System.Numerics;
+using SixLabors.ImageSharp.Processing.Processors.Transforms;
+using SixLabors.Primitives;
+
+namespace SixLabors.ImageSharp.Processing
+{
+    /// <summary>
+    /// A helper class for constructing <see cref="Matrix3x2"/> instances for use in affine transforms.
+    /// </summary>
+    public class AffineTransformBuilder
+    {
+        private readonly List<Func<Size, Matrix3x2>> matrixFactories = new List<Func<Size, Matrix3x2>>();
+
+        /// <summary>
+        /// Prepends a rotation matrix using the given rotation angle in degrees
+        /// and the image center point as rotation center.
+        /// </summary>
+        /// <param name="degrees">The amount of rotation, in degrees.</param>
+        /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
+        public AffineTransformBuilder PrependRotationDegrees(float degrees)
+            => this.PrependRotationRadians(GeometryUtilities.DegreeToRadian(degrees));
+
+        /// <summary>
+        /// Prepends a rotation matrix using the given rotation angle in radians
+        /// and the image center point as rotation center.
+        /// </summary>
+        /// <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));
+
+        /// <summary>
+        /// Prepends a rotation matrix using the given rotation in degrees at the given origin.
+        /// </summary>
+        /// <param name="degrees">The amount of rotation, in degrees.</param>
+        /// <param name="origin">The rotation origin point.</param>
+        /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
+        public AffineTransformBuilder PrependRotationDegrees(float degrees, Vector2 origin)
+            => this.PrependRotationRadians(GeometryUtilities.DegreeToRadian(degrees), origin);
+
+        /// <summary>
+        /// Prepends a rotation matrix using the given rotation in radians at the given origin.
+        /// </summary>
+        /// <param name="radians">The amount of rotation, in radians.</param>
+        /// <param name="origin">The rotation origin point.</param>
+        /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
+        public AffineTransformBuilder PrependRotationRadians(float radians, Vector2 origin)
+            => this.PrependMatrix(Matrix3x2.CreateRotation(radians, origin));
+
+        /// <summary>
+        /// Appends a rotation matrix using the given rotation angle in degrees
+        /// and the image center point as rotation center.
+        /// </summary>
+        /// <param name="degrees">The amount of rotation, in degrees.</param>
+        /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
+        public AffineTransformBuilder AppendRotationDegrees(float degrees)
+            => this.AppendRotationRadians(GeometryUtilities.DegreeToRadian(degrees));
+
+        /// <summary>
+        /// Appends a rotation matrix using the given rotation angle in radians
+        /// and the image center point as rotation center.
+        /// </summary>
+        /// <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));
+
+        /// <summary>
+        /// Appends a rotation matrix using the given rotation in degrees at the given origin.
+        /// </summary>
+        /// <param name="degrees">The amount of rotation, in degrees.</param>
+        /// <param name="origin">The rotation origin point.</param>
+        /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
+        public AffineTransformBuilder AppendRotationDegrees(float degrees, Vector2 origin)
+            => this.AppendRotationRadians(GeometryUtilities.DegreeToRadian(degrees), origin);
+
+        /// <summary>
+        /// Appends a rotation matrix using the given rotation in radians at the given origin.
+        /// </summary>
+        /// <param name="radians">The amount of rotation, in radians.</param>
+        /// <param name="origin">The rotation origin point.</param>
+        /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
+        public AffineTransformBuilder AppendRotationRadians(float radians, Vector2 origin)
+            => this.AppendMatrix(Matrix3x2.CreateRotation(radians, origin));
+
+        /// <summary>
+        /// Prepends a scale matrix from the given uniform scale.
+        /// </summary>
+        /// <param name="scale">The uniform scale.</param>
+        /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
+        public AffineTransformBuilder PrependScale(float scale)
+            => this.PrependMatrix(Matrix3x2.CreateScale(scale));
+
+        /// <summary>
+        /// Prepends a scale matrix from the given vector scale.
+        /// </summary>
+        /// <param name="scale">The horizontal and vertical scale.</param>
+        /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
+        public AffineTransformBuilder PrependScale(SizeF scale)
+            => this.PrependScale((Vector2)scale);
+
+        /// <summary>
+        /// Prepends a scale matrix from the given vector scale.
+        /// </summary>
+        /// <param name="scales">The horizontal and vertical scale.</param>
+        /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
+        public AffineTransformBuilder PrependScale(Vector2 scales)
+            => this.PrependMatrix(Matrix3x2.CreateScale(scales));
+
+        /// <summary>
+        /// Appends a scale matrix from the given uniform scale.
+        /// </summary>
+        /// <param name="scale">The uniform scale.</param>
+        /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
+        public AffineTransformBuilder AppendScale(float scale)
+            => this.AppendMatrix(Matrix3x2.CreateScale(scale));
+
+        /// <summary>
+        /// Appends a scale matrix from the given vector scale.
+        /// </summary>
+        /// <param name="scales">The horizontal and vertical scale.</param>
+        /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
+        public AffineTransformBuilder AppendScale(SizeF scales)
+            => this.AppendScale((Vector2)scales);
+
+        /// <summary>
+        /// Appends a scale matrix from the given vector scale.
+        /// </summary>
+        /// <param name="scales">The horizontal and vertical scale.</param>
+        /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
+        public AffineTransformBuilder AppendScale(Vector2 scales)
+            => this.AppendMatrix(Matrix3x2.CreateScale(scales));
+
+        /// <summary>
+        /// Prepends a centered skew matrix from the give angles in degrees.
+        /// </summary>
+        /// <param name="degreesX">The X angle, in degrees.</param>
+        /// <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));
+
+        /// <summary>
+        /// Prepends a centered skew matrix from the give angles in radians.
+        /// </summary>
+        /// <param name="radiansX">The X angle, in radians.</param>
+        /// <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));
+
+        /// <summary>
+        /// Prepends a skew matrix using the given angles in degrees at the given origin.
+        /// </summary>
+        /// <param name="degreesX">The X angle, in degrees.</param>
+        /// <param name="degreesY">The Y angle, in degrees.</param>
+        /// <param name="origin">The skew origin point.</param>
+        /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
+        public AffineTransformBuilder PrependSkewDegrees(float degreesX, float degreesY, Vector2 origin)
+            => this.PrependSkewRadians(GeometryUtilities.DegreeToRadian(degreesX), GeometryUtilities.DegreeToRadian(degreesY), origin);
+
+        /// <summary>
+        /// Prepends a skew matrix using the given angles in radians at the given origin.
+        /// </summary>
+        /// <param name="radiansX">The X angle, in radians.</param>
+        /// <param name="radiansY">The Y angle, in radians.</param>
+        /// <param name="origin">The skew origin point.</param>
+        /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
+        public AffineTransformBuilder PrependSkewRadians(float radiansX, float radiansY, Vector2 origin)
+            => this.PrependMatrix(Matrix3x2.CreateSkew(radiansX, radiansY, origin));
+
+        /// <summary>
+        /// Appends a centered skew matrix from the give angles in degrees.
+        /// </summary>
+        /// <param name="degreesX">The X angle, in degrees.</param>
+        /// <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));
+
+        /// <summary>
+        /// Appends a centered skew matrix from the give angles in radians.
+        /// </summary>
+        /// <param name="radiansX">The X angle, in radians.</param>
+        /// <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));
+
+        /// <summary>
+        /// Appends a skew matrix using the given angles in degrees at the given origin.
+        /// </summary>
+        /// <param name="degreesX">The X angle, in degrees.</param>
+        /// <param name="degreesY">The Y angle, in degrees.</param>
+        /// <param name="origin">The skew origin point.</param>
+        /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
+        public AffineTransformBuilder AppendSkewDegrees(float degreesX, float degreesY, Vector2 origin)
+            => this.AppendSkewRadians(GeometryUtilities.DegreeToRadian(degreesX), GeometryUtilities.DegreeToRadian(degreesY), origin);
+
+        /// <summary>
+        /// Appends a skew matrix using the given angles in radians at the given origin.
+        /// </summary>
+        /// <param name="radiansX">The X angle, in radians.</param>
+        /// <param name="radiansY">The Y angle, in radians.</param>
+        /// <param name="origin">The skew origin point.</param>
+        /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
+        public AffineTransformBuilder AppendSkewRadians(float radiansX, float radiansY, Vector2 origin)
+            => this.AppendMatrix(Matrix3x2.CreateSkew(radiansX, radiansY, origin));
+
+        /// <summary>
+        /// Prepends a translation matrix from the given vector.
+        /// </summary>
+        /// <param name="position">The translation position.</param>
+        /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
+        public AffineTransformBuilder PrependTranslation(PointF position)
+            => this.PrependTranslation((Vector2)position);
+
+        /// <summary>
+        /// Prepends a translation matrix from the given vector.
+        /// </summary>
+        /// <param name="position">The translation position.</param>
+        /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
+        public AffineTransformBuilder PrependTranslation(Vector2 position)
+            => this.PrependMatrix(Matrix3x2.CreateTranslation(position));
+
+        /// <summary>
+        /// Appends a translation matrix from the given vector.
+        /// </summary>
+        /// <param name="position">The translation position.</param>
+        /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
+        public AffineTransformBuilder AppendTranslation(PointF position)
+            => this.AppendTranslation((Vector2)position);
+
+        /// <summary>
+        /// Appends a translation matrix from the given vector.
+        /// </summary>
+        /// <param name="position">The translation position.</param>
+        /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
+        public AffineTransformBuilder AppendTranslation(Vector2 position)
+            => this.AppendMatrix(Matrix3x2.CreateTranslation(position));
+
+        /// <summary>
+        /// Prepends a raw matrix.
+        /// </summary>
+        /// <param name="matrix">The matrix to prepend.</param>
+        /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
+        public AffineTransformBuilder PrependMatrix(Matrix3x2 matrix) => this.Prepend(_ => matrix);
+
+        /// <summary>
+        /// Appends a raw matrix.
+        /// </summary>
+        /// <param name="matrix">The matrix to append.</param>
+        /// <returns>The <see cref="AffineTransformBuilder"/>.</returns>
+        public AffineTransformBuilder AppendMatrix(Matrix3x2 matrix) => this.Append(_ => matrix);
+
+        /// <summary>
+        /// Returns the combined matrix for a given source size.
+        /// </summary>
+        /// <param name="sourceSize">The source image size.</param>
+        /// <returns>The <see cref="Matrix3x2"/>.</returns>
+        public Matrix3x2 BuildMatrix(Size sourceSize) => this.BuildMatrix(new Rectangle(Point.Empty, sourceSize));
+
+        /// <summary>
+        /// Returns the combined matrix for a given source rectangle.
+        /// </summary>
+        /// <param name="sourceRectangle">The rectangle in the source image.</param>
+        /// <returns>The <see cref="Matrix3x2"/>.</returns>
+        public Matrix3x2 BuildMatrix(Rectangle sourceRectangle)
+        {
+            Guard.MustBeGreaterThan(sourceRectangle.Width, 0, nameof(sourceRectangle));
+            Guard.MustBeGreaterThan(sourceRectangle.Height, 0, nameof(sourceRectangle));
+
+            // Translate the origin matrix to cater for source rectangle offsets.
+            var matrix = Matrix3x2.CreateTranslation(-sourceRectangle.Location);
+
+            Size size = sourceRectangle.Size;
+
+            foreach (Func<Size, Matrix3x2> factory in this.matrixFactories)
+            {
+                matrix *= factory(size);
+            }
+
+            return matrix;
+        }
+
+        private AffineTransformBuilder Prepend(Func<Size, Matrix3x2> factory)
+        {
+            this.matrixFactories.Insert(0, factory);
+            return this;
+        }
+
+        private AffineTransformBuilder Append(Func<Size, Matrix3x2> factory)
+        {
+            this.matrixFactories.Add(factory);
+            return this;
+        }
+    }
+}

src/ImageSharp/Processing/KnownFilterMatrices.cs

@@ -322,7 +322,7 @@ namespace SixLabors.ImageSharp.Processing
                 degrees += 360;
             }
 
-            float radian = MathFExtensions.DegreeToRadian(degrees);
+            float radian = GeometryUtilities.DegreeToRadian(degrees);
             float cosRadian = MathF.Cos(radian);
             float sinRadian = MathF.Sin(radian);
 

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

@@ -5,13 +5,9 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using SixLabors.ImageSharp.Advanced;
-using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.ParallelUtils;
 using SixLabors.ImageSharp.PixelFormats;
-using SixLabors.Memory;
 using SixLabors.Primitives;
 
 namespace SixLabors.ImageSharp.Processing.Processors.Transforms
@@ -20,29 +16,35 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
     /// Provides the base methods to perform affine transforms on an image.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
-    internal class AffineTransformProcessor<TPixel> : InterpolatedTransformProcessorBase<TPixel>
+    internal class AffineTransformProcessor<TPixel> : TransformProcessorBase<TPixel>
         where TPixel : struct, IPixel<TPixel>
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="AffineTransformProcessor{TPixel}"/> class.
         /// </summary>
-        /// <param name="matrix">The transform matrix</param>
+        /// <param name="matrix">The transform matrix.</param>
         /// <param name="sampler">The sampler to perform the transform operation.</param>
-        /// <param name="targetDimensions">The target dimensions to constrain the transformed image to.</param>
+        /// <param name="targetDimensions">The target dimensions.</param>
         public AffineTransformProcessor(Matrix3x2 matrix, IResampler sampler, Size targetDimensions)
-            : base(sampler)
         {
+            Guard.NotNull(sampler, nameof(sampler));
+            this.Sampler = sampler;
             this.TransformMatrix = matrix;
             this.TargetDimensions = targetDimensions;
         }
 
         /// <summary>
-        /// Gets the matrix used to supply the affine transform
+        /// Gets the sampler to perform interpolation of the transform operation.
+        /// </summary>
+        public IResampler Sampler { get; }
+
+        /// <summary>
+        /// Gets the matrix used to supply the affine transform.
         /// </summary>
         public Matrix3x2 TransformMatrix { get; }
 
         /// <summary>
-        /// Gets the target dimensions to constrain the transformed image to
+        /// Gets the target dimensions to constrain the transformed image to.
         /// </summary>
         public Size TargetDimensions { get; }
 
@@ -64,17 +66,19 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
             Rectangle sourceRectangle,
             Configuration configuration)
         {
-            int height = this.TargetDimensions.Height;
+            // Handle tranforms that result in output identical to the original.
-            int width = this.TargetDimensions.Width;
+            if (this.TransformMatrix.Equals(default) || this.TransformMatrix.Equals(Matrix3x2.Identity))
-
+            {
-            Rectangle sourceBounds = source.Bounds();
+                // The clone will be blank here copy all the pixel data over
-            var targetBounds = new Rectangle(0, 0, width, height);
+                source.GetPixelSpan().CopyTo(destination.GetPixelSpan());
+                return;
+            }
 
-            // Since could potentially be resizing the canvas we might need to re-calculate the matrix
+            int width = this.TargetDimensions.Width;
-            Matrix3x2 matrix = this.GetProcessingMatrix(sourceBounds, targetBounds);
+            var targetBounds = new Rectangle(Point.Empty, this.TargetDimensions);
 
             // Convert from screen to world space.
-            Matrix3x2.Invert(matrix, out matrix);
+            Matrix3x2.Invert(this.TransformMatrix, out Matrix3x2 matrix);
 
             if (this.Sampler is NearestNeighborResampler)
             {
@@ -82,158 +86,57 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
                     targetBounds,
                     configuration,
                     rows =>
+                    {
+                        for (int y = rows.Min; y < rows.Max; y++)
                         {
-                            for (int y = rows.Min; y < rows.Max; y++)
+                            Span<TPixel> destRow = destination.GetPixelRowSpan(y);
-                            {
-                                Span<TPixel> destRow = destination.GetPixelRowSpan(y);
 
-                                for (int x = 0; x < width; x++)
+                            for (int x = 0; x < width; x++)
+                            {
+                                var point = Point.Transform(new Point(x, y), matrix);
+                                if (sourceRectangle.Contains(point.X, point.Y))
                                 {
-                                    var point = Point.Transform(new Point(x, y), matrix);
+                                    destRow[x] = source[point.X, point.Y];
-                                    if (sourceBounds.Contains(point.X, point.Y))
-                                    {
-                                        destRow[x] = source[point.X, point.Y];
-                                    }
                                 }
                             }
-                        });
+                        }
+                    });
 
                 return;
             }
 
-            int maxSourceX = source.Width - 1;
+            var kernel = new TransformKernelMap(configuration, source.Size(), destination.Size(), this.Sampler);
-            int maxSourceY = source.Height - 1;
+            try
-            (float radius, float scale, float ratio) xRadiusScale = this.GetSamplingRadius(source.Width, destination.Width);
-            (float radius, float scale, float ratio) yRadiusScale = this.GetSamplingRadius(source.Height, destination.Height);
-            float xScale = xRadiusScale.scale;
-            float yScale = yRadiusScale.scale;
-            var radius = new Vector2(xRadiusScale.radius, yRadiusScale.radius);
-            IResampler sampler = this.Sampler;
-            var maxSource = new Vector4(maxSourceX, maxSourceY, maxSourceX, maxSourceY);
-            int xLength = (int)MathF.Ceiling((radius.X * 2) + 2);
-            int yLength = (int)MathF.Ceiling((radius.Y * 2) + 2);
-
-            MemoryAllocator memoryAllocator = configuration.MemoryAllocator;
-
-            using (Buffer2D<float> yBuffer = memoryAllocator.Allocate2D<float>(yLength, height))
-            using (Buffer2D<float> xBuffer = memoryAllocator.Allocate2D<float>(xLength, height))
             {
-                ParallelHelper.IterateRows(
+                ParallelHelper.IterateRowsWithTempBuffer<Vector4>(
                     targetBounds,
                     configuration,
-                    rows =>
+                    (rows, vectorBuffer) =>
+                    {
+                        Span<Vector4> vectorSpan = vectorBuffer.Span;
+                        for (int y = rows.Min; y < rows.Max; y++)
                         {
-                            for (int y = rows.Min; y < rows.Max; y++)
+                            Span<TPixel> targetRowSpan = destination.GetPixelRowSpan(y);
-                            {
+                            PixelOperations<TPixel>.Instance.ToVector4(configuration, targetRowSpan, vectorSpan);
-                                ref TPixel destRowRef = ref MemoryMarshal.GetReference(destination.GetPixelRowSpan(y));
+                            ref float ySpanRef = ref kernel.GetYStartReference(y);
-                                ref float ySpanRef = ref MemoryMarshal.GetReference(yBuffer.GetRowSpan(y));
+                            ref float xSpanRef = ref kernel.GetXStartReference(y);
-                                ref float xSpanRef = ref MemoryMarshal.GetReference(xBuffer.GetRowSpan(y));
 
-                                for (int x = 0; x < width; x++)
+                            for (int x = 0; x < width; x++)
-                                {
+                            {
-                                    // Use the single precision position to calculate correct bounding pixels
+                                // Use the single precision position to calculate correct bounding pixels
-                                    // otherwise we get rogue pixels outside of the bounds.
+                                // otherwise we get rogue pixels outside of the bounds.
-                                    var point = Vector2.Transform(new Vector2(x, y), matrix);
+                                var point = Vector2.Transform(new Vector2(x, y), matrix);
-
+                                kernel.Convolve(point, x, ref ySpanRef, ref xSpanRef, source.PixelBuffer, vectorSpan);
-                                    // Clamp sampling pixel radial extents to the source image edges
-                                    Vector2 maxXY = point + radius;
-                                    Vector2 minXY = point - radius;
-
-                                    // max, maxY, minX, minY
-                                    var extents = new Vector4(
-                                        MathF.Floor(maxXY.X + .5F),
-                                        MathF.Floor(maxXY.Y + .5F),
-                                        MathF.Ceiling(minXY.X - .5F),
-                                        MathF.Ceiling(minXY.Y - .5F));
-
-                                    int right = (int)extents.X;
-                                    int bottom = (int)extents.Y;
-                                    int left = (int)extents.Z;
-                                    int top = (int)extents.W;
-
-                                    extents = Vector4.Clamp(extents, Vector4.Zero, maxSource);
-
-                                    int maxX = (int)extents.X;
-                                    int maxY = (int)extents.Y;
-                                    int minX = (int)extents.Z;
-                                    int minY = (int)extents.W;
-
-                                    if (minX == maxX || minY == maxY)
-                                    {
-                                        continue;
-                                    }
-
-                                    // It appears these have to be calculated on-the-fly.
-                                    // Precalculating transformed weights would require prior knowledge of every transformed pixel location
-                                    // since they can be at sub-pixel positions on both axis.
-                                    // I've optimized where I can but am always open to suggestions.
-                                    if (yScale > 1 && xScale > 1)
-                                    {
-                                        CalculateWeightsDown(
-                                            top,
-                                            bottom,
-                                            minY,
-                                            maxY,
-                                            point.Y,
-                                            sampler,
-                                            yScale,
-                                            ref ySpanRef,
-                                            yLength);
-
-                                        CalculateWeightsDown(
-                                            left,
-                                            right,
-                                            minX,
-                                            maxX,
-                                            point.X,
-                                            sampler,
-                                            xScale,
-                                            ref xSpanRef,
-                                            xLength);
-                                    }
-                                    else
-                                    {
-                                        CalculateWeightsScaleUp(minY, maxY, point.Y, sampler, ref ySpanRef);
-                                        CalculateWeightsScaleUp(minX, maxX, point.X, sampler, ref xSpanRef);
-                                    }
-
-                                    // Now multiply the results against the offsets
-                                    Vector4 sum = Vector4.Zero;
-                                    for (int yy = 0, j = minY; j <= maxY; j++, yy++)
-                                    {
-                                        float yWeight = Unsafe.Add(ref ySpanRef, yy);
-
-                                        for (int xx = 0, i = minX; i <= maxX; i++, xx++)
-                                        {
-                                            float xWeight = Unsafe.Add(ref xSpanRef, xx);
-
-                                            // Values are first premultiplied to prevent darkening of edge pixels
-                                            var current = source[i, j].ToVector4();
-                                            Vector4Utils.Premultiply(ref current);
-                                            sum += current * xWeight * yWeight;
-                                        }
-                                    }
-
-                                    ref TPixel dest = ref Unsafe.Add(ref destRowRef, x);
-
-                                    // Reverse the premultiplication
-                                    Vector4Utils.UnPremultiply(ref sum);
-                                    dest.FromVector4(sum);
-                                }
                             }
-                        });
+
+                            PixelOperations<TPixel>.Instance.FromVector4(configuration, vectorSpan, targetRowSpan);
+                        }
+                    });
+            }
+            finally
+            {
+                kernel.Dispose();
             }
         }
-
-        /// <summary>
-        /// Gets a transform matrix adjusted for final processing based upon the target image bounds.
-        /// </summary>
-        /// <param name="sourceRectangle">The source image bounds.</param>
-        /// <param name="destinationRectangle">The destination image bounds.</param>
-        /// <returns>
-        /// The <see cref="Matrix3x2"/>.
-        /// </returns>
-        protected virtual Matrix3x2 GetProcessingMatrix(Rectangle sourceRectangle, Rectangle destinationRectangle)
-            => this.TransformMatrix;
     }
 }

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

@@ -1,38 +0,0 @@
-// Copyright (c) Six Labors and contributors.
-// Licensed under the Apache License, Version 2.0.
-
-using System.Numerics;
-using SixLabors.ImageSharp.PixelFormats;
-using SixLabors.Primitives;
-
-namespace SixLabors.ImageSharp.Processing.Processors.Transforms
-{
-    /// <summary>
-    /// A base class that provides methods to allow the automatic centering of affine transforms
-    /// </summary>
-    /// <typeparam name="TPixel">The pixel format.</typeparam>
-    internal abstract class CenteredAffineTransformProcessor<TPixel> : AffineTransformProcessor<TPixel>
-        where TPixel : struct, IPixel<TPixel>
-    {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="CenteredAffineTransformProcessor{TPixel}"/> class.
-        /// </summary>
-        /// <param name="matrix">The transform matrix</param>
-        /// <param name="sampler">The sampler to perform the transform operation.</param>
-        /// <param name="sourceSize">The source image size</param>
-        protected CenteredAffineTransformProcessor(Matrix3x2 matrix, IResampler sampler, Size sourceSize)
-            : base(matrix, sampler, GetTransformedDimensions(sourceSize, matrix))
-        {
-        }
-
-        /// <inheritdoc/>
-        protected override Matrix3x2 GetProcessingMatrix(Rectangle sourceRectangle, Rectangle destinationRectangle)
-            => TransformHelpers.GetCenteredTransformMatrix(sourceRectangle, destinationRectangle, this.TransformMatrix);
-
-        private static Size GetTransformedDimensions(Size sourceDimensions, Matrix3x2 matrix)
-        {
-            var sourceRectangle = new Rectangle(0, 0, sourceDimensions.Width, sourceDimensions.Height);
-            return TransformHelpers.GetTransformedBoundingRectangle(sourceRectangle, matrix).Size;
-        }
-    }
-}

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

@@ -1,40 +0,0 @@
-// Copyright (c) Six Labors and contributors.
-// Licensed under the Apache License, Version 2.0.
-
-using System.Numerics;
-using SixLabors.ImageSharp.PixelFormats;
-using SixLabors.Primitives;
-
-namespace SixLabors.ImageSharp.Processing.Processors.Transforms
-{
-    /// <summary>
-    /// A base class that provides methods to allow the automatic centering of non-affine transforms
-    /// </summary>
-    /// <typeparam name="TPixel">The pixel format.</typeparam>
-    internal abstract class CenteredProjectiveTransformProcessor<TPixel> : ProjectiveTransformProcessor<TPixel>
-        where TPixel : struct, IPixel<TPixel>
-    {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="CenteredProjectiveTransformProcessor{TPixel}"/> class.
-        /// </summary>
-        /// <param name="matrix">The transform matrix</param>
-        /// <param name="sampler">The sampler to perform the transform operation.</param>
-        /// <param name="sourceSize">The source image size</param>
-        protected CenteredProjectiveTransformProcessor(Matrix4x4 matrix, IResampler sampler, Size sourceSize)
-            : base(matrix, sampler, GetTransformedDimensions(sourceSize, matrix))
-        {
-        }
-
-        /// <inheritdoc/>
-        protected override Matrix4x4 GetProcessingMatrix(Rectangle sourceRectangle, Rectangle destinationRectangle)
-        {
-            return TransformHelpers.GetCenteredTransformMatrix(sourceRectangle, destinationRectangle, this.TransformMatrix);
-        }
-
-        private static Size GetTransformedDimensions(Size sourceDimensions, Matrix4x4 matrix)
-        {
-            var sourceRectangle = new Rectangle(0, 0, sourceDimensions.Width, sourceDimensions.Height);
-            return TransformHelpers.GetTransformedBoundingRectangle(sourceRectangle, matrix).Size;
-        }
-    }
-}

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

@@ -1,117 +0,0 @@
-// Copyright (c) Six Labors and contributors.
-// Licensed under the Apache License, Version 2.0.
-
-using System;
-using System.Runtime.CompilerServices;
-using SixLabors.ImageSharp.PixelFormats;
-
-namespace SixLabors.ImageSharp.Processing.Processors.Transforms
-{
-    /// <summary>
-    /// The base class for performing interpolated affine and non-affine transforms.
-    /// </summary>
-    /// <typeparam name="TPixel">The pixel format.</typeparam>
-    internal abstract class InterpolatedTransformProcessorBase<TPixel> : TransformProcessorBase<TPixel>
-        where TPixel : struct, IPixel<TPixel>
-    {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="InterpolatedTransformProcessorBase{TPixel}"/> class.
-        /// </summary>
-        /// <param name="sampler">The sampler to perform the transform operation.</param>
-        protected InterpolatedTransformProcessorBase(IResampler sampler)
-        {
-            Guard.NotNull(sampler, nameof(sampler));
-            this.Sampler = sampler;
-        }
-
-        /// <summary>
-        /// Gets the sampler to perform interpolation of the transform operation.
-        /// </summary>
-        public IResampler Sampler { get; }
-
-        /// <summary>
-        /// Calculated the weights for the given point.
-        /// This method uses more samples than the upscaled version to ensure edge pixels are correctly rendered.
-        /// Additionally the weights are normalized.
-        /// </summary>
-        /// <param name="min">The minimum sampling offset</param>
-        /// <param name="max">The maximum sampling offset</param>
-        /// <param name="sourceMin">The minimum source bounds</param>
-        /// <param name="sourceMax">The maximum source bounds</param>
-        /// <param name="point">The transformed point dimension</param>
-        /// <param name="sampler">The sampler</param>
-        /// <param name="scale">The transformed image scale relative to the source</param>
-        /// <param name="weightsRef">The reference to the collection of weights</param>
-        /// <param name="length">The length of the weights collection</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        protected static void CalculateWeightsDown(int min, int max, int sourceMin, int sourceMax, float point, IResampler sampler, float scale, ref float weightsRef, int length)
-        {
-            float sum = 0;
-
-            // Downsampling weights requires more edge sampling plus normalization of the weights
-            for (int x = 0, i = min; i <= max; i++, x++)
-            {
-                int index = i;
-                if (index < sourceMin)
-                {
-                    index = sourceMin;
-                }
-
-                if (index > sourceMax)
-                {
-                    index = sourceMax;
-                }
-
-                float weight = sampler.GetValue((index - point) / scale);
-                sum += weight;
-                Unsafe.Add(ref weightsRef, x) = weight;
-            }
-
-            if (sum > 0)
-            {
-                for (int i = 0; i < length; i++)
-                {
-                    ref float wRef = ref Unsafe.Add(ref weightsRef, i);
-                    wRef = wRef / sum;
-                }
-            }
-        }
-
-        /// <summary>
-        /// Calculated the weights for the given point.
-        /// </summary>
-        /// <param name="sourceMin">The minimum source bounds</param>
-        /// <param name="sourceMax">The maximum source bounds</param>
-        /// <param name="point">The transformed point dimension</param>
-        /// <param name="sampler">The sampler</param>
-        /// <param name="weightsRef">The reference to the collection of weights</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        protected static void CalculateWeightsScaleUp(int sourceMin, int sourceMax, float point, IResampler sampler, ref float weightsRef)
-        {
-            for (int x = 0, i = sourceMin; i <= sourceMax; i++, x++)
-            {
-                float weight = sampler.GetValue(i - point);
-                Unsafe.Add(ref weightsRef, x) = weight;
-            }
-        }
-
-        /// <summary>
-        /// Calculates the sampling radius for the current sampler
-        /// </summary>
-        /// <param name="sourceSize">The source dimension size</param>
-        /// <param name="destinationSize">The destination dimension size</param>
-        /// <returns>The radius, and scaling factor</returns>
-        protected (float radius, float scale, float ratio) GetSamplingRadius(int sourceSize, int destinationSize)
-        {
-            float ratio = (float)sourceSize / destinationSize;
-            float scale = ratio;
-
-            if (scale < 1F)
-            {
-                scale = 1F;
-            }
-
-            return (MathF.Ceiling(scale * this.Sampler.Radius), scale, ratio);
-        }
-    }
-}

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

@@ -5,13 +5,9 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using SixLabors.ImageSharp.Advanced;
-using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.ParallelUtils;
 using SixLabors.ImageSharp.PixelFormats;
-using SixLabors.Memory;
 using SixLabors.Primitives;
 
 namespace SixLabors.ImageSharp.Processing.Processors.Transforms
@@ -20,22 +16,28 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
     /// Provides the base methods to perform non-affine transforms on an image.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
-    internal class ProjectiveTransformProcessor<TPixel> : InterpolatedTransformProcessorBase<TPixel>
+    internal class ProjectiveTransformProcessor<TPixel> : TransformProcessorBase<TPixel>
         where TPixel : struct, IPixel<TPixel>
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="ProjectiveTransformProcessor{TPixel}"/> class.
         /// </summary>
-        /// <param name="matrix">The transform matrix</param>
+        /// <param name="matrix">The transform matrix.</param>
         /// <param name="sampler">The sampler to perform the transform operation.</param>
-        /// <param name="targetDimensions">The target dimensions to constrain the transformed image to.</param>
+        /// <param name="targetDimensions">The target dimensions.</param>
         public ProjectiveTransformProcessor(Matrix4x4 matrix, IResampler sampler, Size targetDimensions)
-            : base(sampler)
         {
+            Guard.NotNull(sampler, nameof(sampler));
+            this.Sampler = sampler;
             this.TransformMatrix = matrix;
             this.TargetDimensions = targetDimensions;
         }
 
+        /// <summary>
+        /// Gets the sampler to perform interpolation of the transform operation.
+        /// </summary>
+        public IResampler Sampler { get; }
+
         /// <summary>
         /// Gets the matrix used to supply the projective transform
         /// </summary>
@@ -60,17 +62,19 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
         /// <inheritdoc/>
         protected override void OnFrameApply(ImageFrame<TPixel> source, ImageFrame<TPixel> destination, Rectangle sourceRectangle, Configuration configuration)
         {
-            int height = this.TargetDimensions.Height;
+            // Handle tranforms that result in output identical to the original.
-            int width = this.TargetDimensions.Width;
+            if (this.TransformMatrix.Equals(default) || this.TransformMatrix.Equals(Matrix4x4.Identity))
-
+            {
-            Rectangle sourceBounds = source.Bounds();
+                // The clone will be blank here copy all the pixel data over
-            var targetBounds = new Rectangle(0, 0, width, height);
+                source.GetPixelSpan().CopyTo(destination.GetPixelSpan());
+                return;
+            }
 
-            // Since could potentially be resizing the canvas we might need to re-calculate the matrix
+            int width = this.TargetDimensions.Width;
-            Matrix4x4 matrix = this.GetProcessingMatrix(sourceBounds, targetBounds);
+            var targetBounds = new Rectangle(Point.Empty, this.TargetDimensions);
 
             // Convert from screen to world space.
-            Matrix4x4.Invert(matrix, out matrix);
+            Matrix4x4.Invert(this.TransformMatrix, out Matrix4x4 matrix);
             const float Epsilon = 0.0000001F;
 
             if (this.Sampler is NearestNeighborResampler)
@@ -92,7 +96,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
                                     int px = (int)MathF.Round(v3.X / z);
                                     int py = (int)MathF.Round(v3.Y / z);
 
-                                    if (sourceBounds.Contains(px, py))
+                                    if (sourceRectangle.Contains(px, py))
                                     {
                                         destRow[x] = source[px, py];
                                     }
@@ -103,145 +107,40 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
                 return;
             }
 
-            int maxSourceX = source.Width - 1;
+            var kernel = new TransformKernelMap(configuration, source.Size(), destination.Size(), this.Sampler);
-            int maxSourceY = source.Height - 1;
+            try
-            (float radius, float scale, float ratio) xRadiusScale = this.GetSamplingRadius(source.Width, destination.Width);
-            (float radius, float scale, float ratio) yRadiusScale = this.GetSamplingRadius(source.Height, destination.Height);
-            float xScale = xRadiusScale.scale;
-            float yScale = yRadiusScale.scale;
-
-            // Using Vector4 with dummy 0-s, because Vector2 SIMD implementation is not reliable:
-            var radius = new Vector4(xRadiusScale.radius, yRadiusScale.radius, 0, 0);
-
-            IResampler sampler = this.Sampler;
-            var maxSource = new Vector4(maxSourceX, maxSourceY, maxSourceX, maxSourceY);
-            int xLength = (int)MathF.Ceiling((radius.X * 2) + 2);
-            int yLength = (int)MathF.Ceiling((radius.Y * 2) + 2);
-
-            MemoryAllocator memoryAllocator = configuration.MemoryAllocator;
-
-            using (Buffer2D<float> yBuffer = memoryAllocator.Allocate2D<float>(yLength, height))
-            using (Buffer2D<float> xBuffer = memoryAllocator.Allocate2D<float>(xLength, height))
             {
-                ParallelHelper.IterateRows(
+                ParallelHelper.IterateRowsWithTempBuffer<Vector4>(
                     targetBounds,
                     configuration,
-                    rows =>
+                    (rows, vectorBuffer) =>
+                    {
+                        Span<Vector4> vectorSpan = vectorBuffer.Span;
+                        for (int y = rows.Min; y < rows.Max; y++)
                         {
-                            for (int y = rows.Min; y < rows.Max; y++)
+                            Span<TPixel> targetRowSpan = destination.GetPixelRowSpan(y);
-                            {
+                            PixelOperations<TPixel>.Instance.ToVector4(configuration, targetRowSpan, vectorSpan);
-                                ref TPixel destRowRef = ref MemoryMarshal.GetReference(destination.GetPixelRowSpan(y));
+                            ref float ySpanRef = ref kernel.GetYStartReference(y);
-                                ref float ySpanRef = ref MemoryMarshal.GetReference(yBuffer.GetRowSpan(y));
+                            ref float xSpanRef = ref kernel.GetXStartReference(y);
-                                ref float xSpanRef = ref MemoryMarshal.GetReference(xBuffer.GetRowSpan(y));
-
-                                for (int x = 0; x < width; x++)
-                                {
-                                    // Use the single precision position to calculate correct bounding pixels
-                                    // otherwise we get rogue pixels outside of the bounds.
-                                    var v3 = Vector3.Transform(new Vector3(x, y, 1), matrix);
-                                    float z = MathF.Max(v3.Z, Epsilon);
-
-                                    // Using Vector4 with dummy 0-s, because Vector2 SIMD implementation is not reliable:
-                                    Vector4 point = new Vector4(v3.X, v3.Y, 0, 0) / z;
-
-                                    // Clamp sampling pixel radial extents to the source image edges
-                                    Vector4 maxXY = point + radius;
-                                    Vector4 minXY = point - radius;
-
-                                    // max, maxY, minX, minY
-                                    var extents = new Vector4(
-                                        MathF.Floor(maxXY.X + .5F),
-                                        MathF.Floor(maxXY.Y + .5F),
-                                        MathF.Ceiling(minXY.X - .5F),
-                                        MathF.Ceiling(minXY.Y - .5F));
 
-                                    int right = (int)extents.X;
+                            for (int x = 0; x < width; x++)
-                                    int bottom = (int)extents.Y;
+                            {
-                                    int left = (int)extents.Z;
+                                // Use the single precision position to calculate correct bounding pixels
-                                    int top = (int)extents.W;
+                                // otherwise we get rogue pixels outside of the bounds.
-
+                                var v3 = Vector3.Transform(new Vector3(x, y, 1F), matrix);
-                                    extents = Vector4.Clamp(extents, Vector4.Zero, maxSource);
+                                Vector2 point = new Vector2(v3.X, v3.Y) / MathF.Max(v3.Z, Epsilon);
-
-                                    int maxX = (int)extents.X;
-                                    int maxY = (int)extents.Y;
-                                    int minX = (int)extents.Z;
-                                    int minY = (int)extents.W;
-
-                                    if (minX == maxX || minY == maxY)
-                                    {
-                                        continue;
-                                    }
-
-                                    // It appears these have to be calculated on-the-fly.
-                                    // Precalulating transformed weights would require prior knowledge of every transformed pixel location
-                                    // since they can be at sub-pixel positions on both axis.
-                                    // I've optimized where I can but am always open to suggestions.
-                                    if (yScale > 1 && xScale > 1)
-                                    {
-                                        CalculateWeightsDown(
-                                            top,
-                                            bottom,
-                                            minY,
-                                            maxY,
-                                            point.Y,
-                                            sampler,
-                                            yScale,
-                                            ref ySpanRef,
-                                            yLength);
-
-                                        CalculateWeightsDown(
-                                            left,
-                                            right,
-                                            minX,
-                                            maxX,
-                                            point.X,
-                                            sampler,
-                                            xScale,
-                                            ref xSpanRef,
-                                            xLength);
-                                    }
-                                    else
-                                    {
-                                        CalculateWeightsScaleUp(minY, maxY, point.Y, sampler, ref ySpanRef);
-                                        CalculateWeightsScaleUp(minX, maxX, point.X, sampler, ref xSpanRef);
-                                    }
-
-                                    // Now multiply the results against the offsets
-                                    Vector4 sum = Vector4.Zero;
-                                    for (int yy = 0, j = minY; j <= maxY; j++, yy++)
-                                    {
-                                        float yWeight = Unsafe.Add(ref ySpanRef, yy);
-
-                                        for (int xx = 0, i = minX; i <= maxX; i++, xx++)
-                                        {
-                                            float xWeight = Unsafe.Add(ref xSpanRef, xx);
-
-                                            // Values are first premultiplied to prevent darkening of edge pixels
-                                            var current = source[i, j].ToVector4();
-                                            Vector4Utils.Premultiply(ref current);
-                                            sum += current * xWeight * yWeight;
-                                        }
-                                    }
-
-                                    ref TPixel dest = ref Unsafe.Add(ref destRowRef, x);
 
-                                    // Reverse the premultiplication
+                                kernel.Convolve(point, x, ref ySpanRef, ref xSpanRef, source.PixelBuffer, vectorSpan);
-                                    Vector4Utils.UnPremultiply(ref sum);
-                                    dest.FromVector4(sum);
-                                }
                             }
-                        });
+
+                            PixelOperations<TPixel>.Instance.FromVector4(configuration, vectorSpan, targetRowSpan);
+                        }
+                    });
+            }
+            finally
+            {
+                kernel.Dispose();
             }
         }
-
-        /// <summary>
-        /// Gets a transform matrix adjusted for final processing based upon the target image bounds.
-        /// </summary>
-        /// <param name="sourceRectangle">The source image bounds.</param>
-        /// <param name="destinationRectangle">The destination image bounds.</param>
-        /// <returns>
-        /// The <see cref="Matrix4x4"/>.
-        /// </returns>
-        protected virtual Matrix4x4 GetProcessingMatrix(Rectangle sourceRectangle, Rectangle destinationRectangle) => this.TransformMatrix;
     }
 }

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

@@ -2,12 +2,12 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
-using System.Threading.Tasks;
+using System.Numerics;
+
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.MetaData.Profiles.Exif;
 using SixLabors.ImageSharp.ParallelUtils;
 using SixLabors.ImageSharp.PixelFormats;
-using SixLabors.ImageSharp.Processing.Processors.Transforms;
 using SixLabors.Primitives;
 
 namespace SixLabors.ImageSharp.Processing.Processors.Transforms
@@ -16,7 +16,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
     /// Provides methods that allow the rotating of images.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
-    internal class RotateProcessor<TPixel> : CenteredAffineTransformProcessor<TPixel>
+    internal class RotateProcessor<TPixel> : AffineTransformProcessor<TPixel>
         where TPixel : struct, IPixel<TPixel>
     {
         /// <summary>
@@ -36,9 +36,16 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
         /// <param name="sampler">The sampler to perform the rotating operation.</param>
         /// <param name="sourceSize">The source image size</param>
         public RotateProcessor(float degrees, IResampler sampler, Size sourceSize)
-            : base(Matrix3x2Extensions.CreateRotationDegrees(degrees, PointF.Empty), sampler, sourceSize)
+            : this(
+                 TransformUtils.CreateRotationMatrixDegrees(degrees, sourceSize),
+                 sampler,
+                 sourceSize)
+            => this.Degrees = degrees;
+
+        // Helper constructor
+        private RotateProcessor(Matrix3x2 rotationMatrix, IResampler sampler, Size sourceSize)
+            : base(rotationMatrix, sampler, TransformUtils.GetTransformedSize(sourceSize, rotationMatrix))
         {
-            this.Degrees = degrees;
         }
 
         /// <summary>
@@ -84,7 +91,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
         /// <returns>The <see cref="float"/></returns>
         private static float WrapDegrees(float degrees)
         {
-            degrees = degrees % 360;
+            degrees %= 360;
 
             while (degrees < 0)
             {
@@ -223,7 +230,6 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
                             int newX = height - y - 1;
                             for (int x = 0; x < width; x++)
                             {
-                                // TODO: Optimize this:
                                 if (destinationBounds.Contains(newX, x))
                                 {
                                     destination[newX, x] = sourceRow[x];

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

@@ -1,8 +1,9 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
+using System.Numerics;
+
 using SixLabors.ImageSharp.PixelFormats;
-using SixLabors.ImageSharp.Processing.Processors.Transforms;
 using SixLabors.Primitives;
 
 namespace SixLabors.ImageSharp.Processing.Processors.Transforms
@@ -11,7 +12,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
     /// Provides methods that allow the skewing of images.
     /// </summary>
     /// <typeparam name="TPixel">The pixel format.</typeparam>
-    internal class SkewProcessor<TPixel> : CenteredAffineTransformProcessor<TPixel>
+    internal class SkewProcessor<TPixel> : AffineTransformProcessor<TPixel>
         where TPixel : struct, IPixel<TPixel>
     {
         /// <summary>
@@ -33,12 +34,21 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
         /// <param name="sampler">The sampler to perform the skew operation.</param>
         /// <param name="sourceSize">The source image size</param>
         public SkewProcessor(float degreesX, float degreesY, IResampler sampler, Size sourceSize)
-            : base(Matrix3x2Extensions.CreateSkewDegrees(degreesX, degreesY, PointF.Empty), sampler, sourceSize)
+            : this(
+                 TransformUtils.CreateSkewMatrixDegrees(degreesX, degreesY, sourceSize),
+                 sampler,
+                 sourceSize)
         {
             this.DegreesX = degreesX;
             this.DegreesY = degreesY;
         }
 
+        // Helper constructor:
+        private SkewProcessor(Matrix3x2 skewMatrix, IResampler sampler, Size sourceSize)
+            : base(skewMatrix, sampler, TransformUtils.GetTransformedSize(sourceSize, skewMatrix))
+        {
+        }
+
         /// <summary>
         /// Gets the angle of rotation along the x-axis in degrees.
         /// </summary>

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

@@ -1,158 +0,0 @@
-// Copyright (c) Six Labors and contributors.
-// Licensed under the Apache License, Version 2.0.
-
-using System;
-using System.Numerics;
-using SixLabors.ImageSharp.MetaData.Profiles.Exif;
-using SixLabors.ImageSharp.PixelFormats;
-using SixLabors.Primitives;
-
-namespace SixLabors.ImageSharp.Processing.Processors.Transforms
-{
-    /// <summary>
-    /// Contains helper methods for working with affine and non-affine transforms
-    /// </summary>
-    internal static class TransformHelpers
-    {
-        /// <summary>
-        /// Updates the dimensional metadata of a transformed image
-        /// </summary>
-        /// <typeparam name="TPixel">The pixel format.</typeparam>
-        /// <param name="image">The image to update</param>
-        public static void UpdateDimensionalMetData<TPixel>(Image<TPixel> image)
-            where TPixel : struct, IPixel<TPixel>
-        {
-            ExifProfile profile = image.MetaData.ExifProfile;
-            if (profile is null)
-            {
-                return;
-            }
-
-            // Removing the previously stored value allows us to set a value with our own data tag if required.
-            if (profile.GetValue(ExifTag.PixelXDimension) != null)
-            {
-                profile.RemoveValue(ExifTag.PixelXDimension);
-
-                if (image.Width <= ushort.MaxValue)
-                {
-                    profile.SetValue(ExifTag.PixelXDimension, (ushort)image.Width);
-                }
-                else
-                {
-                    profile.SetValue(ExifTag.PixelXDimension, (uint)image.Width);
-                }
-            }
-
-            if (profile.GetValue(ExifTag.PixelYDimension) != null)
-            {
-                profile.RemoveValue(ExifTag.PixelYDimension);
-
-                if (image.Height <= ushort.MaxValue)
-                {
-                    profile.SetValue(ExifTag.PixelYDimension, (ushort)image.Height);
-                }
-                else
-                {
-                    profile.SetValue(ExifTag.PixelYDimension, (uint)image.Height);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Gets the centered transform matrix based upon the source and destination rectangles
-        /// </summary>
-        /// <param name="sourceRectangle">The source image bounds.</param>
-        /// <param name="destinationRectangle">The destination image bounds.</param>
-        /// <param name="matrix">The transformation matrix.</param>
-        /// <returns>The <see cref="Matrix3x2"/></returns>
-        public static Matrix3x2 GetCenteredTransformMatrix(Rectangle sourceRectangle, Rectangle destinationRectangle, Matrix3x2 matrix)
-        {
-            // We invert the matrix to handle the transformation from screen to world space.
-            // This ensures scaling matrices are correct.
-            Matrix3x2.Invert(matrix, out Matrix3x2 inverted);
-
-            var translationToTargetCenter = Matrix3x2.CreateTranslation(-destinationRectangle.Width * .5F, -destinationRectangle.Height * .5F);
-            var translateToSourceCenter = Matrix3x2.CreateTranslation(sourceRectangle.Width * .5F, sourceRectangle.Height * .5F);
-
-            Matrix3x2.Invert(translationToTargetCenter * inverted * translateToSourceCenter, out Matrix3x2 centered);
-
-            // Translate back to world to pass to the Transform method.
-            return centered;
-        }
-
-        /// <summary>
-        /// Gets the centered transform matrix based upon the source and destination rectangles
-        /// </summary>
-        /// <param name="sourceRectangle">The source image bounds.</param>
-        /// <param name="destinationRectangle">The destination image bounds.</param>
-        /// <param name="matrix">The transformation matrix.</param>
-        /// <returns>The <see cref="Matrix4x4"/></returns>
-        public static Matrix4x4 GetCenteredTransformMatrix(Rectangle sourceRectangle, Rectangle destinationRectangle, Matrix4x4 matrix)
-        {
-            // We invert the matrix to handle the transformation from screen to world space.
-            // This ensures scaling matrices are correct.
-            Matrix4x4.Invert(matrix, out Matrix4x4 inverted);
-
-            var translationToTargetCenter = Matrix4x4.CreateTranslation(-destinationRectangle.Width * .5F, -destinationRectangle.Height * .5F, 0);
-            var translateToSourceCenter = Matrix4x4.CreateTranslation(sourceRectangle.Width * .5F, sourceRectangle.Height * .5F, 0);
-
-            Matrix4x4.Invert(translationToTargetCenter * inverted * translateToSourceCenter, out Matrix4x4 centered);
-
-            // Translate back to world to pass to the Transform method.
-            return centered;
-        }
-
-        /// <summary>
-        /// Returns the bounding rectangle relative to the source for the given transformation matrix.
-        /// </summary>
-        /// <param name="rectangle">The source rectangle.</param>
-        /// <param name="matrix">The transformation matrix.</param>
-        /// <returns>
-        /// The <see cref="Rectangle"/>.
-        /// </returns>
-        public static Rectangle GetTransformedBoundingRectangle(Rectangle rectangle, Matrix3x2 matrix)
-        {
-            // Calculate the position of the four corners in world space by applying
-            // The world matrix to the four corners in object space (0, 0, width, height)
-            var tl = Vector2.Transform(Vector2.Zero, matrix);
-            var tr = Vector2.Transform(new Vector2(rectangle.Width, 0), matrix);
-            var bl = Vector2.Transform(new Vector2(0, rectangle.Height), matrix);
-            var br = Vector2.Transform(new Vector2(rectangle.Width, rectangle.Height), matrix);
-
-            return GetBoundingRectangle(tl, tr, bl, br);
-        }
-
-        /// <summary>
-        /// Returns the bounding rectangle relative to the source for the given transformation matrix.
-        /// </summary>
-        /// <param name="rectangle">The source rectangle.</param>
-        /// <param name="matrix">The transformation matrix.</param>
-        /// <returns>
-        /// The <see cref="Rectangle"/>.
-        /// </returns>
-        public static Rectangle GetTransformedBoundingRectangle(Rectangle rectangle, Matrix4x4 matrix)
-        {
-            // Calculate the position of the four corners in world space by applying
-            // The world matrix to the four corners in object space (0, 0, width, height)
-            var tl = Vector2.Transform(Vector2.Zero, matrix);
-            var tr = Vector2.Transform(new Vector2(rectangle.Width, 0), matrix);
-            var bl = Vector2.Transform(new Vector2(0, rectangle.Height), matrix);
-            var br = Vector2.Transform(new Vector2(rectangle.Width, rectangle.Height), matrix);
-
-            return GetBoundingRectangle(tl, tr, bl, br);
-        }
-
-        private static Rectangle GetBoundingRectangle(Vector2 tl, Vector2 tr, Vector2 bl, Vector2 br)
-        {
-            // Find the minimum and maximum "corners" based on the given vectors
-            float minX = MathF.Min(tl.X, MathF.Min(tr.X, MathF.Min(bl.X, br.X)));
-            float maxX = MathF.Max(tl.X, MathF.Max(tr.X, MathF.Max(bl.X, br.X)));
-            float minY = MathF.Min(tl.Y, MathF.Min(tr.Y, MathF.Min(bl.Y, br.Y)));
-            float maxY = MathF.Max(tl.Y, MathF.Max(tr.Y, MathF.Max(bl.Y, br.Y)));
-            float sizeX = maxX - minX + .5F;
-            float sizeY = maxY - minY + .5F;
-
-            return new Rectangle((int)(MathF.Ceiling(minX) - .5F), (int)(MathF.Ceiling(minY) - .5F), (int)MathF.Floor(sizeX), (int)MathF.Floor(sizeY));
-        }
-    }
-}

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

@@ -0,0 +1,161 @@
+// 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.Primitives;
+
+namespace SixLabors.ImageSharp.Processing.Processors.Transforms
+{
+    /// <summary>
+    /// Contains the methods required to calculate transform kernel convolution.
+    /// </summary>
+    internal class TransformKernelMap : IDisposable
+    {
+        private readonly Buffer2D<float> yBuffer;
+        private readonly Buffer2D<float> xBuffer;
+        private readonly Vector2 extents;
+        private Vector4 maxSourceExtents;
+        private readonly IResampler sampler;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TransformKernelMap"/> class.
+        /// </summary>
+        /// <param name="configuration">The configuration.</param>
+        /// <param name="source">The source size.</param>
+        /// <param name="destination">The destination size.</param>
+        /// <param name="sampler">The sampler.</param>
+        public TransformKernelMap(Configuration configuration, Size source, Size destination, IResampler sampler)
+        {
+            this.sampler = sampler;
+            float yRadius = this.GetSamplingRadius(source.Height, destination.Height);
+            float xRadius = this.GetSamplingRadius(source.Width, destination.Width);
+
+            this.extents = new Vector2(xRadius, yRadius);
+            int xLength = (int)MathF.Ceiling((this.extents.X * 2) + 2);
+            int yLength = (int)MathF.Ceiling((this.extents.Y * 2) + 2);
+
+            // We use 2D buffers so that we can access the weight spans per row in parallel.
+            this.yBuffer = configuration.MemoryAllocator.Allocate2D<float>(yLength, destination.Height);
+            this.xBuffer = configuration.MemoryAllocator.Allocate2D<float>(xLength, destination.Height);
+
+            int maxX = source.Width - 1;
+            int maxY = source.Height - 1;
+            this.maxSourceExtents = new Vector4(maxX, maxY, maxX, maxY);
+        }
+
+        /// <summary>
+        /// Gets a reference to the first item of the y window.
+        /// </summary>
+        /// <returns>The reference to the first item of the window.</returns>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public ref float GetYStartReference(int y)
+            => ref MemoryMarshal.GetReference(this.yBuffer.GetRowSpan(y));
+
+        /// <summary>
+        /// Gets a reference to the first item of the x window.
+        /// </summary>
+        /// <returns>The reference to the first item of the window.</returns>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public ref float GetXStartReference(int y)
+            => ref MemoryMarshal.GetReference(this.xBuffer.GetRowSpan(y));
+
+        public void Convolve<TPixel>(
+            Vector2 transformedPoint,
+            int column,
+            ref float ySpanRef,
+            ref float xSpanRef,
+            Buffer2D<TPixel> sourcePixels,
+            Span<Vector4> targetRow)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            // Clamp sampling pixel radial extents to the source image edges
+            Vector2 minXY = transformedPoint - this.extents;
+            Vector2 maxXY = transformedPoint + this.extents;
+
+            // left, top, right, bottom
+            var extents = new Vector4(
+                MathF.Ceiling(minXY.X - .5F),
+                MathF.Ceiling(minXY.Y - .5F),
+                MathF.Floor(maxXY.X + .5F),
+                MathF.Floor(maxXY.Y + .5F));
+
+            extents = Vector4.Clamp(extents, Vector4.Zero, this.maxSourceExtents);
+
+            int left = (int)extents.X;
+            int top = (int)extents.Y;
+            int right = (int)extents.Z;
+            int bottom = (int)extents.W;
+
+            if (left == right || top == bottom)
+            {
+                return;
+            }
+
+            this.CalculateWeights(top, bottom, transformedPoint.Y, ref ySpanRef);
+            this.CalculateWeights(left, right, transformedPoint.X, ref xSpanRef);
+
+            Vector4 sum = Vector4.Zero;
+            for (int kernelY = 0, y = top; y <= bottom; y++, kernelY++)
+            {
+                float yWeight = Unsafe.Add(ref ySpanRef, kernelY);
+
+                for (int kernelX = 0, x = left; x <= right; x++, kernelX++)
+                {
+                    float xWeight = Unsafe.Add(ref xSpanRef, kernelX);
+
+                    // Values are first premultiplied to prevent darkening of edge pixels.
+                    var current = sourcePixels[x, y].ToVector4();
+                    Vector4Utils.Premultiply(ref current);
+                    sum += current * xWeight * yWeight;
+                }
+            }
+
+            // Reverse the premultiplication
+            Vector4Utils.UnPremultiply(ref sum);
+            targetRow[column] = sum;
+        }
+
+        /// <summary>
+        /// Calculated the normalized weights for the given point.
+        /// </summary>
+        /// <param name="min">The minimum sampling offset</param>
+        /// <param name="max">The maximum sampling offset</param>
+        /// <param name="point">The transformed point dimension</param>
+        /// <param name="weightsRef">The reference to the collection of weights</param>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        private void CalculateWeights(int min, int max, float point, ref float weightsRef)
+        {
+            float sum = 0;
+            for (int x = 0, i = min; i <= max; i++, x++)
+            {
+                float weight = this.sampler.GetValue(i - point);
+                sum += weight;
+                Unsafe.Add(ref weightsRef, x) = weight;
+            }
+        }
+
+        [MethodImpl(InliningOptions.ShortMethod)]
+        private float GetSamplingRadius(int sourceSize, int destinationSize)
+        {
+            float scale = (float)sourceSize / destinationSize;
+
+            if (scale < 1F)
+            {
+                scale = 1F;
+            }
+
+            return MathF.Ceiling(scale * this.sampler.Radius);
+        }
+
+        public void Dispose()
+        {
+            this.yBuffer?.Dispose();
+            this.xBuffer?.Dispose();
+        }
+    }
+}

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

@@ -16,6 +16,6 @@ namespace SixLabors.ImageSharp.Processing.Processors.Transforms
     {
         /// <inheritdoc/>
         protected override void AfterImageApply(Image<TPixel> source, Image<TPixel> destination, Rectangle sourceRectangle)
-            => TransformHelpers.UpdateDimensionalMetData(destination);
+            => TransformProcessorHelpers.UpdateDimensionalMetData(destination);
     }
 }

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

@@ -0,0 +1,58 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using SixLabors.ImageSharp.MetaData.Profiles.Exif;
+using SixLabors.ImageSharp.PixelFormats;
+
+namespace SixLabors.ImageSharp.Processing.Processors.Transforms
+{
+    /// <summary>
+    /// Contains helper methods for working with transforms.
+    /// </summary>
+    internal static class TransformProcessorHelpers
+    {
+        /// <summary>
+        /// Updates the dimensional metadata of a transformed image
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="image">The image to update</param>
+        public static void UpdateDimensionalMetData<TPixel>(Image<TPixel> image)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            ExifProfile profile = image.MetaData.ExifProfile;
+            if (profile is null)
+            {
+                return;
+            }
+
+            // Removing the previously stored value allows us to set a value with our own data tag if required.
+            if (profile.GetValue(ExifTag.PixelXDimension) != null)
+            {
+                profile.RemoveValue(ExifTag.PixelXDimension);
+
+                if (image.Width <= ushort.MaxValue)
+                {
+                    profile.SetValue(ExifTag.PixelXDimension, (ushort)image.Width);
+                }
+                else
+                {
+                    profile.SetValue(ExifTag.PixelXDimension, (uint)image.Width);
+                }
+            }
+
+            if (profile.GetValue(ExifTag.PixelYDimension) != null)
+            {
+                profile.RemoveValue(ExifTag.PixelYDimension);
+
+                if (image.Height <= ushort.MaxValue)
+                {
+                    profile.SetValue(ExifTag.PixelYDimension, (ushort)image.Height);
+                }
+                else
+                {
+                    profile.SetValue(ExifTag.PixelYDimension, (uint)image.Height);
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,332 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Numerics;
+using SixLabors.Primitives;
+
+namespace SixLabors.ImageSharp.Processing.Processors.Transforms
+{
+    /// <summary>
+    /// Contains utility methods for working with transforms.
+    /// </summary>
+    internal static class TransformUtils
+    {
+        /// <summary>
+        /// Creates a centered rotation matrix using the given rotation in degrees and the source size.
+        /// </summary>
+        /// <param name="degrees">The amount of rotation, in degrees.</param>
+        /// <param name="size">The source image size.</param>
+        /// <returns>The <see cref="Matrix3x2"/>.</returns>
+        public static Matrix3x2 CreateRotationMatrixDegrees(float degrees, Size size)
+            => CreateCenteredTransformMatrix(
+                new Rectangle(Point.Empty, size),
+                Matrix3x2Extensions.CreateRotationDegrees(degrees, PointF.Empty));
+
+        /// <summary>
+        /// Creates a centered rotation matrix using the given rotation in radians and the source size.
+        /// </summary>
+        /// <param name="radians">The amount of rotation, in radians.</param>
+        /// <param name="size">The source image size.</param>
+        /// <returns>The <see cref="Matrix3x2"/>.</returns>
+        public static Matrix3x2 CreateRotationMatrixRadians(float radians, Size size)
+            => CreateCenteredTransformMatrix(
+                new Rectangle(Point.Empty, size),
+                Matrix3x2Extensions.CreateRotation(radians, PointF.Empty));
+
+        /// <summary>
+        /// Creates a centered skew matrix from the give angles in degrees and the source size.
+        /// </summary>
+        /// <param name="degreesX">The X angle, in degrees.</param>
+        /// <param name="degreesY">The Y angle, in degrees.</param>
+        /// <param name="size">The source image size.</param>
+        /// <returns>The <see cref="Matrix3x2"/>.</returns>
+        public static Matrix3x2 CreateSkewMatrixDegrees(float degreesX, float degreesY, Size size)
+            => CreateCenteredTransformMatrix(
+                new Rectangle(Point.Empty, size),
+                Matrix3x2Extensions.CreateSkewDegrees(degreesX, degreesY, PointF.Empty));
+
+        /// <summary>
+        /// Creates a centered skew matrix from the give angles in radians and the source size.
+        /// </summary>
+        /// <param name="radiansX">The X angle, in radians.</param>
+        /// <param name="radiansY">The Y angle, in radians.</param>
+        /// <param name="size">The source image size.</param>
+        /// <returns>The <see cref="Matrix3x2"/>.</returns>
+        public static Matrix3x2 CreateSkewMatrixRadians(float radiansX, float radiansY, Size size)
+            => CreateCenteredTransformMatrix(
+                new Rectangle(Point.Empty, size),
+                Matrix3x2Extensions.CreateSkew(radiansX, radiansY, PointF.Empty));
+
+        /// <summary>
+        /// Gets the centered transform matrix based upon the source and destination rectangles.
+        /// </summary>
+        /// <param name="sourceRectangle">The source image bounds.</param>
+        /// <param name="matrix">The transformation matrix.</param>
+        /// <returns>The <see cref="Matrix3x2"/></returns>
+        public static Matrix3x2 CreateCenteredTransformMatrix(Rectangle sourceRectangle, Matrix3x2 matrix)
+        {
+            Rectangle destinationRectangle = GetTransformedBoundingRectangle(sourceRectangle, matrix);
+
+            // We invert the matrix to handle the transformation from screen to world space.
+            // This ensures scaling matrices are correct.
+            Matrix3x2.Invert(matrix, out Matrix3x2 inverted);
+
+            var translationToTargetCenter = Matrix3x2.CreateTranslation(new Vector2(-destinationRectangle.Width, -destinationRectangle.Height) * .5F);
+            var translateToSourceCenter = Matrix3x2.CreateTranslation(new Vector2(sourceRectangle.Width, sourceRectangle.Height) * .5F);
+
+            // Translate back to world space.
+            Matrix3x2.Invert(translationToTargetCenter * inverted * translateToSourceCenter, out Matrix3x2 centered);
+
+            return centered;
+        }
+
+        /// <summary>
+        /// Creates a matrix that performs a tapering projective transform.
+        /// <see href="https://docs.microsoft.com/en-us/xamarin/xamarin-forms/user-interface/graphics/skiasharp/transforms/non-affine"/>
+        /// </summary>
+        /// <param name="size">The rectangular size of the image being transformed.</param>
+        /// <param name="side">An enumeration that indicates the side of the rectangle that tapers.</param>
+        /// <param name="corner">An enumeration that indicates on which corners to taper the rectangle.</param>
+        /// <param name="fraction">The amount to taper.</param>
+        /// <returns>The <see cref="Matrix4x4"/></returns>
+        public static Matrix4x4 CreateTaperMatrix(Size size, TaperSide side, TaperCorner corner, float fraction)
+        {
+            Matrix4x4 matrix = Matrix4x4.Identity;
+
+            switch (side)
+            {
+                case TaperSide.Left:
+                    matrix.M11 = fraction;
+                    matrix.M22 = fraction;
+                    matrix.M13 = (fraction - 1) / size.Width;
+
+                    switch (corner)
+                    {
+                        case TaperCorner.RightOrBottom:
+                            break;
+
+                        case TaperCorner.LeftOrTop:
+                            matrix.M12 = size.Height * matrix.M13;
+                            matrix.M32 = size.Height * (1 - fraction);
+                            break;
+
+                        case TaperCorner.Both:
+                            matrix.M12 = size.Height * .5F * matrix.M13;
+                            matrix.M32 = size.Height * (1 - fraction) / 2;
+                            break;
+                    }
+
+                    break;
+
+                case TaperSide.Top:
+                    matrix.M11 = fraction;
+                    matrix.M22 = fraction;
+                    matrix.M23 = (fraction - 1) / size.Height;
+
+                    switch (corner)
+                    {
+                        case TaperCorner.RightOrBottom:
+                            break;
+
+                        case TaperCorner.LeftOrTop:
+                            matrix.M21 = size.Width * matrix.M23;
+                            matrix.M31 = size.Width * (1 - fraction);
+                            break;
+
+                        case TaperCorner.Both:
+                            matrix.M21 = size.Width * .5F * matrix.M23;
+                            matrix.M31 = size.Width * (1 - fraction) / 2;
+                            break;
+                    }
+
+                    break;
+
+                case TaperSide.Right:
+                    matrix.M11 = 1 / fraction;
+                    matrix.M13 = (1 - fraction) / (size.Width * fraction);
+
+                    switch (corner)
+                    {
+                        case TaperCorner.RightOrBottom:
+                            break;
+
+                        case TaperCorner.LeftOrTop:
+                            matrix.M12 = size.Height * matrix.M13;
+                            break;
+
+                        case TaperCorner.Both:
+                            matrix.M12 = size.Height * .5F * matrix.M13;
+                            break;
+                    }
+
+                    break;
+
+                case TaperSide.Bottom:
+                    matrix.M22 = 1 / fraction;
+                    matrix.M23 = (1 - fraction) / (size.Height * fraction);
+
+                    switch (corner)
+                    {
+                        case TaperCorner.RightOrBottom:
+                            break;
+
+                        case TaperCorner.LeftOrTop:
+                            matrix.M21 = size.Width * matrix.M23;
+                            break;
+
+                        case TaperCorner.Both:
+                            matrix.M21 = size.Width * .5F * matrix.M23;
+                            break;
+                    }
+
+                    break;
+            }
+
+            return matrix;
+        }
+
+        /// <summary>
+        /// Returns the rectangle bounds relative to the source for the given transformation matrix.
+        /// </summary>
+        /// <param name="rectangle">The source rectangle.</param>
+        /// <param name="matrix">The transformation matrix.</param>
+        /// <returns>
+        /// The <see cref="Rectangle"/>.
+        /// </returns>
+        public static Rectangle GetTransformedBoundingRectangle(Rectangle rectangle, Matrix3x2 matrix)
+        {
+            Rectangle transformed = GetTransformedRectangle(rectangle, matrix);
+            return new Rectangle(0, 0, transformed.Width, transformed.Height);
+        }
+
+        /// <summary>
+        /// Returns the rectangle relative to the source for the given transformation matrix.
+        /// </summary>
+        /// <param name="rectangle">The source rectangle.</param>
+        /// <param name="matrix">The transformation matrix.</param>
+        /// <returns>
+        /// The <see cref="Rectangle"/>.
+        /// </returns>
+        public static Rectangle GetTransformedRectangle(Rectangle rectangle, Matrix3x2 matrix)
+        {
+            if (rectangle.Equals(default) || Matrix3x2.Identity.Equals(matrix))
+            {
+                return rectangle;
+            }
+
+            var tl = Vector2.Transform(new Vector2(rectangle.Left, rectangle.Top), matrix);
+            var tr = Vector2.Transform(new Vector2(rectangle.Right, rectangle.Top), matrix);
+            var bl = Vector2.Transform(new Vector2(rectangle.Left, rectangle.Bottom), matrix);
+            var br = Vector2.Transform(new Vector2(rectangle.Right, rectangle.Bottom), matrix);
+
+            return GetBoundingRectangle(tl, tr, bl, br);
+        }
+
+        /// <summary>
+        /// Returns the size relative to the source for the given transformation matrix.
+        /// </summary>
+        /// <param name="size">The source size.</param>
+        /// <param name="matrix">The transformation matrix.</param>
+        /// <returns>
+        /// The <see cref="Size"/>.
+        /// </returns>
+        public static Size GetTransformedSize(Size size, Matrix3x2 matrix)
+        {
+            Guard.IsTrue(size.Width > 0 && size.Height > 0, nameof(size), "Source size dimensions cannot be 0!");
+
+            if (matrix.Equals(default) || matrix.Equals(Matrix3x2.Identity))
+            {
+                return size;
+            }
+
+            Rectangle rectangle = GetTransformedRectangle(new Rectangle(Point.Empty, size), matrix);
+
+            return ConstrainSize(rectangle);
+        }
+
+        /// <summary>
+        /// Returns the rectangle relative to the source for the given transformation matrix.
+        /// </summary>
+        /// <param name="rectangle">The source rectangle.</param>
+        /// <param name="matrix">The transformation matrix.</param>
+        /// <returns>
+        /// The <see cref="Rectangle"/>.
+        /// </returns>
+        public static Rectangle GetTransformedRectangle(Rectangle rectangle, Matrix4x4 matrix)
+        {
+            if (rectangle.Equals(default) || Matrix4x4.Identity.Equals(matrix))
+            {
+                return rectangle;
+            }
+
+            Vector2 GetVector(float x, float y)
+            {
+                const float Epsilon = 0.0000001F;
+                var v3 = Vector3.Transform(new Vector3(x, y, 1F), matrix);
+                return new Vector2(v3.X, v3.Y) / MathF.Max(v3.Z, Epsilon);
+            }
+
+            Vector2 tl = GetVector(rectangle.Left, rectangle.Top);
+            Vector2 tr = GetVector(rectangle.Right, rectangle.Top);
+            Vector2 bl = GetVector(rectangle.Left, rectangle.Bottom);
+            Vector2 br = GetVector(rectangle.Right, rectangle.Bottom);
+
+            return GetBoundingRectangle(tl, tr, bl, br);
+        }
+
+        /// <summary>
+        /// Returns the size relative to the source for the given transformation matrix.
+        /// </summary>
+        /// <param name="size">The source size.</param>
+        /// <param name="matrix">The transformation matrix.</param>
+        /// <returns>
+        /// The <see cref="Size"/>.
+        /// </returns>
+        public static Size GetTransformedSize(Size size, Matrix4x4 matrix)
+        {
+            Guard.IsTrue(size.Width > 0 && size.Height > 0, nameof(size), "Source size dimensions cannot be 0!");
+
+            if (matrix.Equals(default) || matrix.Equals(Matrix4x4.Identity))
+            {
+                return size;
+            }
+
+            Rectangle rectangle = GetTransformedRectangle(new Rectangle(Point.Empty, size), matrix);
+
+            return ConstrainSize(rectangle);
+        }
+
+        private static Size ConstrainSize(Rectangle rectangle)
+        {
+            // We want to resize the canvas here taking into account any translations.
+            int height = rectangle.Top < 0 ? rectangle.Bottom : Math.Max(rectangle.Height, rectangle.Bottom);
+            int width = rectangle.Left < 0 ? rectangle.Right : Math.Max(rectangle.Width, rectangle.Right);
+
+            // If location in either direction is translated to a negative value equal to or exceeding the
+            // dimensions in eith direction we need to reassign the dimension.
+            if (height <= 0)
+            {
+                height = rectangle.Height;
+            }
+
+            if (width <= 0)
+            {
+                width = rectangle.Width;
+            }
+
+            return new Size(width, height);
+        }
+
+        private static Rectangle GetBoundingRectangle(Vector2 tl, Vector2 tr, Vector2 bl, Vector2 br)
+        {
+            // Find the minimum and maximum "corners" based on the given vectors
+            float left = MathF.Min(tl.X, MathF.Min(tr.X, MathF.Min(bl.X, br.X)));
+            float top = MathF.Min(tl.Y, MathF.Min(tr.Y, MathF.Min(bl.Y, br.Y)));
+            float right = MathF.Max(tl.X, MathF.Max(tr.X, MathF.Max(bl.X, br.X)));
+            float bottom = MathF.Max(tl.Y, MathF.Max(tr.Y, MathF.Max(bl.Y, br.Y)));
+
+            return Rectangle.Round(RectangleF.FromLTRB(left, top, right, bottom));
+        }
+    }
+}

src/ImageSharp/Processing/ProjectiveTransformBuilder.cs

@@ -0,0 +1,319 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Collections.Generic;
+using System.Numerics;
+using SixLabors.ImageSharp.Processing.Processors.Transforms;
+using SixLabors.Primitives;
+
+namespace SixLabors.ImageSharp.Processing
+{
+    /// <summary>
+    /// A helper class for constructing <see cref="Matrix4x4"/> instances for use in projective transforms.
+    /// </summary>
+    public class ProjectiveTransformBuilder
+    {
+        private readonly List<Func<Size, Matrix4x4>> matrixFactories = new List<Func<Size, Matrix4x4>>();
+
+        /// <summary>
+        /// Prepends a matrix that performs a tapering projective transform.
+        /// </summary>
+        /// <param name="side">An enumeration that indicates the side of the rectangle that tapers.</param>
+        /// <param name="corner">An enumeration that indicates on which corners to taper the rectangle.</param>
+        /// <param name="fraction">The amount to taper.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        public ProjectiveTransformBuilder PrependTaper(TaperSide side, TaperCorner corner, float fraction)
+            => this.Prepend(size => TransformUtils.CreateTaperMatrix(size, side, corner, fraction));
+
+        /// <summary>
+        /// Appends a matrix that performs a tapering projective transform.
+        /// </summary>
+        /// <param name="side">An enumeration that indicates the side of the rectangle that tapers.</param>
+        /// <param name="corner">An enumeration that indicates on which corners to taper the rectangle.</param>
+        /// <param name="fraction">The amount to taper.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        public ProjectiveTransformBuilder AppendTaper(TaperSide side, TaperCorner corner, float fraction)
+            => this.Append(size => TransformUtils.CreateTaperMatrix(size, side, corner, fraction));
+
+        /// <summary>
+        /// Prepends a centered rotation matrix using the given rotation in degrees.
+        /// </summary>
+        /// <param name="degrees">The amount of rotation, in degrees.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        public ProjectiveTransformBuilder PrependRotationDegrees(float degrees)
+            => this.PrependRotationRadians(GeometryUtilities.DegreeToRadian(degrees));
+
+        /// <summary>
+        /// Prepends a centered rotation matrix using the given rotation in radians.
+        /// </summary>
+        /// <param name="radians">The amount of rotation, in radians.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        public ProjectiveTransformBuilder PrependRotationRadians(float radians)
+            => this.Prepend(size => new Matrix4x4(TransformUtils.CreateRotationMatrixRadians(radians, size)));
+
+        /// <summary>
+        /// Prepends a centered rotation matrix using the given rotation in degrees at the given origin.
+        /// </summary>
+        /// <param name="degrees">The amount of rotation, in radians.</param>
+        /// <param name="origin">The rotation origin point.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        internal ProjectiveTransformBuilder PrependRotationDegrees(float degrees, Vector2 origin)
+            => this.PrependRotationRadians(GeometryUtilities.DegreeToRadian(degrees), origin);
+
+        /// <summary>
+        /// Prepends a centered rotation matrix using the given rotation in radians at the given origin.
+        /// </summary>
+        /// <param name="radians">The amount of rotation, in radians.</param>
+        /// <param name="origin">The rotation origin point.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        internal ProjectiveTransformBuilder PrependRotationRadians(float radians, Vector2 origin)
+            => this.PrependMatrix(Matrix4x4.CreateRotationZ(radians, new Vector3(origin, 0)));
+
+        /// <summary>
+        /// Appends a centered rotation matrix using the given rotation in degrees.
+        /// </summary>
+        /// <param name="degrees">The amount of rotation, in degrees.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        public ProjectiveTransformBuilder AppendRotationDegrees(float degrees)
+            => this.AppendRotationRadians(GeometryUtilities.DegreeToRadian(degrees));
+
+        /// <summary>
+        /// Appends a centered rotation matrix using the given rotation in radians.
+        /// </summary>
+        /// <param name="radians">The amount of rotation, in radians.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        public ProjectiveTransformBuilder AppendRotationRadians(float radians)
+            => this.Append(size => new Matrix4x4(TransformUtils.CreateRotationMatrixRadians(radians, size)));
+
+        /// <summary>
+        /// Appends a centered rotation matrix using the given rotation in degrees at the given origin.
+        /// </summary>
+        /// <param name="degrees">The amount of rotation, in radians.</param>
+        /// <param name="origin">The rotation origin point.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        internal ProjectiveTransformBuilder AppendRotationDegrees(float degrees, Vector2 origin)
+            => this.AppendRotationRadians(GeometryUtilities.DegreeToRadian(degrees), origin);
+
+        /// <summary>
+        /// Appends a centered rotation matrix using the given rotation in radians at the given origin.
+        /// </summary>
+        /// <param name="radians">The amount of rotation, in radians.</param>
+        /// <param name="origin">The rotation origin point.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        internal ProjectiveTransformBuilder AppendRotationRadians(float radians, Vector2 origin)
+            => this.AppendMatrix(Matrix4x4.CreateRotationZ(radians, new Vector3(origin, 0)));
+
+        /// <summary>
+        /// Prepends a scale matrix from the given uniform scale.
+        /// </summary>
+        /// <param name="scale">The uniform scale.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        public ProjectiveTransformBuilder PrependScale(float scale)
+            => this.PrependMatrix(Matrix4x4.CreateScale(scale));
+
+        /// <summary>
+        /// Prepends a scale matrix from the given vector scale.
+        /// </summary>
+        /// <param name="scale">The horizontal and vertical scale.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        public ProjectiveTransformBuilder PrependScale(SizeF scale)
+            => this.PrependScale((Vector2)scale);
+
+        /// <summary>
+        /// Prepends a scale matrix from the given vector scale.
+        /// </summary>
+        /// <param name="scales">The horizontal and vertical scale.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        public ProjectiveTransformBuilder PrependScale(Vector2 scales)
+            => this.PrependMatrix(Matrix4x4.CreateScale(new Vector3(scales, 1F)));
+
+        /// <summary>
+        /// Appends a scale matrix from the given uniform scale.
+        /// </summary>
+        /// <param name="scale">The uniform scale.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        public ProjectiveTransformBuilder AppendScale(float scale)
+            => this.AppendMatrix(Matrix4x4.CreateScale(scale));
+
+        /// <summary>
+        /// Appends a scale matrix from the given vector scale.
+        /// </summary>
+        /// <param name="scales">The horizontal and vertical scale.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        public ProjectiveTransformBuilder AppendScale(SizeF scales)
+            => this.AppendScale((Vector2)scales);
+
+        /// <summary>
+        /// Appends a scale matrix from the given vector scale.
+        /// </summary>
+        /// <param name="scales">The horizontal and vertical scale.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        public ProjectiveTransformBuilder AppendScale(Vector2 scales)
+            => this.AppendMatrix(Matrix4x4.CreateScale(new Vector3(scales, 1F)));
+
+        /// <summary>
+        /// Prepends a centered skew matrix from the give angles in degrees.
+        /// </summary>
+        /// <param name="degreesX">The X angle, in degrees.</param>
+        /// <param name="degreesY">The Y angle, in degrees.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        internal ProjectiveTransformBuilder PrependSkewDegrees(float degreesX, float degreesY)
+            => this.PrependSkewRadians(GeometryUtilities.DegreeToRadian(degreesX), GeometryUtilities.DegreeToRadian(degreesY));
+
+        /// <summary>
+        /// Prepends a centered skew matrix from the give angles in radians.
+        /// </summary>
+        /// <param name="radiansX">The X angle, in radians.</param>
+        /// <param name="radiansY">The Y angle, in radians.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        public ProjectiveTransformBuilder PrependSkewRadians(float radiansX, float radiansY)
+            => this.Prepend(size => new Matrix4x4(TransformUtils.CreateSkewMatrixRadians(radiansX, radiansY, size)));
+
+        /// <summary>
+        /// Prepends a skew matrix using the given angles in degrees at the given origin.
+        /// </summary>
+        /// <param name="degreesX">The X angle, in degrees.</param>
+        /// <param name="degreesY">The Y angle, in degrees.</param>
+        /// <param name="origin">The skew origin point.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        public ProjectiveTransformBuilder PrependSkewDegrees(float degreesX, float degreesY, Vector2 origin)
+            => this.PrependSkewRadians(GeometryUtilities.DegreeToRadian(degreesX), GeometryUtilities.DegreeToRadian(degreesY), origin);
+
+        /// <summary>
+        /// Prepends a skew matrix using the given angles in radians at the given origin.
+        /// </summary>
+        /// <param name="radiansX">The X angle, in radians.</param>
+        /// <param name="radiansY">The Y angle, in radians.</param>
+        /// <param name="origin">The skew origin point.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        public ProjectiveTransformBuilder PrependSkewRadians(float radiansX, float radiansY, Vector2 origin)
+            => this.PrependMatrix(new Matrix4x4(Matrix3x2.CreateSkew(radiansX, radiansY, origin)));
+
+        /// <summary>
+        /// Appends a centered skew matrix from the give angles in degrees.
+        /// </summary>
+        /// <param name="degreesX">The X angle, in degrees.</param>
+        /// <param name="degreesY">The Y angle, in degrees.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        internal ProjectiveTransformBuilder AppendSkewDegrees(float degreesX, float degreesY)
+            => this.AppendSkewRadians(GeometryUtilities.DegreeToRadian(degreesX), GeometryUtilities.DegreeToRadian(degreesY));
+
+        /// <summary>
+        /// Appends a centered skew matrix from the give angles in radians.
+        /// </summary>
+        /// <param name="radiansX">The X angle, in radians.</param>
+        /// <param name="radiansY">The Y angle, in radians.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        public ProjectiveTransformBuilder AppendSkewRadians(float radiansX, float radiansY)
+            => this.Append(size => new Matrix4x4(TransformUtils.CreateSkewMatrixRadians(radiansX, radiansY, size)));
+
+        /// <summary>
+        /// Appends a skew matrix using the given angles in degrees at the given origin.
+        /// </summary>
+        /// <param name="degreesX">The X angle, in degrees.</param>
+        /// <param name="degreesY">The Y angle, in degrees.</param>
+        /// <param name="origin">The skew origin point.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        public ProjectiveTransformBuilder AppendSkewDegrees(float degreesX, float degreesY, Vector2 origin)
+            => this.AppendSkewRadians(GeometryUtilities.DegreeToRadian(degreesX), GeometryUtilities.DegreeToRadian(degreesY), origin);
+
+        /// <summary>
+        /// Appends a skew matrix using the given angles in radians at the given origin.
+        /// </summary>
+        /// <param name="radiansX">The X angle, in radians.</param>
+        /// <param name="radiansY">The Y angle, in radians.</param>
+        /// <param name="origin">The skew origin point.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        public ProjectiveTransformBuilder AppendSkewRadians(float radiansX, float radiansY, Vector2 origin)
+            => this.AppendMatrix(new Matrix4x4(Matrix3x2.CreateSkew(radiansX, radiansY, origin)));
+
+        /// <summary>
+        /// Prepends a translation matrix from the given vector.
+        /// </summary>
+        /// <param name="position">The translation position.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        public ProjectiveTransformBuilder PrependTranslation(PointF position)
+            => this.PrependTranslation((Vector2)position);
+
+        /// <summary>
+        /// Prepends a translation matrix from the given vector.
+        /// </summary>
+        /// <param name="position">The translation position.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        public ProjectiveTransformBuilder PrependTranslation(Vector2 position)
+            => this.PrependMatrix(Matrix4x4.CreateTranslation(new Vector3(position, 0)));
+
+        /// <summary>
+        /// Appends a translation matrix from the given vector.
+        /// </summary>
+        /// <param name="position">The translation position.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        public ProjectiveTransformBuilder AppendTranslation(PointF position)
+            => this.AppendTranslation((Vector2)position);
+
+        /// <summary>
+        /// Appends a translation matrix from the given vector.
+        /// </summary>
+        /// <param name="position">The translation position.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        public ProjectiveTransformBuilder AppendTranslation(Vector2 position)
+            => this.AppendMatrix(Matrix4x4.CreateTranslation(new Vector3(position, 0)));
+
+        /// <summary>
+        /// Prepends a raw matrix.
+        /// </summary>
+        /// <param name="matrix">The matrix to prepend.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        public ProjectiveTransformBuilder PrependMatrix(Matrix4x4 matrix) => this.Prepend(_ => matrix);
+
+        /// <summary>
+        /// Appends a raw matrix.
+        /// </summary>
+        /// <param name="matrix">The matrix to append.</param>
+        /// <returns>The <see cref="ProjectiveTransformBuilder"/>.</returns>
+        public ProjectiveTransformBuilder AppendMatrix(Matrix4x4 matrix) => this.Append(_ => matrix);
+
+        /// <summary>
+        /// Returns the combined matrix for a given source size.
+        /// </summary>
+        /// <param name="sourceSize">The source image size.</param>
+        /// <returns>The <see cref="Matrix4x4"/>.</returns>
+        public Matrix4x4 BuildMatrix(Size sourceSize) => this.BuildMatrix(new Rectangle(Point.Empty, sourceSize));
+
+        /// <summary>
+        /// Returns the combined matrix for a given source rectangle.
+        /// </summary>
+        /// <param name="sourceRectangle">The rectangle in the source image.</param>
+        /// <returns>The <see cref="Matrix4x4"/>.</returns>
+        public Matrix4x4 BuildMatrix(Rectangle sourceRectangle)
+        {
+            Guard.MustBeGreaterThan(sourceRectangle.Width, 0, nameof(sourceRectangle));
+            Guard.MustBeGreaterThan(sourceRectangle.Height, 0, nameof(sourceRectangle));
+
+            // Translate the origin matrix to cater for source rectangle offsets.
+            var matrix = Matrix4x4.CreateTranslation(new Vector3(-sourceRectangle.Location, 0));
+
+            Size size = sourceRectangle.Size;
+
+            foreach (Func<Size, Matrix4x4> factory in this.matrixFactories)
+            {
+                matrix *= factory(size);
+            }
+
+            return matrix;
+        }
+
+        private ProjectiveTransformBuilder Prepend(Func<Size, Matrix4x4> factory)
+        {
+            this.matrixFactories.Insert(0, factory);
+            return this;
+        }
+
+        private ProjectiveTransformBuilder Append(Func<Size, Matrix4x4> factory)
+        {
+            this.matrixFactories.Add(factory);
+            return this;
+        }
+    }
+}

src/ImageSharp/Processing/ProjectiveTransformHelper.cs

@@ -1,166 +0,0 @@
-// Copyright (c) Six Labors and contributors.
-// Licensed under the Apache License, Version 2.0.
-
-using System.Numerics;
-using SixLabors.Primitives;
-
-namespace SixLabors.ImageSharp.Processing
-{
-    /// <summary>
-    /// Enumerates the various options which determine which side to taper
-    /// </summary>
-    public enum TaperSide
-    {
-        /// <summary>
-        /// Taper the left side
-        /// </summary>
-        Left,
-
-        /// <summary>
-        /// Taper the top side
-        /// </summary>
-        Top,
-
-        /// <summary>
-        /// Taper the right side
-        /// </summary>
-        Right,
-
-        /// <summary>
-        /// Taper the bottom side
-        /// </summary>
-        Bottom
-    }
-
-    /// <summary>
-    /// Enumerates the various options which determine how to taper corners
-    /// </summary>
-    public enum TaperCorner
-    {
-        /// <summary>
-        /// Taper the left or top corner
-        /// </summary>
-        LeftOrTop,
-
-        /// <summary>
-        /// Taper the right or bottom corner
-        /// </summary>
-        RightOrBottom,
-
-        /// <summary>
-        /// Taper the both sets of corners
-        /// </summary>
-        Both
-    }
-
-    /// <summary>
-    /// Provides helper methods for working with generalized projective transforms.
-    /// </summary>
-    public static class ProjectiveTransformHelper
-    {
-        /// <summary>
-        /// Creates a matrix that performs a tapering projective transform.
-        /// <see href="https://docs.microsoft.com/en-us/xamarin/xamarin-forms/user-interface/graphics/skiasharp/transforms/non-affine"/>
-        /// </summary>
-        /// <param name="size">The rectangular size of the image being transformed.</param>
-        /// <param name="taperSide">An enumeration that indicates the side of the rectangle that tapers.</param>
-        /// <param name="taperCorner">An enumeration that indicates on which corners to taper the rectangle.</param>
-        /// <param name="taperFraction">The amount to taper.</param>
-        /// <returns>The <see cref="Matrix4x4"/></returns>
-        public static Matrix4x4 CreateTaperMatrix(Size size, TaperSide taperSide, TaperCorner taperCorner, float taperFraction)
-        {
-            Matrix4x4 matrix = Matrix4x4.Identity;
-
-            switch (taperSide)
-            {
-                case TaperSide.Left:
-                    matrix.M11 = taperFraction;
-                    matrix.M22 = taperFraction;
-                    matrix.M13 = (taperFraction - 1) / size.Width;
-
-                    switch (taperCorner)
-                    {
-                        case TaperCorner.RightOrBottom:
-                            break;
-
-                        case TaperCorner.LeftOrTop:
-                            matrix.M12 = size.Height * matrix.M13;
-                            matrix.M32 = size.Height * (1 - taperFraction);
-                            break;
-
-                        case TaperCorner.Both:
-                            matrix.M12 = (size.Height * 0.5f) * matrix.M13;
-                            matrix.M32 = size.Height * (1 - taperFraction) / 2;
-                            break;
-                    }
-
-                    break;
-
-                case TaperSide.Top:
-                    matrix.M11 = taperFraction;
-                    matrix.M22 = taperFraction;
-                    matrix.M23 = (taperFraction - 1) / size.Height;
-
-                    switch (taperCorner)
-                    {
-                        case TaperCorner.RightOrBottom:
-                            break;
-
-                        case TaperCorner.LeftOrTop:
-                            matrix.M21 = size.Width * matrix.M23;
-                            matrix.M31 = size.Width * (1 - taperFraction);
-                            break;
-
-                        case TaperCorner.Both:
-                            matrix.M21 = (size.Width * 0.5f) * matrix.M23;
-                            matrix.M31 = size.Width * (1 - taperFraction) / 2;
-                            break;
-                    }
-
-                    break;
-
-                case TaperSide.Right:
-                    matrix.M11 = 1 / taperFraction;
-                    matrix.M13 = (1 - taperFraction) / (size.Width * taperFraction);
-
-                    switch (taperCorner)
-                    {
-                        case TaperCorner.RightOrBottom:
-                            break;
-
-                        case TaperCorner.LeftOrTop:
-                            matrix.M12 = size.Height * matrix.M13;
-                            break;
-
-                        case TaperCorner.Both:
-                            matrix.M12 = (size.Height * 0.5f) * matrix.M13;
-                            break;
-                    }
-
-                    break;
-
-                case TaperSide.Bottom:
-                    matrix.M22 = 1 / taperFraction;
-                    matrix.M23 = (1 - taperFraction) / (size.Height * taperFraction);
-
-                    switch (taperCorner)
-                    {
-                        case TaperCorner.RightOrBottom:
-                            break;
-
-                        case TaperCorner.LeftOrTop:
-                            matrix.M21 = size.Width * matrix.M23;
-                            break;
-
-                        case TaperCorner.Both:
-                            matrix.M21 = (size.Width * 0.5f) * matrix.M23;
-                            break;
-                    }
-
-                    break;
-            }
-
-            return matrix;
-        }
-    }
-}

src/ImageSharp/Processing/TaperCorner.cs

@@ -0,0 +1,26 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Processing
+{
+    /// <summary>
+    /// Enumerates the various options which determine how to taper corners
+    /// </summary>
+    public enum TaperCorner
+    {
+        /// <summary>
+        /// Taper the left or top corner
+        /// </summary>
+        LeftOrTop,
+
+        /// <summary>
+        /// Taper the right or bottom corner
+        /// </summary>
+        RightOrBottom,
+
+        /// <summary>
+        /// Taper the both sets of corners
+        /// </summary>
+        Both
+    }
+}

src/ImageSharp/Processing/TaperSide.cs

@@ -0,0 +1,31 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Processing
+{
+    /// <summary>
+    /// Enumerates the various options which determine which side to taper
+    /// </summary>
+    public enum TaperSide
+    {
+        /// <summary>
+        /// Taper the left side
+        /// </summary>
+        Left,
+
+        /// <summary>
+        /// Taper the top side
+        /// </summary>
+        Top,
+
+        /// <summary>
+        /// Taper the right side
+        /// </summary>
+        Right,
+
+        /// <summary>
+        /// Taper the bottom side
+        /// </summary>
+        Bottom
+    }
+}

src/ImageSharp/Processing/TransformExtensions.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System.Numerics;
+
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing.Processors.Transforms;
 using SixLabors.Primitives;
@@ -14,109 +15,147 @@ namespace SixLabors.ImageSharp.Processing
     public static class TransformExtensions
     {
         /// <summary>
-        /// Transforms an image by the given matrix.
+        /// Performs an affine transform of an image.
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="source">The image to transform.</param>
-        /// <param name="matrix">The transformation matrix.</param>
+        /// <param name="builder">The affine transform builder.</param>
         /// <returns>The <see cref="Image{TPixel}"/></returns>
-        public static IImageProcessingContext<TPixel> Transform<TPixel>(this IImageProcessingContext<TPixel> source, Matrix3x2 matrix)
+        public static IImageProcessingContext<TPixel> Transform<TPixel>(
+            this IImageProcessingContext<TPixel> source,
+            AffineTransformBuilder builder)
             where TPixel : struct, IPixel<TPixel>
-            => Transform(source, matrix, KnownResamplers.Bicubic);
+            => Transform(source, builder, KnownResamplers.Bicubic);
 
         /// <summary>
-        /// Transforms an image by the given matrix using the specified sampling algorithm.
+        /// Performs an affine transform of an image using the specified sampling algorithm.
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
-        /// <param name="source">The image to transform.</param>
+        /// <param name="ctx">The <see cref="IImageProcessingContext{TPixel}"/>.</param>
-        /// <param name="matrix">The transformation matrix.</param>
+        /// <param name="builder">The affine transform builder.</param>
         /// <param name="sampler">The <see cref="IResampler"/> to perform the resampling.</param>
         /// <returns>The <see cref="Image{TPixel}"/></returns>
-        public static IImageProcessingContext<TPixel> Transform<TPixel>(this IImageProcessingContext<TPixel> source, Matrix3x2 matrix, IResampler sampler)
+        public static IImageProcessingContext<TPixel> Transform<TPixel>(
+            this IImageProcessingContext<TPixel> ctx,
+            AffineTransformBuilder builder,
+            IResampler sampler)
             where TPixel : struct, IPixel<TPixel>
-            => source.ApplyProcessor(new AffineTransformProcessor<TPixel>(matrix, sampler, source.GetCurrentSize()));
+            => ctx.Transform(new Rectangle(Point.Empty, ctx.GetCurrentSize()), builder, sampler);
 
         /// <summary>
-        /// Transforms an image by the given matrix using the specified sampling algorithm
+        /// Performs an affine transform of an image using the specified sampling algorithm.
-        /// and a rectangle defining the transform origin in the source image and the size of the result image.
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
-        /// <param name="source">The image to transform.</param>
+        /// <param name="ctx">The <see cref="IImageProcessingContext{TPixel}"/>.</param>
-        /// <param name="matrix">The transformation matrix.</param>
+        /// <param name="sourceRectangle">The source rectangle</param>
+        /// <param name="builder">The affine transform builder.</param>
         /// <param name="sampler">The <see cref="IResampler"/> to perform the resampling.</param>
-        /// <param name="rectangle">
-        /// The rectangle defining the transform origin in the source image, and the size of the result image.
-        /// </param>
         /// <returns>The <see cref="Image{TPixel}"/></returns>
         public static IImageProcessingContext<TPixel> Transform<TPixel>(
-            this IImageProcessingContext<TPixel> source,
+            this IImageProcessingContext<TPixel> ctx,
-            Matrix3x2 matrix,
+            Rectangle sourceRectangle,
-            IResampler sampler,
+            AffineTransformBuilder builder,
-            Rectangle rectangle)
+            IResampler sampler)
             where TPixel : struct, IPixel<TPixel>
         {
-            var t = Matrix3x2.CreateTranslation(-rectangle.Location);
+            Matrix3x2 transform = builder.BuildMatrix(sourceRectangle);
-            Matrix3x2 combinedMatrix = t * matrix;
+            Size targetDimensions = TransformUtils.GetTransformedSize(sourceRectangle.Size, transform);
-            return source.ApplyProcessor(new AffineTransformProcessor<TPixel>(combinedMatrix, sampler, rectangle.Size));
+            return ctx.Transform(sourceRectangle, transform, targetDimensions, sampler);
         }
 
         /// <summary>
-        /// Transforms an image by the given matrix using the specified sampling algorithm,
+        /// Performs an affine transform of an image using the specified sampling algorithm.
-        /// cropping or extending the image according to <paramref name="destinationSize"/>.
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
-        /// <param name="source">The image to transform.</param>
+        /// <param name="ctx">The <see cref="IImageProcessingContext{TPixel}"/>.</param>
-        /// <param name="matrix">The transformation matrix.</param>
+        /// <param name="sourceRectangle">The source rectangle</param>
+        /// <param name="transform">The transformation matrix.</param>
+        /// <param name="targetDimensions">The size of the result image.</param>
         /// <param name="sampler">The <see cref="IResampler"/> to perform the resampling.</param>
-        /// <param name="destinationSize">The size of the destination image.</param>
         /// <returns>The <see cref="Image{TPixel}"/></returns>
         public static IImageProcessingContext<TPixel> Transform<TPixel>(
-            this IImageProcessingContext<TPixel> source,
+            this IImageProcessingContext<TPixel> ctx,
-            Matrix3x2 matrix,
+            Rectangle sourceRectangle,
-            IResampler sampler,
+            Matrix3x2 transform,
-            Size destinationSize)
+            Size targetDimensions,
+            IResampler sampler)
             where TPixel : struct, IPixel<TPixel>
-            => source.ApplyProcessor(new AffineTransformProcessor<TPixel>(matrix, sampler, destinationSize));
+        {
+            return ctx.ApplyProcessor(
+                new AffineTransformProcessor<TPixel>(transform, sampler, targetDimensions),
+                sourceRectangle);
+        }
 
         /// <summary>
-        /// Transforms an image by the given matrix.
+        /// Performs a projective transform of an image.
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
         /// <param name="source">The image to transform.</param>
-        /// <param name="matrix">The transformation matrix.</param>
+        /// <param name="builder">The affine transform builder.</param>
         /// <returns>The <see cref="Image{TPixel}"/></returns>
-        public static IImageProcessingContext<TPixel> Transform<TPixel>(this IImageProcessingContext<TPixel> source, Matrix4x4 matrix)
+        public static IImageProcessingContext<TPixel> Transform<TPixel>(
+            this IImageProcessingContext<TPixel> source,
+            ProjectiveTransformBuilder builder)
             where TPixel : struct, IPixel<TPixel>
-            => Transform(source, matrix, KnownResamplers.Bicubic);
+            => Transform(source, builder, KnownResamplers.Bicubic);
 
         /// <summary>
-        /// Applies a projective transform to the image by the given matrix using the specified sampling algorithm.
+        /// Performs a projective transform of an image using the specified sampling algorithm.
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
-        /// <param name="source">The image to transform.</param>
+        /// <param name="ctx">The <see cref="IImageProcessingContext{TPixel}"/>.</param>
-        /// <param name="matrix">The transformation matrix.</param>
+        /// <param name="builder">The projective transform builder.</param>
         /// <param name="sampler">The <see cref="IResampler"/> to perform the resampling.</param>
         /// <returns>The <see cref="Image{TPixel}"/></returns>
-        public static IImageProcessingContext<TPixel> Transform<TPixel>(this IImageProcessingContext<TPixel> source, Matrix4x4 matrix, IResampler sampler)
+        public static IImageProcessingContext<TPixel> Transform<TPixel>(
+            this IImageProcessingContext<TPixel> ctx,
+            ProjectiveTransformBuilder builder,
+            IResampler sampler)
             where TPixel : struct, IPixel<TPixel>
-            => source.ApplyProcessor(new ProjectiveTransformProcessor<TPixel>(matrix, sampler, source.GetCurrentSize()));
+            => ctx.Transform(new Rectangle(Point.Empty, ctx.GetCurrentSize()), builder, sampler);
 
         /// <summary>
-        /// Applies a projective transform to the image by the given matrix using the specified sampling algorithm.
+        /// Performs a projective transform of an image using the specified sampling algorithm.
-        /// TODO: Should we be offsetting the matrix here?
         /// </summary>
         /// <typeparam name="TPixel">The pixel format.</typeparam>
-        /// <param name="source">The image to transform.</param>
+        /// <param name="ctx">The <see cref="IImageProcessingContext{TPixel}"/>.</param>
-        /// <param name="matrix">The transformation matrix.</param>
+        /// <param name="sourceRectangle">The source rectangle</param>
+        /// <param name="builder">The projective transform builder.</param>
         /// <param name="sampler">The <see cref="IResampler"/> to perform the resampling.</param>
-        /// <param name="rectangle">The rectangle to constrain the transformed image to.</param>
         /// <returns>The <see cref="Image{TPixel}"/></returns>
-        internal static IImageProcessingContext<TPixel> Transform<TPixel>(this IImageProcessingContext<TPixel> source, Matrix4x4 matrix, IResampler sampler, Rectangle rectangle)
+        public static IImageProcessingContext<TPixel> Transform<TPixel>(
+            this IImageProcessingContext<TPixel> ctx,
+            Rectangle sourceRectangle,
+            ProjectiveTransformBuilder builder,
+            IResampler sampler)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            Matrix4x4 transform = builder.BuildMatrix(sourceRectangle);
+            Size targetDimensions = TransformUtils.GetTransformedSize(sourceRectangle.Size, transform);
+            return ctx.Transform(sourceRectangle, transform, targetDimensions, sampler);
+        }
+
+        /// <summary>
+        /// Performs a projective transform of an image using the specified sampling algorithm.
+        /// </summary>
+        /// <typeparam name="TPixel">The pixel format.</typeparam>
+        /// <param name="ctx">The <see cref="IImageProcessingContext{TPixel}"/>.</param>
+        /// <param name="sourceRectangle">The source rectangle</param>
+        /// <param name="transform">The transformation matrix.</param>
+        /// <param name="targetDimensions">The size of the result image.</param>
+        /// <param name="sampler">The <see cref="IResampler"/> to perform the resampling.</param>
+        /// <returns>The <see cref="Image{TPixel}"/></returns>
+        public static IImageProcessingContext<TPixel> Transform<TPixel>(
+            this IImageProcessingContext<TPixel> ctx,
+            Rectangle sourceRectangle,
+            Matrix4x4 transform,
+            Size targetDimensions,
+            IResampler sampler)
             where TPixel : struct, IPixel<TPixel>
         {
-            var t = Matrix4x4.CreateTranslation(new Vector3(-rectangle.Location, 0));
+            return ctx.ApplyProcessor(
-            Matrix4x4 combinedMatrix = t * matrix;
+                new ProjectiveTransformProcessor<TPixel>(transform, sampler, targetDimensions),
-            return source.ApplyProcessor(new ProjectiveTransformProcessor<TPixel>(combinedMatrix, sampler, rectangle.Size));
+                sourceRectangle);
         }
     }
 }

tests/ImageSharp.Benchmarks/Samplers/Rotate.cs

@@ -0,0 +1,45 @@
+using BenchmarkDotNet.Attributes;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing;
+using SixLabors.Primitives;
+
+namespace SixLabors.ImageSharp.Benchmarks.Samplers
+{
+    [Config(typeof(Config.ShortClr))]
+    public class Rotate
+    {
+        [Benchmark]
+        public Size DoRotate()
+        {
+            using (var image = new Image<Rgba32>(Configuration.Default, 400, 400, Rgba32.BlanchedAlmond))
+            {
+                image.Mutate(x => x.Rotate(37.5F));
+
+                return image.Size();
+            }
+        }
+    }
+}
+
+// Nov 7 2018
+//BenchmarkDotNet=v0.10.14, OS=Windows 10.0.17763
+//Intel Core i7-6600U CPU 2.60GHz(Skylake), 1 CPU, 4 logical and 2 physical cores
+//.NET Core SDK = 2.1.403
+
+// [Host]     : .NET Core 2.1.5 (CoreCLR 4.6.26919.02, CoreFX 4.6.26919.02), 64bit RyuJIT
+//  Job-KKDIMW : .NET Framework 4.7.1 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3190.0
+//  Job-IUZRFA : .NET Core 2.1.5 (CoreCLR 4.6.26919.02, CoreFX 4.6.26919.02), 64bit RyuJIT
+
+//LaunchCount=1  TargetCount=3  WarmupCount=3
+
+// #### BEFORE ####:
+//   Method | Runtime |     Mean |     Error |    StdDev | Allocated |
+//--------- |-------- |---------:|----------:|----------:|----------:|
+// DoRotate |     Clr | 85.19 ms | 13.379 ms | 0.7560 ms |      6 KB |
+// DoRotate |    Core | 53.51 ms |  9.512 ms | 0.5375 ms |   4.29 KB |
+
+// #### AFTER ####:
+//Method | Runtime |     Mean |    Error |   StdDev | Allocated |
+//--------- |-------- |---------:|---------:|---------:|----------:|
+// DoRotate |     Clr | 77.08 ms | 23.97 ms | 1.354 ms |      6 KB |
+// DoRotate |    Core | 40.36 ms | 47.43 ms | 2.680 ms |   4.36 KB |

tests/ImageSharp.Benchmarks/Samplers/Skew.cs

@@ -0,0 +1,45 @@
+using BenchmarkDotNet.Attributes;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing;
+using SixLabors.Primitives;
+
+namespace SixLabors.ImageSharp.Benchmarks.Samplers
+{
+    [Config(typeof(Config.ShortClr))]
+    public class Skew
+    {
+        [Benchmark]
+        public Size DoSkew()
+        {
+            using (var image = new Image<Rgba32>(Configuration.Default, 400, 400, Rgba32.BlanchedAlmond))
+            {
+                image.Mutate(x => x.Skew(20, 10));
+
+                return image.Size();
+            }
+        }
+    }
+}
+
+// Nov 7 2018
+//BenchmarkDotNet=v0.10.14, OS=Windows 10.0.17763
+//Intel Core i7-6600U CPU 2.60GHz(Skylake), 1 CPU, 4 logical and 2 physical cores
+//.NET Core SDK = 2.1.403
+
+// [Host]     : .NET Core 2.1.5 (CoreCLR 4.6.26919.02, CoreFX 4.6.26919.02), 64bit RyuJIT
+//  Job-KKDIMW : .NET Framework 4.7.1 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3190.0
+//  Job-IUZRFA : .NET Core 2.1.5 (CoreCLR 4.6.26919.02, CoreFX 4.6.26919.02), 64bit RyuJIT
+
+//LaunchCount=1  TargetCount=3  WarmupCount=3
+
+// #### BEFORE ####:
+//Method | Runtime |     Mean |    Error |    StdDev | Allocated |
+//------- |-------- |---------:|---------:|----------:|----------:|
+// DoSkew |     Clr | 78.14 ms | 8.383 ms | 0.4736 ms |      6 KB |
+// DoSkew |    Core | 44.22 ms | 4.109 ms | 0.2322 ms |   4.28 KB |
+
+// #### AFTER ####:
+//Method | Runtime |     Mean |     Error |    StdDev | Allocated |
+//------- |-------- |---------:|----------:|----------:|----------:|
+// DoSkew |     Clr | 71.63 ms | 25.589 ms | 1.4458 ms |      6 KB |
+// DoSkew |    Core | 38.99 ms |  8.640 ms | 0.4882 ms |   4.36 KB |

tests/ImageSharp.Tests/Advanced/AotCompilerTests.cs

@@ -10,9 +10,6 @@ namespace SixLabors.ImageSharp.Tests.Advanced
     public class AotCompilerTests
     {
         [Fact]
-        public void AotCompiler_NoExceptions()
+        public void AotCompiler_NoExceptions() => AotCompilerTools.Seed<Rgba32, Rgb24, Bgr24>();
-        {
-            AotCompilerTools.Seed<Rgba32>();
-        }
     }
 }

tests/ImageSharp.Tests/Drawing/DrawImageTest.cs

@@ -2,10 +2,8 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
-using System.Numerics;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
-using SixLabors.ImageSharp.Processing.Processors.Transforms;
 using SixLabors.ImageSharp.Tests.TestUtilities.ImageComparison;
 using SixLabors.Primitives;
 using Xunit;
@@ -75,21 +73,15 @@ namespace SixLabors.ImageSharp.Tests
             using (Image<TPixel> image = provider.GetImage())
             using (var blend = Image.Load<TPixel>(TestFile.Create(TestImages.Bmp.Car).Bytes))
             {
-                Matrix3x2 rotate = Matrix3x2Extensions.CreateRotationDegrees(45F);
+                AffineTransformBuilder builder = new AffineTransformBuilder()
-                Matrix3x2 scale = Matrix3x2Extensions.CreateScale(new SizeF(.25F, .25F));
+                    .AppendRotationDegrees(45F)
-                Matrix3x2 matrix = rotate * scale;
+                    .AppendScale(new SizeF(.25F, .25F))
+                    .AppendTranslation(new PointF(10, 10));
 
-                // Lets center the matrix so we can tell whether any cut-off issues we may have belong to the drawing processor
+                // Apply a background color so we can see the translation.
-                Rectangle srcBounds = blend.Bounds();
+                blend.Mutate(x => x.Transform(builder).BackgroundColor(NamedColors<TPixel>.HotPink));
-                Rectangle destBounds = TransformHelpers.GetTransformedBoundingRectangle(srcBounds, matrix);
-                Matrix3x2 centeredMatrix = TransformHelpers.GetCenteredTransformMatrix(srcBounds, destBounds, matrix);
-
-                // We pass a new rectangle here based on the dest bounds since we've offset the matrix
-                blend.Mutate(x => x.Transform(
-                    centeredMatrix,
-                    KnownResamplers.Bicubic,
-                    new Rectangle(0, 0, destBounds.Width, destBounds.Height)));
 
+                // Lets center the matrix so we can tell whether any cut-off issues we may have belong to the drawing processor
                 var position = new Point((image.Width - blend.Width) / 2, (image.Height - blend.Height) / 2);
                 image.Mutate(x => x.DrawImage(blend, position, mode, .75F));
                 image.DebugSave(provider, new[] { "Transformed" });

tests/ImageSharp.Tests/Formats/Jpg/JpegDecoderTests.cs

@@ -49,7 +49,8 @@ namespace SixLabors.ImageSharp.Tests.Formats.Jpg
                     TestImages.Jpeg.Issues.NoEoiProgressive517,
                     TestImages.Jpeg.Issues.BadRstProgressive518,
                     TestImages.Jpeg.Issues.InvalidEOI695,
-                    TestImages.Jpeg.Issues.ExifResizeOutOfRange696
+                    TestImages.Jpeg.Issues.ExifResizeOutOfRange696,
+                    TestImages.Jpeg.Issues.ExifGetString750Transform
                 };
 
             return !TestEnvironment.Is64BitProcess && largeImagesToSkipOn32Bit.Contains(provider.SourceFileOrDescription);

tests/ImageSharp.Tests/Processing/Transforms/AffineTransformBuilderTests.cs

@@ -0,0 +1,71 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System.Numerics;
+using SixLabors.ImageSharp.Processing;
+using SixLabors.Primitives;
+
+namespace SixLabors.ImageSharp.Tests.Processing.Transforms
+{
+    public class AffineTransformBuilderTests : TransformBuilderTestBase<AffineTransformBuilder>
+    {
+        protected override AffineTransformBuilder CreateBuilder(Rectangle rectangle) => new AffineTransformBuilder();
+
+        protected override void AppendRotationDegrees(AffineTransformBuilder builder, float degrees)
+            => builder.AppendRotationDegrees(degrees);
+
+        protected override void AppendRotationDegrees(AffineTransformBuilder builder, float degrees, Vector2 origin)
+            => builder.AppendRotationDegrees(degrees, origin);
+
+        protected override void AppendRotationRadians(AffineTransformBuilder builder, float radians)
+            => builder.AppendRotationRadians(radians);
+
+        protected override void AppendRotationRadians(AffineTransformBuilder builder, float radians, Vector2 origin)
+            => builder.AppendRotationRadians(radians, origin);
+
+        protected override void AppendScale(AffineTransformBuilder builder, SizeF scale)
+            => builder.AppendScale(scale);
+
+        protected override void AppendSkewDegrees(AffineTransformBuilder builder, float degreesX, float degreesY)
+            => builder.AppendSkewDegrees(degreesX, degreesY);
+
+        protected override void AppendSkewDegrees(AffineTransformBuilder builder, float degreesX, float degreesY, Vector2 origin)
+            => builder.AppendSkewDegrees(degreesX, degreesY, origin);
+
+        protected override void AppendSkewRadians(AffineTransformBuilder builder, float radiansX, float radiansY)
+            => builder.AppendSkewRadians(radiansX, radiansY);
+
+        protected override void AppendSkewRadians(AffineTransformBuilder builder, float radiansX, float radiansY, Vector2 origin)
+            => builder.AppendSkewRadians(radiansX, radiansY, origin);
+
+        protected override void AppendTranslation(AffineTransformBuilder builder, PointF translate)
+            => builder.AppendTranslation(translate);
+
+        protected override void PrependRotationRadians(AffineTransformBuilder builder, float radians)
+            => builder.PrependRotationRadians(radians);
+
+        protected override void PrependRotationRadians(AffineTransformBuilder builder, float radians, Vector2 origin)
+            => builder.PrependRotationRadians(radians, origin);
+
+        protected override void PrependScale(AffineTransformBuilder builder, SizeF scale)
+            => builder.PrependScale(scale);
+
+        protected override void PrependSkewRadians(AffineTransformBuilder builder, float radiansX, float radiansY)
+            => builder.PrependSkewRadians(radiansX, radiansY);
+
+        protected override void PrependSkewRadians(AffineTransformBuilder builder, float radiansX, float radiansY, Vector2 origin)
+            => builder.PrependSkewRadians(radiansX, radiansY, origin);
+
+        protected override void PrependTranslation(AffineTransformBuilder builder, PointF translate)
+            => builder.PrependTranslation(translate);
+
+        protected override Vector2 Execute(
+            AffineTransformBuilder builder,
+            Rectangle rectangle,
+            Vector2 sourcePoint)
+        {
+            Matrix3x2 matrix = builder.BuildMatrix(rectangle);
+            return Vector2.Transform(sourcePoint, matrix);
+        }
+    }
+}

tests/ImageSharp.Tests/Processing/Transforms/AffineTransformTests.cs

@@ -17,7 +17,8 @@ namespace SixLabors.ImageSharp.Tests.Processing.Transforms
     {
         private readonly ITestOutputHelper Output;
 
-        private static readonly ImageComparer ValidatorComparer = ImageComparer.TolerantPercentage(0.0085f, 3);
+        // 1 byte difference on one color component.
+        private static readonly ImageComparer ValidatorComparer = ImageComparer.TolerantPercentage(0.0134F, 3);
 
         /// <summary>
         /// angleDeg, sx, sy, tx, ty
@@ -78,15 +79,10 @@ namespace SixLabors.ImageSharp.Tests.Processing.Transforms
             IResampler resampler = GetResampler(resamplerName);
             using (Image<TPixel> image = provider.GetImage())
             {
-                var rotate = Matrix3x2.CreateRotation((float)Math.PI / 4F, new Vector2(5 / 2F, 5 / 2F));
+                AffineTransformBuilder builder = new AffineTransformBuilder()
-                var translate = Matrix3x2.CreateTranslation((7 - 5) / 2F, (7 - 5) / 2F);
+                    .AppendRotationDegrees(30);
 
-                Rectangle sourceRectangle = image.Bounds();
+                image.Mutate(c => c.Transform(builder, resampler));
-                Matrix3x2 matrix = rotate * translate;
-
-                Rectangle destRectangle = TransformHelpers.GetTransformedBoundingRectangle(sourceRectangle, matrix);
-
-                image.Mutate(c => c.Transform(matrix, resampler, destRectangle));
                 image.DebugSave(provider, resamplerName);
 
                 VerifyAllPixelsAreWhiteOrTransparent(image);
@@ -104,14 +100,15 @@ namespace SixLabors.ImageSharp.Tests.Processing.Transforms
         {
             using (Image<TPixel> image = provider.GetImage())
             {
-                Matrix3x2 rotate = Matrix3x2Extensions.CreateRotationDegrees(angleDeg);
+                image.DebugSave(provider, $"_original");
-                var translate = Matrix3x2.CreateTranslation(tx, ty);
+                AffineTransformBuilder builder = new AffineTransformBuilder()
-                var scale = Matrix3x2.CreateScale(sx, sy);
+                    .AppendRotationDegrees(angleDeg)
-                Matrix3x2 m = rotate * scale * translate;
+                    .AppendScale(new SizeF(sx, sy))
+                    .AppendTranslation(new PointF(tx, ty));
 
-                this.PrintMatrix(m);
+                this.PrintMatrix(builder.BuildMatrix(image.Size()));
 
-                image.Mutate(i => i.Transform(m, KnownResamplers.Bicubic));
+                image.Mutate(i => i.Transform(builder, KnownResamplers.Bicubic));
 
                 FormattableString testOutputDetails = $"R({angleDeg})_S({sx},{sy})_T({tx},{ty})";
                 image.DebugSave(provider, testOutputDetails);
@@ -126,9 +123,11 @@ namespace SixLabors.ImageSharp.Tests.Processing.Transforms
         {
             using (Image<TPixel> image = provider.GetImage())
             {
-                Matrix3x2 m = this.MakeManuallyCenteredMatrix(angleDeg, s, image);
+                AffineTransformBuilder builder = new AffineTransformBuilder()
+                    .AppendRotationDegrees(angleDeg)
+                    .AppendScale(new SizeF(s, s));
 
-                image.Mutate(i => i.Transform(m, KnownResamplers.Bicubic));
+                image.Mutate(i => i.Transform(builder, KnownResamplers.Bicubic));
 
                 FormattableString testOutputDetails = $"R({angleDeg})_S({s})";
                 image.DebugSave(provider, testOutputDetails);
@@ -155,13 +154,15 @@ namespace SixLabors.ImageSharp.Tests.Processing.Transforms
         public void Transform_FromSourceRectangle1<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : struct, IPixel<TPixel>
         {
-            var rectangle = new Rectangle(48, 0, 96, 36);
+            var rectangle = new Rectangle(48, 0, 48, 24);
 
             using (Image<TPixel> image = provider.GetImage())
             {
-                var m = Matrix3x2.CreateScale(2.0F, 1.5F);
+                image.DebugSave(provider, $"_original");
+                AffineTransformBuilder builder = new AffineTransformBuilder()
+                    .AppendScale(new SizeF(2, 1.5F));
 
-                image.Mutate(i => i.Transform(m, KnownResamplers.Spline, rectangle));
+                image.Mutate(i => i.Transform(rectangle, builder, KnownResamplers.Spline));
 
                 image.DebugSave(provider);
                 image.CompareToReferenceOutput(ValidatorComparer, provider);
@@ -173,13 +174,14 @@ namespace SixLabors.ImageSharp.Tests.Processing.Transforms
         public void Transform_FromSourceRectangle2<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : struct, IPixel<TPixel>
         {
-            var rectangle = new Rectangle(0, 24, 48, 48);
+            var rectangle = new Rectangle(0, 24, 48, 24);
 
             using (Image<TPixel> image = provider.GetImage())
             {
-                var m = Matrix3x2.CreateScale(1.0F, 2.0F);
+                AffineTransformBuilder builder = new AffineTransformBuilder()
+                    .AppendScale(new SizeF(1F, 2F));
 
-                image.Mutate(i => i.Transform(m, KnownResamplers.Spline, rectangle));
+                image.Mutate(i => i.Transform(rectangle, builder, KnownResamplers.Spline));
 
                 image.DebugSave(provider);
                 image.CompareToReferenceOutput(ValidatorComparer, provider);
@@ -194,33 +196,17 @@ namespace SixLabors.ImageSharp.Tests.Processing.Transforms
             IResampler sampler = GetResampler(resamplerName);
             using (Image<TPixel> image = provider.GetImage())
             {
-                Matrix3x2 m = this.MakeManuallyCenteredMatrix(50, 0.6f, image);
+                AffineTransformBuilder builder = new AffineTransformBuilder()
+                    .AppendRotationDegrees(50)
+                    .AppendScale(new SizeF(.6F, .6F));
 
-                image.Mutate(i =>
+                image.Mutate(i => i.Transform(builder, sampler));
-                    {
-                        i.Transform(m, sampler);
-                    });
 
                 image.DebugSave(provider, resamplerName);
                 image.CompareToReferenceOutput(ValidatorComparer, provider, resamplerName);
             }
         }
 
-        private Matrix3x2 MakeManuallyCenteredMatrix<TPixel>(float angleDeg, float s, Image<TPixel> image)
-            where TPixel : struct, IPixel<TPixel>
-        {
-            Matrix3x2 rotate = Matrix3x2Extensions.CreateRotationDegrees(angleDeg);
-            Vector2 toCenter = 0.5f * new Vector2(image.Width, image.Height);
-            var translate = Matrix3x2.CreateTranslation(-toCenter);
-            var translateBack = Matrix3x2.CreateTranslation(toCenter);
-            var scale = Matrix3x2.CreateScale(s);
-
-            Matrix3x2 m = translate * rotate * scale * translateBack;
-
-            this.PrintMatrix(m);
-            return m;
-        }
-
         private static IResampler GetResampler(string name)
         {
             PropertyInfo property = typeof(KnownResamplers).GetTypeInfo().GetProperty(name);

tests/ImageSharp.Tests/Processing/Transforms/ProjectiveTransformBuilderTests.cs

@@ -0,0 +1,62 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System.Numerics;
+using SixLabors.ImageSharp.Processing;
+using SixLabors.Primitives;
+
+namespace SixLabors.ImageSharp.Tests.Processing.Transforms
+{
+    public class ProjectiveTransformBuilderTests : TransformBuilderTestBase<ProjectiveTransformBuilder>
+    {
+        protected override ProjectiveTransformBuilder CreateBuilder(Rectangle rectangle) => new ProjectiveTransformBuilder();
+
+        protected override void AppendRotationDegrees(ProjectiveTransformBuilder builder, float degrees) => builder.AppendRotationDegrees(degrees);
+
+        protected override void AppendRotationDegrees(ProjectiveTransformBuilder builder, float degrees, Vector2 origin) => builder.AppendRotationDegrees(degrees, origin);
+
+        protected override void AppendRotationRadians(ProjectiveTransformBuilder builder, float radians) => builder.AppendRotationRadians(radians);
+
+        protected override void AppendRotationRadians(ProjectiveTransformBuilder builder, float radians, Vector2 origin) => builder.AppendRotationRadians(radians, origin);
+
+        protected override void AppendScale(ProjectiveTransformBuilder builder, SizeF scale) => builder.AppendScale(scale);
+
+        protected override void AppendSkewDegrees(ProjectiveTransformBuilder builder, float degreesX, float degreesY)
+    => builder.AppendSkewDegrees(degreesX, degreesY);
+
+        protected override void AppendSkewDegrees(ProjectiveTransformBuilder builder, float degreesX, float degreesY, Vector2 origin)
+            => builder.AppendSkewDegrees(degreesX, degreesY, origin);
+
+        protected override void AppendSkewRadians(ProjectiveTransformBuilder builder, float radiansX, float radiansY)
+            => builder.AppendSkewRadians(radiansX, radiansY);
+
+        protected override void AppendSkewRadians(ProjectiveTransformBuilder builder, float radiansX, float radiansY, Vector2 origin)
+            => builder.AppendSkewRadians(radiansX, radiansY, origin);
+
+        protected override void AppendTranslation(ProjectiveTransformBuilder builder, PointF translate) => builder.AppendTranslation(translate);
+
+        protected override void PrependRotationRadians(ProjectiveTransformBuilder builder, float radians) => builder.PrependRotationRadians(radians);
+
+        protected override void PrependScale(ProjectiveTransformBuilder builder, SizeF scale) => builder.PrependScale(scale);
+
+        protected override void PrependSkewRadians(ProjectiveTransformBuilder builder, float radiansX, float radiansY)
+            => builder.PrependSkewRadians(radiansX, radiansY);
+
+        protected override void PrependSkewRadians(ProjectiveTransformBuilder builder, float radiansX, float radiansY, Vector2 origin)
+            => builder.PrependSkewRadians(radiansX, radiansY, origin);
+
+        protected override void PrependTranslation(ProjectiveTransformBuilder builder, PointF translate) => builder.PrependTranslation(translate);
+
+        protected override void PrependRotationRadians(ProjectiveTransformBuilder builder, float radians, Vector2 origin) =>
+            builder.PrependRotationRadians(radians, origin);
+
+        protected override Vector2 Execute(
+            ProjectiveTransformBuilder builder,
+            Rectangle rectangle,
+            Vector2 sourcePoint)
+        {
+            Matrix4x4 matrix = builder.BuildMatrix(rectangle);
+            return Vector2.Transform(sourcePoint, matrix);
+        }
+    }
+}

tests/ImageSharp.Tests/Processing/Transforms/ProjectiveTransformTests.cs

@@ -20,7 +20,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Transforms
         private static readonly ImageComparer TolerantComparer = ImageComparer.TolerantPercentage(0.5f, 3);
 
         private ITestOutputHelper Output { get; }
-        
+
         public static readonly TheoryData<string> ResamplerNames = new TheoryData<string>
         {
             nameof(KnownResamplers.Bicubic),
@@ -60,10 +60,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Transforms
 
         };
 
-        public ProjectiveTransformTests(ITestOutputHelper output)
+        public ProjectiveTransformTests(ITestOutputHelper output) => this.Output = output;
-        {
-            this.Output = output;
-        }
 
         [Theory]
         [WithTestPatternImages(nameof(ResamplerNames), 150, 150, PixelTypes.Rgba32)]
@@ -73,9 +70,10 @@ namespace SixLabors.ImageSharp.Tests.Processing.Transforms
             IResampler sampler = GetResampler(resamplerName);
             using (Image<TPixel> image = provider.GetImage())
             {
-                Matrix4x4 m = ProjectiveTransformHelper.CreateTaperMatrix(image.Size(), TaperSide.Right, TaperCorner.Both, .5F);
+                ProjectiveTransformBuilder builder = new ProjectiveTransformBuilder()
+                    .AppendTaper(TaperSide.Right, TaperCorner.Both, .5F);
 
-                image.Mutate(i => { i.Transform(m, sampler); });
+                image.Mutate(i => i.Transform(builder, sampler));
 
                 image.DebugSave(provider, resamplerName);
                 image.CompareToReferenceOutput(ValidatorComparer, provider, resamplerName);
@@ -89,8 +87,10 @@ namespace SixLabors.ImageSharp.Tests.Processing.Transforms
         {
             using (Image<TPixel> image = provider.GetImage())
             {
-                Matrix4x4 m = ProjectiveTransformHelper.CreateTaperMatrix(image.Size(), taperSide, taperCorner, .5F);
+                ProjectiveTransformBuilder builder = new ProjectiveTransformBuilder()
-                image.Mutate(i => { i.Transform(m); });
+                    .AppendTaper(taperSide, taperCorner, .5F);
+
+                image.Mutate(i => i.Transform(builder));
 
                 FormattableString testOutputDetails = $"{taperSide}-{taperCorner}";
                 image.DebugSave(provider, testOutputDetails);
@@ -110,10 +110,13 @@ namespace SixLabors.ImageSharp.Tests.Processing.Transforms
             // https://docs.microsoft.com/en-us/xamarin/xamarin-forms/user-interface/graphics/skiasharp/transforms/non-affine
             using (Image<TPixel> image = provider.GetImage())
             {
-                Matrix4x4 m = Matrix4x4.Identity;
+                Matrix4x4 matrix = Matrix4x4.Identity;
-                m.M13 = 0.01F;
+                matrix.M13 = 0.01F;
+
+                ProjectiveTransformBuilder builder = new ProjectiveTransformBuilder()
+                .AppendMatrix(matrix);
 
-                image.Mutate(i => { i.Transform(m); });
+                image.Mutate(i => i.Transform(builder));
 
                 image.DebugSave(provider);
                 image.CompareToReferenceOutput(TolerantComparer, provider);

tests/ImageSharp.Tests/Processing/Transforms/TransformBuilderTestBase.cs

@@ -0,0 +1,275 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Numerics;
+using SixLabors.ImageSharp.Processing.Processors.Transforms;
+using SixLabors.Primitives;
+
+using Xunit;
+
+namespace SixLabors.ImageSharp.Tests.Processing.Transforms
+{
+    public abstract class TransformBuilderTestBase<TBuilder>
+    {
+        private static readonly ApproximateFloatComparer Comparer = new ApproximateFloatComparer(1e-6f);
+
+        public static readonly TheoryData<Vector2, Vector2, Vector2, Vector2> ScaleTranslate_Data =
+            new TheoryData<Vector2, Vector2, Vector2, Vector2>
+                {
+                    // scale, translate, source, expectedDest
+                    { Vector2.One, Vector2.Zero, Vector2.Zero, Vector2.Zero },
+                    { Vector2.One, Vector2.Zero, new Vector2(10, 20), new Vector2(10, 20) },
+                    { Vector2.One, new Vector2(3, 1), new Vector2(10, 20), new Vector2(13, 21) },
+                    { new Vector2(2, 0.5f), new Vector2(3, 1), new Vector2(10, 20), new Vector2(23, 11) },
+                };
+
+        [Theory]
+        [MemberData(nameof(ScaleTranslate_Data))]
+        public void _1Scale_2Translate(Vector2 scale, Vector2 translate, Vector2 source, Vector2 expectedDest)
+        {
+            // These operations should be size-agnostic:
+            var size = new Size(123, 321);
+            TBuilder builder = this.CreateBuilder(size);
+
+            this.AppendScale(builder, new SizeF(scale));
+            this.AppendTranslation(builder, translate);
+
+            Vector2 actualDest = this.Execute(builder, new Rectangle(Point.Empty, size), source);
+            Assert.True(Comparer.Equals(expectedDest, actualDest));
+        }
+
+        public static readonly TheoryData<Vector2, Vector2, Vector2, Vector2> TranslateScale_Data =
+            new TheoryData<Vector2, Vector2, Vector2, Vector2>
+                {
+                    // translate, scale, source, expectedDest
+                    { Vector2.Zero, Vector2.One, Vector2.Zero, Vector2.Zero },
+                    { Vector2.Zero, Vector2.One, new Vector2(10, 20), new Vector2(10, 20) },
+                    { new Vector2(3, 1), new Vector2(2, 0.5f), new Vector2(10, 20), new Vector2(26, 10.5f) },
+                };
+
+        [Theory]
+        [MemberData(nameof(TranslateScale_Data))]
+        public void _1Translate_2Scale(Vector2 translate, Vector2 scale, Vector2 source, Vector2 expectedDest)
+        {
+            // Translate ans scale are size-agnostic:
+            var size = new Size(456, 432);
+            TBuilder builder = this.CreateBuilder(size);
+
+            this.AppendTranslation(builder, translate);
+            this.AppendScale(builder, new SizeF(scale));
+
+            Vector2 actualDest = this.Execute(builder, new Rectangle(Point.Empty, size), source);
+            Assert.Equal(expectedDest, actualDest, Comparer);
+        }
+
+        [Theory]
+        [InlineData(10, 20)]
+        [InlineData(-20, 10)]
+        public void LocationOffsetIsPrepended(int locationX, int locationY)
+        {
+            var rectangle = new Rectangle(locationX, locationY, 10, 10);
+            TBuilder builder = this.CreateBuilder(rectangle);
+
+            this.AppendScale(builder, new SizeF(2, 2));
+
+            Vector2 actual = this.Execute(builder, rectangle, Vector2.One);
+            Vector2 expected = new Vector2(-locationX + 1, -locationY + 1) * 2;
+
+            Assert.Equal(actual, expected, Comparer);
+        }
+
+        [Theory]
+        [InlineData(200, 100, 10, 42, 84)]
+        [InlineData(200, 100, 100, 42, 84)]
+        [InlineData(100, 200, -10, 42, 84)]
+        public void AppendRotationDegrees_WithoutSpecificRotationCenter_RotationIsCenteredAroundImageCenter(
+            int width,
+            int height,
+            float degrees,
+            float x,
+            float y)
+        {
+            var size = new Size(width, height);
+            TBuilder builder = this.CreateBuilder(size);
+
+            this.AppendRotationDegrees(builder, degrees);
+
+            // TODO: We should also test CreateRotationMatrixDegrees() (and all TransformUtils stuff!) for correctness
+            Matrix3x2 matrix = TransformUtils.CreateRotationMatrixDegrees(degrees, size);
+
+            var position = new Vector2(x, y);
+            var expected = Vector2.Transform(position, matrix);
+            Vector2 actual = this.Execute(builder, new Rectangle(Point.Empty, size), position);
+
+            Assert.Equal(actual, expected, Comparer);
+        }
+
+        [Theory]
+        [InlineData(200, 100, 10, 30, 61, 42, 84)]
+        [InlineData(200, 100, 100, 30, 10, 20, 84)]
+        [InlineData(100, 200, -10, 30, 20, 11, 84)]
+        public void AppendRotationDegrees_WithRotationCenter(
+            int width,
+            int height,
+            float degrees,
+            float cx,
+            float cy,
+            float x,
+            float y)
+        {
+            var size = new Size(width, height);
+            TBuilder builder = this.CreateBuilder(size);
+
+            var centerPoint = new Vector2(cx, cy);
+            this.AppendRotationDegrees(builder, degrees, centerPoint);
+
+            var matrix = Matrix3x2.CreateRotation(GeometryUtilities.DegreeToRadian(degrees), centerPoint);
+
+            var position = new Vector2(x, y);
+            var expected = Vector2.Transform(position, matrix);
+            Vector2 actual = this.Execute(builder, new Rectangle(Point.Empty, size), position);
+
+            Assert.Equal(actual, expected, Comparer);
+        }
+
+        [Theory]
+        [InlineData(200, 100, 10, 10, 42, 84)]
+        [InlineData(200, 100, 100, 100, 42, 84)]
+        [InlineData(100, 200, -10, -10, 42, 84)]
+        public void AppendSkewDegrees_WithoutSpecificSkewCenter_SkewIsCenteredAroundImageCenter(
+            int width,
+            int height,
+            float degreesX,
+            float degreesY,
+            float x,
+            float y)
+        {
+            var size = new Size(width, height);
+            TBuilder builder = this.CreateBuilder(size);
+
+            this.AppendSkewDegrees(builder, degreesX, degreesY);
+
+            Matrix3x2 matrix = TransformUtils.CreateSkewMatrixDegrees(degreesX, degreesY, size);
+
+            var position = new Vector2(x, y);
+            var expected = Vector2.Transform(position, matrix);
+            Vector2 actual = this.Execute(builder, new Rectangle(Point.Empty, size), position);
+            Assert.Equal(actual, expected, Comparer);
+        }
+
+        [Theory]
+        [InlineData(200, 100, 10, 10, 30, 61, 42, 84)]
+        [InlineData(200, 100, 100, 100, 30, 10, 20, 84)]
+        [InlineData(100, 200, -10, -10, 30, 20, 11, 84)]
+        public void AppendSkewDegrees_WithSkewCenter(
+            int width,
+            int height,
+            float degreesX,
+            float degreesY,
+            float cx,
+            float cy,
+            float x,
+            float y)
+        {
+            var size = new Size(width, height);
+            TBuilder builder = this.CreateBuilder(size);
+
+            var centerPoint = new Vector2(cx, cy);
+            this.AppendSkewDegrees(builder, degreesX, degreesY, centerPoint);
+
+            var matrix = Matrix3x2.CreateSkew(GeometryUtilities.DegreeToRadian(degreesX), GeometryUtilities.DegreeToRadian(degreesY), centerPoint);
+
+            var position = new Vector2(x, y);
+            var expected = Vector2.Transform(position, matrix);
+            Vector2 actual = this.Execute(builder, new Rectangle(Point.Empty, size), position);
+
+            Assert.Equal(actual, expected, Comparer);
+        }
+
+        [Fact]
+        public void AppendPrependOpposite()
+        {
+            var rectangle = new Rectangle(-1, -1, 3, 3);
+            TBuilder b1 = this.CreateBuilder(rectangle);
+            TBuilder b2 = this.CreateBuilder(rectangle);
+
+            const float pi = (float)Math.PI;
+
+            // Forwards
+            this.AppendRotationRadians(b1, pi);
+            this.AppendSkewRadians(b1, pi, pi);
+            this.AppendScale(b1, new SizeF(2, 0.5f));
+            this.AppendRotationRadians(b1, pi / 2, new Vector2(-0.5f, -0.1f));
+            this.AppendSkewRadians(b1, pi, pi / 2, new Vector2(-0.5f, -0.1f));
+            this.AppendTranslation(b1, new PointF(123, 321));
+
+            // Backwards
+            this.PrependTranslation(b2, new PointF(123, 321));
+            this.PrependSkewRadians(b2, pi, pi / 2, new Vector2(-0.5f, -0.1f));
+            this.PrependRotationRadians(b2, pi / 2, new Vector2(-0.5f, -0.1f));
+            this.PrependScale(b2, new SizeF(2, 0.5f));
+            this.PrependSkewRadians(b2, pi, pi);
+            this.PrependRotationRadians(b2, pi);
+
+            Vector2 p1 = this.Execute(b1, rectangle, new Vector2(32, 65));
+            Vector2 p2 = this.Execute(b2, rectangle, new Vector2(32, 65));
+
+            Assert.Equal(p1, p2, Comparer);
+        }
+
+        [Theory]
+        [InlineData(0, 1)]
+        [InlineData(1, 0)]
+        [InlineData(-1, 0)]
+        public void ThrowsForInvalidSizes(int width, int height)
+        {
+            var size = new Size(width, height);
+
+            Assert.ThrowsAny<ArgumentOutOfRangeException>(
+                () =>
+                    {
+                        TBuilder builder = this.CreateBuilder(size);
+                        this.Execute(builder, new Rectangle(Point.Empty, size), Vector2.Zero);
+                    });
+        }
+
+        protected TBuilder CreateBuilder(Size size) => this.CreateBuilder(new Rectangle(Point.Empty, size));
+
+        protected abstract TBuilder CreateBuilder(Rectangle rectangle);
+
+        protected abstract void AppendRotationDegrees(TBuilder builder, float degrees);
+
+        protected abstract void AppendRotationDegrees(TBuilder builder, float degrees, Vector2 origin);
+
+        protected abstract void AppendRotationRadians(TBuilder builder, float radians);
+
+        protected abstract void AppendRotationRadians(TBuilder builder, float radians, Vector2 origin);
+
+        protected abstract void AppendScale(TBuilder builder, SizeF scale);
+
+        protected abstract void AppendSkewDegrees(TBuilder builder, float degreesX, float degreesY);
+
+        protected abstract void AppendSkewDegrees(TBuilder builder, float degreesX, float degreesY, Vector2 origin);
+
+        protected abstract void AppendSkewRadians(TBuilder builder, float radiansX, float radiansY);
+
+        protected abstract void AppendSkewRadians(TBuilder builder, float radiansX, float radiansY, Vector2 origin);
+
+        protected abstract void AppendTranslation(TBuilder builder, PointF translate);
+
+        protected abstract void PrependRotationRadians(TBuilder builder, float radians);
+
+        protected abstract void PrependRotationRadians(TBuilder builder, float radians, Vector2 origin);
+
+        protected abstract void PrependScale(TBuilder builder, SizeF scale);
+
+        protected abstract void PrependSkewRadians(TBuilder builder, float radiansX, float radiansY);
+
+        protected abstract void PrependSkewRadians(TBuilder builder, float radiansX, float radiansY, Vector2 origin);
+
+        protected abstract void PrependTranslation(TBuilder builder, PointF translate);
+
+        protected abstract Vector2 Execute(TBuilder builder, Rectangle rectangle, Vector2 sourcePoint);
+    }
+}

tests/ImageSharp.Tests/Processing/Transforms/TransformsHelpersTest.cs

@@ -25,7 +25,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Transforms
                 Assert.Equal(ExifDataType.Long, profile.GetValue(ExifTag.PixelXDimension).DataType);
                 Assert.Equal(ExifDataType.Long, profile.GetValue(ExifTag.PixelYDimension).DataType);
 
-                TransformHelpers.UpdateDimensionalMetData(img);
+                TransformProcessorHelpers.UpdateDimensionalMetData(img);
 
                 Assert.Equal(ExifDataType.Short, profile.GetValue(ExifTag.PixelXDimension).DataType);
                 Assert.Equal(ExifDataType.Short, profile.GetValue(ExifTag.PixelYDimension).DataType);

tests/ImageSharp.Tests/TestUtilities/ApproximateFloatComparer.cs

@@ -11,7 +11,8 @@ namespace SixLabors.ImageSharp.Tests
     /// </summary>
     internal readonly struct ApproximateFloatComparer :
         IEqualityComparer<float>,
-        IEqualityComparer<Vector4>
+        IEqualityComparer<Vector4>,
+        IEqualityComparer<Vector2>
     {
         private readonly float Epsilon;
 
@@ -33,9 +34,17 @@ namespace SixLabors.ImageSharp.Tests
         public int GetHashCode(float obj) => obj.GetHashCode();
 
         /// <inheritdoc/>
-        public bool Equals(Vector4 x, Vector4 y) => this.Equals(x.X, y.X) && this.Equals(x.Y, y.Y) && this.Equals(x.Z, y.Z) && this.Equals(x.W, y.W);
+        public bool Equals(Vector4 a, Vector4 b) => this.Equals(a.X, b.X) && this.Equals(a.Y, b.Y) && this.Equals(a.Z, b.Z) && this.Equals(a.W, b.W);
 
         /// <inheritdoc/>
         public int GetHashCode(Vector4 obj) => obj.GetHashCode();
+
+        /// <inheritdoc/>
+        public bool Equals(Vector2 a, Vector2 b) => this.Equals(a.X, b.X) && this.Equals(a.Y, b.Y);
+
+        public int GetHashCode(Vector2 obj)
+        {
+            throw new System.NotImplementedException();
+        }
     }
 }

tests/Images/External

@@ -1 +1 @@
-Subproject commit ed8a7b0b6fe1b2e2a7c822aa617103ae31192655
+Subproject commit e7e0f1311d1d585ea8e38efb5a69fca98c44e8a4