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