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 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; } }