/// <summary> /// Save the file via a Uri. /// </summary> /// <param name="url"> Web or file path. </param> /// <param name="foldername"> Folder name in PicturesLibrary. </param> /// <returns> Saved successfully returns **true**. </returns> public static async Task<bool> Save(string url, string foldername) { try { string[] Splits = url.Split('/'); string name = Splits.Last(); CanvasBitmap bitmap = await Palette.GetBitmapFormImage(new Uri(url)); CanvasBitmapFileFormat format = Palette.GetFormat(name); StorageFolder folder = await KnownFolders.PicturesLibrary.CreateFolderAsync(foldername, CreationCollisionOption.OpenIfExists); StorageFile file = await folder.CreateFileAsync(name); using (IRandomAccessStream fileStream = await file.OpenAsync(FileAccessMode.ReadWrite)) { await bitmap.SaveAsync(fileStream, format); } return true; } catch (Exception) { return false; } }
/// <summary> /// Save the file via a Uri. /// </summary> /// <param name="url"> Web or file path. </param> /// <param name="folder"> Destination folder. </param> /// <returns> Saved successfully returns **true**. </returns> public static async Task <bool> Save(string url, StorageFolder folder) { try { string[] Splits = url.Split('/'); string name = Splits.Last(); CanvasBitmap bitmap = await Palette.GetBitmapFormImage(new Uri(url)); CanvasBitmapFileFormat format = Palette.GetFormat(name); StorageFile file = await folder.CreateFileAsync(name); using (IRandomAccessStream fileStream = await file.OpenAsync(FileAccessMode.ReadWrite)) { await bitmap.SaveAsync(fileStream, format); } return(true); } catch (Exception) { return(false); } }
public async Task SaveAsync(StorageFile file, bool measuresOnly) { if (file == null || measureBitmap == null) { return; } Debug.WriteLine(file.ContentType + " " + file.FileType); var fileType = file.ContentType?.Trim().ToLower(); CanvasBitmapFileFormat fileFormat = CanvasBitmapFileFormat.Png; switch (fileType) { case "image/jpeg": fileFormat = CanvasBitmapFileFormat.Jpeg; break; case "image/bmp": fileFormat = CanvasBitmapFileFormat.Bmp; break; case "image/gif": fileFormat = CanvasBitmapFileFormat.Gif; break; case "image/png": default: break; } var device = CanvasDevice.GetSharedDevice(); var size = measureBitmap.Size; var target = new CanvasRenderTarget(device, (float)size.Width, (float)size.Height, measureBitmap.Dpi, DirectXPixelFormat.B8G8R8A8UIntNormalized, CanvasAlphaMode.Premultiplied); using (var g = target.CreateDrawingSession()) { g.Clear(fileFormat == CanvasBitmapFileFormat.Png ? Colors.Transparent : Colors.White); if (!measuresOnly) { g.DrawImage(measureBitmap); g.Antialiasing = CanvasAntialiasing.Antialiased; g.TextAntialiasing = CanvasTextAntialiasing.Auto; } foreach (var item in measureObjects) { item.Draw(g, false); } } var stream = await file.OpenAsync(FileAccessMode.ReadWrite); await target.SaveAsync(stream, fileFormat); stream.Dispose(); target.Dispose(); }
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(); } }
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); }
protected override void saveImage(ui.Image image, java.io.OutputStream response, string format, float quality) { CanvasBitmapFileFormat fileFormat = CanvasBitmapFileFormat.Png; if (format.Equals(FORMAT_JPEG)) { fileFormat = CanvasBitmapFileFormat.Jpeg; } CodenameOneImage img = (CodenameOneImage)image.getImage(); CanvasBitmap cb = img.image; InMemoryRandomAccessStream ms = new InMemoryRandomAccessStream(); cb.SaveAsync(ms, fileFormat, quality).AsTask().ConfigureAwait(false).GetAwaiter().GetResult();; ms.Seek(0); byte[] buf = new byte[ms.Size]; DataReader dr = new DataReader(ms); dr.LoadAsync((uint)ms.Size).AsTask().ConfigureAwait(false).GetAwaiter().GetResult();; dr.ReadBytes(buf); response.write(buf); }
public override void save(java.io.InputStream image, java.io.OutputStream response, string format, int width, int height, float quality) { CanvasBitmapFileFormat fileFormat = CanvasBitmapFileFormat.Png; if (format.Equals(FORMAT_JPEG)) { fileFormat = CanvasBitmapFileFormat.Jpeg; } CodenameOneImage img = (CodenameOneImage)SilverlightImplementation.instance.createImage(image); CodenameOneImage scaledImage = (CodenameOneImage)SilverlightImplementation.instance.scale(img, width, height); InMemoryRandomAccessStream ms = new InMemoryRandomAccessStream(); scaledImage.image.SaveAsync(ms, fileFormat, quality).AsTask().ConfigureAwait(false).GetAwaiter().GetResult(); ms.Seek(0); byte[] buf = new byte[ms.Size]; DataReader dr = new DataReader(ms); dr.LoadAsync((uint)ms.Size).AsTask().ConfigureAwait(false).GetAwaiter().GetResult(); dr.ReadBytes(buf); response.write(buf); }
/*var picker = new Windows.Storage.Pickers.FileOpenPicker(); * picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail; * picker.SuggestedStartLocation = * Windows.Storage.Pickers.PickerLocationId.PicturesLibrary; * picker.FileTypeFilter.Add(".jpg"); * picker.FileTypeFilter.Add(".jpeg"); * picker.FileTypeFilter.Add(".png"); * * Windows.Storage.StorageFile file = await picker.PickSingleFileAsync(); * if (file != null) * { * // Application now has read/write access to the picked file * this.textBlock.Text = "Picked photo: " + file.Name; * } * else * { * this.textBlock.Text = "Operation cancelled."; * }*/ public async void exportMap(CanvasControl sender) { /*Bitmap myBitmap; * ImageCodecInfo myImageCodecInfo; * System.Drawing.Imaging.Encoder myEncoder; * EncoderParameter myEncoderParameter; * EncoderParameters myEncoderParameters;*/ int imageBorder = (int)(100 * GlobalNodeHandler.viewNode.scale); double sourceScale = GlobalNodeHandler.viewNode.scale; //double exportScale = 1.0d; FileSavePicker saveFileDialog1 = new FileSavePicker(); int height = GlobalNodeHandler.viewNode.GetMinMaxSpanY(); int width = GlobalNodeHandler.viewNode.GetMinMaxSpanX(); int minx = GlobalNodeHandler.viewNode.GetMinChildX().xpos; int miny = GlobalNodeHandler.viewNode.GetMinChildY().ypos; // Set filter options and filter index. saveFileDialog1.FileTypeChoices.Add("Image File| JPG", new List <string>() { ".jpeg" }); saveFileDialog1.FileTypeChoices.Add("Image File| JPEG", new List <string>() { ".jpg" }); saveFileDialog1.FileTypeChoices.Add("Image File| PNG", new List <string>() { ".png" }); saveFileDialog1.FileTypeChoices.Add("Image File| GIF", new List <string>() { ".gif" }); saveFileDialog1.FileTypeChoices.Add("Image File| BMP", new List <string>() { ".bmp" }); saveFileDialog1.FileTypeChoices.Add("Image File| Tiff", new List <string>() { ".tiff" }); //saveFileDialog1.FileTypeChoices.Add("PDF Document", new List<string>() { ".pdf" }); if (height > -1 && width > -1) { CanvasDevice device = CanvasDevice.GetSharedDevice(); //CanvasRenderTarget savemap = new CanvasRenderTarget(device, width, height, 96); CanvasRenderTarget savemap = new CanvasRenderTarget(device, width + 3 * imageBorder, height + 2 * imageBorder, 96); using (CanvasDrawingSession g2d = savemap.CreateDrawingSession()) { g2d.Clear(Colors.White); g2d.Antialiasing = CanvasAntialiasing.Antialiased; //GlobalNodeHandler.viewNode.SetNodeScale(exportScale); //GlobalNodeHandler.viewNode.UpdateViewRepresentation(); height = GlobalNodeHandler.viewNode.GetMinMaxSpanY(); width = GlobalNodeHandler.viewNode.GetMinMaxSpanX(); minx = GlobalNodeHandler.viewNode.GetMinChildX().xpos; miny = GlobalNodeHandler.viewNode.GetMinChildY().ypos; if (GlobalNodeHandler.viewNode.height != 0 && GlobalNodeHandler.viewNode.width != 0) { GlobalNodeHandler.viewNode.DrawRepresentationAt(g2d, 5, 5); } GlobalNodeHandler.viewNode.drawView(sender, g2d, -minx + imageBorder, -miny + imageBorder); } //GlobalNodeHandler.viewNode.SetNodeScale(sourceScale); //GlobalNodeHandler.viewNode.UpdateViewRepresentation(); Windows.Storage.StorageFile newfile = await saveFileDialog1.PickSaveFileAsync(); if (newfile != null) { CanvasBitmapFileFormat fileformat = CanvasBitmapFileFormat.Bmp; if (newfile.FileType.Equals(".jpeg") || newfile.FileType.Equals(".jpg")) { fileformat = CanvasBitmapFileFormat.JpegXR; } if (newfile.FileType.Equals(".png")) { fileformat = CanvasBitmapFileFormat.Png; } if (newfile.FileType.Equals(".bmp")) { fileformat = CanvasBitmapFileFormat.Bmp; } if (newfile.FileType.Equals(".gif")) { fileformat = CanvasBitmapFileFormat.Gif; } if (newfile.FileType.Equals(".tiff")) { fileformat = CanvasBitmapFileFormat.Tiff; } using (var output = await newfile.OpenAsync(FileAccessMode.ReadWrite)) { await savemap.SaveAsync(output, fileformat); await output.FlushAsync(); } } } /*myImageCodecInfo = GetEncoderInfo("image/jpeg"); * * if (ext.Equals("jpg")) * { * // Get an ImageCodecInfo object that represents the JPEG codec. * myImageCodecInfo = GetEncoderInfo("image/jpeg"); * * } * if (ext.Equals("bmp")) * { * // Get an ImageCodecInfo object that represents the JPEG codec. * myImageCodecInfo = GetEncoderInfo("image/bmp"); * * } * * // for the Quality parameter category. * myEncoder = System.Drawing.Imaging.Encoder.Quality; * * myEncoderParameters = new EncoderParameters(1); * * * // Save the bitmap as a JPEG file with quality level 75. * myEncoderParameter = new EncoderParameter(myEncoder, 100L); * myEncoderParameters.Param[0] = myEncoderParameter; * myBitmap.Save(saveFileDialog1.InitialDirectory + saveFileDialog1.FileName, myImageCodecInfo, myEncoderParameters); * * }*/ }
public async Task PickSaveFile() { if (simplePhotoEditor.canvasRenderTarget == null) { StartWritingOutput("No Effects Applied"); return; } FileSavePicker picker = new FileSavePicker(); picker.SuggestedStartLocation = PickerLocationId.PicturesLibrary; picker.SuggestedFileName = "SavedImage"; picker.DefaultFileExtension = ".png"; picker.FileTypeChoices.Add("Image Files (*.png, *.jpg, *.tiff, *.gif) ", new List <string> { ".png", ".jpg", ".tiff", ".gif" }); StorageFile outfile = await picker.PickSaveFileAsync(); if (outfile != null) { CanvasBitmapFileFormat canvasBitmapFileFormat = CanvasBitmapFileFormat.Png; string filepath = outfile.Path; filepath = filepath.ToLower(); int index = filepath.IndexOf(".jpg"); if (index > 0) { canvasBitmapFileFormat = CanvasBitmapFileFormat.Jpeg; } else { index = filepath.IndexOf(".png"); if (index > 0) { canvasBitmapFileFormat = CanvasBitmapFileFormat.Png; } else { index = filepath.IndexOf(".tif"); if (index > 0) { canvasBitmapFileFormat = CanvasBitmapFileFormat.Tiff; } else { index = filepath.IndexOf(".gif"); if (index > 0) { canvasBitmapFileFormat = CanvasBitmapFileFormat.Gif; } } } } ApplyFilterEffects(true); await simplePhotoEditor.SaveCanvasBitmap(outfile, canvasBitmapFileFormat); ApplyFilterEffects(false, null, false); canvas2d.Invalidate(); } }
public static async Task <AnimatedImage> DecodeAnimatedImage(StorageFile source, CanvasBitmapFileFormat format) { string[] props = new string[] { "/grctlext/Delay" }; List <ImageFrame> frames = new List <ImageFrame>(); BitmapDecoder decoder = await BitmapDecoder.CreateAsync( BitmapDecoder.GifDecoderId, await source.OpenAsync(FileAccessMode.Read)); CanvasDevice device = CanvasDevice.GetSharedDevice(); CanvasRenderTarget renderTarget = new CanvasRenderTarget( device, decoder.PixelWidth, decoder.PixelHeight, 96); CanvasBitmap buffer; var count = decoder.FrameCount; TimeSpan delay; TimeSpan startTime = new TimeSpan(); Rect rect = new Rect(0, 0, decoder.PixelWidth, decoder.PixelHeight); // Перебираем кадры. for (uint frameIdx = 0; frameIdx < decoder.FrameCount; frameIdx++) { var frame = await decoder.GetFrameAsync(frameIdx); // Получаем длительность кадра var propSet = await frame.BitmapProperties.GetPropertiesAsync(props); var prop = propSet.FirstOrDefault(); delay = TimeSpan.FromMilliseconds(10 * (UInt16)prop.Value.Value); if (delay.Ticks == 0) { delay = TimeSpan.FromMilliseconds(100); } var softwareBitmap = SoftwareBitmap.Convert( await frame.GetSoftwareBitmapAsync(), BitmapPixelFormat.Rgba16, BitmapAlphaMode.Premultiplied); // Создаем прадварительный буфер. buffer = CanvasBitmap.CreateFromSoftwareBitmap(device, softwareBitmap); using (var session = renderTarget.CreateDrawingSession()) { session.DrawImage(buffer, rect); } using (var stream = new InMemoryRandomAccessStream()) { await renderTarget.SaveAsync(stream, format); BitmapImage bitmap = new BitmapImage(); bitmap.SetSource(stream); ImageFrame decodedFrame = new ImageFrame() { Duration = delay, StartTime = startTime, ImageSource = SoftwareBitmap.Convert( await SoftwareBitmap.CreateCopyFromSurfaceAsync(renderTarget), BitmapPixelFormat.Rgba16, BitmapAlphaMode.Premultiplied) }; frames.Add(decodedFrame); startTime += delay; } } return(new AnimatedImage(frames, startTime) { Width = decoder.PixelWidth, Height = decoder.PixelHeight }); }
/// <summary> /// Saves the entire bitmap to the specified stream /// with the specified file format and quality level. /// </summary> /// <param name="renderTarget"> The render target.</param> /// <param name="fileChoices"> The file choices. </param> /// <param name="suggestedFileName"> The suggested name of file. </param> /// <param name="fileFormat"> The file format. </param> /// <param name="quality"> The file quality. </param> /// <returns> Saved successful? </returns> public static async Task <bool> SaveCanvasBitmapFile(CanvasRenderTarget renderTarget, string fileChoices = ".Jpeg", string suggestedFileName = "Untitled", CanvasBitmapFileFormat fileFormat = CanvasBitmapFileFormat.Jpeg, float quality = 1.0f) { //FileSavePicker FileSavePicker savePicker = new FileSavePicker { SuggestedStartLocation = PickerLocationId.Desktop, SuggestedFileName = suggestedFileName, }; savePicker.FileTypeChoices.Add("DB", new[] { fileChoices }); //PickSaveFileAsync StorageFile file = await savePicker.PickSaveFileAsync(); if (file == null) { return(false); } try { using (IRandomAccessStream accessStream = await file.OpenAsync(FileAccessMode.ReadWrite)) { await renderTarget.SaveAsync(accessStream, fileFormat, quality); } renderTarget.Dispose(); return(true); } catch (Exception) { renderTarget.Dispose(); return(false); } }