mirror of https://github.com/SixLabors/ImageSharp
James Jackson-South
8 years ago
committed by
GitHub
GitHub
39 changed files with 2029 additions and 976 deletions
@ -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; |
|||
} |
|||
} |
|||
} |
|||
@ -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; |
|||
} |
|||
} |
|||
} |
|||
@ -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; |
|||
} |
|||
} |
|||
} |
|||
@ -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); |
|||
} |
|||
} |
|||
} |
|||
@ -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)); |
|||
} |
|||
} |
|||
} |
|||
@ -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(); |
|||
} |
|||
} |
|||
} |
|||
@ -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); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -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)); |
|||
} |
|||
} |
|||
} |
|||
@ -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; |
|||
} |
|||
} |
|||
} |
|||
@ -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; |
|||
} |
|||
} |
|||
} |
|||
@ -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 |
|||
} |
|||
} |
|||
@ -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 |
|||
} |
|||
} |
|||
@ -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 |
|
|||
@ -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 |
|
|||
@ -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); |
|||
} |
|||
} |
|||
} |
|||
@ -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); |
|||
} |
|||
} |
|||
} |
|||
@ -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); |
|||
} |
|||
} |
|||
@ -1 +1 @@ |
|||
Subproject commit ed8a7b0b6fe1b2e2a7c822aa617103ae31192655 |
|||
Subproject commit e7e0f1311d1d585ea8e38efb5a69fca98c44e8a4 |
|||
Loading…
Reference in new issue