private async void Button_Click(object sender, RoutedEventArgs e)
{
using (var stream = await Root.RenderToRandomAccessStream())
{
var device = new CanvasDevice();
var bitmap = await CanvasBitmap.LoadAsync(device, stream);
var renderer = new CanvasRenderTarget(device, bitmap.SizeInPixels.Width, bitmap.SizeInPixels.Height, bitmap.Dpi);
using (var ds = renderer.CreateDrawingSession())
{
var blur = new GaussianBlurEffect();
blur.BlurAmount = 5.0f;
blur.Source = bitmap;
ds.DrawImage(blur);
}
stream.Seek(0);
await renderer.SaveAsync(stream, CanvasBitmapFileFormat.Png);
BitmapImage image = new BitmapImage();
image.SetSource(stream);
Blured.Source = image;
}
}
public byte[] DrawStrokeOnImageBackground(IReadOnlyList<InkStroke> strokes, byte[] backgroundImageBuffer)
{
var stmbuffer = new InMemoryRandomAccessStream();
stmbuffer.AsStreamForWrite().AsOutputStream().WriteAsync(backgroundImageBuffer.AsBuffer()).AsTask().Wait();
CanvasDevice device = CanvasDevice.GetSharedDevice();
var canbit = CanvasBitmap.LoadAsync(device, stmbuffer, 96).AsTask().Result;
CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, canbit.SizeInPixels.Width, canbit.SizeInPixels.Height, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(Colors.Transparent);
if (backgroundImageBuffer != null)
{
ds.DrawImage(canbit);
}
ds.DrawInk(strokes);
}
var stm = new InMemoryRandomAccessStream();
renderTarget.SaveAsync(stm, CanvasBitmapFileFormat.Png).AsTask().Wait();
var readfrom = stm.GetInputStreamAt(0).AsStreamForRead();
var ms = new MemoryStream();
readfrom.CopyTo(ms);
var outputBuffer = ms.ToArray();
return outputBuffer;
}
public async static Task<Uri> ToQrDataUri(this ISdp sdp, int width, int height)
{
var qrCodeWriter = new QRCodeWriter();
var bitMatrix = qrCodeWriter.encode(sdp.ToString(), ZXing.BarcodeFormat.QR_CODE, width, height);
using (var canvasRenderTarget = new CanvasRenderTarget(CanvasDevice.GetSharedDevice(), 500, 500, 96))
{
using (var drawingSession = canvasRenderTarget.CreateDrawingSession())
{
for (var y = 0; y < height; y++)
{
for (var x = 0; x < width; x++)
{
drawingSession.DrawRectangle(x, y, 1, 1, bitMatrix.get(x, y) ? Color.FromArgb(0, 0, 0, 0) : Color.FromArgb(255, 255, 255, 255));
}
}
}
using (var inMemoryRandomAccessStream = new InMemoryRandomAccessStream())
{
await canvasRenderTarget.SaveAsync(inMemoryRandomAccessStream, CanvasBitmapFileFormat.Png);
inMemoryRandomAccessStream.Seek(0);
var buffer = new byte[inMemoryRandomAccessStream.Size];
await inMemoryRandomAccessStream.ReadAsync(buffer.AsBuffer(), (uint)inMemoryRandomAccessStream.Size, InputStreamOptions.None);
return new Uri($"data:image/png;base64,{Convert.ToBase64String(buffer)}");
}
}
}
public void MultithreadedSaveToFile()
{
//
// This test can create a deadlock if the SaveAsync code holds on to the
// ID2D1Multithread resource lock longer than necessary.
//
// A previous implementation waited until destruction of the IAsyncAction before calling Leave().
// In managed code this can happen on an arbitrary thread and so could result in deadlock situations
// where other worker threads were waiting for a Leave on the original thread that never arrived.
//
using (new DisableDebugLayer()) // 6184116 causes the debug layer to fail when CanvasBitmap::SaveAsync is called
{
var task = Task.Run(async () =>
{
var device = new CanvasDevice();
var rt = new CanvasRenderTarget(device, 16, 16, 96);
var filename = Path.Combine(ApplicationData.Current.TemporaryFolder.Path, "testfile.jpg");
await rt.SaveAsync(filename);
rt.Dispose();
});
task.Wait();
}
}
/// <summary>
/// Applys a blur to a UI element
/// </summary>
/// <param name="sourceElement">UIElement to blur, generally an Image control, but can be anything</param>
/// <param name="blurAmount">Level of blur to apply</param>
/// <returns>Blurred UIElement as BitmapImage</returns>
public static async Task<BitmapImage> BlurElementAsync(this UIElement sourceElement, float blurAmount = 2.0f)
{
if (sourceElement == null)
return null;
var rtb = new RenderTargetBitmap();
await rtb.RenderAsync(sourceElement);
var buffer = await rtb.GetPixelsAsync();
var array = buffer.ToArray();
var displayInformation = DisplayInformation.GetForCurrentView();
using (var stream = new InMemoryRandomAccessStream())
{
var pngEncoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, stream);
pngEncoder.SetPixelData(BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Premultiplied,
(uint) rtb.PixelWidth,
(uint) rtb.PixelHeight,
displayInformation.RawDpiX,
displayInformation.RawDpiY,
array);
await pngEncoder.FlushAsync();
stream.Seek(0);
var canvasDevice = new CanvasDevice();
var bitmap = await CanvasBitmap.LoadAsync(canvasDevice, stream);
var renderer = new CanvasRenderTarget(canvasDevice,
bitmap.SizeInPixels.Width,
bitmap.SizeInPixels.Height,
bitmap.Dpi);
using (var ds = renderer.CreateDrawingSession())
{
var blur = new GaussianBlurEffect
{
BlurAmount = blurAmount,
Source = bitmap
};
ds.DrawImage(blur);
}
stream.Seek(0);
await renderer.SaveAsync(stream, CanvasBitmapFileFormat.Png);
var image = new BitmapImage();
await image.SetSourceAsync(stream);
return image;
}
}
public async Task <Size> DrawOutlineText(int dim, string font, string text, string saved_file)
{
Size size = new Size();
CanvasDevice device = CanvasDevice.GetSharedDevice();
using (CanvasRenderTarget offscreen = new CanvasRenderTarget(device, dim, dim, 96, Windows.Graphics.DirectX.DirectXPixelFormat.B8G8R8A8UIntNormalized,
CanvasAlphaMode.Premultiplied))
{
using (CanvasDrawingSession ds = offscreen.CreateDrawingSession())
{
ds.Clear(ColorHelper.FromArgb(255, 255, 255, 255));
Color text_color = Colors.White;
CanvasSolidColorBrush brush = new CanvasSolidColorBrush(device, text_color);
CanvasTextFormat format = new CanvasTextFormat();
format.FontFamily = font;
format.FontStyle = Windows.UI.Text.FontStyle.Normal;
format.FontSize = 60;
format.FontWeight = Windows.UI.Text.FontWeights.Bold;
float layoutWidth = dim;
float layoutHeight = dim;
CanvasTextLayout textLayout = new CanvasTextLayout(device, text, format, layoutWidth, layoutHeight);
CanvasGeometry geometry = CanvasGeometry.CreateText(textLayout);
CanvasStrokeStyle stroke = new CanvasStrokeStyle();
stroke.DashStyle = CanvasDashStyle.Solid;
stroke.DashCap = CanvasCapStyle.Round;
stroke.StartCap = CanvasCapStyle.Round;
stroke.EndCap = CanvasCapStyle.Round;
stroke.LineJoin = CanvasLineJoin.Round;
ds.DrawGeometry(geometry, 10.0f, 10.0f, Colors.Black, 10.0f, stroke);
ds.FillGeometry(geometry, 10.0f, 10.0f, brush);
}
Windows.Storage.StorageFolder storageFolder =
Windows.Storage.ApplicationData.Current.TemporaryFolder;
string saved_file2 = "\\";
saved_file2 += saved_file;
await offscreen.SaveAsync(storageFolder.Path + saved_file2);
imgOutlineText.Source = new BitmapImage(new Uri(storageFolder.Path + saved_file2));
using (CanvasDrawingSession ds = offscreen.CreateDrawingSession())
{
ds.Clear(Colors.White);
}
return(size);
}
}
public static async Task RenderScreenshotAsync(Win2DScene scene, ICanvasResourceCreator device, Stream stream, Vector3 background, float?dpi = null, float padding = 20)
{
Guard.NotNull(scene, nameof(scene));
Guard.NotNull(stream, nameof(stream));
Guard.NotNull(device, nameof(device));
Guard.GreaterThan(padding, 0, nameof(padding));
var sceneBounds = scene.RenderBounds;
var w = sceneBounds.Size.X + (2 * padding);
var h = sceneBounds.Size.Y + (2 * padding);
var dpiValue = dpi ?? DisplayInformation.GetForCurrentView().LogicalDpi;
var dpiFactor = dpiValue / DpiWithPixelMapping;
var wPixels = (int)(w * dpiFactor);
var hPixels = (int)(h * dpiFactor);
var maxPixels = Math.Min(MaxSize, device.Device.MaximumBitmapSizeInPixels - 100);
var wDiff = wPixels - maxPixels;
var hDiff = hPixels - maxPixels;
if (wDiff > 0 || hDiff > 0)
{
if (wDiff > hDiff)
{
dpiValue = (int)(dpiValue * ((float)maxPixels / wPixels));
}
else
{
dpiValue = (int)(dpiValue * ((float)maxPixels / hPixels));
}
}
using (var target = new CanvasRenderTarget(device, w, h, dpiValue))
{
using (var session = target.CreateDrawingSession())
{
session.Clear(background.ToColor());
session.Transform =
Matrix3x2.CreateTranslation(
-sceneBounds.Position.X + padding,
-sceneBounds.Position.Y + padding);
scene.Render(session, false, Rect2.Infinite);
}
await target.SaveAsync(stream.AsRandomAccessStream(), CanvasBitmapFileFormat.Png).AsTask();
}
}
private async Task GetImageStreamAsync(InMemoryRandomAccessStream stream)
{
var canvasRenderTarget = new CanvasRenderTarget(_canvasControl, (float)Window.Current.Bounds.Width,
(float)Window.Current.Bounds.Height, _dpi);
using (var ds = canvasRenderTarget.CreateDrawingSession())
{
ds.DrawImage(_effectCanvas);
}
await canvasRenderTarget.SaveAsync(stream, CanvasBitmapFileFormat.Jpeg, 0.5f);
}
async Task GenerateIcon(AppInfo appInfo, IconInfo iconInfo, StorageFolder folder)
{
// Draw the icon image into a command list.
var iconImage = new CanvasCommandList(device);
using (var ds = iconImage.CreateDrawingSession())
{
appInfo.DrawIconImage(ds, iconInfo);
}
// Rasterize into a rendertarget.
var renderTarget = new CanvasRenderTarget(device, iconInfo.Width, iconInfo.Height, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
// Initialize with the appropriate background color.
ds.Clear(iconInfo.TransparentBackground ? Colors.Transparent : appInfo.BackgroundColor);
// Work out where to position the icon image.
var imageBounds = iconImage.GetBounds(ds);
imageBounds.Height *= 1 + iconInfo.BottomPadding;
float scaleUpTheSmallerIcons = Math.Max(1, 1 + (60f - iconInfo.Width) / 50f);
float imageScale = appInfo.ImageScale * scaleUpTheSmallerIcons;
ds.Transform = Matrix3x2.CreateTranslation((float)-imageBounds.X, (float)-imageBounds.Y) *
Utils.GetDisplayTransform(renderTarget.Size.ToVector2(), new Vector2((float)imageBounds.Width, (float)imageBounds.Height)) *
Matrix3x2.CreateScale(imageScale, renderTarget.Size.ToVector2() / 2);
// Optional shadow effet.
if (appInfo.AddShadow)
{
var shadow = new ShadowEffect
{
Source = iconImage,
BlurAmount = 12,
};
ds.DrawImage(shadow);
}
// draw the main icon image.
ds.DrawImage(iconImage);
}
// Save to a file.
using (var stream = await folder.OpenStreamForWriteAsync(iconInfo.Filename, CreationCollisionOption.ReplaceExisting))
{
await renderTarget.SaveAsync(stream.AsRandomAccessStream(), CanvasBitmapFileFormat.Png);
}
}
public async Task <Size> DrawVacationText(int dim, string font, string text, string saved_file)
{
Size size = new Size();
CanvasDevice device = CanvasDevice.GetSharedDevice();
using (CanvasRenderTarget offscreen = CanvasHelper.GenImage(dim, dim, Colors.White))
{
CanvasTextFormat format = new CanvasTextFormat();
format.FontFamily = font;
format.FontStyle = Windows.UI.Text.FontStyle.Normal;
format.FontSize = 52;
format.FontWeight = Windows.UI.Text.FontWeights.Black;
float layoutWidth = dim;
float layoutHeight = dim;
CanvasTextLayout textLayout = new CanvasTextLayout(device, text, format, layoutWidth, layoutHeight);
Color light_purple = Color.FromArgb(255, 102, 159, 206);
Color dark_purple = Color.FromArgb(255, 35, 68, 95);
Point pt = new Point(10.0, 10.0);
using (var strategyOutline3 = CanvasHelper.TextGradOutline(light_purple, dark_purple, light_purple, 9, GradientType.Linear))
{
CanvasHelper.DrawTextImage(strategyOutline3, offscreen, pt, textLayout);
}
CanvasRenderTarget maskOutline2;
using (var strategyOutline2 = CanvasHelper.TextNoOutline(MaskColor.Blue))
{
maskOutline2 = CanvasHelper.GenMask(strategyOutline2, dim, dim, pt, textLayout);
}
Color light_yellow = Color.FromArgb(255, 255, 227, 85);
Color dark_yellow = Color.FromArgb(255, 243, 163, 73);
using (CanvasRenderTarget text_image = CanvasHelper.GenImage(dim, dim, dark_yellow))
{
using (var strategyText2 = CanvasHelper.TextGradOutlineLast(light_yellow, dark_yellow, light_yellow, 9, GradientType.Sinusoid))
{
CanvasHelper.DrawTextImage(strategyText2, text_image, pt, textLayout);
CanvasHelper.ApplyImageToMask(text_image, maskOutline2, offscreen, MaskColor.Blue, true);
}
}
Windows.Storage.StorageFolder storageFolder =
Windows.Storage.ApplicationData.Current.TemporaryFolder;
string saved_file2 = "\\";
saved_file2 += saved_file;
await offscreen.SaveAsync(storageFolder.Path + saved_file2);
imgOutlineText.Source = new BitmapImage(new Uri(storageFolder.Path + saved_file2));
return(size);
}
}
public void SaveImage(string path)
{
if ((_image != null) && !string.IsNullOrWhiteSpace(path))
{
var task = System.Threading.Tasks.Task.Run(async() => { await _image.SaveAsync(path); });
if (task != null)
{
System.Threading.Tasks.Task.WaitAll(task);
}
}
_image = null;
}
private async void Button_Click(object sender, Windows.UI.Xaml.RoutedEventArgs e)
{
CanvasDevice device = CanvasDevice.GetSharedDevice();
CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, (int)inkDataCanvas.ActualWidth, (int)inkDataCanvas.ActualHeight, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(Colors.Black);
ds.DrawInk(inkDataCanvas.InkPresenter.StrokeContainer.GetStrokes());
}
using (var ms = new InMemoryRandomAccessStream())
{
await renderTarget.SaveAsync(ms, CanvasBitmapFileFormat.Jpeg, 1);
await ms.FlushAsync();
var decoder = await BitmapDecoder.CreateAsync(ms);
var img = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore);
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, ms);
encoder.BitmapTransform.ScaledHeight = 227;
encoder.BitmapTransform.ScaledWidth = 227;
encoder.SetSoftwareBitmap(img);
await encoder.FlushAsync();
decoder = await BitmapDecoder.CreateAsync(ms);
img = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore);
img = SoftwareBitmap.Convert(img, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore);
var model = await CustomGestureModel.CreateFromStreamAsync(await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///CustomGesture.onnx")));
var output = await model.EvaluateAsync(new CustomGestureInput
{
data = ImageFeatureValue.CreateFromVideoFrame(VideoFrame.CreateWithSoftwareBitmap(img))
});
if (output != null)
{
var res = output.classLabel.GetAsVectorView().ToList();
var label = res.FirstOrDefault();
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
await new MessageDialog(label).ShowAsync();
});
}
}
}
public async Task <IRandomAccessStream> GenerateImageWithEffect(EffectType effectType)
{
using (var ds = _canvasRenderer.CreateDrawingSession())
{
ds.Clear(Colors.Black);
ds.DrawImageWithEffect(_canvasBitmap, _imgRect, new Rect(0, 0, _canvasBitmap.Size.Width, _canvasBitmap.Size.Height), effectType);
}
InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream();
await _canvasRenderer.SaveAsync(stream, CanvasBitmapFileFormat.Png);
return(stream);
}
public static async Task <Uri> CreateCachedImageAsync(string internetUri, string saveName)
{
// Check that there is an image to save
if (string.IsNullOrEmpty(internetUri))
{
return(null);
}
try
{
// Create a canvas device
using (var device = new CanvasDevice())
{
// Create items used to same image to file
var bitmap = await CanvasBitmap.LoadAsync(device, new Uri(internetUri));
// Create a renderer
var renderer = new CanvasRenderTarget(device, bitmap.SizeInPixels.Width, bitmap.SizeInPixels.Height,
bitmap.Dpi);
// Draw the image
using (var ds = renderer.CreateDrawingSession())
{
ds.DrawImage(bitmap);
}
// Open the cache folder
var cacheFolder =
await ApplicationData.Current.LocalFolder.CreateFolderAsync("cache",
CreationCollisionOption.OpenIfExists);
// Create a file
var imageFile = await cacheFolder.CreateFileAsync(string.Format("{0}.jpg", saveName),
CreationCollisionOption.OpenIfExists);
// Write the image to the file
using (var stream = await imageFile.OpenAsync(FileAccessMode.ReadWrite))
{
await renderer.SaveAsync(stream, CanvasBitmapFileFormat.Png);
return(new Uri(string.Format("ms-appdata:///local/cache/{0}.jpg", saveName), UriKind.Absolute));
}
}
}
catch (Exception ex)
{
App.Telemetry.TrackException(ex, false);
return(null);
}
}
private async Task <Grid> CreateControlBorder2(DanmakuModel model)
{
float size = (float)model.size * (float)sizeZoom;
CanvasDevice device = CanvasDevice.GetSharedDevice();
CanvasTextFormat fmt = new CanvasTextFormat()
{
FontSize = size
};
if (bold)
{
fmt.FontWeight = FontWeights.Bold;
}
if (font != "")
{
fmt.FontFamily = font;
}
var myBitmap = new CanvasRenderTarget(device, model.text.Length * size, 34, 96);
CanvasTextLayout canvasTextLayout = new CanvasTextLayout(device, model.text, fmt, model.text.Length * size, 0);
CanvasGeometry combinedGeometry = CanvasGeometry.CreateText(canvasTextLayout);
using (var ds = myBitmap.CreateDrawingSession())
{
ds.FillGeometry(combinedGeometry, model.color);
ds.DrawGeometry(combinedGeometry, SetBorder(model.color), 1.0f);
}
Image image = new Image();
BitmapImage im = new BitmapImage();
using (InMemoryRandomAccessStream oStream = new InMemoryRandomAccessStream())
{
// Save the Win2D canvas renderer a stream.
await myBitmap.SaveAsync(oStream, CanvasBitmapFileFormat.Png, 1.0f);
// Stream our Win2D pixels into the Bitmap
await im.SetSourceAsync(oStream);
}
image.Source = im;
image.Stretch = Stretch.None;
Grid grid = new Grid();
grid.Tag = model;
grid.Children.Add(image);
return(grid);
}
public async Task SaveCanvasBitmap(StorageFile outfile,CanvasBitmapFileFormat canvasBitmapFileFormat)
{
IRandomAccessStream randomAccessStream = await outfile.OpenAsync(FileAccessMode.ReadWrite);
if (canvasRenderTarget != null)
{
try
{
await canvasRenderTarget.SaveAsync(randomAccessStream, canvasBitmapFileFormat);
await randomAccessStream.FlushAsync();
randomAccessStream.Dispose();
}
catch (Exception e)
{
if (parent != null)
parent.StartWritingOutput("Error Saving File : " + e.Message,1);
ContentDialog contentDialogA = new ContentDialog();
contentDialogA.Title = "File Saved";
contentDialogA.Content = "Error Saving File : " + e.Message;
contentDialogA.CloseButtonText = "OK";
await contentDialogA.ShowAsync();
return;
}
if (parent != null)
parent.StartWritingOutput("File Saved to " + outfile.Path,1);
ContentDialog contentDialog = new ContentDialog();
contentDialog.Title = "File Saved";
contentDialog.Content = "The photo has been saved successfully.";
contentDialog.CloseButtonText = "OK";
await contentDialog.ShowAsync();
//canvasRenderTarget.Dispose();
//canvasRenderTarget = null;
//CreatePreviewBitmap();
}
}
public async Task SaveInStreamAsync(IRandomAccessStream randomAccessStream)
{
var device = CanvasDevice.GetSharedDevice();
using (var renderTarget = new CanvasRenderTarget(device, (float)CanvasSize.Width, (float)CanvasSize.Height, 97))
{
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(BackgroundColor);
Layers.ToList().ForEach(lm => lm.Canvas_Draw(lm.Canvas, new CanvasDrawEventArgs(ds)));
ds.Flush();
await renderTarget.SaveAsync(randomAccessStream, CanvasBitmapFileFormat.Png);
}
}
}
private async Task Save_InkedImagetoFile(StorageFile saveFile)
{
try
{
sharefile = await ApplicationData.Current.LocalFolder.CreateFileAsync("imgshare.png", CreationCollisionOption.ReplaceExisting);
CachedFileManager.DeferUpdates(sharefile);
using (var outStream = await sharefile.OpenAsync(FileAccessMode.ReadWrite))
{
var file = await ApplicationData.Current.LocalFolder.GetFileAsync("inkSample");
CanvasDevice device = CanvasDevice.GetSharedDevice();
var image = await CanvasBitmap.LoadAsync(device, file.Path);
using (var renderTarget = new CanvasRenderTarget(device, (int)inkCanvas.ActualWidth, (int)inkCanvas.ActualHeight, image.Dpi))
{
using (CanvasDrawingSession ds = renderTarget.CreateDrawingSession())
{
ds.Clear(Colors.White);
ds.DrawImage(image, new Rect(0, 0, (int)inkCanvas.ActualWidth, (int)inkCanvas.ActualHeight));
ds.DrawInk(inkCanvas.InkPresenter.StrokeContainer.GetStrokes());
}
await renderTarget.SaveAsync(outStream, CanvasBitmapFileFormat.Png);
}
image.Dispose();
Windows.Storage.Provider.FileUpdateStatus status = await CachedFileManager.CompleteUpdatesAsync(sharefile);
if (status == Windows.Storage.Provider.FileUpdateStatus.Complete)
{
if (saveFile != null)
{
await sharefile.CopyAndReplaceAsync(saveFile);
MainPage.ncSettings.objValue = "Photo has been saved successfully!";
MainPage.ncSettings.setSettings = "msgNotify";
inkCanvas.InkPresenter.StrokeContainer.Clear();
await Task.Delay(new TimeSpan(0, 0, 1));
this.Visibility = Visibility.Collapsed;
}
}
}
}
catch (Exception)
{
UtilityClass.MessageDialog("An error occured while saving photo, Please try again", "An error occured");
}
}
public async static Task BlurXaml(FrameworkElement rootElement, float blurAmount, IRandomAccessStream outStream)
{
try
{
RenderTargetBitmap rtb = new RenderTargetBitmap();
await rtb.RenderAsync(rootElement);
IBuffer buffer = await rtb.GetPixelsAsync();
byte[] outputArray = buffer.ToArray();
var device = CanvasDevice.GetSharedDevice(false);
using (var stream = new InMemoryRandomAccessStream())
{
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, stream);
encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied, (uint)(rtb.PixelWidth), (uint)(rtb.PixelHeight), 96, 96, outputArray);
await encoder.FlushAsync();
using (var bitmap = await CanvasBitmap.LoadAsync(device, stream))
{
var renderWidth = (int)bitmap.Size.Width;
var renderHeight = (int)(bitmap.Size.Height);
using (var renderer = new CanvasRenderTarget(device, renderWidth, renderHeight, bitmap.Dpi))
{
using (var ds = renderer.CreateDrawingSession())
{
using (var blur = new GaussianBlurEffect())
{
blur.BlurAmount = blurAmount;
blur.BorderMode = EffectBorderMode.Hard;
blur.Optimization = EffectOptimization.Speed;
blur.Source = bitmap;
ds.DrawImage(blur);
}
}
await renderer.SaveAsync(outStream, CanvasBitmapFileFormat.Bmp);
}
}
}
}
catch
{
// Ignore
}
}
private InMemoryRandomAccessStream GetFormatedImage(CanvasBitmapFileFormat fmt)
{
CanvasDevice device = CanvasDevice.GetSharedDevice();
CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, (int)inkCanvas.ActualWidth, (int)inkCanvas.ActualHeight, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(BackgroundColor);
ds.DrawInk(inkCanvas.InkPresenter.StrokeContainer.GetStrokes());
}
InMemoryRandomAccessStream memoryStream;
memoryStream = new InMemoryRandomAccessStream();
renderTarget.SaveAsync(memoryStream, fmt, 1f).AsTask().Wait();
return(memoryStream);
}
private async Task <InMemoryRandomAccessStream> RenderImage()
{
CanvasDevice device = CanvasDevice.GetSharedDevice();
CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, (int)Inker.ActualWidth, (int)Inker.ActualHeight, 96);
var stream = new InMemoryRandomAccessStream();
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(Colors.White);
ds.DrawInk(Inker.InkPresenter.StrokeContainer.GetStrokes());
}
await renderTarget.SaveAsync(stream, CanvasBitmapFileFormat.Png, 1f);
return(stream);
}
public void MultithreadedSaveToStream()
{
// This is the stream version of the above test
var task = Task.Run(async () =>
{
var device = new CanvasDevice();
var rt = new CanvasRenderTarget(device, 16, 16, 96);
var stream = new MemoryStream();
await rt.SaveAsync(stream.AsRandomAccessStream(), CanvasBitmapFileFormat.Bmp);
rt.Dispose();
});
task.Wait();
}
public void MultithreadedSaveToStream()
{
// This is the stream version of the above test
var task = Task.Run(async() =>
{
var device = new CanvasDevice();
var rt = new CanvasRenderTarget(device, 16, 16, 96);
var stream = new MemoryStream();
await rt.SaveAsync(stream.AsRandomAccessStream(), CanvasBitmapFileFormat.Bmp);
rt.Dispose();
});
task.Wait();
}
private async void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
CanvasDevice device = CanvasDevice.GetSharedDevice();
CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, (int)inkDataCanvas.ActualWidth, (int)inkDataCanvas.ActualHeight, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(Colors.Black);
ds.DrawInk(inkDataCanvas.InkPresenter.StrokeContainer.GetStrokes());
}
using (var ms = new InMemoryRandomAccessStream())
{
await renderTarget.SaveAsync(ms, CanvasBitmapFileFormat.Jpeg, 1);
await ms.FlushAsync();
var decoder = await BitmapDecoder.CreateAsync(ms);
var img = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore);
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, ms);
encoder.BitmapTransform.ScaledHeight = (uint)ViewModelLocator.Instance.Main.ImageSize;
encoder.BitmapTransform.ScaledWidth = (uint)ViewModelLocator.Instance.Main.ImageSize;
encoder.SetSoftwareBitmap(img);
await encoder.FlushAsync();
decoder = await BitmapDecoder.CreateAsync(ms);
img = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore);
img = SoftwareBitmap.Convert(img, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore);
var sbs = new SoftwareBitmapSource();
await sbs.SetBitmapAsync(img);
inkImage.Source = sbs;
//var targetImage = new SoftwareBitmap(BitmapPixelFormat.Bgra8, img.PixelWidth, img.PixelHeight);
// img.CopyTo(targetImage);
ViewModelLocator.Instance.Main.CurrentInkImage = ms.CloneStream();
ms.Dispose();
}
}
public byte[] DrawStrokeOnSolidColorBackground(IReadOnlyList<InkStroke> strokes, int width, int height, Color color )
{
CanvasDevice device = CanvasDevice.GetSharedDevice();
CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, width, height, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(color);
ds.DrawInk(strokes);
}
var stm = new InMemoryRandomAccessStream();
renderTarget.SaveAsync(stm, CanvasBitmapFileFormat.Png).AsTask().Wait();
var readfrom = stm.GetInputStreamAt(0).AsStreamForRead();
var ms = new MemoryStream();
readfrom.CopyTo(ms);
var outputBuffer = ms.ToArray();
return outputBuffer;
}
private async void SaveButton_Click(object sender, RoutedEventArgs e)
{
// Here we have to create a CanvasRenderTarget and then draw
// our content there. Then we can save that as an image. This
// is why we abstracted the draw away from our CanvasControl's
// event handler.
// Get our storage file
var file = await GetTargetFileAsync();
// If the user cancels or does not wish to save the image, then
// our file object should be null. Don't continue if that's the
// case.
if (file == null)
{
return;
}
// Get the CanvasDevice (You can think of this like a Direct3D device)
var canvasDevice = CanvasDevice.GetSharedDevice();
// Create our render target
using (var renderTarget = new CanvasRenderTarget(canvasDevice, // Device
200, // Width
200, // Height
96)) // DPI (this doesn't matter
// as much sicne we aren't
// displaying this to the
// screen and are instead
// saving directly to an image)
{
// Draw to our render target
using (var drawingSession = renderTarget.CreateDrawingSession())
{
Draw(drawingSession);
}
// Save to an image
using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
await renderTarget.SaveAsync(stream, CanvasBitmapFileFormat.Png);
}
}
}
public async Task <Size> DrawOutlineTextWithLibrary(int dim, string font, string text, string saved_file)
{
Size size = new Size();
CanvasDevice device = CanvasDevice.GetSharedDevice();
using (CanvasRenderTarget offscreen = new CanvasRenderTarget(device, dim, dim, 96, Windows.Graphics.DirectX.DirectXPixelFormat.B8G8R8A8UIntNormalized,
CanvasAlphaMode.Premultiplied))
{
using (CanvasDrawingSession ds = offscreen.CreateDrawingSession())
{
ds.Clear(Colors.White);
}
Color text_color = Colors.White;
CanvasSolidColorBrush brush = new CanvasSolidColorBrush(device, text_color);
CanvasTextFormat format = new CanvasTextFormat();
format.FontFamily = font;
format.FontStyle = Windows.UI.Text.FontStyle.Normal;
format.FontSize = 60;
format.FontWeight = Windows.UI.Text.FontWeights.Bold;
float layoutWidth = dim;
float layoutHeight = dim;
CanvasTextLayout textLayout = new CanvasTextLayout(device, text, format, layoutWidth, layoutHeight);
ITextStrategy strat = CanvasHelper.TextOutline(Colors.Blue, Colors.Black, 10);
CanvasHelper.DrawTextImage(strat, offscreen, new Point(10.0, 10.0), textLayout);
Windows.Storage.StorageFolder storageFolder =
Windows.Storage.ApplicationData.Current.TemporaryFolder;
string saved_file2 = "\\";
saved_file2 += saved_file;
await offscreen.SaveAsync(storageFolder.Path + saved_file2);
imgOutlineText.Source = new BitmapImage(new Uri(storageFolder.Path + saved_file2));
using (CanvasDrawingSession ds = offscreen.CreateDrawingSession())
{
ds.Clear(Colors.White);
}
return(size);
}
}
public async Task WaterBerbouPelJicayweeno(string str)
{
var duvDbecdgiu = CanvasBitmap;
using (var canvasRenderTarget = new CanvasRenderTarget(duvDbecdgiu, duvDbecdgiu.Size))
{
using (var dc = canvasRenderTarget.CreateDrawingSession())
{
dc.DrawImage(duvDbecdgiu);
if (!string.IsNullOrEmpty(str))
{
using (var canvasTextFormat = new CanvasTextFormat()
{
FontSize = 15f,
WordWrapping = CanvasWordWrapping.NoWrap
})
using (var canvasTextLayout =
new CanvasTextLayout(canvasRenderTarget, str, canvasTextFormat, 0, 0))
{
var kjrjuxzaKrbgwk = canvasTextLayout.LayoutBounds;
if (kjrjuxzaKrbgwk.Width < duvDbecdgiu.Size.Width)
{
dc.DrawText(str,
new Vector2((float)(duvDbecdgiu.Size.Width / 2),
(float)duvDbecdgiu.Size.Height / 2),
Colors.Black);
}
}
}
}
var file = await KuaxShft();
using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
await canvasRenderTarget.SaveAsync(stream,
ImageEnumToCanvasBitmapFileFormat(SaveImage));
}
File = file;
}
}
static async Task <string> GenerateAndSaveTileImage(CanvasDevice device, float width, float height)
{
using (var renderTarget = new CanvasRenderTarget(device, width, height, 96))
{
using (var ds = renderTarget.CreateDrawingSession())
{
DrawTile(ds, width, height);
}
var filename = string.Format("tile-{0}x{1}-{2}.png",
(int)width,
(int)height,
Guid.NewGuid().ToString());
await renderTarget.SaveAsync(Path.Combine(ApplicationData.Current.LocalFolder.Path, filename));
return(filename);
}
}
private async void BtnSave_Click(object sender, RoutedEventArgs e)
{
StorageFolder storageFolder = KnownFolders.SavedPictures;
var file = await storageFolder.CreateFileAsync("sample.jpg", CreationCollisionOption.ReplaceExisting);
CanvasDevice device = CanvasDevice.GetSharedDevice();
CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, (int)MyInkCanvas.ActualWidth, (int)MyInkCanvas.ActualHeight, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(Colors.White);
ds.DrawInk(MyInkCanvas.InkPresenter.StrokeContainer.GetStrokes());
}
using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
await renderTarget.SaveAsync(fileStream, CanvasBitmapFileFormat.Jpeg, 1f);
}
}
private async void BtnSave_Click(object sender, RoutedEventArgs e)
{
StorageFolder storageFolder = KnownFolders.SavedPictures;
var file = await storageFolder.CreateFileAsync("sample.jpg", CreationCollisionOption.ReplaceExisting);
CanvasDevice device = CanvasDevice.GetSharedDevice();
CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, (int)MyInkCanvas.ActualWidth, (int)MyInkCanvas.ActualHeight, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(Colors.White);
ds.DrawInk(MyInkCanvas.InkPresenter.StrokeContainer.GetStrokes());
}
using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
await renderTarget.SaveAsync(fileStream, CanvasBitmapFileFormat.Jpeg, 1f);
}
}
private async Task <bool> Save_InkedImagetoStream(IRandomAccessStream stream)
{
bool hasXamlOverlay = xamloverlay.Children.Count > 0;
if (_data == null)
{
_data = Player.InkNoteData;
}
if (_data == null)
{
return(false);
}
using (var imageStream = await _data.GetImageStream())
{
CanvasDevice device = CanvasDevice.GetSharedDevice();
var image = await CanvasBitmap.LoadAsync(device, imageStream);
using (var renderTarget = new CanvasRenderTarget(device, (int)inkingCanvas.ActualWidth, (int)inkingCanvas.ActualHeight, 96))
{
using (CanvasDrawingSession ds = renderTarget.CreateDrawingSession())
{
ds.Clear(Colors.White);
ds.DrawImage(image, new Rect(0, 0, (int)inkingCanvas.ActualWidth, (int)inkingCanvas.ActualHeight));
if (hasXamlOverlay)
{
await DrawXamlOverlay(device, renderTarget, ds);
}
ds.Units = CanvasUnits.Pixels;
ds.DrawInk(inkingCanvas.InkPresenter.StrokeContainer.GetStrokes());
}
await renderTarget.SaveAsync(stream, CanvasBitmapFileFormat.Png);
}
}
return(true);
}
private async Task Save()
{
StorageFolder storageFolder = KnownFolders.PicturesLibrary;
var file = await storageFolder.CreateFileAsync(fileName,
CreationCollisionOption.ReplaceExisting);
CanvasDevice device = CanvasDevice.GetSharedDevice();
CanvasRenderTarget renderTarget = new CanvasRenderTarget(device,
(int)canvas.ActualWidth, (int)canvas.ActualHeight, 10);
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(Colors.White);
ds.DrawInk(canvas.InkPresenter.StrokeContainer.GetStrokes());
}
using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
await renderTarget.SaveAsync(fileStream, CanvasBitmapFileFormat.Bmp, 1f);
}
}
private static void RendererImage(Stream stream, SvgImageRendererSettings settings)
{
var svg = settings.Document;
var viewPort = svg.RootElement.ViewPort;
if (!viewPort.HasValue) throw new ArgumentException(nameof(settings));
var width = viewPort.Value.Width;
var height = viewPort.Value.Height;
var device = CanvasDevice.GetSharedDevice();
using (var offScreen = new CanvasRenderTarget(device, width, height, settings.Scaling * 96.0F))
{
using (var renderer = new Win2dRenderer(offScreen, svg))
using (var session = offScreen.CreateDrawingSession())
{
session.Clear(Colors.Transparent);
renderer.Render(width, height, session);
}
offScreen.SaveAsync(stream.AsRandomAccessStream(), (CanvasBitmapFileFormat)settings.Format, settings.Quality).AsTask().GetAwaiter().GetResult();
}
}
public void MultithreadedSaveToStream()
{
// This is the stream version of the above test
using (new DisableDebugLayer()) // 6184116 causes the debug layer to fail when CanvasBitmap::SaveAsync is called
{
var task = Task.Run(async() =>
{
var device = new CanvasDevice();
var rt = new CanvasRenderTarget(device, 16, 16, 96);
var stream = new MemoryStream();
await rt.SaveAsync(stream.AsRandomAccessStream(), CanvasBitmapFileFormat.Bmp);
rt.Dispose();
});
task.Wait();
}
}
public void MultithreadedSaveToStream()
{
// This is the stream version of the above test
using (new DisableDebugLayer()) // 6184116 causes the debug layer to fail when CanvasBitmap::SaveAsync is called
{
var task = Task.Run(async () =>
{
var device = new CanvasDevice();
var rt = new CanvasRenderTarget(device, 16, 16, 96);
var stream = new MemoryStream();
await rt.SaveAsync(stream.AsRandomAccessStream(), CanvasBitmapFileFormat.Bmp);
rt.Dispose();
});
task.Wait();
}
}
public async Task <WriteableBitmap> ToWriteableBitmap()
{
WriteableBitmap result = null;
if (IsValid)
{
if (Source is WriteableBitmap)
{
result = Source as WriteableBitmap;
}
else if (Source is BitmapSource)
{
var bmp = Source as BitmapImage;
result = await bmp.ToWriteableBitmap();
}
else if (Source is SvgImageSource)
{
var svg = Source as SvgImageSource;
if (Bytes is byte[])
{
CanvasDevice device = CanvasDevice.GetSharedDevice();
var svgDocument = new CanvasSvgDocument(device);
svgDocument = CanvasSvgDocument.LoadFromXml(device, Encoding.UTF8.GetString(Bytes));
using (var offscreen = new CanvasRenderTarget(device, (float)svg.RasterizePixelWidth, (float)svg.RasterizePixelHeight, 96))
{
var session = offscreen.CreateDrawingSession();
session.DrawSvg(svgDocument, new Size(Size, Size), 0, 0);
using (var imras = new InMemoryRandomAccessStream())
{
await offscreen.SaveAsync(imras, CanvasBitmapFileFormat.Png);
result = await imras.ToWriteableBitmap();
}
}
}
}
}
return(result);
}
private async void ExportImage()
{
CanvasDevice device = CanvasDevice.GetSharedDevice();
using (CanvasRenderTarget offscreen = new CanvasRenderTarget(device, item.ImageBitmap.PixelWidth, item.ImageBitmap.PixelHeight, 96))
{
using (IRandomAccessStream stream = new InMemoryRandomAccessStream())
{
await item.ImageBitmap.ToStream(stream, BitmapEncoder.BmpEncoderId);
using (CanvasBitmap image = await CanvasBitmap.LoadAsync(offscreen, stream))
{
ImageEffectsBrush.SetSource(image);
using (CanvasDrawingSession ds = offscreen.CreateDrawingSession())
{
ds.Clear(Windows.UI.Colors.Black);
var img = ImageEffectsBrush.Image;
ds.DrawImage(img);
}
}
//stream.Dispose();
}
using (IRandomAccessStream outstream = new InMemoryRandomAccessStream())
{
WriteableBitmap writeableBitmap = new WriteableBitmap(ImageSource.PixelWidth, ImageSource.PixelHeight);
await offscreen.SaveAsync(outstream, CanvasBitmapFileFormat.Bmp);
outstream.Seek(0);
writeableBitmap.SetSource(outstream);
_LocalPersistentObject.bitmapProcessingImage = writeableBitmap;
ThumbnailImage.Source = _LocalPersistentObject.bitmapProcessingImage;
}
}
}
public byte[] DrawStrokeOnSolidColorBackground(IReadOnlyList <InkStroke> strokes, int width, int height, Color color)
{
CanvasDevice device = CanvasDevice.GetSharedDevice();
CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, width, height, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(color);
ds.DrawInk(strokes);
}
var stm = new InMemoryRandomAccessStream();
renderTarget.SaveAsync(stm, CanvasBitmapFileFormat.Png).AsTask().Wait();
var readfrom = stm.GetInputStreamAt(0).AsStreamForRead();
var ms = new MemoryStream();
readfrom.CopyTo(ms);
var outputBuffer = ms.ToArray();
return(outputBuffer);
}
/// Save coloring page as PNG to specified stream.
private async Task Save_InkedImagetoStream(IRandomAccessStream stream)
{
var file = await Windows.Storage.StorageFile.GetFileFromApplicationUriAsync(((BitmapImage)myImage.Source).UriSource);
CanvasDevice device = CanvasDevice.GetSharedDevice();
var image = await CanvasBitmap.LoadAsync(device, file.Path);
using (var renderTarget = new CanvasRenderTarget(device, (int)myInkCanvas.ActualWidth, (int)myInkCanvas.ActualHeight, image.Dpi))
{
using (CanvasDrawingSession ds = renderTarget.CreateDrawingSession())
{
ds.Clear(Colors.White);
ds.DrawImage(image, new Rect(0, 0, (int)myInkCanvas.ActualWidth, (int)myInkCanvas.ActualHeight));
ds.DrawInk(myInkCanvas.InkPresenter.StrokeContainer.GetStrokes());
}
await renderTarget.SaveAsync(stream, CanvasBitmapFileFormat.Png);
}
}
public static IRandomAccessStream GenerateFromString(string str, string fontFamily, Color color)
{
float size = 512;
using (var device = new CanvasDevice())
using (var renderTarget = new CanvasRenderTarget(device, size, size, 96))
{
using (var ds = renderTarget.CreateDrawingSession())
{
ds.DrawText(str, size / 2, size / 2, color,
new CanvasTextFormat()
{
FontFamily = fontFamily,
FontSize = size / 2,
HorizontalAlignment = CanvasHorizontalAlignment.Center,
VerticalAlignment = CanvasVerticalAlignment.Center
});
}
InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream();
renderTarget.SaveAsync(stream, CanvasBitmapFileFormat.Png).AsTask().Wait();
return stream;
}
}
async Task GenerateIcon(AppInfo appInfo, IconInfo iconInfo, StorageFolder folder)
{
// Draw the icon image into a command list.
var commandList = new CanvasCommandList(device);
using (var ds = commandList.CreateDrawingSession())
{
appInfo.DrawIconImage(ds, iconInfo);
}
ICanvasImage iconImage = commandList;
// Rasterize into a rendertarget.
var renderTarget = new CanvasRenderTarget(device, iconInfo.Width, iconInfo.Height, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
// Initialize with the appropriate background color.
ds.Clear(iconInfo.TransparentBackground ? Colors.Transparent : appInfo.BackgroundColor);
// Work out where to position the icon image.
var imageBounds = iconImage.GetBounds(ds);
imageBounds.Height *= 1 + iconInfo.BottomPadding;
float scaleUpTheSmallerIcons = Math.Max(1, 1 + (60f - iconInfo.Width) / 50f);
float imageScale = appInfo.ImageScale * scaleUpTheSmallerIcons;
var transform = Matrix3x2.CreateTranslation((float)-imageBounds.X, (float)-imageBounds.Y) *
Utils.GetDisplayTransform(renderTarget.Size.ToVector2(), new Vector2((float)imageBounds.Width, (float)imageBounds.Height)) *
Matrix3x2.CreateScale(imageScale, renderTarget.Size.ToVector2() / 2);
if (iconInfo.Monochrome)
{
// Optionally convert to monochrome.
iconImage = new DiscreteTransferEffect
{
Source = new Transform2DEffect
{
Source = new LuminanceToAlphaEffect { Source = iconImage },
TransformMatrix = transform
},
RedTable = new float[] { 1 },
GreenTable = new float[] { 1 },
BlueTable = new float[] { 1 },
AlphaTable = new float[] { 0, 1 }
};
}
else
{
ds.Transform = transform;
// Optional shadow effect.
if (appInfo.AddShadow)
{
var shadow = new ShadowEffect
{
Source = iconImage,
BlurAmount = 12,
};
ds.DrawImage(shadow);
}
}
// draw the main icon image.
ds.DrawImage(iconImage);
}
// Save to a file.
using (var stream = await folder.OpenStreamForWriteAsync(iconInfo.Filename, CreationCollisionOption.ReplaceExisting))
{
await renderTarget.SaveAsync(stream.AsRandomAccessStream(), CanvasBitmapFileFormat.Png);
}
}
/// <summary>
/// Save a rendered pdf page with inking to png file.
/// </summary>
/// <param name="pageNumber"></param>
/// <param name="saveFile"></param>
/// <returns></returns>
public async Task ExportPageImage(int pageNumber, InkCanvas inkCanvas, StorageFile saveFile)
{
CanvasDevice device = CanvasDevice.GetSharedDevice();
CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, (int)inkCanvas.ActualWidth, (int)inkCanvas.ActualHeight, 96 * 2);
// Render pdf page
InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream();
PdfPage page = PdfDoc.GetPage(Convert.ToUInt32(pageNumber - 1));
PdfPageRenderOptions options = new PdfPageRenderOptions();
options.DestinationWidth = (uint)inkCanvas.ActualWidth * 2;
await page.RenderToStreamAsync(stream, options);
CanvasBitmap bitmap = await CanvasBitmap.LoadAsync(device, stream, 96 * 2);
// Draw image with ink
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(Windows.UI.Colors.White);
ds.DrawImage(bitmap);
ds.DrawInk(inkCanvas.InkPresenter.StrokeContainer.GetStrokes());
}
// Encode the image to the selected file on disk
using (var fileStream = await saveFile.OpenAsync(FileAccessMode.ReadWrite))
await renderTarget.SaveAsync(fileStream, CanvasBitmapFileFormat.Png, 1f);
}
public async Task Save(StorageFile file)
{
var image = GetImage();
// Measure the extent of the image (which may be cropped).
Rect imageBounds;
using (var commandList = new CanvasCommandList(sourceBitmap.Device))
using (var drawingSession = commandList.CreateDrawingSession())
{
imageBounds = image.GetBounds(drawingSession);
}
// Rasterize the image into a rendertarget.
using (var renderTarget = new CanvasRenderTarget(sourceBitmap.Device, (float)imageBounds.Width, (float)imageBounds.Height, 96))
{
using (var drawingSession = renderTarget.CreateDrawingSession())
{
drawingSession.Blend = CanvasBlend.Copy;
drawingSession.DrawImage(image, -(float)imageBounds.X, -(float)imageBounds.Y);
}
// Save it out.
var format = file.FileType.Equals(".png", StringComparison.OrdinalIgnoreCase) ? CanvasBitmapFileFormat.Png : CanvasBitmapFileFormat.Jpeg;
using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
stream.Size = 0;
await renderTarget.SaveAsync(stream, format);
}
}
}
private async void SaveInkPicture()
{
if (ink.Width == 0)
{
return;
}
//ink.Width = WB_CapturedImage.PixelWidth;
//ink.Height = WB_CapturedImage.PixelHeight;
((App)App.Current).SyncStrokeEx(strokeMapping, ink.InkPresenter.StrokeContainer, ink.Width, true);
CanvasDevice device = CanvasDevice.GetSharedDevice();
//CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, WB_CapturedImage.PixelWidth, WB_CapturedImage.PixelHeight, 96);
CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, (float)ink.Width, (float)ink.Height, 96);
using (var ds = renderTarget.CreateDrawingSession())
{
ds.Clear(Color.FromArgb(0, 255, 255, 255));
ds.DrawInk(ink.InkPresenter.StrokeContainer.GetStrokes());
}
StorageFolder savedPics = KnownFolders.PicturesLibrary;
string fileName = DateTime.Now.ToString("yyyyMMddHHmmss") + ".png";
StorageFile file = await savedPics.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
await renderTarget.SaveAsync(fileStream, CanvasBitmapFileFormat.Png, 1f);
}
using (IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite))
{
//image.SetSource(fileStream);
WriteableBitmap InkImage = new WriteableBitmap(WB_CapturedImage.PixelWidth, WB_CapturedImage.PixelHeight);
await InkImage.SetSourceAsync(fileStream);
imageInk.Source = InkImage;
imageInk.Visibility = Visibility.Visible;
ink.InkPresenter.StrokeContainer.Clear();
ink.Visibility = Visibility.Collapsed;
}
RenderTargetBitmap rtb = new RenderTargetBitmap();
await rtb.RenderAsync(this.imagePanel);
// 提取像素数据
IBuffer buffer = await rtb.GetPixelsAsync();
// 获取文件流
IRandomAccessStream streamOut = await file.OpenAsync(FileAccessMode.ReadWrite);
// 实例化编码器
BitmapEncoder pngEncoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, streamOut);
//重写writeablebitmap
WB_CapturedImage = new WriteableBitmap((int)rtb.PixelWidth, (int)rtb.PixelHeight);
// 写入像素数据
byte[] data = buffer.ToArray();
pngEncoder.SetPixelData(BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Straight,
(uint)rtb.PixelWidth,
(uint)rtb.PixelHeight,
96d, 96d, data);
await pngEncoder.FlushAsync();
streamOut.Dispose();
ink.Visibility = Visibility.Visible;
imageInk.Visibility = Visibility.Collapsed;
using (IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite))
{
await WB_CapturedImage.SetSourceAsync(fileStream);
image.Source = WB_CapturedImage;
}
//var bmp = new RenderTargetBitmap();
//await bmp.RenderAsync(ink);
//StorageFolder savedPics = KnownFolders.PicturesLibrary;
//string fileName = DateTime.Now.ToString("yyyyMMddHHmmss") + ".png";
//StorageFile file = await savedPics.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
//// Saving to file.
//using (var stream = await file.OpenStreamForWriteAsync())
//{
// // Initialization.
// var pixelBuffer = await bmp.GetPixelsAsync();
// var logicalDpi = DisplayInformation.GetForCurrentView().LogicalDpi;
// // convert stream to IRandomAccessStream
// var randomAccessStream = stream.AsRandomAccessStream();
// // encoding to PNG
// var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, randomAccessStream);
// // Finish saving
// encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, (uint)bmp.PixelWidth,
// (uint)bmp.PixelHeight, logicalDpi, logicalDpi, pixelBuffer.ToArray());
// // Flush encoder.
// await encoder.FlushAsync();
// filePath = file.Path;
//}
}
private async void PlayBackImage_ImageOpened(IRandomAccessStream stream)
{
if (CurrentSong != null)
{
{
var device = new CanvasDevice();
var bitmap = await CanvasBitmap.LoadAsync(device, stream);
var renderer = new CanvasRenderTarget(device,
bitmap.SizeInPixels.Width,
bitmap.SizeInPixels.Height, bitmap.Dpi);
using (var ds = renderer.CreateDrawingSession())
{
var blur = new GaussianBlurEffect
{
Source = bitmap
};
blur.BlurAmount = 16.0f;
blur.BorderMode = EffectBorderMode.Hard;
ds.DrawImage(blur);
}
stream.Seek(0);
await renderer.SaveAsync(stream, CanvasBitmapFileFormat.Png);
stream.Seek(0);
BitmapImage image = new BitmapImage();
image.SetSource(stream);
BackgroundBlur.Source = image;
renderer = null;
bitmap = null;
device = null;
GC.Collect();
}
}
}
static async Task<string> GenerateAndSaveTileImage(CanvasDevice device, float width, float height)
{
using (var renderTarget = new CanvasRenderTarget(device, width, height, 96))
{
using (var ds = renderTarget.CreateDrawingSession())
{
DrawTile(ds, width, height);
}
var filename = string.Format("tile-{0}x{1}-{2}.png",
(int)width,
(int)height,
Guid.NewGuid().ToString());
await renderTarget.SaveAsync(Path.Combine(ApplicationData.Current.LocalFolder.Path, filename));
return filename;
}
}
