ICanvasImage CreateCheckerBoard(CanvasControl control)
{
var color1 = Color.FromArgb(255, 254, 254, 254);
var color2 = Color.FromArgb(255, 250, 250, 250);
Color[] twoByTwoChecker =
{
color1, color2,
color2, color1
};
var checker = new DpiCompensationEffect
{
Source = new ScaleEffect
{
Source = new BorderEffect
{
Source = CanvasBitmap.CreateFromColors(control, twoByTwoChecker, 2, 2),
ExtendX = CanvasEdgeBehavior.Wrap,
ExtendY = CanvasEdgeBehavior.Wrap
},
Scale = new Vector2(8, 8),
InterpolationMode = CanvasImageInterpolation.NearestNeighbor
}
};
return(checker);
}
static CanvasBitmap CreateTestBitmap(ICanvasResourceCreatorWithDpi resourceCreator, float dpi)
{
int pixelSize = (int)Math.Round(testSize * dpi / defaultDpi);
// Initialize to solid gray.
Color[] colors = Enumerable.Repeat(Colors.Gray, pixelSize * pixelSize).ToArray();
// Diagonal lines.
for (int i = 0; i < pixelSize; i++)
{
colors[i * pixelSize + i] = Colors.Red;
colors[i * pixelSize + (pixelSize - i - 1)] = Colors.Red;
}
// Single pixel border.
for (int i = 0; i < pixelSize; i++)
{
colors[i] = Colors.Blue;
colors[i * pixelSize] = Colors.Blue;
colors[i * pixelSize + pixelSize - 1] = Colors.Blue;
colors[pixelSize * (pixelSize - 1) + i] = Colors.Blue;
}
if (dpi == defaultDpi)
{
// We could always just use the "else" path, but want to test this default overload as well.
return(CanvasBitmap.CreateFromColors(resourceCreator, colors, pixelSize, pixelSize));
}
else
{
return(CanvasBitmap.CreateFromColors(resourceCreator, colors, pixelSize, pixelSize, dpi));
}
}
public void CanvasBitmap_CreateFromSoftwareBitmap_Roundtrip()
{
var colors = new Color[]
{
Colors.Red, Colors.Green, Colors.Yellow,
Colors.Green, Colors.Yellow, Colors.Red,
Colors.Yellow, Colors.Red, Colors.Green
};
float anyDpi = 10;
var device = new CanvasDevice(true);
var originalBitmap = CanvasBitmap.CreateFromColors(device, colors, 3, 3, anyDpi);
var softwareBitmap = SoftwareBitmap.CreateCopyFromSurfaceAsync(originalBitmap, BitmapAlphaMode.Premultiplied).AsTask().Result;
softwareBitmap.DpiX = anyDpi;
softwareBitmap.DpiY = anyDpi;
var roundtrippedBitmap = CanvasBitmap.CreateFromSoftwareBitmap(device, softwareBitmap);
Assert.AreEqual(originalBitmap.Format, roundtrippedBitmap.Format);
Assert.AreEqual(anyDpi, roundtrippedBitmap.Dpi);
var roundtrippedColors = roundtrippedBitmap.GetPixelColors();
Assert.AreEqual(colors.Length, roundtrippedColors.Length);
for (var i = 0; i < colors.Length; ++i)
{
Assert.AreEqual(colors[i], roundtrippedColors[i]);
}
}
/// <summary>
/// Dropws the shadow_ draw.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="args">The <see cref="Microsoft.Graphics.Canvas.UI.Xaml.CanvasDrawEventArgs" /> instance containing the event data.</param>
protected void DropShadow_Draw(CanvasControl sender, CanvasDrawEventArgs args)
{
Color[] colors = new Color[(int)(sender.Size.Width * sender.Size.Height)];
for (int x = 0; x < sender.ActualWidth; x++)
{
if (x < sender.ActualWidth)
{
colors[x] = Colors.{ ThemeResource SystemControlForegroundChromeHighBrush };
}
}
using (CanvasBitmap bitmap = CanvasBitmap.CreateFromColors(sender, colors, (int)sender.Size.Width, (int)sender.Size.Height))
{
using (ShadowEffect shadow = new ShadowEffect())
{
shadow.Source = bitmap;
shadow.BlurAmount = 3;
shadow.Optimization = EffectOptimization.Speed;
args.DrawingSession.DrawImage(shadow);
}
}
}
#endif
}
public void CanvasImage_ComputeHistogram()
{
Color[] colors =
{
Colors.Red, Colors.Lime,
Colors.Blue, Colors.White
};
var device = new CanvasDevice();
var bitmap = CanvasBitmap.CreateFromColors(device, colors, 2, 2);
// Histogram over the entire 2x2 bitmap (covering red, green, blue, and white pixels).
TestHistogram(bitmap, new Rect(0, 0, 2, 2), EffectChannelSelect.Red, 0.5f, 0.5f);
TestHistogram(bitmap, new Rect(0, 0, 2, 2), EffectChannelSelect.Green, 0.5f, 0.5f);
TestHistogram(bitmap, new Rect(0, 0, 2, 2), EffectChannelSelect.Blue, 0.5f, 0.5f);
// Histogram of just the top left 1x1 (single red pixel).
TestHistogram(bitmap, new Rect(0, 0, 1, 1), EffectChannelSelect.Red, 0, 1);
TestHistogram(bitmap, new Rect(0, 0, 1, 1), EffectChannelSelect.Green, 1, 0);
TestHistogram(bitmap, new Rect(0, 0, 1, 1), EffectChannelSelect.Blue, 1, 0);
// Histogram of the top right 1x1 (single green pixel).
TestHistogram(bitmap, new Rect(1, 0, 1, 1), EffectChannelSelect.Red, 1, 0);
TestHistogram(bitmap, new Rect(1, 0, 1, 1), EffectChannelSelect.Green, 0, 1);
TestHistogram(bitmap, new Rect(1, 0, 1, 1), EffectChannelSelect.Blue, 1, 0);
// Histogram of the bottom row (blue and white pixels).
TestHistogram(bitmap, new Rect(0, 1, 2, 1), EffectChannelSelect.Red, 0.5f, 0.5f);
TestHistogram(bitmap, new Rect(0, 1, 2, 1), EffectChannelSelect.Green, 0.5f, 0.5f);
TestHistogram(bitmap, new Rect(0, 1, 2, 1), EffectChannelSelect.Blue, 0, 1);
}
//创建灰白网格底图
public static ICanvasImage GrayWhite(ICanvasResourceCreator crc, int width, int height)
{
return(new CropEffect //裁切成画布大小
{
Source = new DpiCompensationEffect //根据DPI适配
{
Source = new ScaleEffect //缩放
{
Source = new BorderEffect //无限延伸图片
{
Source = CanvasBitmap.CreateFromColors(crc, new
Color[] //从数组创建2x2图片
{
Color.FromArgb(255, 233, 233, 233), Colors.White,
Colors.White, Color.FromArgb(255, 233, 233, 233),
}, 2, 2),
ExtendX = CanvasEdgeBehavior.Wrap,
ExtendY = CanvasEdgeBehavior.Wrap
},
Scale = new Vector2(8, 8),
InterpolationMode = CanvasImageInterpolation.NearestNeighbor
}
},
SourceRectangle = new Rect(0, 0, App.Model.Width, App.Model.Height),
});
}
private void FillCanvas(CanvasRenderTarget canvas, object drawLock, Vector2 position)
{
// This seems pretty hacky... maybe dpi should be handled in the layer above the tools
position *= (GraphicsInformation.Dpi / 96.0f);
lock (drawLock)
{
var canvasSize = canvas.SizeInPixels.ToVector2();
var colors = canvas.GetPixelColors();
var rect = new Rect(0, 0, canvas.SizeInPixels.Width, canvas.SizeInPixels.Height);
if ((position.X >= rect.Left && position.X <= rect.Right) ||
(position.Y >= rect.Top && position.Y <= rect.Bottom))
{
var targetColor = colors[(int)(position.X + position.Y * canvasSize.X)];
if (targetColor != _color)
{
FloodPixel((int)position.X, (int)position.Y, colors, targetColor, canvasSize, rect);
using (var bitmap = CanvasBitmap.CreateFromColors(_device, colors, (int)canvas.SizeInPixels.Width, (int)canvas.SizeInPixels.Height, GraphicsInformation.Dpi))
using (var drawingSession = canvas.CreateDrawingSession())
using (var layer = drawingSession.CreateLayer(1.0f, rect))
{
drawingSession.DrawImage(bitmap);
}
}
}
}
}
private ICanvasImage CreateChromaKey()
{
textLabel = requiresWin10;
var chromaKeyEffect = new ChromaKeyEffect
{
Source = bitmapTiger,
Color = Color.FromArgb(255, 162, 125, 73),
Feather = true
};
// Composite the chromakeyed image on top of a background checker pattern.
Color[] twoByTwoChecker =
{
Colors.LightGray, Colors.DarkGray,
Colors.DarkGray, Colors.LightGray,
};
var compositeEffect = new CompositeEffect
{
Sources =
{
// Create the checkered background by scaling up a tiled 2x2 bitmap.
new CropEffect
{
Source = new DpiCompensationEffect
{
Source = new ScaleEffect
{
Source = new BorderEffect
{
Source = CanvasBitmap.CreateFromColors(canvas, twoByTwoChecker, 2, 2),
ExtendX = CanvasEdgeBehavior.Wrap,
ExtendY = CanvasEdgeBehavior.Wrap
},
Scale = new Vector2(8, 8),
InterpolationMode = CanvasImageInterpolation.NearestNeighbor
}
},
SourceRectangle = bitmapTiger.Bounds
},
// Composite the chromakey result on top of the background.
chromaKeyEffect
}
};
// Animation changes the chromakey matching tolerance.
animationFunction = elapsedTime =>
{
chromaKeyEffect.Tolerance = 0.1f + (float)Math.Sin(elapsedTime) * 0.1f;
};
return(compositeEffect);
}
private CanvasBitmap CreateEmptyBitmap(int width, int height, CanvasControl canvasControl = null)
{
canvasControl = canvasControl ?? this.canvas;
var colors = new Color[width * height];
for (int i = 0; i < colors.Length; i++)
{
colors[i] = canvasControl.ClearColor;
}
var bitmap = CanvasBitmap.CreateFromColors(canvasControl, colors, width, height);
return(bitmap);
}
private void canvasControl_CreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args)
{
modeInstance = null;
args.TrackAsyncAction(canvasControl_CreateResourcesAsync(sender).AsAsyncAction());
var checks = CanvasBitmap.CreateFromColors(sender, new Color[] { Colors.Gray, Colors.Black, Colors.Black, Colors.Gray }, 2, 2);
checkedFillPattern = new CanvasImageBrush(sender, checks)
{
ExtendX = CanvasEdgeBehavior.Wrap,
ExtendY = CanvasEdgeBehavior.Wrap,
Transform = Matrix3x2.CreateScale(16),
Interpolation = CanvasImageInterpolation.NearestNeighbor
};
}
public void SetPixelColorsReadHazards()
{
var device = new CanvasDevice();
var bitmap = CanvasBitmap.CreateFromColors(device, new Color[1], 1, 1);
var renderTarget = new CanvasRenderTarget(device, 2, 1, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
bitmap.SetPixelColors(new Color[] { Colors.Blue });
ds.DrawImage(bitmap, 0, 0);
bitmap.SetPixelColors(new Color[] { Colors.Red });
ds.DrawImage(bitmap, 1, 0);
}
CollectionAssert.AreEqual(new Color[] { Colors.Blue, Colors.Red }, renderTarget.GetPixelColors());
}
public Task LoadTextures(CanvasAnimatedControl Canvas, TextureLoader Textures)
{
// ParaBg
ResCreator = Canvas;
Color MaskColor = LayoutSettings.MajorBackgroundColor;
MaskColor.A = ( byte )Math.Floor(255 * 0.8);
MaskBrush = new CanvasSolidColorBrush(ResCreator, MaskColor);
ReloadBackground();
// RippleEx
CoverBmp = CanvasBitmap.CreateFromColors(Canvas, new Color[] { Colors.Transparent }, 1, 1);
RingBrush = new CanvasSolidColorBrush(Canvas, LayoutSettings.Shades90);
TextBrush = new CanvasSolidColorBrush(ResCreator, Colors.White);
CoverBrush = new CanvasSolidColorBrush(Canvas, Colors.Transparent);
UpdateText(Canvas);
return(ReloadCover());
}
async private void OnLoadBitmapAsyncClicked(object sender, RoutedEventArgs e)
{
string fileNameTiger = "imageTiger.jpg";
m_bitmap_tiger = await CanvasBitmap.LoadAsync(m_canvasControl, fileNameTiger);
m_bitmap_colorGrids = new CanvasBitmap[3];
Uri uri = new Uri("ms-appx:///HighDpiGrid.png");
m_bitmap_colorGrids[0] = await CanvasBitmap.LoadAsync(m_canvasControl, uri);
byte[] imageBytes = new byte[]
{
0xFF, 0x0, 0x0, 0xFF, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
};
m_bitmap_colorGrids[1] = CanvasBitmap.CreateFromBytes( // Doesn't necessarily need to be async, but grouped here for organization.
m_canvasControl,
imageBytes,
4,
2,
Microsoft.Graphics.Canvas.DirectX.DirectXPixelFormat.B8G8R8A8UIntNormalized,
CanvasAlphaMode.Premultiplied);
Color[] imageColors = new Color[]
{
Colors.Blue, Colors.Black, Colors.Black, Colors.Red,
Colors.White, Colors.White, Colors.White, Colors.White
};
m_bitmap_colorGrids[2] = CanvasBitmap.CreateFromColors(
m_canvasControl,
imageColors,
4,
2,
CanvasAlphaMode.Premultiplied);
m_canvasControl.Invalidate();
}
public void ProcessFrame(ProcessVideoFrameContext context)
{
var inputDirect3DSurface = context.InputFrame.Direct3DSurface;
float anyDpi = 96.0f;
var width = context.OutputFrame.Direct3DSurface.Description.Width;
var height = context.OutputFrame.Direct3DSurface.Description.Height;
// Part 1: Apply effect using Imaging SDK
CanvasRenderTarget renderTarget = new CanvasRenderTarget(canvasDevice, (float)width, (float)height, anyDpi);
if (inputDirect3DSurface != null && renderTarget != null)
{
if (m_direct3DSurfaceImageSource == null)
{
m_direct3DSurfaceImageSource = new Direct3DSurfaceImageSource();
}
m_direct3DSurfaceImageSource.Direct3DSurface = inputDirect3DSurface;
((IImageConsumer)m_grayScaleEffect).Source = m_direct3DSurfaceImageSource;
if (m_direct3DSurfaceRenderer == null)
{
m_direct3DSurfaceRenderer = new Direct3DSurfaceRenderer();
}
m_direct3DSurfaceRenderer.Direct3DSurface = renderTarget;
m_direct3DSurfaceRenderer.Source = m_grayScaleEffect;
var task = m_direct3DSurfaceRenderer.RenderAsync().AsTask();
task.Wait();
m_direct3DSurfaceRenderer.Direct3DSurface = null;
m_direct3DSurfaceImageSource.Direct3DSurface = null;
}
// Part 2: Apply another effect using Win2D
var size = context.OutputFrame.Direct3DSurface.Description.Width * context.OutputFrame.Direct3DSurface.Description.Height;
var colors = Enumerable.Repeat(Colors.Black, size).ToArray();
var inputBitmap = CanvasBitmap.CreateFromColors(canvasDevice, colors, width, height, anyDpi);
inputBitmap.CopyPixelsFromBitmap(renderTarget);
using (CanvasRenderTarget output = CanvasRenderTarget.CreateFromDirect3D11Surface(canvasDevice, context.OutputFrame.Direct3DSurface))
using (CanvasDrawingSession ds = output.CreateDrawingSession())
{
TimeSpan time = context.InputFrame.RelativeTime.HasValue ? context.InputFrame.RelativeTime.Value : new TimeSpan();
float dispX = (float)Math.Cos(time.TotalSeconds) * 75f;
float dispY = (float)Math.Sin(time.TotalSeconds) * 75f;
ds.Clear(Colors.Black);
var dispMap = new DisplacementMapEffect()
{
Source = inputBitmap,
XChannelSelect = EffectChannelSelect.Red,
YChannelSelect = EffectChannelSelect.Green,
Amount = 100f,
Displacement = new Transform2DEffect()
{
TransformMatrix = Matrix3x2.CreateTranslation(dispX, dispY),
Source = new BorderEffect()
{
ExtendX = CanvasEdgeBehavior.Mirror,
ExtendY = CanvasEdgeBehavior.Mirror,
Source = new TurbulenceEffect()
{
Octaves = 3
}
}
}
};
ds.DrawImage(dispMap, -25f, -25f);
}
((IDisposable)renderTarget).Dispose();
((IDisposable)inputBitmap).Dispose();
}
private void UpdateSpectrogramBitmaps()
{
var spectraCount = _spectrogram.Count;
var spectrumSize = _spectrogram.First().Length;
// ============ create 2D spectrogram bitmap ============
var colors2D = new Color[spectraCount * spectrumSize];
for (var i = 0; i < spectraCount; i++)
{
// ...flip rows bottom-to-top...
var pos = (spectrumSize - 1) * spectraCount + i;
for (var j = 0; j < spectrumSize; j++)
{
colors2D[pos] = _cmap[_spectrogram[i][j]].ToUwpColor();
// ...flip rows bottom-to-top...
pos -= spectraCount;
}
}
_spectrogram2D = CanvasBitmap.CreateFromColors(SpectrumView,
colors2D,
spectraCount,
spectrumSize);
// ============ create 3D spectrogram bitmap ============
const int width3D = 700;
const int height3D = 700;
const int size3D = width3D * height3D;
var colors3D = Enumerable.Range(0, size3D)
.Select(i => _cmap.Colors().First().ToUwpColor())
.ToArray();
for (var x = 0; x < spectraCount; x++)
{
for (var y = 0; y < spectrumSize; y++)
{
var z = _spectrogram[x][y];
while (z > 0)
{
var coords = RotateY(x, y, z, AngleY);
coords = RotateX(coords[0], coords[1], coords[2], AngleX);
coords = RotateZ(coords[0], coords[1], coords[2], AngleZ);
if (coords[0] + CenterY < height3D && coords[1] + CenterX < width3D)
{
var pos = ((int)coords[0] + CenterY) * width3D +
(int)coords[1] + CenterX;
colors3D[pos] = _cmap[z].ToUwpColor();
}
z -= Stride;
}
}
}
_spectrogram3D = CanvasBitmap.CreateFromColors(SpectrumView3D,
colors3D,
height3D,
width3D);
// redraw panels:
SpectrumView.Invalidate();
SpectrumView3D.Invalidate();
}
