mirror of https://github.com/SixLabors/ImageSharp
James Jackson-South
8 years ago
11 changed files with 523 additions and 181 deletions
@ -0,0 +1,43 @@ |
|||||
|
// 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 |
||||
|
{ |
||||
|
/// <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 CenteredNonAffineTransformProcessor<TPixel> : NonAffineTransformProcessor<TPixel> |
||||
|
where TPixel : struct, IPixel<TPixel> |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Initializes a new instance of the <see cref="CenteredNonAffineTransformProcessor{TPixel}"/> class.
|
||||
|
/// </summary>
|
||||
|
/// <param name="matrix">The transform matrix</param>
|
||||
|
/// <param name="sampler">The sampler to perform the transform operation.</param>
|
||||
|
protected CenteredNonAffineTransformProcessor(Matrix4x4 matrix, IResampler sampler) |
||||
|
: base(matrix, sampler) |
||||
|
{ |
||||
|
} |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
protected override Matrix4x4 GetProcessingMatrix(Rectangle sourceRectangle, Rectangle destinationRectangle) |
||||
|
{ |
||||
|
var translationToTargetCenter = Matrix4x4.CreateTranslation(-destinationRectangle.Width * .5F, -destinationRectangle.Height * .5F, 0); |
||||
|
var translateToSourceCenter = Matrix4x4.CreateTranslation(sourceRectangle.Width * .5F, sourceRectangle.Height * .5F, 0); |
||||
|
return translationToTargetCenter * this.TransformMatrix * translateToSourceCenter; |
||||
|
} |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
protected override Rectangle GetTransformedBoundingRectangle(Rectangle sourceRectangle, Matrix4x4 matrix) |
||||
|
{ |
||||
|
return Matrix4x4.Invert(this.TransformMatrix, out Matrix4x4 sizeMatrix) |
||||
|
? TransformHelpers.GetTransformedBoundingRectangle(sourceRectangle, sizeMatrix) |
||||
|
: sourceRectangle; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,139 @@ |
|||||
|
// Copyright (c) Six Labors and contributors.
|
||||
|
// Licensed under the Apache License, Version 2.0.
|
||||
|
|
||||
|
using System; |
||||
|
using System.Runtime.CompilerServices; |
||||
|
using SixLabors.ImageSharp.MetaData.Profiles.Exif; |
||||
|
using SixLabors.ImageSharp.PixelFormats; |
||||
|
using SixLabors.Primitives; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Processing.Processors |
||||
|
{ |
||||
|
/// <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> : CloningImageProcessor<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) |
||||
|
{ |
||||
|
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 nomalized.
|
||||
|
/// </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="weights">The collection of weights</param>
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
protected static void CalculateWeightsDown(int min, int max, int sourceMin, int sourceMax, float point, IResampler sampler, float scale, Span<float> weights) |
||||
|
{ |
||||
|
float sum = 0; |
||||
|
ref float weightsBaseRef = ref weights[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 weightsBaseRef, x) = weight; |
||||
|
} |
||||
|
|
||||
|
if (sum > 0) |
||||
|
{ |
||||
|
for (int i = 0; i < weights.Length; i++) |
||||
|
{ |
||||
|
ref float wRef = ref Unsafe.Add(ref weightsBaseRef, 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="weights">The collection of weights</param>
|
||||
|
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
||||
|
protected static void CalculateWeightsScaleUp(int sourceMin, int sourceMax, float point, IResampler sampler, Span<float> weights) |
||||
|
{ |
||||
|
ref float weightsBaseRef = ref weights[0]; |
||||
|
for (int x = 0, i = sourceMin; i <= sourceMax; i++, x++) |
||||
|
{ |
||||
|
float weight = sampler.GetValue(i - point); |
||||
|
Unsafe.Add(ref weightsBaseRef, 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); |
||||
|
} |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
protected override void AfterImageApply(Image<TPixel> source, Image<TPixel> destination, Rectangle sourceRectangle) |
||||
|
{ |
||||
|
ExifProfile profile = destination.MetaData.ExifProfile; |
||||
|
if (profile == null) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
if (profile.GetValue(ExifTag.PixelXDimension) != null) |
||||
|
{ |
||||
|
profile.SetValue(ExifTag.PixelXDimension, destination.Width); |
||||
|
} |
||||
|
|
||||
|
if (profile.GetValue(ExifTag.PixelYDimension) != null) |
||||
|
{ |
||||
|
profile.SetValue(ExifTag.PixelYDimension, destination.Height); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,238 @@ |
|||||
|
// Copyright (c) Six Labors and contributors.
|
||||
|
// Licensed under the Apache License, Version 2.0.
|
||||
|
|
||||
|
using System; |
||||
|
using System.Collections.Generic; |
||||
|
using System.Linq; |
||||
|
using System.Numerics; |
||||
|
using System.Threading.Tasks; |
||||
|
using SixLabors.ImageSharp.Advanced; |
||||
|
using SixLabors.ImageSharp.Helpers; |
||||
|
using SixLabors.ImageSharp.Memory; |
||||
|
using SixLabors.ImageSharp.PixelFormats; |
||||
|
using SixLabors.Primitives; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Processing.Processors |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Provides the base methods to perform non-affine transforms on an image.
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="TPixel">The pixel format.</typeparam>
|
||||
|
internal class NonAffineTransformProcessor<TPixel> : InterpolatedTransformProcessorBase<TPixel> |
||||
|
where TPixel : struct, IPixel<TPixel> |
||||
|
{ |
||||
|
private Rectangle targetRectangle; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Initializes a new instance of the <see cref="NonAffineTransformProcessor{TPixel}"/> class.
|
||||
|
/// </summary>
|
||||
|
/// <param name="matrix">The transform matrix</param>
|
||||
|
public NonAffineTransformProcessor(Matrix4x4 matrix) |
||||
|
: this(matrix, KnownResamplers.Bicubic) |
||||
|
{ |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Initializes a new instance of the <see cref="NonAffineTransformProcessor{TPixel}"/> class.
|
||||
|
/// </summary>
|
||||
|
/// <param name="matrix">The transform matrix</param>
|
||||
|
/// <param name="sampler">The sampler to perform the transform operation.</param>
|
||||
|
public NonAffineTransformProcessor(Matrix4x4 matrix, IResampler sampler) |
||||
|
: this(matrix, sampler, Rectangle.Empty) |
||||
|
{ |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Initializes a new instance of the <see cref="NonAffineTransformProcessor{TPixel}"/> class.
|
||||
|
/// </summary>
|
||||
|
/// <param name="matrix">The transform matrix</param>
|
||||
|
/// <param name="sampler">The sampler to perform the transform operation.</param>
|
||||
|
/// <param name="rectangle">The rectangle to constrain the transformed image to.</param>
|
||||
|
public NonAffineTransformProcessor(Matrix4x4 matrix, IResampler sampler, Rectangle rectangle) |
||||
|
: base(sampler) |
||||
|
{ |
||||
|
// Tansforms are inverted else the output is the opposite of the expected.
|
||||
|
Matrix4x4.Invert(matrix, out matrix); |
||||
|
this.TransformMatrix = matrix; |
||||
|
this.targetRectangle = rectangle; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the matrix used to supply the non-affine transform
|
||||
|
/// </summary>
|
||||
|
public Matrix4x4 TransformMatrix { get; } |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
protected override Image<TPixel> CreateDestination(Image<TPixel> source, Rectangle sourceRectangle) |
||||
|
{ |
||||
|
if (this.targetRectangle == Rectangle.Empty) |
||||
|
{ |
||||
|
this.targetRectangle = this.GetTransformedBoundingRectangle(sourceRectangle, this.TransformMatrix); |
||||
|
} |
||||
|
|
||||
|
// We will always be creating the clone even for mutate because we may need to resize the canvas
|
||||
|
IEnumerable<ImageFrame<TPixel>> frames = |
||||
|
source.Frames.Select(x => new ImageFrame<TPixel>(this.targetRectangle.Width, this.targetRectangle.Height, x.MetaData.Clone())); |
||||
|
|
||||
|
// Use the overload to prevent an extra frame being added
|
||||
|
return new Image<TPixel>(source.GetConfiguration(), source.MetaData.Clone(), frames); |
||||
|
} |
||||
|
|
||||
|
/// <inheritdoc/>
|
||||
|
protected override void OnApply(ImageFrame<TPixel> source, ImageFrame<TPixel> destination, Rectangle sourceRectangle, Configuration configuration) |
||||
|
{ |
||||
|
int height = this.targetRectangle.Height; |
||||
|
int width = this.targetRectangle.Width; |
||||
|
Rectangle sourceBounds = source.Bounds(); |
||||
|
|
||||
|
// Since could potentially be resizing the canvas we might need to re-calculate the matrix
|
||||
|
Matrix4x4 matrix = this.GetProcessingMatrix(sourceBounds, this.targetRectangle); |
||||
|
|
||||
|
if (this.Sampler is NearestNeighborResampler) |
||||
|
{ |
||||
|
Parallel.For( |
||||
|
0, |
||||
|
height, |
||||
|
configuration.ParallelOptions, |
||||
|
y => |
||||
|
{ |
||||
|
Span<TPixel> destRow = destination.GetPixelRowSpan(y); |
||||
|
|
||||
|
for (int x = 0; x < width; x++) |
||||
|
{ |
||||
|
var point = Point.Round(Vector2.Transform(new Vector2(x, y), matrix)); |
||||
|
if (sourceBounds.Contains(point.X, point.Y)) |
||||
|
{ |
||||
|
destRow[x] = source[point.X, point.Y]; |
||||
|
} |
||||
|
} |
||||
|
}); |
||||
|
|
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
int maxSourceX = source.Width - 1; |
||||
|
int maxSourceY = source.Height - 1; |
||||
|
(float radius, float scale, float ratio) xRadiusScale = this.GetSamplingRadius(source.Width, destination.Width); |
||||
|
(float radius, float scale, float ratio) yRadiusScale = this.GetSamplingRadius(source.Height, destination.Height); |
||||
|
float xScale = xRadiusScale.scale; |
||||
|
float yScale = yRadiusScale.scale; |
||||
|
var radius = new Vector2(xRadiusScale.radius, yRadiusScale.radius); |
||||
|
IResampler sampler = this.Sampler; |
||||
|
var maxSource = new Vector4(maxSourceX, maxSourceY, maxSourceX, maxSourceY); |
||||
|
int xLength = (int)MathF.Ceiling((radius.X * 2) + 2); |
||||
|
int yLength = (int)MathF.Ceiling((radius.Y * 2) + 2); |
||||
|
|
||||
|
using (var yBuffer = new Buffer2D<float>(yLength, height)) |
||||
|
using (var xBuffer = new Buffer2D<float>(xLength, height)) |
||||
|
{ |
||||
|
Parallel.For( |
||||
|
0, |
||||
|
height, |
||||
|
configuration.ParallelOptions, |
||||
|
y => |
||||
|
{ |
||||
|
Span<TPixel> destRow = destination.GetPixelRowSpan(y); |
||||
|
Span<float> ySpan = yBuffer.GetRowSpan(y); |
||||
|
Span<float> xSpan = xBuffer.GetRowSpan(y); |
||||
|
|
||||
|
for (int x = 0; x < width; x++) |
||||
|
{ |
||||
|
// Use the single precision position to calculate correct bounding pixels
|
||||
|
// otherwise we get rogue pixels outside of the bounds.
|
||||
|
var point = Vector2.Transform(new Vector2(x, y), matrix); |
||||
|
|
||||
|
// Clamp sampling pixel radial extents to the source image edges
|
||||
|
Vector2 maxXY = point + radius; |
||||
|
Vector2 minXY = point - radius; |
||||
|
|
||||
|
// max, maxY, minX, minY
|
||||
|
var extents = new Vector4( |
||||
|
MathF.Floor(maxXY.X + .5F), |
||||
|
MathF.Floor(maxXY.Y + .5F), |
||||
|
MathF.Ceiling(minXY.X - .5F), |
||||
|
MathF.Ceiling(minXY.Y - .5F)); |
||||
|
|
||||
|
int right = (int)extents.X; |
||||
|
int bottom = (int)extents.Y; |
||||
|
int left = (int)extents.Z; |
||||
|
int top = (int)extents.W; |
||||
|
|
||||
|
extents = Vector4.Clamp(extents, Vector4.Zero, maxSource); |
||||
|
|
||||
|
int maxX = (int)extents.X; |
||||
|
int maxY = (int)extents.Y; |
||||
|
int minX = (int)extents.Z; |
||||
|
int minY = (int)extents.W; |
||||
|
|
||||
|
if (minX == maxX || minY == maxY) |
||||
|
{ |
||||
|
continue; |
||||
|
} |
||||
|
|
||||
|
// It appears these have to be calculated on-the-fly.
|
||||
|
// Precalulating transformed weights would require prior knowledge of every transformed pixel location
|
||||
|
// since they can be at sub-pixel positions on both axis.
|
||||
|
// I've optimized where I can but am always open to suggestions.
|
||||
|
if (yScale > 1 && xScale > 1) |
||||
|
{ |
||||
|
CalculateWeightsDown(top, bottom, minY, maxY, point.Y, sampler, yScale, ySpan); |
||||
|
CalculateWeightsDown(left, right, minX, maxX, point.X, sampler, xScale, xSpan); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
CalculateWeightsScaleUp(minY, maxY, point.Y, sampler, ySpan); |
||||
|
CalculateWeightsScaleUp(minX, maxX, point.X, sampler, xSpan); |
||||
|
} |
||||
|
|
||||
|
// Now multiply the results against the offsets
|
||||
|
Vector4 sum = Vector4.Zero; |
||||
|
for (int yy = 0, j = minY; j <= maxY; j++, yy++) |
||||
|
{ |
||||
|
float yWeight = ySpan[yy]; |
||||
|
|
||||
|
for (int xx = 0, i = minX; i <= maxX; i++, xx++) |
||||
|
{ |
||||
|
float xWeight = xSpan[xx]; |
||||
|
var vector = source[i, j].ToVector4(); |
||||
|
|
||||
|
// Values are first premultiplied to prevent darkening of edge pixels
|
||||
|
var mupltiplied = new Vector4(new Vector3(vector.X, vector.Y, vector.Z) * vector.W, vector.W); |
||||
|
sum += mupltiplied * xWeight * yWeight; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
ref TPixel dest = ref destRow[x]; |
||||
|
|
||||
|
// Reverse the premultiplication
|
||||
|
dest.PackFromVector4(new Vector4(new Vector3(sum.X, sum.Y, sum.Z) / sum.W, sum.W)); |
||||
|
} |
||||
|
}); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets a transform matrix adjusted for final processing based upon the target image bounds.
|
||||
|
/// </summary>
|
||||
|
/// <param name="sourceRectangle">The source image bounds.</param>
|
||||
|
/// <param name="destinationRectangle">The destination image bounds.</param>
|
||||
|
/// <returns>
|
||||
|
/// The <see cref="Matrix4x4"/>.
|
||||
|
/// </returns>
|
||||
|
protected virtual Matrix4x4 GetProcessingMatrix(Rectangle sourceRectangle, Rectangle destinationRectangle) |
||||
|
{ |
||||
|
return this.TransformMatrix; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the bounding <see cref="Rectangle"/> relative to the source for the given transformation matrix.
|
||||
|
/// </summary>
|
||||
|
/// <param name="sourceRectangle">The source rectangle.</param>
|
||||
|
/// <param name="matrix">The transformation matrix.</param>
|
||||
|
/// <returns>The <see cref="Rectangle"/></returns>
|
||||
|
protected virtual Rectangle GetTransformedBoundingRectangle(Rectangle sourceRectangle, Matrix4x4 matrix) |
||||
|
{ |
||||
|
return sourceRectangle; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -1,47 +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 |
|
||||
{ |
|
||||
/// <summary>
|
|
||||
/// Provides methods that allow the tranformation of images using various algorithms.
|
|
||||
/// </summary>
|
|
||||
/// <typeparam name="TPixel">The pixel format.</typeparam>
|
|
||||
internal class TransformProcessor<TPixel> : AffineProcessor<TPixel> |
|
||||
where TPixel : struct, IPixel<TPixel> |
|
||||
{ |
|
||||
/// <summary>
|
|
||||
/// Initializes a new instance of the <see cref="TransformProcessor{TPixel}"/> class.
|
|
||||
/// </summary>
|
|
||||
/// <param name="matrix">The transformation matrix</param>
|
|
||||
public TransformProcessor(Matrix3x2 matrix) |
|
||||
: this(matrix, KnownResamplers.Bicubic) |
|
||||
{ |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Initializes a new instance of the <see cref="TransformProcessor{TPixel}"/> class.
|
|
||||
/// </summary>
|
|
||||
/// <param name="matrix">The transformation matrix</param>
|
|
||||
/// <param name="sampler">The sampler to perform the transform operation.</param>
|
|
||||
public TransformProcessor(Matrix3x2 matrix, IResampler sampler) |
|
||||
: base(matrix, sampler) |
|
||||
{ |
|
||||
} |
|
||||
|
|
||||
/// <summary>
|
|
||||
/// Initializes a new instance of the <see cref="TransformProcessor{TPixel}"/> class.
|
|
||||
/// </summary>
|
|
||||
/// <param name="matrix">The transform matrix</param>
|
|
||||
/// <param name="sampler">The sampler to perform the transform operation.</param>
|
|
||||
/// <param name="rectangle">The rectangle to constrain the transformed image to.</param>
|
|
||||
public TransformProcessor(Matrix3x2 matrix, IResampler sampler, Rectangle rectangle) |
|
||||
: base(matrix, sampler, rectangle) |
|
||||
{ |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
Loading…
Reference in new issue