/// <summary>
/// GetImage by Filter
/// </summary>
/// <param name="stream"></param>
/// <param name="filter"></param>
/// <returns></returns>
public async static Task <WriteableBitmap> GetImageByFilter(this IRandomAccessStream stream, IFilter filter)
{
stream.Seek(0);
var imageFormat = ImageFormat.Jpeg;
var imageType = await getImageType(stream);
if (imageType == ImageType.PNG)
{
imageFormat = ImageFormat.Png;
}
using (var source = new RandomAccessStreamImageSource(stream, imageFormat))
{
// Create effect collection with the source stream
using (var filters = new FilterEffect(source))
{
// Initialize the filter and add the filter to the FilterEffect collection
filters.Filters = new IFilter[] { filter };
// Create a target where the filtered image will be rendered to
var target = new WriteableBitmap((int)(Window.Current.Bounds.Width), (int)(Window.Current.Bounds.Height));
// Create a new renderer which outputs WriteableBitmaps
using (var renderer = new WriteableBitmapRenderer(filters, target))
{
// Render the image with the filter(s)
target = await renderer.RenderAsync();
target.Invalidate();
return(target);
}
}
}
}
public static async Task <ImageSource> BlurImageAsync([NotNull] IBuffer buffer, int blur)
{
using (Stream imageStream = buffer.AsStream())
using (IRandomAccessStream randomImageStream = imageStream.AsRandomAccessStream())
{
BitmapDecoder decoder;
try
{
decoder = await BitmapDecoder.CreateAsync(randomImageStream);
}
catch
{
// Invalid image data
return(null);
}
randomImageStream.Seek(0);
using (RandomAccessStreamImageSource imageProvider = new RandomAccessStreamImageSource(randomImageStream))
using (BlurEffect blurEffect = new BlurEffect(imageProvider)
{
KernelSize = blur
})
{
WriteableBitmap blurred = new WriteableBitmap((int)decoder.PixelWidth, (int)decoder.PixelHeight);
return(await blurEffect.GetBitmapAsync(blurred, OutputOption.Stretch));
}
}
}
private async void OnImageUrlChanged()
{
if (ImageUrl == null)
{
return;
}
var rass = RandomAccessStreamReference.CreateFromUri(new Uri(ImageUrl, UriKind.Absolute));
IRandomAccessStream stream = await rass.OpenReadAsync();
var decoder = await BitmapDecoder.CreateAsync(stream);
Rect bounds = Window.Current.Bounds;
//WriteableBitmap bmp = new WriteableBitmap((int)bounds.Width, (int)bounds.Height);
var displayWidth = Math.Min(decoder.PixelWidth, bounds.Width);
var displayHeight = Math.Min(decoder.PixelHeight, bounds.Height);
WriteableBitmap bmp = new WriteableBitmap((int)displayWidth, (int)displayHeight);
stream.Seek(0);
//var blurFilter = new BlurFilter(60);
using (var source = new RandomAccessStreamImageSource(stream))
using (var blurFilter = new LensBlurEffect(source, new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Circle, 20)))
//using (var filterEffect = new FilterEffect(source) { Filters = new[] { blurFilter } })
using (var renderer = new WriteableBitmapRenderer(blurFilter, bmp))
{
bmp = await renderer.RenderAsync();
bmp.Invalidate();
BackgroundImage.Source = bmp;
}
}
public static async Task <Tuple <ImageSource, ImageSource> > GetImageAndBlurredCopyFromPixelDataAsync([NotNull] IBuffer buffer, int blur)
{
// Check if the input is valid
if (buffer.Length == 0)
{
return(null);
}
// Apply the blur effect on a copy of the original image
using (Stream imageStream = buffer.AsStream())
using (IRandomAccessStream randomImageStream = imageStream.AsRandomAccessStream())
{
// Load the default image
BitmapImage original = new BitmapImage();
await original.SetSourceAsync(randomImageStream);
// Blur the copy of the image
randomImageStream.Seek(0);
using (RandomAccessStreamImageSource imageProvider = new RandomAccessStreamImageSource(randomImageStream))
using (BlurEffect blurEffect = new BlurEffect(imageProvider)
{
KernelSize = blur
})
{
// Process the blurred image
WriteableBitmap blurred = new WriteableBitmap((int)original.PixelWidth, (int)original.PixelHeight);
await blurEffect.GetBitmapAsync(blurred, OutputOption.Stretch);
// Return the two images
return(Tuple.Create <ImageSource, ImageSource>(original, blurred));
}
}
}
public async Task SaveToPicturesLibraryAsync(InMemoryRandomAccessStream stream)
{
try
{
var rotationAngle = ConvertDeviceOrientationToDegrees(GetCameraOrientation());
IsCaptureEnabled = false;
var file = await KnownFolders.PicturesLibrary.CreateFileAsync("LumiaImagingCapturedImage.jpg", CreationCollisionOption.GenerateUniqueName);
stream.Seek(0);
var imageSource = new RandomAccessStreamImageSource(stream);
using (var jpegRenderer = new JpegRenderer(imageSource))
using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
if (rotationAngle != 0)
{
jpegRenderer.Source = new RotationEffect(imageSource, rotationAngle - 180); //Andjust to Lumia.Imaging Rotation
}
// Jpeg renderer gives the raw buffer containing the filtered image.
IBuffer jpegBuffer = await jpegRenderer.RenderAsync();
await fileStream.WriteAsync(jpegBuffer);
await fileStream.FlushAsync();
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
IsCaptureEnabled = true;
}
private async void UpdateCustomEffectSource(RandomAccessStreamImageSource imageStream)
{
foreach (var customEffectViewModel in CustomEffects)
{
((IImageConsumer2)customEffectViewModel.Effect).Source = imageStream;
await customEffectViewModel.UpdateThumbnailAsync();
}
}
private async Task <bool> ApplyFilterAsync(StorageFile file)
{
// Open a stream for the selected file.
IRandomAccessStream fileStream = await file.OpenAsync(FileAccessMode.Read);
string errorMessage = null;
try
{
// Show thumbnail of original image.
_thumbnailImageBitmap.SetSource(fileStream);
OriginalImage.Source = _thumbnailImageBitmap;
// Rewind stream to start.
fileStream.Seek(0);
// A cartoon effect is initialized with selected image stream as source.
var imageStream = new RandomAccessStreamImageSource(fileStream);
_cartoonEffect = new FilterEffect(imageStream);
// Add the cartoon filter as the only filter for the effect.
var cartoonFilter = new CartoonFilter();
_cartoonEffect.Filters = new[] { cartoonFilter };
// Render the image to a WriteableBitmap.
var renderer = new WriteableBitmapRenderer(_cartoonEffect, _cartoonImageBitmap);
_cartoonImageBitmap = await renderer.RenderAsync();
_cartoonImageBitmap.Invalidate();
// Set the rendered image as source for the cartoon image control.
CartoonImage.Source = _cartoonImageBitmap;
}
catch (Exception exception)
{
errorMessage = exception.Message;
}
if (!string.IsNullOrEmpty(errorMessage))
{
var dialog = new MessageDialog(errorMessage);
await dialog.ShowAsync();
return(false);
}
return(true);
}
public static async Task <WriteableBitmap> Blur(WriteableBitmap srcBmp, int blurLevel)
{
using (var stream = await GetPngRanStream(srcBmp))
{
try
{
using (var source = new RandomAccessStreamImageSource(stream))
using (var effect = new BlurEffect(source, blurLevel))
{
var target = new WriteableBitmap(srcBmp.PixelWidth, srcBmp.PixelHeight);
var renderer = new WriteableBitmapRenderer(effect, target);
await renderer.RenderAsync();
return(target);
}
}catch (Exception e)
{
Debug.WriteLine(e.StackTrace + "\r\n");
return(new WriteableBitmap(1920, 1080));
}
}
}
private async Task <IRandomAccessStream> GetFilteredThumbnailStreamAsync()
{
#if DEBUG
System.Diagnostics.Debug.WriteLine("GetFilteredThumbnailStreamAsync invoked " + this.GetHashCode());
#endif
IRandomAccessStream filteredStream = null;
using (var ticket = await TicketManager.AcquireTicket())
using (var stream = await _photo.GetThumbnailAsync())
{
if (Filters.Count > 0)
{
var list = Filters.Select(filter => filter.GetFilter()).ToList();
filteredStream = new InMemoryRandomAccessStream();
using (var source = new RandomAccessStreamImageSource(stream))
using (var effect = new FilterEffect(source)
{
Filters = list
})
using (var renderer = new JpegRenderer(effect))
{
var buffer = await renderer.RenderAsync();
await filteredStream.WriteAsync(buffer);
}
}
else
{
filteredStream = stream.CloneStream();
}
}
return(filteredStream);
}
private static async void SourceCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var url = e.NewValue as string;
var image = d as Image;
var imageBrush = d as ImageBrush;
if (image != null) image.Source = null;
else if (imageBrush != null) imageBrush.ImageSource = null;
if (string.IsNullOrEmpty(url) || (image == null && imageBrush == null)) return;
HttpResponseMessage resp = null;
Stream stream;
if (url.StartsWith("http"))
{
// Download the image
using (var client = new HttpClient())
{
resp = await client.GetAsync(url).ConfigureAwait(false);
// If it fails, then abort!
if (!resp.IsSuccessStatusCode) return;
stream = await resp.Content.ReadAsStreamAsync().ConfigureAwait(false);
}
}
else
{
// Get the file
StorageFile file;
if (url.StartsWith("ms-appx:"))
{
url = url.Replace("ms-appx://", "");
url = url.Replace("ms-appx:", "");
}
if (url.StartsWith("ms-appdata:"))
{
url = url.Replace("ms-appdata:/local/", "");
url = url.Replace("ms-appdata:///local/", "");
file = await WinRtStorageHelper.GetFileAsync(url).ConfigureAwait(false);
}
else if (url.StartsWith("/"))
file =
await
StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx://" + url))
.AsTask()
.ConfigureAwait(false);
else
file = await StorageFile.GetFileFromPathAsync(url).AsTask().ConfigureAwait(false);
stream = await file.OpenStreamForReadAsync().ConfigureAwait(false);
}
using (stream)
{
if (stream.Length == 0) return;
using (var rnd = stream.AsRandomAccessStream())
{
// Then we can create the Random Access Stream Image
using (var source = new RandomAccessStreamImageSource(rnd, ImageFormat.Undefined))
{
// Create effect collection with the source stream
using (var filters = new FilterEffect(source))
{
double blurPercent = 1;
await DispatcherHelper.RunAsync(
() => blurPercent = GetBlurPercent(d)*256);
// Initialize the filter and add the filter to the FilterEffect collection
filters.Filters = new IFilter[] {new BlurFilter((int) blurPercent)};
// Create a target where the filtered image will be rendered to
WriteableBitmap target = null;
// Now that you have the raw bytes, create a Image Decoder
var decoder = await BitmapDecoder.CreateAsync(rnd).AsTask().ConfigureAwait(false);
// Get the first frame from the decoder because we are picking an image
var frame = await decoder.GetFrameAsync(0).AsTask().ConfigureAwait(false);
// Need to switch to UI thread for this
await DispatcherHelper.RunAsync(
() =>
{
var wid = (int) frame.PixelWidth;
var hgt = (int) frame.PixelHeight;
target = new WriteableBitmap(wid, hgt);
}).AsTask().ConfigureAwait(false);
// Create a new renderer which outputs WriteableBitmaps
using (var renderer = new WriteableBitmapRenderer(filters, target))
{
rnd.Seek(0);
// Render the image with the filter(s)
await renderer.RenderAsync().AsTask().ConfigureAwait(false);
// Set the output image to Image control as a source
// Need to switch to UI thread for this
await DispatcherHelper.RunAsync(() =>
{
if (image != null) image.Source = target;
else if (imageBrush != null) imageBrush.ImageSource = target;
}).AsTask().ConfigureAwait(false);
}
}
}
}
}
if (resp != null) resp.Dispose();
}
public async Task SaveToPicturesLibraryAsync(InMemoryRandomAccessStream stream)
{
try
{
var rotationAngle = ConvertDeviceOrientationToDegrees(GetCameraOrientation());
IsCaptureEnabled = false;
var file = await KnownFolders.PicturesLibrary.CreateFileAsync("LumiaImagingCapturedImage.jpg", CreationCollisionOption.GenerateUniqueName);
stream.Seek(0);
var imageSource = new RandomAccessStreamImageSource(stream);
using (var jpegRenderer = new JpegRenderer(imageSource))
using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
if (rotationAngle != 0)
{
jpegRenderer.Source = new RotationEffect(imageSource, rotationAngle - 180); //Andjust to Lumia.Imaging Rotation
}
// Jpeg renderer gives the raw buffer containing the filtered image.
IBuffer jpegBuffer = await jpegRenderer.RenderAsync();
await fileStream.WriteAsync(jpegBuffer);
await fileStream.FlushAsync();
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
IsCaptureEnabled = true;
}
private async void UpdateCustomEffectSource(RandomAccessStreamImageSource imageStream)
{
foreach (var customEffectViewModel in CustomEffects)
{
((IImageConsumer2)customEffectViewModel.Effect).Source = imageStream;
await customEffectViewModel.UpdateThumbnailAsync();
}
}
private static async void SourceCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var url = e.NewValue as string;
var image = d as Image;
var imageBrush = d as ImageBrush;
if (image != null)
{
image.Source = null;
}
else if (imageBrush != null)
{
imageBrush.ImageSource = null;
}
if (string.IsNullOrEmpty(url) || (image == null && imageBrush == null))
{
return;
}
HttpResponseMessage resp = null;
Stream stream;
if (url.StartsWith("http"))
{
// Download the image
using (var client = new HttpClient())
{
resp = await client.GetAsync(url).ConfigureAwait(false);
// If it fails, then abort!
if (!resp.IsSuccessStatusCode)
{
return;
}
stream = await resp.Content.ReadAsStreamAsync().ConfigureAwait(false);
}
}
else
{
// Get the file
StorageFile file;
if (url.StartsWith("ms-appx:"))
{
url = url.Replace("ms-appx://", "");
url = url.Replace("ms-appx:", "");
}
if (url.StartsWith("ms-appdata:"))
{
url = url.Replace("ms-appdata:/local/", "");
url = url.Replace("ms-appdata:///local/", "");
file = await WinRtStorageHelper.GetFileAsync(url).ConfigureAwait(false);
}
else if (url.StartsWith("/"))
{
file =
await
StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx://" + url))
.AsTask()
.ConfigureAwait(false);
}
else
{
file = await StorageFile.GetFileFromPathAsync(url).AsTask().ConfigureAwait(false);
}
stream = await file.OpenStreamForReadAsync().ConfigureAwait(false);
}
using (stream)
{
if (stream.Length == 0)
{
return;
}
using (var rnd = stream.AsRandomAccessStream())
{
// Then we can create the Random Access Stream Image
using (var source = new RandomAccessStreamImageSource(rnd, ImageFormat.Undefined))
{
// Create effect collection with the source stream
using (var filters = new FilterEffect(source))
{
double blurPercent = 1;
await DispatcherHelper.RunAsync(
() => blurPercent = GetBlurPercent(d) *256);
// Initialize the filter and add the filter to the FilterEffect collection
filters.Filters = new IFilter[] { new BlurFilter((int)blurPercent) };
// Create a target where the filtered image will be rendered to
WriteableBitmap target = null;
// Now that you have the raw bytes, create a Image Decoder
var decoder = await BitmapDecoder.CreateAsync(rnd).AsTask().ConfigureAwait(false);
// Get the first frame from the decoder because we are picking an image
var frame = await decoder.GetFrameAsync(0).AsTask().ConfigureAwait(false);
// Need to switch to UI thread for this
await DispatcherHelper.RunAsync(
() =>
{
var wid = (int)frame.PixelWidth;
var hgt = (int)frame.PixelHeight;
target = new WriteableBitmap(wid, hgt);
}).AsTask().ConfigureAwait(false);
// Create a new renderer which outputs WriteableBitmaps
using (var renderer = new WriteableBitmapRenderer(filters, target))
{
rnd.Seek(0);
// Render the image with the filter(s)
await renderer.RenderAsync().AsTask().ConfigureAwait(false);
// Set the output image to Image control as a source
// Need to switch to UI thread for this
await DispatcherHelper.RunAsync(() =>
{
if (image != null)
{
image.Source = target;
}
else if (imageBrush != null)
{
imageBrush.ImageSource = target;
}
}).AsTask().ConfigureAwait(false);
}
}
}
}
}
if (resp != null)
{
resp.Dispose();
}
}
private async Task<bool> ApplyFilterAsync(StorageFile file)
{
// Open a stream for the selected file.
IRandomAccessStream fileStream = await file.OpenAsync(FileAccessMode.Read);
string errorMessage = null;
try
{
// Show thumbnail of original image.
_thumbnailImageBitmap.SetSource(fileStream);
OriginalImage.Source = _thumbnailImageBitmap;
// Rewind stream to start.
fileStream.Seek(0);
// A cartoon effect is initialized with selected image stream as source.
var imageStream = new RandomAccessStreamImageSource(fileStream);
_cartoonEffect = new FilterEffect(imageStream);
// Add the cartoon filter as the only filter for the effect.
var cartoonFilter = new CartoonFilter();
_cartoonEffect.Filters = new[] { cartoonFilter };
// Render the image to a WriteableBitmap.
var renderer = new WriteableBitmapRenderer(_cartoonEffect, _cartoonImageBitmap);
_cartoonImageBitmap = await renderer.RenderAsync();
_cartoonImageBitmap.Invalidate();
// Set the rendered image as source for the cartoon image control.
CartoonImage.Source = _cartoonImageBitmap;
}
catch (Exception exception)
{
errorMessage = exception.Message;
}
if (!string.IsNullOrEmpty(errorMessage))
{
var dialog = new MessageDialog(errorMessage);
await dialog.ShowAsync();
return false;
}
return true;
}
private async Task<IRandomAccessStream> ResizeStreamAsync(IRandomAccessStream stream, Size size, PhotoOrientation orientation)
{
var rotation = 0;
switch (orientation)
{
case PhotoOrientation.Rotate180:
{
rotation = -180;
};
break;
case PhotoOrientation.Rotate270:
{
rotation = -270;
};
break;
case PhotoOrientation.Rotate90:
{
rotation = -90;
};
break;
}
using (var resizedStream = new InMemoryRandomAccessStream())
{
var buffer = new byte[stream.Size].AsBuffer();
stream.Seek(0);
await stream.ReadAsync(buffer, buffer.Length, InputStreamOptions.None);
var resizeConfiguration = new AutoResizeConfiguration(
(uint)(size.Width * size.Height * 4 * 2), size,
new Size(0, 0), AutoResizeMode.Automatic, 0.7, ColorSpace.Yuv420);
buffer = await JpegTools.AutoResizeAsync(buffer, resizeConfiguration);
await resizedStream.WriteAsync(buffer);
await resizedStream.FlushAsync();
if (rotation != 0)
{
resizedStream.Seek(0);
var filters = new List<IFilter>() { new RotationFilter(rotation) };
using (var source = new RandomAccessStreamImageSource(resizedStream))
using (var effect = new FilterEffect(source) { Filters = filters })
using (var renderer = new JpegRenderer(effect))
{
buffer = await renderer.RenderAsync();
using (var rotatedResizedStream = new InMemoryRandomAccessStream())
{
await rotatedResizedStream.WriteAsync(buffer);
await rotatedResizedStream.FlushAsync();
return rotatedResizedStream.CloneStream();
}
}
}
else
{
return resizedStream.CloneStream();
}
}
}
private async Task <IRandomAccessStream> ResizeStreamAsync(IRandomAccessStream stream, Size size, PhotoOrientation orientation)
{
var rotation = 0;
switch (orientation)
{
case PhotoOrientation.Rotate180:
{
rotation = -180;
};
break;
case PhotoOrientation.Rotate270:
{
rotation = -270;
};
break;
case PhotoOrientation.Rotate90:
{
rotation = -90;
};
break;
}
using (var resizedStream = new InMemoryRandomAccessStream())
{
var buffer = new byte[stream.Size].AsBuffer();
stream.Seek(0);
await stream.ReadAsync(buffer, buffer.Length, InputStreamOptions.None);
var resizeConfiguration = new AutoResizeConfiguration(
(uint)(size.Width * size.Height * 4 * 2), size,
new Size(0, 0), AutoResizeMode.Automatic, 0.7, ColorSpace.Yuv420);
buffer = await JpegTools.AutoResizeAsync(buffer, resizeConfiguration);
await resizedStream.WriteAsync(buffer);
await resizedStream.FlushAsync();
if (rotation != 0)
{
resizedStream.Seek(0);
var filters = new List <IFilter>()
{
new RotationFilter(rotation)
};
using (var source = new RandomAccessStreamImageSource(resizedStream))
using (var effect = new FilterEffect(source)
{
Filters = filters
})
using (var renderer = new JpegRenderer(effect))
{
buffer = await renderer.RenderAsync();
using (var rotatedResizedStream = new InMemoryRandomAccessStream())
{
await rotatedResizedStream.WriteAsync(buffer);
await rotatedResizedStream.FlushAsync();
return(rotatedResizedStream.CloneStream());
}
}
}
else
{
return(resizedStream.CloneStream());
}
}
}
private async Task<IRandomAccessStream> GetFilteredThumbnailStreamAsync()
{
#if DEBUG
System.Diagnostics.Debug.WriteLine("GetFilteredThumbnailStreamAsync invoked " + this.GetHashCode());
#endif
IRandomAccessStream filteredStream = null;
using (var ticket = await TicketManager.AcquireTicket())
using (var stream = await _photo.GetThumbnailAsync())
{
if (Filters.Count > 0)
{
var list = new List<IFilter>();
foreach (var filter in Filters)
{
list.Add(filter.GetFilter());
}
filteredStream = new InMemoryRandomAccessStream();
using (var source = new RandomAccessStreamImageSource(stream))
using (var effect = new FilterEffect(source) { Filters = list })
using (var renderer = new JpegRenderer(effect))
{
var buffer = await renderer.RenderAsync();
await filteredStream.WriteAsync(buffer);
}
}
else
{
filteredStream = stream.CloneStream();
}
}
return filteredStream;
}
