public async Task ImageProviderTopology()
{
var backgroundImage = new ColorImageSource(new Size(100, 100), Color.FromArgb(255, 128, 128, 128));
var layerList = new LayerList(backgroundImage, backgroundImage.ImageSize, new Layer[]
{
new Layer(LayerStyle.Multiply(), context => new ColorImageSource(context.BackgroundLayer.ImageSize, Color.FromArgb(255, 32, 16, 8))),
new AdjustmentLayer(LayerStyle.Screen(0.5), new ContrastEffect(0.7)),
new AdjustmentLayer(LayerStyle.Normal(), new BrightnessEffect(0.7)),
new AdjustmentLayer(LayerStyle.Normal(), new GrayscaleEffect())
});
var layersEffect = await layerList.ToImageProvider(new Size(50, 50)).AsTask();
var chain = GetChain(layersEffect);
Assert.AreEqual(5, chain.Count);
Assert.AreSame(backgroundImage, chain.FirstOrDefault());
Assert.IsInstanceOfType(chain[1], typeof(BlendEffect)); // Layer with ColorImageSource
Assert.IsInstanceOfType(((BlendEffect)chain[1]).ForegroundSource, typeof(ColorImageSource));
Assert.IsInstanceOfType(chain[2], typeof(BlendEffect));
Assert.IsInstanceOfType(((BlendEffect)chain[2]).ForegroundSource, typeof(ContrastEffect));
Assert.IsInstanceOfType(chain[3], typeof(BrightnessEffect));
Assert.IsInstanceOfType(chain[4], typeof(GrayscaleEffect));
}
private void CreateImageProvider()
{
if ((int)Math.Min(m_requestedSize.Width, m_requestedSize.Height) <= 0)
{
throw new ArgumentOutOfRangeException("renderSize");
}
if ((int)Math.Min(m_tileSize.Width, m_tileSize.Height) <= 0)
{
throw new ArgumentOutOfRangeException("renderSize");
}
int outBgWidth = (int)m_requestedSize.Width;
int outBgHeight = (int)m_requestedSize.Height;
int tileWidth = (int)((Size)m_tileSize).Width;
int tileHeight = (int)((Size)m_tileSize).Height;
m_relativeTileSize = new Size(m_tileSize.Width / m_requestedSize.Width, m_tileSize.Height / m_requestedSize.Height);
var backgroundCanvas = new ColorImageSource(new Size(outBgWidth, outBgHeight), Color.FromArgb(255, 0, 0, 0));
m_disposables.Add(backgroundCanvas);
m_imageProvider = backgroundCanvas;
BlendTilesToFillCanvas(outBgWidth, outBgHeight, tileWidth, tileHeight);
}
public void LayerListCanBeCreatedWithBackgroundImageAndLayers()
{
var backgroundImage = new ColorImageSource(new Size(100, 100), Colors.AliceBlue);
var layerList = new LayerList(backgroundImage, backgroundImage.ImageSize, new Layer[]
{
new Layer(LayerStyle.Add(0.5), context => new ColorImageSource(context.BackgroundLayer.ImageSize, Color.FromArgb(255, 128, 128, 128))),
new AdjustmentLayer(LayerStyle.Normal(), new BrightnessEffect(0.9))
});
}
private LayerContext CreateFakeLayerContext(Layer layer)
{
var backgroundImage = new ColorImageSource(BackgroundLayerSize, Colors.AliceBlue);
var backgroundLayer = new Layer(LayerStyle.Normal(), backgroundImage, BackgroundLayerSize);
var invariants = new LayerContext.Invariants(backgroundLayer, new MaybeTask<IImageProvider>(backgroundImage), new Size(0, 0));
var layerContext = new LayerContext(invariants, backgroundLayer, layer, 1);
layerContext.PreviousImage = layerContext.BackgroundImage;
return layerContext;
}
private LayerContext CreateFakeLayerContext(Layer layer)
{
var backgroundImage = new ColorImageSource(BackgroundLayerSize, Colors.AliceBlue);
var backgroundLayer = new Layer(LayerStyle.Normal(), backgroundImage, BackgroundLayerSize);
var invariants = new LayerContext.Invariants(backgroundLayer, new MaybeTask <IImageProvider>(backgroundImage), new Size(0, 0));
var layerContext = new LayerContext(invariants, backgroundLayer, layer, 1);
layerContext.PreviousImage = layerContext.BackgroundImage;
return(layerContext);
}
public void CreateWithTaskMask()
{
var mask = new ColorImageSource(new Size(100, 100), Colors.AliceBlue);
var rect = new Rect(1, 2, 3, 4);
var layerStyle = new LayerStyle(BlendFunction.Screen, 0.7, Task.FromResult<IImageProvider>(mask), rect);
Assert.AreEqual(BlendFunction.Screen, layerStyle.BlendFunction);
Assert.AreEqual(0.7, layerStyle.Opacity);
Assert.AreSame(mask, layerStyle.MaskResolver(null).Result);
Assert.AreEqual(rect, layerStyle.TargetArea);
}
public void CreateWithTaskMask()
{
var mask = new ColorImageSource(new Size(100, 100), Colors.AliceBlue);
var rect = new Rect(1, 2, 3, 4);
var layerStyle = new LayerStyle(BlendFunction.Screen, 0.7, Task.FromResult <IImageProvider>(mask), rect);
Assert.AreEqual(BlendFunction.Screen, layerStyle.BlendFunction);
Assert.AreEqual(0.7, layerStyle.Opacity);
Assert.AreSame(mask, layerStyle.MaskResolver(null).Result);
Assert.AreEqual(rect, layerStyle.TargetArea);
}
public async Task GetImageProviderReturnsExpectedResultWhenCreatedWithLambda()
{
var backgroundImage = new ColorImageSource(BackgroundLayerSize, Colors.AliceBlue);
var backgroundLayer = new Layer(LayerStyle.Normal(), backgroundImage, BackgroundLayerSize);
var layer = new AdjustmentLayer(LayerStyle.Normal(), context => CreateTestEffect(context));
var imageProvider = layer.GetImageProvider(CreateFakeLayerContext(backgroundLayer, backgroundImage, layer));
((IImageConsumer)await imageProvider.AsTask()).Source = backgroundImage;
Assert.IsTrue(imageProvider.IsSynchronous);
Assert.IsNotNull(imageProvider.Result);
var imageProviderInfo = await imageProvider.Result.GetInfoAsync();
Assert.AreEqual(BackgroundLayerSize, imageProviderInfo.ImageSize);
}
public async Task GetImageProviderReturnsExpectedResult()
{
var backgroundImage = new ColorImageSource(BackgroundLayerSize, Colors.AliceBlue);
var backgroundLayer = new Layer(LayerStyle.Normal(), backgroundImage, BackgroundLayerSize);
var layer = new AdjustmentLayer(LayerStyle.Normal(), CreateTestEffect());
var imageProvider = layer.GetImageProvider(CreateFakeLayerContext(backgroundLayer, backgroundImage, layer));
((IImageConsumer)await imageProvider.AsTask()).Source = backgroundImage;
Assert.IsTrue(imageProvider.IsSynchronous);
Assert.IsNotNull(imageProvider.Result);
var bitmapRenderer = new BitmapRenderer(imageProvider.Result);
var bitmap = await bitmapRenderer.RenderAsync();
Assert.AreEqual(BackgroundLayerSize, bitmap.Dimensions);
}
public async Task ImageProviderTopologyWithNesting()
{
var secondaryBackgroundImage = new ColorImageSource(new Size(100, 100), Colors.RosyBrown);
var secondaryLayerList = new LayerList(secondaryBackgroundImage, secondaryBackgroundImage.Size, new Layer[]
{
new AdjustmentLayer(LayerStyle.Normal(), new BrightnessFilter(1.0), new ContrastFilter(0.1))
});
var backgroundImage = new ColorImageSource(new Size(100, 100), Color.FromArgb(255, 128, 128, 128));
var layerList = new LayerList(backgroundImage, backgroundImage.Size, new Layer[]
{
new Layer(LayerStyle.Multiply(), context => new ColorImageSource(context.BackgroundLayer.ImageSize, Color.FromArgb(255, 32, 16, 8))),
new AdjustmentLayer(LayerStyle.Screen(0.5), new ContrastFilter(0.7)),
new AdjustmentLayer(LayerStyle.Normal(), new BrightnessFilter(0.7)),
new AdjustmentLayer(LayerStyle.Normal(), new GrayscaleFilter()),
new AdjustmentLayer(LayerStyle.Overlay(), secondaryLayerList.ToImageProvider())
});
var layersEffect = await layerList.ToImageProvider(new Size(50, 50)).AsTask();
var chain = GetChain(layersEffect);
Assert.AreEqual(6, chain.Count);
Assert.AreSame(backgroundImage, chain.FirstOrDefault());
Assert.IsInstanceOfType(chain[1], typeof(BlendEffect)); // Layer with ColorImageSource
Assert.IsInstanceOfType(((BlendEffect)chain[1]).ForegroundSource, typeof(ColorImageSource));
Assert.IsInstanceOfType(chain[2], typeof(BlendEffect));
Assert.IsInstanceOfType(((BlendEffect)chain[2]).ForegroundSource, typeof(FilterEffect));
Assert.IsInstanceOfType(((FilterEffect)((BlendEffect)chain[2]).ForegroundSource).Filters.Single(), typeof(ContrastFilter));
Assert.IsInstanceOfType(chain[3], typeof(FilterEffect));
Assert.IsInstanceOfType(((FilterEffect)chain[3]).Filters.Single(), typeof(BrightnessFilter));
Assert.IsInstanceOfType(chain[4], typeof(FilterEffect));
Assert.IsInstanceOfType(((FilterEffect)chain[4]).Filters.Single(), typeof(GrayscaleFilter));
Assert.IsInstanceOfType(chain[5], typeof(BlendEffect));
Assert.IsInstanceOfType(((BlendEffect)chain[5]).ForegroundSource, typeof(FilterEffect));
var filters = ((FilterEffect)((BlendEffect)chain[5]).ForegroundSource).Filters.ToArray();
Assert.IsInstanceOfType(filters[0], typeof(BrightnessFilter));
Assert.IsInstanceOfType(filters[1], typeof(ContrastFilter));
}
public async Task RenderWithBackgroundPassedInConstructor()
{
var backgroundImage = new ColorImageSource(new Size(100, 100), Color.FromArgb(255, 128, 128, 128));
var layerList = new LayerList(backgroundImage, backgroundImage.Size, new Layer[]
{
new Layer(LayerStyle.Add(), context => new ColorImageSource(context.BackgroundLayer.ImageSize, Color.FromArgb(255, 32, 16, 8)))
});
var layersEffect = await layerList.ToImageProvider().AsTask();
var renderedBitmap = await layersEffect.GetBitmapAsync(null, OutputOption.PreserveAspectRatio);
var pixels = renderedBitmap.Buffers[0].Buffer.ToArray();
Assert.AreEqual(135, pixels[0]);
Assert.AreEqual(143, pixels[1]);
Assert.AreEqual(159, pixels[2]);
Assert.AreEqual(255, pixels[3]);
}
public async Task RenderWithBackgroundAndDifferentRenderSizePassedInToImageProvider()
{
var layerList = new LayerList(new Layer[]
{
new Layer(LayerStyle.Add(), context => new ColorImageSource(context.BackgroundLayer.ImageSize, Color.FromArgb(255, 32, 16, 8)))
});
var backgroundImage = new ColorImageSource(new Size(100, 100), Color.FromArgb(255, 128, 128, 128));
var layersEffect = await layerList.ToImageProvider(backgroundImage, backgroundImage.Size, new Size(50, 50)).AsTask();
var bitmap = new Bitmap(new Size(50, 50), ColorMode.Bgra8888);
await layersEffect.GetBitmapAsync(bitmap, OutputOption.PreserveAspectRatio);
var pixels = bitmap.Buffers[0].Buffer.ToArray();
Assert.AreEqual(135, pixels[0]);
Assert.AreEqual(143, pixels[1]);
Assert.AreEqual(160, pixels[2]);
Assert.AreEqual(255, pixels[3]);
}
private static IImageProvider2 CreateSource(Size renderSize, int grainSize)
{
if ((int)Math.Min(renderSize.Width, renderSize.Height) <= 0)
{
throw new ArgumentOutOfRangeException("renderSize");
}
const int smallerAxisFor5MPixels = 1728;
double scaleFactor = smallerAxisFor5MPixels / Math.Min(renderSize.Width, renderSize.Height);
var noiseImageSize = new Size(renderSize.Width * scaleFactor, renderSize.Height * scaleFactor);
var limitedScaleFactor = Math.Max(1.0, scaleFactor);
var colorImageSource = new ColorImageSource(noiseImageSize, Color.FromArgb(255, 128, 128, 128));
var filterEffect = new GaussianNoiseEffect(colorImageSource, Math.Max(1, grainSize / limitedScaleFactor));
return(filterEffect);
}
private static IImageProvider2 CreateSource(Size renderSize, int grainSize)
{
if ((int)Math.Min(renderSize.Width, renderSize.Height) <= 0)
{
throw new ArgumentOutOfRangeException("renderSize");
}
const int smallerAxisFor5MPixels = 1728;
double scaleFactor = smallerAxisFor5MPixels / Math.Min(renderSize.Width, renderSize.Height);
var noiseImageSize = new Size(renderSize.Width * scaleFactor, renderSize.Height * scaleFactor);
var limitedScaleFactor = Math.Max(1.0, scaleFactor);
var colorImageSource = new ColorImageSource(noiseImageSize, Color.FromArgb(255, 128, 128, 128));
var filterEffect = new GaussianNoiseEffect(colorImageSource, Math.Max(1, grainSize / limitedScaleFactor));
return filterEffect;
}
public async Task RenderWithBackgroundPassedInConstructor()
{
var backgroundImage = new ColorImageSource(new Size(100, 100), Color.FromArgb(255, 128, 128, 128));
var layerList = new LayerList(backgroundImage, backgroundImage.ImageSize, new Layer[]
{
new Layer(LayerStyle.Add(), context => new ColorImageSource(context.BackgroundLayer.ImageSize, Color.FromArgb(255, 32, 16, 8)))
});
var layersEffect = await layerList.ToImageProvider().AsTask();
var bitmapRenderer = new BitmapRenderer(layersEffect);
var renderedBitmap = await bitmapRenderer.RenderAsync();
var pixels = renderedBitmap.Buffers[0].Buffer.ToArray();
Assert.AreEqual(136, pixels[0]);
Assert.AreEqual(144, pixels[1]);
Assert.AreEqual(160, pixels[2]);
Assert.AreEqual(255, pixels[3]);
}
public void FactoryMethodsGiveCorrectMask()
{
var mask = new ColorImageSource(new Size(100, 100), Colors.AliceBlue);
Assert.AreSame(mask, LayerStyle.Normal(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Add(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Color(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Colorburn(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Colordodge(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Darken(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Difference(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Exclusion(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Hardlight(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Hue(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Lighten(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Lineardodge(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Linearlight(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Multiply(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Overlay(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Screen(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Softlight(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Vividlight(1.0, mask).MaskResolver(null).Result);
}
public void LayerListCanBeCreatedWithBackgroundImage()
{
var backgroundImage = new ColorImageSource(new Size(100, 100), Colors.AliceBlue);
var layerList = new LayerList(backgroundImage, backgroundImage.ImageSize);
}
public void LayerListCanBeCreatedWithBackgroundImageAndLayers()
{
var backgroundImage = new ColorImageSource(new Size(100, 100), Colors.AliceBlue);
var layerList = new LayerList(backgroundImage, backgroundImage.ImageSize, new Layer[]
{
new Layer(LayerStyle.Add(0.5), context => new ColorImageSource(context.BackgroundLayer.ImageSize, Color.FromArgb(255,128,128,128))),
new AdjustmentLayer(LayerStyle.Normal(), new BrightnessEffect(0.9))
});
}
public async Task RenderWithBackgroundAndDifferentRenderSizePassedInToImageProvider()
{
var layerList = new LayerList(new Layer[]
{
new Layer(LayerStyle.Add(), context => new ColorImageSource(context.BackgroundLayer.ImageSize, Color.FromArgb(255,32,16,8)))
});
var backgroundImage = new ColorImageSource(new Size(100, 100), Color.FromArgb(255, 128, 128, 128));
var layersEffect = await layerList.ToImageProvider(backgroundImage, backgroundImage.ImageSize, new Size(50,50)).AsTask();
var bitmap = new Bitmap(new Size(50,50), ColorMode.Bgra8888);
var bitmapRenderer = new BitmapRenderer(layersEffect, bitmap);
var renderedBitmap = await bitmapRenderer.RenderAsync();
var pixels = bitmap.Buffers[0].Buffer.ToArray();
Assert.AreEqual(136, pixels[0]);
Assert.AreEqual(144, pixels[1]);
Assert.AreEqual(160, pixels[2]);
Assert.AreEqual(255, pixels[3]);
}
public async Task ImageProviderTopology()
{
var backgroundImage = new ColorImageSource(new Size(100, 100), Color.FromArgb(255, 128, 128, 128));
var layerList = new LayerList(backgroundImage, backgroundImage.ImageSize, new Layer[]
{
new Layer(LayerStyle.Multiply(), context => new ColorImageSource(context.BackgroundLayer.ImageSize, Color.FromArgb(255,32,16,8))),
new AdjustmentLayer(LayerStyle.Screen(0.5), new ContrastEffect(0.7)),
new AdjustmentLayer(LayerStyle.Normal(), new BrightnessEffect(0.7)),
new AdjustmentLayer(LayerStyle.Normal(), new GrayscaleEffect())
});
var layersEffect = await layerList.ToImageProvider(new Size(50,50)).AsTask();
var chain = GetChain(layersEffect);
Assert.AreEqual(5, chain.Count);
Assert.AreSame(backgroundImage, chain.FirstOrDefault());
Assert.IsInstanceOfType(chain[1],typeof(BlendEffect)); // Layer with ColorImageSource
Assert.IsInstanceOfType(((BlendEffect)chain[1]).ForegroundSource, typeof(ColorImageSource));
Assert.IsInstanceOfType(chain[2], typeof(BlendEffect));
Assert.IsInstanceOfType(((BlendEffect)chain[2]).ForegroundSource, typeof(ContrastEffect));
Assert.IsInstanceOfType(chain[3], typeof(BrightnessEffect));
Assert.IsInstanceOfType(chain[4], typeof(GrayscaleEffect));
}
public void LayerListCanBeCreatedWithBackgroundImage()
{
var backgroundImage = new ColorImageSource(new Size(100, 100), Colors.AliceBlue);
var layerList = new LayerList(backgroundImage, backgroundImage.Size);
}
public void FactoryMethodsGiveCorrectMask()
{
var mask = new ColorImageSource(new Size(100, 100), Colors.AliceBlue);
Assert.AreSame(mask, LayerStyle.Normal(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Add(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Color(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Colorburn(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Colordodge(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Darken(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Difference(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Exclusion(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Hardlight(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Hue(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Lighten(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Lineardodge(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Linearlight(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Multiply(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Overlay(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Screen(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Softlight(1.0, mask).MaskResolver(null).Result);
Assert.AreSame(mask, LayerStyle.Vividlight(1.0, mask).MaskResolver(null).Result);
}
public async Task GetImageProviderReturnsExpectedResultWhenCreatedWithAsynchronousImageProvider()
{
var backgroundImage = new ColorImageSource(BackgroundLayerSize, Colors.AliceBlue);
var backgroundLayer = new Layer(LayerStyle.Normal(), backgroundImage, BackgroundLayerSize);
var layer = new AdjustmentLayer(LayerStyle.Normal(), CreateTestEffectAsync());
var imageProvider = layer.GetImageProvider(CreateFakeLayerContext(backgroundLayer, backgroundImage, layer));
((IImageConsumer)await imageProvider.AsTask()).Source = backgroundImage;
Assert.IsFalse(imageProvider.WasSynchronous);
var imageProviderResult = await imageProvider.AsTask();
Assert.IsNotNull(imageProviderResult);
var bitmapRenderer = new BitmapRenderer(imageProvider.Result);
var bitmap = await bitmapRenderer.RenderAsync();
Assert.AreEqual(BackgroundLayerSize, bitmap.Dimensions);
}
public async Task GetImageProviderReturnsExpectedResultWhenCreatedWithLambdaReturningAsynchronousImageProvider()
{
var backgroundImage = new ColorImageSource(BackgroundLayerSize, Colors.AliceBlue);
var backgroundLayer = new Layer(LayerStyle.Normal(), backgroundImage, BackgroundLayerSize);
var layer = new AdjustmentLayer(LayerStyle.Normal(), context => CreateTestEffectAsync(context));
var imageProvider = layer.GetImageProvider(CreateFakeLayerContext(backgroundLayer, backgroundImage, layer));
((IImageConsumer)await imageProvider.AsTask()).Source = backgroundImage;
Assert.IsFalse(imageProvider.WasSynchronous);
var imageProviderResult = await imageProvider.AsTask();
Assert.IsNotNull(imageProviderResult);
var imageProviderInfo = await imageProvider.Result.GetInfoAsync();
Assert.AreEqual(BackgroundLayerSize, imageProviderInfo.ImageSize);
}
public async Task ImageProviderTopologyWithNesting()
{
var secondaryBackgroundImage = new ColorImageSource(new Size(100, 100), Colors.RosyBrown);
var secondaryLayerList = new LayerList(secondaryBackgroundImage, secondaryBackgroundImage.Size, new Layer[]
{
new AdjustmentLayer(LayerStyle.Normal(), new BrightnessFilter(1.0), new ContrastFilter(0.1))
});
var backgroundImage = new ColorImageSource(new Size(100, 100), Color.FromArgb(255, 128, 128, 128));
var layerList = new LayerList(backgroundImage, backgroundImage.Size, new Layer[]
{
new Layer(LayerStyle.Multiply(), context => new ColorImageSource(context.BackgroundLayer.ImageSize, Color.FromArgb(255,32,16,8))),
new AdjustmentLayer(LayerStyle.Screen(0.5), new ContrastFilter(0.7)),
new AdjustmentLayer(LayerStyle.Normal(), new BrightnessFilter(0.7)),
new AdjustmentLayer(LayerStyle.Normal(), new GrayscaleFilter()),
new AdjustmentLayer(LayerStyle.Overlay(), secondaryLayerList.ToImageProvider())
});
var layersEffect = await layerList.ToImageProvider(new Size(50, 50)).AsTask();
var chain = GetChain(layersEffect);
Assert.AreEqual(6, chain.Count);
Assert.AreSame(backgroundImage, chain.FirstOrDefault());
Assert.IsInstanceOfType(chain[1], typeof(BlendEffect)); // Layer with ColorImageSource
Assert.IsInstanceOfType(((BlendEffect)chain[1]).ForegroundSource, typeof(ColorImageSource));
Assert.IsInstanceOfType(chain[2], typeof(BlendEffect));
Assert.IsInstanceOfType(((BlendEffect)chain[2]).ForegroundSource, typeof(FilterEffect));
Assert.IsInstanceOfType(((FilterEffect)((BlendEffect)chain[2]).ForegroundSource).Filters.Single(), typeof(ContrastFilter));
Assert.IsInstanceOfType(chain[3], typeof(FilterEffect));
Assert.IsInstanceOfType(((FilterEffect)chain[3]).Filters.Single(), typeof(BrightnessFilter));
Assert.IsInstanceOfType(chain[4], typeof(FilterEffect));
Assert.IsInstanceOfType(((FilterEffect)chain[4]).Filters.Single(), typeof(GrayscaleFilter));
Assert.IsInstanceOfType(chain[5], typeof(BlendEffect));
Assert.IsInstanceOfType(((BlendEffect)chain[5]).ForegroundSource, typeof(FilterEffect));
var filters = ((FilterEffect)((BlendEffect)chain[5]).ForegroundSource).Filters.ToArray();
Assert.IsInstanceOfType(filters[0], typeof(BrightnessFilter));
Assert.IsInstanceOfType(filters[1], typeof(ContrastFilter));
}
public async Task RenderWithBackgroundAndDifferentRenderSizePassedInToImageProvider()
{
var layerList = new LayerList(new Layer[]
{
new Layer(LayerStyle.Add(), context => new ColorImageSource(context.BackgroundLayer.ImageSize, Color.FromArgb(255,32,16,8)))
});
var backgroundImage = new ColorImageSource(new Size(100, 100), Color.FromArgb(255, 128, 128, 128));
var layersEffect = await layerList.ToImageProvider(backgroundImage, backgroundImage.Size, new Size(50,50)).AsTask();
var bitmap = new Bitmap(new Size(50,50), ColorMode.Bgra8888);
await layersEffect.GetBitmapAsync(bitmap, OutputOption.PreserveAspectRatio);
var pixels = bitmap.Buffers[0].Buffer.ToArray();
Assert.AreEqual(135, pixels[0]);
Assert.AreEqual(143, pixels[1]);
Assert.AreEqual(159, pixels[2]);
Assert.AreEqual(255, pixels[3]);
}
private void CreateImageProvider()
{
if ((int)Math.Min(m_requestedSize.Width, m_requestedSize.Height) <= 0)
{
throw new ArgumentOutOfRangeException("renderSize");
}
if ((int)Math.Min(m_tileSize.Width, m_tileSize.Height) <= 0)
{
throw new ArgumentOutOfRangeException("renderSize");
}
int outBgWidth = (int)m_requestedSize.Width;
int outBgHeight = (int)m_requestedSize.Height;
int tileWidth = (int)((Size)m_tileSize).Width;
int tileHeight = (int)((Size)m_tileSize).Height;
m_relativeTileSize = new Size(m_tileSize.Width / m_requestedSize.Width, m_tileSize.Height / m_requestedSize.Height);
var backgroundCanvas = new ColorImageSource(new Size(outBgWidth, outBgHeight), Color.FromArgb(255, 0, 0, 0));
m_disposables.Add(backgroundCanvas);
m_imageProvider = backgroundCanvas;
BlendTilesToFillCanvas(outBgWidth, outBgHeight, tileWidth, tileHeight);
}
