public void _1DarkBlueRect_2BlendHotPinkRect <TPixel>(
TestImageProvider <TPixel> provider,
PixelColorBlendingMode blending,
PixelAlphaCompositionMode composition)
where TPixel : struct, IPixel <TPixel>
{
using (Image <TPixel> img = provider.GetImage())
{
int scaleX = img.Width / 100;
int scaleY = img.Height / 100;
img.Mutate(
x => x.Fill(
Color.DarkBlue,
new Rectangle(0 * scaleX, 40 * scaleY, 100 * scaleX, 20 * scaleY)
)
.Fill(
new GraphicsOptions {
Antialias = true, ColorBlendingMode = blending, AlphaCompositionMode = composition
},
Color.HotPink,
new Rectangle(20 * scaleX, 0 * scaleY, 30 * scaleX, 100 * scaleY))
);
VerifyImage(provider, blending, composition, img);
}
}
/// <summary>
/// Draws the given image together with the current one by blending their pixels.
/// </summary>
/// <param name="source">The image this method extends.</param>
/// <param name="image">The image to blend with the currently processing image.</param>
/// <param name="colorBlending">The color blending mode.</param>
/// <param name="alphaComposition">The alpha composition mode.</param>
/// <param name="opacity">The opacity of the image to blend. Must be between 0 and 1.</param>
/// <returns>The <see cref="Image{TPixelDst}"/>.</returns>
public static IImageProcessingContext DrawImage(
this IImageProcessingContext source,
Image image,
PixelColorBlendingMode colorBlending,
PixelAlphaCompositionMode alphaComposition,
float opacity) =>
source.ApplyProcessor(new DrawImageProcessor(image, Point.Empty, colorBlending, alphaComposition, opacity));
public void WorksWithDifferentConfigurations <TPixel>(
TestImageProvider <TPixel> provider,
string brushImage,
PixelColorBlendingMode mode,
float opacity)
where TPixel : struct, IPixel <TPixel>
{
using (Image <TPixel> image = provider.GetImage())
using (var blend = Image.Load <TPixel>(TestFile.Create(brushImage).Bytes))
{
var size = new Size(image.Width * 3 / 4, image.Height * 3 / 4);
var position = new Point(image.Width / 8, image.Height / 8);
blend.Mutate(x => x.Resize(size.Width, size.Height, KnownResamplers.Bicubic));
image.Mutate(x => x.DrawImage(blend, position, mode, opacity));
FormattableString testInfo = $"{System.IO.Path.GetFileNameWithoutExtension(brushImage)}-{mode}-{opacity}";
var encoder = new PngEncoder();
if (provider.PixelType == PixelTypes.Rgba64)
{
encoder.BitDepth = PngBitDepth.Bit16;
}
image.DebugSave(provider, testInfo, encoder: encoder);
image.CompareToReferenceOutput(ImageComparer.TolerantPercentage(0.01f),
provider,
testInfo);
}
}
public void _1DarkBlueRect_2BlendHotPinkRect_3BlendTransparentEllipse <TPixel>(
TestImageProvider <TPixel> provider,
PixelColorBlendingMode blending,
PixelAlphaCompositionMode composition)
where TPixel : struct, IPixel <TPixel>
{
using (Image <TPixel> img = provider.GetImage())
{
int scaleX = img.Width / 100;
int scaleY = img.Height / 100;
img.Mutate(
x => x.Fill(
NamedColors <TPixel> .DarkBlue,
new Rectangle(0 * scaleX, 40 * scaleY, 100 * scaleX, 20 * scaleY)));
img.Mutate(
x => x.Fill(
new GraphicsOptions(true)
{
ColorBlendingMode = blending, AlphaCompositionMode = composition
},
NamedColors <TPixel> .HotPink,
new Rectangle(20 * scaleX, 0 * scaleY, 30 * scaleX, 100 * scaleY)));
img.Mutate(
x => x.Fill(
new GraphicsOptions(true)
{
ColorBlendingMode = blending, AlphaCompositionMode = composition
},
NamedColors <TPixel> .Transparent,
new Shapes.EllipsePolygon(40 * scaleX, 50 * scaleY, 50 * scaleX, 50 * scaleY))
);
VerifyImage(provider, blending, composition, img);
}
}
public void _1DarkBlueRect_2BlendBlackEllipse <TPixel>(
TestImageProvider <TPixel> provider,
PixelColorBlendingMode blending,
PixelAlphaCompositionMode composition)
where TPixel : struct, IPixel <TPixel>
{
using (Image <TPixel> dstImg = provider.GetImage(), srcImg = provider.GetImage())
{
int scaleX = (dstImg.Width / 100);
int scaleY = (dstImg.Height / 100);
dstImg.Mutate(
x => x.Fill(
NamedColors <TPixel> .DarkBlue,
new Rectangle(0 * scaleX, 40 * scaleY, 100 * scaleX, 20 * scaleY)));
srcImg.Mutate(
x => x.Fill(
NamedColors <TPixel> .Black,
new Shapes.EllipsePolygon(40 * scaleX, 50 * scaleY, 50 * scaleX, 50 * scaleY)));
dstImg.Mutate(
x => x.DrawImage(srcImg, new GraphicsOptions(true)
{
ColorBlendingMode = blending, AlphaCompositionMode = composition
})
);
VerifyImage(provider, blending, composition, dstImg);
}
}
#pragma warning disable IDE1006 // Naming Styles
#pragma warning disable SA1300 // Element should begin with upper-case letter
public void _1DarkBlueRect_2BlendHotPinkRect <TPixel>(
TestImageProvider <TPixel> provider,
PixelColorBlendingMode blending,
PixelAlphaCompositionMode composition)
where TPixel : unmanaged, IPixel <TPixel>
#pragma warning restore SA1300 // Element should begin with upper-case letter
#pragma warning restore IDE1006 // Naming Styles
{
using (Image <TPixel> img = provider.GetImage())
{
int scaleX = img.Width / 100;
int scaleY = img.Height / 100;
img.Mutate(
x => x.Fill(
Color.DarkBlue,
new Rectangle(0 * scaleX, 40 * scaleY, 100 * scaleX, 20 * scaleY))
.Fill(
new ShapeGraphicsOptions
{
GraphicsOptions =
{
Antialias = true, ColorBlendingMode = blending, AlphaCompositionMode = composition
}
},
Color.HotPink,
new Rectangle(20 * scaleX, 0 * scaleY, 30 * scaleX, 100 * scaleY)));
VerifyImage(provider, blending, composition, img);
}
}
public void DefaultGraphicsOptionsColorBlendingMode()
{
const PixelColorBlendingMode Expected = PixelColorBlendingMode.Normal;
Assert.Equal(Expected, this.newGraphicsOptions.ColorBlendingMode);
Assert.Equal(Expected, this.cloneGraphicsOptions.ColorBlendingMode);
}
public void _1DarkBlueRect_2BlendBlackEllipse <TPixel>(
TestImageProvider <TPixel> provider,
PixelColorBlendingMode blending,
PixelAlphaCompositionMode composition)
where TPixel : unmanaged, IPixel <TPixel>
{
using (Image <TPixel> dstImg = provider.GetImage(), srcImg = provider.GetImage())
{
int scaleX = dstImg.Width / 100;
int scaleY = dstImg.Height / 100;
dstImg.Mutate(
x => x.Fill(
Color.DarkBlue,
new Rectangle(0 * scaleX, 40 * scaleY, 100 * scaleX, 20 * scaleY)));
srcImg.Mutate(
x => x.Fill(
Color.Black,
new EllipsePolygon(40 * scaleX, 50 * scaleY, 50 * scaleX, 50 * scaleY)));
dstImg.Mutate(
x => x.DrawImage(srcImg, new GraphicsOptions {
Antialias = true, ColorBlendingMode = blending, AlphaCompositionMode = composition
}));
VerifyImage(provider, blending, composition, dstImg);
}
}
#pragma warning disable IDE1006 // Naming Styles
#pragma warning disable SA1300 // Element should begin with upper-case letter
public void _1DarkBlueRect_2BlendBlackEllipse <TPixel>(
TestImageProvider <TPixel> provider,
PixelColorBlendingMode blending,
PixelAlphaCompositionMode composition)
where TPixel : unmanaged, IPixel <TPixel>
#pragma warning restore SA1300 // Element should begin with upper-case letter
#pragma warning restore IDE1006 // Naming Styles
{
using (Image <TPixel> dstImg = provider.GetImage(), srcImg = provider.GetImage())
{
int scaleX = dstImg.Width / 100;
int scaleY = dstImg.Height / 100;
dstImg.Mutate(
x => x.Fill(
Color.DarkBlue,
new Rectangle(0 * scaleX, 40 * scaleY, 100 * scaleX, 20 * scaleY)));
srcImg.Mutate(
x => x.Fill(
Color.Black,
new EllipsePolygon(40 * scaleX, 50 * scaleY, 50 * scaleX, 50 * scaleY)));
dstImg.Mutate(
x => x.DrawImage(srcImg, new GraphicsOptions {
Antialias = true, ColorBlendingMode = blending, AlphaCompositionMode = composition
}));
VerifyImage(provider, blending, composition, dstImg);
}
}
public void BlendFillColorOverBackround <TPixel>(
TestImageProvider <TPixel> provider,
bool triggerFillRegion,
string newColorName,
float alpha,
PixelColorBlendingMode blenderMode,
float blendPercentage)
where TPixel : struct, IPixel <TPixel>
{
var vec = TestUtils.GetPixelOfNamedColor <RgbaVector>(newColorName).ToVector4();
vec.W = alpha;
TPixel fillColor = default;
fillColor.PackFromVector4(vec);
using (Image <TPixel> image = provider.GetImage())
{
TPixel bgColor = image[0, 0];
var options = new GraphicsOptions(false)
{
ColorBlendingMode = blenderMode,
BlendPercentage = blendPercentage
};
if (triggerFillRegion)
{
var region = new ShapeRegion(new RectangularPolygon(0, 0, 16, 16));
image.Mutate(c => c.Fill(options, new SolidBrush <TPixel>(fillColor), region));
}
else
{
image.Mutate(c => c.Fill(options, new SolidBrush <TPixel>(fillColor)));
}
var testOutputDetails = new
{
triggerFillRegion = triggerFillRegion,
newColorName = newColorName,
alpha = alpha,
blenderMode = blenderMode,
blendPercentage = blendPercentage
};
image.DebugSave(
provider,
testOutputDetails,
appendPixelTypeToFileName: false,
appendSourceFileOrDescription: false);
PixelBlender <TPixel> blender = PixelOperations <TPixel> .Instance.GetPixelBlender(blenderMode, PixelAlphaCompositionMode.SrcOver);
TPixel expectedPixel = blender.Blend(bgColor, fillColor, blendPercentage);
image.ComparePixelBufferTo(expectedPixel);
}
}
public void BlendFillColorOverBackground <TPixel>(
TestImageProvider <TPixel> provider,
bool triggerFillRegion,
string newColorName,
float alpha,
PixelColorBlendingMode blenderMode,
float blendPercentage)
where TPixel : unmanaged, IPixel <TPixel>
{
Color fillColor = TestUtils.GetColorByName(newColorName).WithAlpha(alpha);
using (Image <TPixel> image = provider.GetImage())
{
TPixel bgColor = image[0, 0];
var options = new DrawingOptions
{
GraphicsOptions = new GraphicsOptions
{
Antialias = false,
ColorBlendingMode = blenderMode,
BlendPercentage = blendPercentage
}
};
if (triggerFillRegion)
{
var path = new RectangularPolygon(0, 0, 16, 16);
image.Mutate(c => c.SetGraphicsOptions(options.GraphicsOptions).Fill(new SolidBrush(fillColor), path));
}
else
{
image.Mutate(c => c.Fill(options, new SolidBrush(fillColor)));
}
var testOutputDetails = new
{
triggerFillRegion,
newColorName,
alpha,
blenderMode,
blendPercentage
};
image.DebugSave(
provider,
testOutputDetails,
appendPixelTypeToFileName: false,
appendSourceFileOrDescription: false);
PixelBlender <TPixel> blender = PixelOperations <TPixel> .Instance.GetPixelBlender(
blenderMode,
PixelAlphaCompositionMode.SrcOver);
TPixel expectedPixel = blender.Blend(bgColor, fillColor.ToPixel <TPixel>(), blendPercentage);
image.ComparePixelBufferTo(expectedPixel);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="GraphicsOptions"/> struct.
/// </summary>
/// <param name="enableAntialiasing">If set to <c>true</c> [enable antialiasing].</param>
public GraphicsOptions(bool enableAntialiasing)
{
this.colorBlendingMode = PixelColorBlendingMode.Normal;
this.alphaCompositionMode = PixelAlphaCompositionMode.SrcOver;
this.blendPercentage = 1;
this.antialiasSubpixelDepth = 16;
this.antialias = enableAntialiasing;
}
/// <summary>
/// Initializes a new instance of the <see cref="GraphicsOptions"/> struct.
/// </summary>
/// <param name="enableAntialiasing">If set to <c>true</c> [enable antialiasing].</param>
/// <param name="opacity">blending percentage to apply to the drawing operation</param>
/// <param name="blending">color blending mode to apply to the drawing operation</param>
/// <param name="composition">alpha composition mode to apply to the drawing operation</param>
public GraphicsOptions(bool enableAntialiasing, PixelColorBlendingMode blending, PixelAlphaCompositionMode composition, float opacity)
{
Guard.MustBeBetweenOrEqualTo(opacity, 0, 1, nameof(opacity));
this.colorBlendingMode = blending;
this.alphaCompositionMode = composition;
this.blendPercentage = opacity;
this.antialiasSubpixelDepth = 16;
this.antialias = enableAntialiasing;
}
/// <summary>
/// Initializes a new instance of the <see cref="DrawImageProcessor{TPixelDst, TPixelSrc}"/> class.
/// </summary>
/// <param name="image">The image to blend with the currently processing image.</param>
/// <param name="location">The location to draw the blended image.</param>
/// <param name="colorBlendingMode">The blending mode to use when drawing the image.</param>
/// <param name="alphaCompositionMode">The Alpha blending mode to use when drawing the image.</param>
/// <param name="opacity">The opacity of the image to blend. Must be between 0 and 1.</param>
public DrawImageProcessor(Image <TPixelSrc> image, Point location, PixelColorBlendingMode colorBlendingMode, PixelAlphaCompositionMode alphaCompositionMode, float opacity)
{
Guard.MustBeBetweenOrEqualTo(opacity, 0, 1, nameof(opacity));
this.Image = image;
this.Opacity = opacity;
this.Blender = PixelOperations <TPixelDst> .Instance.GetPixelBlender(colorBlendingMode, alphaCompositionMode);
this.Location = location;
}
/// <summary>
/// Draws the given image together with the current one by blending their pixels.
/// </summary>
/// <param name="source">The image this method extends.</param>
/// <param name="image">The image to blend with the currently processing image.</param>
/// <param name="location">The location to draw the blended image.</param>
/// <param name="colorBlending">The color blending to apply.</param>
/// <param name="opacity">The opacity of the image to blend. Must be between 0 and 1.</param>
/// <returns>The <see cref="Image{TPixelDst}"/>.</returns>
public static IImageProcessingContext DrawImage(
this IImageProcessingContext source,
Image image,
Point location,
PixelColorBlendingMode colorBlending,
float opacity) =>
source.ApplyProcessor(
new DrawImageProcessor(
image,
location,
colorBlending,
GraphicsOptions.Default.AlphaCompositionMode,
opacity));
/// <summary>
/// Initializes a new instance of the <see cref="DrawImageProcessor"/> class.
/// </summary>
/// <param name="image">The image to blend.</param>
/// <param name="location">The location to draw the blended image.</param>
/// <param name="colorBlendingMode">The blending mode to use when drawing the image.</param>
/// <param name="alphaCompositionMode">The Alpha blending mode to use when drawing the image.</param>
/// <param name="opacity">The opacity of the image to blend.</param>
public DrawImageProcessor(
Image image,
Point location,
PixelColorBlendingMode colorBlendingMode,
PixelAlphaCompositionMode alphaCompositionMode,
float opacity)
{
this.Image = image;
this.Location = location;
this.ColorBlendingMode = colorBlendingMode;
this.AlphaCompositionMode = alphaCompositionMode;
this.Opacity = opacity;
}
/// <summary>
/// Initializes a new instance of the <see cref="TextGraphicsOptions" /> struct.
/// </summary>
/// <param name="enableAntialiasing">If set to <c>true</c> [enable antialiasing].</param>
public TextGraphicsOptions(bool enableAntialiasing)
{
this.applyKerning = true;
this.tabWidth = 4;
this.wrapTextWidth = 0;
this.horizontalAlignment = HorizontalAlignment.Left;
this.verticalAlignment = VerticalAlignment.Top;
this.antialiasSubpixelDepth = 16;
this.colorBlendingMode = PixelColorBlendingMode.Normal;
this.alphaCompositionMode = PixelAlphaCompositionMode.SrcOver;
this.blendPercentage = 1;
this.antialias = enableAntialiasing;
this.dpiX = DefaultTextDpi;
this.dpiY = DefaultTextDpi;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:SixLabors.ImageSharp.Processing.Processors.Drawing.DrawImageProcessor`2" /> class.
/// </summary>
/// <param name="configuration">The configuration which allows altering default behaviour or extending the library.</param>
/// <param name="image">The foreground <see cref="T:SixLabors.ImageSharp.Image`1" /> to blend with the currently processing image.</param>
/// <param name="source">The source <see cref="T:SixLabors.ImageSharp.Image`1" /> for the current processor instance.</param>
/// <param name="sourceRectangle">The source area to process for the current processor instance.</param>
/// <param name="location">The location to draw the blended image.</param>
/// <param name="colorBlendingMode">The blending mode to use when drawing the image.</param>
/// <param name="alphaCompositionMode">The Alpha blending mode to use when drawing the image.</param>
/// <param name="interpolationValue">The interpolation progress. Must be between 0 and 1.</param>
public InterpolateProcessor(Configuration configuration,
SixLabors.ImageSharp.Image <TPixelFg> image,
SixLabors.ImageSharp.Image <TPixelBg> source,
SixLabors.ImageSharp.Rectangle sourceRectangle,
Point location,
PixelColorBlendingMode colorBlendingMode,
PixelAlphaCompositionMode alphaCompositionMode,
float interpolationValue) : base(configuration, source, sourceRectangle)
{
// Guard.MustBeBetweenOrEqualTo(opacity, 0.0f, 1f, nameof(opacity));
this.Image = image;
this.InterpolationValue = interpolationValue;
this.Blender = PixelOperations <TPixelBg> .Instance.GetPixelBlender(colorBlendingMode, alphaCompositionMode);
this.Location = location;
}
#pragma warning disable IDE1006 // Naming Styles
#pragma warning disable SA1300 // Element should begin with upper-case letter
public void _1DarkBlueRect_2BlendHotPinkRect_3BlendSemiTransparentRedEllipse <TPixel>(
TestImageProvider <TPixel> provider,
PixelColorBlendingMode blending,
PixelAlphaCompositionMode composition)
where TPixel : unmanaged, IPixel <TPixel>
#pragma warning restore SA1300 // Element should begin with upper-case letter
#pragma warning restore IDE1006 // Naming Styles
{
using (Image <TPixel> img = provider.GetImage())
{
int scaleX = img.Width / 100;
int scaleY = img.Height / 100;
img.Mutate(
x => x.Fill(
Color.DarkBlue,
new Rectangle(0 * scaleX, 40, 100 * scaleX, 20 * scaleY)));
img.Mutate(
x => x.Fill(
new DrawingOptions
{
GraphicsOptions = new GraphicsOptions {
Antialias = true, ColorBlendingMode = blending, AlphaCompositionMode = composition
}
},
Color.HotPink,
new Rectangle(20 * scaleX, 0, 30 * scaleX, 100 * scaleY)));
Color transparentRed = Color.Red.WithAlpha(0.5f);
img.Mutate(
x => x.Fill(
new DrawingOptions
{
GraphicsOptions = new GraphicsOptions {
Antialias = true, ColorBlendingMode = blending, AlphaCompositionMode = composition
}
},
transparentRed,
new EllipsePolygon(40 * scaleX, 50 * scaleY, 50 * scaleX, 50 * scaleY)));
VerifyImage(provider, blending, composition, img);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DrawImageProcessor{TPixelBg, TPixelFg}"/> class.
/// </summary>
/// <param name="configuration">The configuration which allows altering default behaviour or extending the library.</param>
/// <param name="image">The foreground <see cref="Image{TPixelFg}"/> to blend with the currently processing image.</param>
/// <param name="source">The source <see cref="Image{TPixelBg}"/> for the current processor instance.</param>
/// <param name="sourceRectangle">The source area to process for the current processor instance.</param>
/// <param name="location">The location to draw the blended image.</param>
/// <param name="colorBlendingMode">The blending mode to use when drawing the image.</param>
/// <param name="alphaCompositionMode">The Alpha blending mode to use when drawing the image.</param>
/// <param name="opacity">The opacity of the image to blend. Must be between 0 and 1.</param>
public DrawImageProcessor(
Configuration configuration,
Image <TPixelFg> image,
Image <TPixelBg> source,
Rectangle sourceRectangle,
Point location,
PixelColorBlendingMode colorBlendingMode,
PixelAlphaCompositionMode alphaCompositionMode,
float opacity)
: base(configuration, source, sourceRectangle)
{
Guard.MustBeBetweenOrEqualTo(opacity, 0, 1, nameof(opacity));
this.Image = image;
this.Opacity = opacity;
this.Blender = PixelOperations <TPixelBg> .Instance.GetPixelBlender(colorBlendingMode, alphaCompositionMode);
this.Location = location;
}
public void _1DarkBlueRect_2BlendHotPinkRect_3BlendSemiTransparentRedEllipse <TPixel>(
TestImageProvider <TPixel> provider,
PixelColorBlendingMode blending,
PixelAlphaCompositionMode composition)
where TPixel : unmanaged, IPixel <TPixel>
{
using (Image <TPixel> img = provider.GetImage())
{
int scaleX = (img.Width / 100);
int scaleY = (img.Height / 100);
img.Mutate(
x => x.Fill(
Color.DarkBlue,
new Rectangle(0 * scaleX, 40, 100 * scaleX, 20 * scaleY)));
img.Mutate(
x => x.Fill(
new ShapeGraphicsOptions
{
GraphicsOptions = new GraphicsOptions {
Antialias = true, ColorBlendingMode = blending, AlphaCompositionMode = composition
}
},
Color.HotPink,
new Rectangle(20 * scaleX, 0, 30 * scaleX, 100 * scaleY)));
Color transparentRed = Color.Red.WithAlpha(0.5f);
img.Mutate(
x => x.Fill(
new ShapeGraphicsOptions
{
GraphicsOptions = new GraphicsOptions {
Antialias = true, ColorBlendingMode = blending, AlphaCompositionMode = composition
}
},
transparentRed,
new EllipsePolygon(40 * scaleX, 50 * scaleY, 50 * scaleX, 50 * scaleY))
);
VerifyImage(provider, blending, composition, img);;
}
}
private static void VerifyImage <TPixel>(
TestImageProvider <TPixel> provider,
PixelColorBlendingMode mode,
Image <TPixel> img)
where TPixel : struct, IPixel <TPixel>
{
img.DebugSave(
provider,
new { mode },
appendPixelTypeToFileName: false,
appendSourceFileOrDescription: false);
var comparer = ImageComparer.TolerantPercentage(0.01F, 3);
img.CompareFirstFrameToReferenceOutput(comparer,
provider,
new { mode },
appendPixelTypeToFileName: false,
appendSourceFileOrDescription: false);
}
public void _1DarkBlueRect_2BlendHotPinkRect_3BlendSemiTransparentRedEllipse <TPixel>(
TestImageProvider <TPixel> provider,
PixelColorBlendingMode blending,
PixelAlphaCompositionMode composition)
where TPixel : struct, IPixel <TPixel>
{
using (Image <TPixel> img = provider.GetImage())
{
int scaleX = (img.Width / 100);
int scaleY = (img.Height / 100);
img.Mutate(
x => x.Fill(
NamedColors <TPixel> .DarkBlue,
new Rectangle(0 * scaleX, 40, 100 * scaleX, 20 * scaleY)));
img.Mutate(
x => x.Fill(
new GraphicsOptions(true)
{
ColorBlendingMode = blending, AlphaCompositionMode = composition
},
NamedColors <TPixel> .HotPink,
new Rectangle(20 * scaleX, 0, 30 * scaleX, 100 * scaleY)));
var c = NamedColors <TPixel> .Red.ToVector4();
c.W *= 0.5f;
var pixel = default(TPixel);
pixel.FromVector4(c);
img.Mutate(
x => x.Fill(
new GraphicsOptions(true)
{
ColorBlendingMode = blending, AlphaCompositionMode = composition
},
pixel,
new Shapes.EllipsePolygon(40 * scaleX, 50 * scaleY, 50 * scaleX, 50 * scaleY))
);
VerifyImage(provider, blending, composition, img);;
}
}
private static void VerifyImage <TPixel>(
TestImageProvider <TPixel> provider,
PixelColorBlendingMode blending,
PixelAlphaCompositionMode composition,
Image <TPixel> img)
where TPixel : unmanaged, IPixel <TPixel>
{
img.DebugSave(
provider,
new { composition, blending },
appendPixelTypeToFileName: false,
appendSourceFileOrDescription: false);
var comparer = ImageComparer.TolerantPercentage(0.01f, 3);
img.CompareFirstFrameToReferenceOutput(comparer,
provider,
new { composition, blending },
appendPixelTypeToFileName: false,
appendSourceFileOrDescription: false);
}
/// <summary>
/// Composes the underlay with a target image.
/// </summary>
private void Compose(Image target, PixelColorBlendingMode blendingMode = PixelColorBlendingMode.Normal)
{
_image.Mutate(context => context.DrawImage(target, blendingMode, 1.0f));
}
public void ImageBlendingMatchesSvgSpecExamples <TPixel>(TestImageProvider <TPixel> provider, PixelColorBlendingMode mode)
where TPixel : struct, IPixel <TPixel>
{
using (Image <TPixel> background = provider.GetImage())
using (var source = Image.Load <TPixel>(TestFile.Create(TestImages.Png.Ducky).Bytes))
{
background.Mutate(x => x.DrawImage(source, mode, 1F));
VerifyImage(provider, mode, background);
}
}
public void ImageShouldDrawTransformedImage <TPixel>(TestImageProvider <TPixel> provider, PixelColorBlendingMode mode)
where TPixel : struct, IPixel <TPixel>
{
using (Image <TPixel> image = provider.GetImage())
using (var blend = Image.Load <TPixel>(TestFile.Create(TestImages.Bmp.Car).Bytes))
{
AffineTransformBuilder builder = new AffineTransformBuilder()
.AppendRotationDegrees(45F)
.AppendScale(new SizeF(.25F, .25F))
.AppendTranslation(new PointF(10, 10));
// Apply a background color so we can see the translation.
blend.Mutate(x => x.Transform(builder).BackgroundColor(NamedColors <TPixel> .HotPink));
// Lets center the matrix so we can tell whether any cut-off issues we may have belong to the drawing processor
var position = new Point((image.Width - blend.Width) / 2, (image.Height - blend.Height) / 2);
image.Mutate(x => x.DrawImage(blend, position, mode, .75F));
image.DebugSave(provider, new[] { "Transformed" });
}
}
public void TestColorBlendingModes(Rgba32 backdrop, Rgba32 source, float opacity, PixelColorBlendingMode mode, Rgba32 expectedResult)
{
PixelBlender <Rgba32> blender = PixelOperations <Rgba32> .Instance.GetPixelBlender(mode, PixelAlphaCompositionMode.SrcOver);
Rgba32 actualResult = blender.Blend(backdrop, source, opacity);
// var str = actualResult.Rgba.ToString("X8"); // used to extract expectedResults
Assert.Equal(actualResult.ToVector4(), expectedResult.ToVector4());
}
public void ReturnsCorrectBlender <TPixel>(TestPixel <TPixel> pixel, Type type, PixelColorBlendingMode mode)
where TPixel : unmanaged, IPixel <TPixel>
{
PixelBlender <TPixel> blender = PixelOperations <TPixel> .Instance.GetPixelBlender(mode, PixelAlphaCompositionMode.SrcOver);
Assert.IsType(type, blender);
}
public void ImageBlendingMatchesSvgSpecExamples <TPixel>(TestImageProvider <TPixel> provider, PixelColorBlendingMode mode)
where TPixel : struct, IPixel <TPixel>
{
using (Image <TPixel> background = provider.GetImage())
using (var source = Image.Load <TPixel>(TestFile.Create(TestImages.Png.Ducky).Bytes))
{
background.Mutate(x => x.DrawImage(source, mode, 1F));
background.DebugSave(
provider,
new { mode = mode },
appendPixelTypeToFileName: false,
appendSourceFileOrDescription: false);
var comparer = ImageComparer.TolerantPercentage(0.01F);
background.CompareToReferenceOutput(comparer,
provider,
new { mode = mode },
appendPixelTypeToFileName: false,
appendSourceFileOrDescription: false);
}
}
