/// <summary>
/// Save the primitive image and thumbnail image and return the Photo model with local url
/// </summary>
/// <param name="imageBuffer"></param>
/// <returns></returns>
public static async Task<Photo> SaveImage(IBuffer imageBuffer)
{
try
{
Photo photo = new Photo
{
CreatedTime = DateTime.UtcNow
};
AutoResizeConfiguration tbRC = null;
AutoResizeConfiguration pvRC = null;
Rect thumbnailRect;
Size pvSize;
using (var source = new BufferImageSource(imageBuffer))
{
var info = await source.GetInfoAsync();
//var thumbnailSize = ImageHelper.CalculateSize(info.ImageSize);
thumbnailRect = CalculateRect(info.ImageSize);
pvSize = CalculateSize(info.ImageSize);
tbRC = new AutoResizeConfiguration(ImageHelper.thumbnailMaxBytes, thumbnailMaxSize, new Size(0, 0), AutoResizeMode.Automatic, 0, ColorSpace.Yuv420);
pvRC = new AutoResizeConfiguration(ImageHelper.pvMaxBytes, pvSize, new Size(0, 0), AutoResizeMode.Automatic, 0, ColorSpace.Yuv420);
}
using (var store = IsolatedStorageFile.GetUserStoreForApplication())
{
//Get LocalPath
var localPath = AppResources.LocalImagePath;
if (!store.DirectoryExists(localPath))
{
store.CreateDirectory(localPath);
}
//Save the primitive bitmap file
using (var file = store.CreateFile(photo.LocalUri = localPath + @"\" + photo.Tag + @"_Raw"))
{
using (var localImage = imageBuffer.AsStream())
{
localImage.CopyTo(file);
file.Flush();
localImage.Close();
}
}
//Save Preview Image
if (pvRC != null)
{
//Resize the Image to priview image
var pvBuffer = await Nokia.Graphics.Imaging.JpegTools.AutoResizeAsync(imageBuffer, pvRC);
//Save Preview Image
using (var file = store.CreateFile(localPath + @"\" + photo.Tag + @"_Preview.jpg"))
{
photo.PreviewDetailUri = file.Name;
;
using (var localImage = pvBuffer.AsStream())
{
localImage.CopyTo(file);
file.Flush();
localImage.Close();
}
}
}
//Save thumbnail Image
if(tbRC != null)
{
//Crop to the square
var rb = await Reframe(imageBuffer, thumbnailRect);
//Resize the Image to thumbnail
var tb = await Nokia.Graphics.Imaging.JpegTools.AutoResizeAsync(rb, tbRC);
//Save thumbnail
using (var file = store.CreateFile(photo.LocalThumbnailUri = localPath + @"\" + photo.Tag + @"_Thumbnail.jpg"))
{
photo.ThumbnailDetailUri = file.Name;
using (var localImage = tb.AsStream())
{
localImage.CopyTo(file);
file.Flush();
localImage.Close();
}
}
}
}
return photo;
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <Windows.Foundation.Size> GetImageSizeAsync()
{
using (var source = new BufferImageSource(_buffer))
{
return((await source.GetInfoAsync()).ImageSize);
}
}
/// <summary>
/// Renders a thumbnail of requested size from the center of the current image with
/// filters applied.
/// </summary>
/// <param name="side">Side length of square thumbnail to render</param>
/// <returns>Rendered thumbnail bitmap</returns>
public async Task <Bitmap> RenderThumbnailBitmapAsync(int side)
{
Windows.Foundation.Size dimensions = await GetImageSizeAsync();
int minSide = (int)Math.Min(dimensions.Width, dimensions.Height);
Windows.Foundation.Rect rect = new Windows.Foundation.Rect()
{
Width = minSide,
Height = minSide,
X = (dimensions.Width - minSide) / 2,
Y = (dimensions.Height - minSide) / 2,
};
_components.Add(new CropFilter(rect));
Bitmap bitmap = new Bitmap(new Windows.Foundation.Size(side, side), ColorMode.Ayuv4444);
using (BufferImageSource source = new BufferImageSource(_buffer))
using (FilterEffect effect = new FilterEffect(source)
{
Filters = _components
})
using (BitmapRenderer renderer = new BitmapRenderer(effect, bitmap, OutputOption.Stretch))
{
await renderer.RenderAsync();
}
_components.RemoveAt(_components.Count - 1);
return(bitmap);
}
/// <summary>
/// Renders current image with applied filters to a buffer and returns it.
/// Meant to be used where the filtered image is for example going to be
/// saved to a file.
/// </summary>
/// <param name="buffer">The buffer containing the original image data.</param>
/// <returns>Buffer containing the filtered image data.</returns>
public async Task <IBuffer> RenderJpegAsync(IBuffer buffer)
{
using (BufferImageSource source = new BufferImageSource(buffer))
using (JpegRenderer renderer = new JpegRenderer(_effect))
{
return(await renderer.RenderAsync());
}
}
/// <summary>
/// Renders current image with applied filters to a buffer and returns it.
/// Meant to be used where the filtered image is for example going to be
/// saved to a file.
/// </summary>
/// <returns>Buffer containing the filtered image data</returns>
public async Task <IBuffer> RenderFullBufferAsync()
{
using (var source = new BufferImageSource(_buffer))
using (var effect = new FilterEffect(source)
{
Filters = _components
})
using (var renderer = new JpegRenderer(effect))
{
return(await renderer.RenderAsync());
}
}
/// <summary>
/// Constructeur de la classe photo qui permet de transformer l'image sélectionnée en Buffer pour l'application des filtres
/// </summary>
/// <param name="photoSelectionne"></param>
/// <param name="largeurPiece"></param>
/// <param name="hauteurPiece"></param>
public Photo(WriteableBitmap photoSelectionne, int largeurPiece, int hauteurPiece)
{
PhotoSelectionne = photoSelectionne;
var fileStream = new MemoryStream();
photoSelectionne.SaveJpeg(fileStream, largeurPiece, hauteurPiece, 100, 100);
fileStream.Seek(0, SeekOrigin.Begin);
IBuffer buffer = fileStream.GetWindowsRuntimeBuffer();
PhotoBuffer = new BufferImageSource(buffer);
}
private async Task <IImageProvider> GetEffectInternal2Async(IImageProvider source, Windows.Foundation.Size sourceSize, Windows.Foundation.Size renderSize)
{
if (m_foregroundSource == null)
{
m_foregroundSource = new BufferImageSource(await PreloadedImages.Man.ConfigureAwait(false));
}
m_blendEffect.Source = source;
m_blendEffect.ForegroundSource = m_foregroundSource;
m_blendEffect.GlobalAlpha = m_globalAlpha;
m_blendEffect.BlendFunction = m_blendFunction;
return(m_blendEffect);
}
/// <summary>
/// Renders current image with applied filters to the given bitmap.
/// </summary>
/// <param name="bitmap">Bitmap to render to</param>
public async Task RenderBitmapAsync(WriteableBitmap bitmap)
{
using (var source = new BufferImageSource(_buffer))
using (var effect = new FilterEffect(source)
{
Filters = _components
})
using (var renderer = new WriteableBitmapRenderer(effect, bitmap))
{
await renderer.RenderAsync();
bitmap.Invalidate();
}
}
/// <summary>
/// From IDisposable.
/// </summary>
public void Dispose()
{
System.Diagnostics.Debug.WriteLine("Disposing effect.");
if (_source != null)
{
_source.Dispose();
_source = null;
}
if (_effect != null)
{
_effect.Dispose();
_effect = null;
}
}
private async Task <ImageSource> ProcessImage(byte[] inputBytes)
{
// Manipulate image color
IBuffer inputBuffer = inputBytes.AsBuffer();
/*Lumia.Imaging.*/ BufferImageSource bufferImageSource = null;
bufferImageSource = new /*Lumia.Imaging.*/ BufferImageSource(inputBuffer);
var output = new /*Windows.UI.Xaml.Media.Imaging.*/ WriteableBitmap((int)bufferImageSource.ImageSize.Width,
(int)bufferImageSource.ImageSize.Height);
await ColorizeImageInternalAsync(bufferImageSource, output);
return(output);
}
/// <summary>
/// From IDisposable.
/// </summary>
public virtual void Dispose()
{
Debug.WriteLine("Disposing effect.");
if (Source != null)
{
Source.Dispose();
Source = null;
}
if (Effect != null)
{
Effect.Dispose();
Effect = null;
}
}
/// <summary>
/// From IDisposable.
/// </summary>
public virtual void Dispose()
{
Debug.WriteLine("Disposing effect.");
if (_source != null)
{
_source.Dispose();
_source = null;
}
if (_effect != null)
{
_effect.Dispose();
_effect = null;
}
}
private async Task <string> SaveToCameraRoll(Stream cameraImage, string filenameBase)
{
string filename = filenameBase + ".jpg";
StorageFolder storageFolder = KnownFolders.CameraRoll;
AutoResizeConfiguration resizeConfiguration = null;
var buffer = StreamToBuffer(cameraImage);
// Store low resolution image
using (var source = new BufferImageSource(buffer))
{
var info = await source.GetInfoAsync();
if (info.ImageSize.Width * info.ImageSize.Height > LibraryMaxArea)
{
var compactedSize = CalculateSize(info.ImageSize, LibraryMaxSize, LibraryMaxArea);
resizeConfiguration = new AutoResizeConfiguration(LibraryMaxBytes, compactedSize,
new Size(0, 0), AutoResizeMode.Automatic, 0, ColorSpace.Yuv420);
buffer = await Nokia.Graphics.Imaging.JpegTools.AutoResizeAsync(buffer, resizeConfiguration);
}
using (var library = new MediaLibrary())
{
library.SavePictureToCameraRoll(filename, buffer.AsStream());
}
}
// Store high resolution image
if (resizeConfiguration != null)
{
filename = filenameBase + HIGH_RESOLUTION_PHOTO_SUFFIX + @".jpg";
cameraImage.Position = 0;
using (var stream = await storageFolder.OpenStreamForWriteAsync(filename, CreationCollisionOption.GenerateUniqueName))
{
await cameraImage.CopyToAsync(stream);
}
}
_saved = true;
return(storageFolder.Path + "\\" + filename);
}
public async override Task <IBuffer> RenderJpegAsync(IBuffer buffer)
{
if (buffer == null || buffer.Length == 0)
{
Debug.WriteLine(DebugTag + Name + ": RenderJpegAsync(): The given buffer is null or empty!");
return(null);
}
IBuffer outputBuffer;
using (var source = new BufferImageSource(buffer))
{
_hdrEffect.Source = source;
using (var renderer = new JpegRenderer(_hdrEffect))
{
outputBuffer = await renderer.RenderAsync();
}
_hdrEffect.Dispose();
}
return(outputBuffer);
}
/// <summary>
/// Renders the given buffer with the applied filters to an output
/// buffer and returns it. Meant to be used where the filtered image
/// is, for example, going to be saved to a file.
/// </summary>
/// <param name="buffer">The buffer containing the original image data.</param>
/// <returns>Buffer containing the filtered image data.</returns>
public virtual async Task <IBuffer> RenderJpegAsync(IBuffer buffer)
{
if (buffer == null || buffer.Length == 0)
{
Debug.WriteLine(DebugTag + Name + ": RenderJpegAsync(): The given buffer is null or empty!");
return(null);
}
if (_effect != null)
{
_effect.Dispose();
_effect = null;
}
// Construct the FilterEffect instance and set the
// filters.
_effect = new FilterEffect(_source);
SetFilters(_effect);
IBuffer outputBuffer;
using (var source = new BufferImageSource(buffer))
{
var effect = new FilterEffect(source);
SetFilters(effect);
using (var renderer = new JpegRenderer(effect))
{
outputBuffer = await renderer.RenderAsync();
}
effect.Dispose();
}
return(outputBuffer);
}
public async override Task<IBuffer> RenderJpegAsync(IBuffer buffer)
{
if (buffer == null || buffer.Length == 0)
{
Debug.WriteLine(DebugTag + Name + ": RenderJpegAsync(): The given buffer is null or empty!");
return null;
}
IBuffer outputBuffer;
using (var source = new BufferImageSource(buffer))
{
_hdrEffect.Source = source;
using (var renderer = new JpegRenderer(_hdrEffect))
{
outputBuffer = await renderer.RenderAsync();
}
_hdrEffect.Dispose();
}
return outputBuffer;
}
/// <summary>
/// Renders the given buffer with the applied filters to an output
/// buffer and returns it. Meant to be used where the filtered image
/// is, for example, going to be saved to a file.
/// </summary>
/// <param name="buffer">The buffer containing the original image data.</param>
/// <returns>Buffer containing the filtered image data.</returns>
public virtual async Task<IBuffer> RenderJpegAsync(IBuffer buffer)
{
if (buffer == null || buffer.Length == 0)
{
Debug.WriteLine(DebugTag + Name + ": RenderJpegAsync(): The given buffer is null or empty!");
return null;
}
if (_effect != null)
{
_effect.Dispose();
_effect = null;
}
// Construct the FilterEffect instance and set the
// filters.
_effect = new FilterEffect(_source);
SetFilters(_effect);
IBuffer outputBuffer;
using (var source = new BufferImageSource(buffer))
{
var effect = new FilterEffect(source);
SetFilters(effect);
using (var renderer = new JpegRenderer(effect))
{
outputBuffer = await renderer.RenderAsync();
}
effect.Dispose();
}
return outputBuffer;
}
private async Task<string> SaveToCameraRoll(Stream cameraImage, string filenameBase)
{
string filename = filenameBase + ".jpg";
StorageFolder storageFolder = KnownFolders.CameraRoll;
AutoResizeConfiguration resizeConfiguration = null;
var buffer = StreamToBuffer(cameraImage);
// Store low resolution image
using (var source = new BufferImageSource(buffer))
{
var info = await source.GetInfoAsync();
if (info.ImageSize.Width * info.ImageSize.Height > LibraryMaxArea)
{
var compactedSize = CalculateSize(info.ImageSize, LibraryMaxSize, LibraryMaxArea);
resizeConfiguration = new AutoResizeConfiguration(LibraryMaxBytes, compactedSize,
new Size(0, 0), AutoResizeMode.Automatic, 0, ColorSpace.Yuv420);
buffer = await Nokia.Graphics.Imaging.JpegTools.AutoResizeAsync(buffer, resizeConfiguration);
}
using (var library = new MediaLibrary())
{
library.SavePictureToCameraRoll(filename, buffer.AsStream());
}
}
// Store high resolution image
if (resizeConfiguration != null)
{
filename = filenameBase + HIGH_RESOLUTION_PHOTO_SUFFIX + @".jpg";
cameraImage.Position = 0;
using (var stream = await storageFolder.OpenStreamForWriteAsync(filename, CreationCollisionOption.GenerateUniqueName))
{
await cameraImage.CopyToAsync(stream);
}
}
_saved = true;
return storageFolder.Path + "\\" + filename;
}
public async Task<Windows.Foundation.Size> GetImageSizeAsync()
{
using (BufferImageSource source = new BufferImageSource(_buffer))
{
return (await source.GetInfoAsync()).ImageSize;
}
}
/// <summary>
/// Renders a thumbnail of requested size from the center of the current image with
/// filters applied.
/// </summary>
/// <param name="side">Side length of square thumbnail to render</param>
/// <returns>Rendered thumbnail bitmap</returns>
public async Task<Bitmap> RenderThumbnailBitmapAsync(int side)
{
Windows.Foundation.Size dimensions = await GetImageSizeAsync();
int minSide = (int)Math.Min(dimensions.Width, dimensions.Height);
Windows.Foundation.Rect rect = new Windows.Foundation.Rect()
{
Width = minSide,
Height = minSide,
X = (dimensions.Width - minSide) / 2,
Y = (dimensions.Height - minSide) / 2,
};
_components.Add(new CropFilter(rect));
Bitmap bitmap = new Bitmap(new Windows.Foundation.Size(side, side), ColorMode.Ayuv4444);
using (BufferImageSource source = new BufferImageSource(_buffer))
using (FilterEffect effect = new FilterEffect(source) { Filters = _components })
using (BitmapRenderer renderer = new BitmapRenderer(effect, bitmap, OutputOption.Stretch))
{
await renderer.RenderAsync();
}
_components.RemoveAt(_components.Count - 1);
return bitmap;
}
async void setInput(Stream s)
{
//Dispose old session ressources.
if (source != null)
{
source.Dispose(); source = null;
filter.Dispose(); filter = null;
reframing = null;
rendererLR.Dispose(); rendererLR = null;
rendererHR.Dispose(); rendererHR = null;
}
//reset stream position
s.Seek(0, SeekOrigin.Begin);
MemoryStream mstream = new MemoryStream();
s.CopyTo(mstream);
var tmpsource = new BufferImageSource(mstream.GetBuffer().AsBuffer());
// var tmpsource = new StreamImageSource(s);
{
var info = await tmpsource.GetInfoAsync();
filter = new FilterEffect(tmpsource);
reframing = new ReframingFilter();
filter.Filters = new IFilter[] { reframing };
rendererLR = new WriteableBitmapRenderer(filter, outputBitmapLRTmp);
rendererHR = new WriteableBitmapRenderer(filter, outputBitmapHRTmp);
inputSize = new Size() { Width = info.ImageSize.Width, Height = info.ImageSize.Height };
currentPos = new Point(info.ImageSize.Width / 2, info.ImageSize.Height / 2);
if (info.ImageSize.Width > info.ImageSize.Height)
{
currentScale = output.Height / info.ImageSize.Height;
}
else
{
currentScale = output.Width / info.ImageSize.Width;
}
currentAngle = 0.0;
saveLastPossaveLastPositionData();
GC.Collect();
}
source = tmpsource;
requestProcessing();
}
public void Dispose()
{
if (source != null)
{
source.Dispose(); source = null;
filter.Dispose(); filter = null;
reframing = null;
rendererLR.Dispose(); rendererLR = null;
rendererHR.Dispose(); rendererHR = null;
}
outputBitmapLRTmp = null;
outputBitmapLR = null;
outputBitmapHRTmp = null;
outputBitmapHR = null;
if (output != null)
{
output.ManipulationStarted -= ManipulationStarted;
output.ManipulationDelta -= ManipulationDelta;
output.ManipulationCompleted -= ManipulationCompleted;
}
output = null;
}
protected override async void Render()
{
try
{
if (Source != null)
{
Debug.WriteLine(DebugTag + Name + ": Rendering...");
foreach (var change in Changes)
{
change();
}
Changes.Clear();
//blend source layer with mode overlay
var blendEffect = new BlendEffect();
blendEffect.Source = Source;// new StreamImageSource(new MemoryStream());
blendEffect.ForegroundSource = Source;
blendEffect.BlendFunction = BlendFunction.Overlay;
blendEffect.GlobalAlpha = 0.0;
var renderer = new JpegRenderer(blendEffect);
var outBuffer = await renderer.RenderAsync();
blendEffect.Dispose();
var highPassSource = new BufferImageSource(outBuffer);
var highPassFilter = new HighpassEffect(6, false, 1);
highPassFilter.Source = highPassSource;
var highPassRenderer = new JpegRenderer(highPassFilter);
var highPassOutBuffer = await highPassRenderer.RenderAsync();
highPassFilter.Dispose();
var negativeFilter = new NegativeFilter();
var filterEffect = new FilterEffect();
filterEffect.Filters = new List<IFilter>() { negativeFilter };
filterEffect.Source = new BufferImageSource(highPassOutBuffer);
var invertRenderer = new JpegRenderer(filterEffect);
var invertOutBuffer = await invertRenderer.RenderAsync();
blendEffect = new BlendEffect(Source, new BufferImageSource(invertOutBuffer), BlendFunction.Overlay, 0.5);
using (var bmpRender = new WriteableBitmapRenderer(blendEffect, TmpBitmap))
{
await bmpRender.RenderAsync();
}
TmpBitmap.Pixels.CopyTo(PreviewBitmap.Pixels, 0);
PreviewBitmap.Invalidate(); // Force a redraw
}
else
{
Debug.WriteLine(DebugTag + Name + ": Render(): No buffer set!");
}
}
catch (Exception e)
{
Debug.WriteLine(DebugTag + Name + ": Render(): " + e.Message);
}
finally
{
switch (State)
{
case States.Apply:
State = States.Wait;
break;
case States.Schedule:
State = States.Apply;
Render();
break;
default:
break;
}
}
}
/// <summary>
/// From IDisposable.
/// </summary>
public virtual void Dispose()
{
Debug.WriteLine("Disposing effect.");
if (Source != null)
{
Source.Dispose();
Source = null;
}
if (Effect != null)
{
Effect.Dispose();
Effect = null;
}
}
/// <summary>
/// Renders current image with applied filters to a buffer and returns it.
/// Meant to be used where the filtered image is for example going to be
/// saved to a file.
/// </summary>
/// <returns>Buffer containing the filtered image data</returns>
public async Task<IBuffer> RenderFullBufferAsync()
{
using (BufferImageSource source = new BufferImageSource(_buffer))
using (FilterEffect effect = new FilterEffect(source) { Filters = _components })
using (JpegRenderer renderer = new JpegRenderer(effect))
{
return await renderer.RenderAsync();
}
}
/// <summary>
/// From IDisposable.
/// </summary>
public virtual void Dispose()
{
Debug.WriteLine("Disposing effect.");
if (_source != null)
{
_source.Dispose();
_source = null;
}
if (_effect != null)
{
_effect.Dispose();
_effect = null;
}
}
/// <summary>
/// Asynchronously saves a low resolution version of the photo to MediaLibrary and if the photo is too large to be saved
/// to MediaLibrary as is also saves the original high resolution photo to application's local storage so that the
/// high resolution version is not lost.
/// </summary>
public async Task SaveAsync()
{
if (_image != null && _image.Length > 0 && LibraryPath == null)
{
var buffer = StreamToBuffer(_image);
AutoResizeConfiguration resizeConfiguration = null;
using (var source = new BufferImageSource(buffer))
{
var info = await source.GetInfoAsync();
if (info.ImageSize.Width * info.ImageSize.Height > LibraryMaxArea)
{
var compactedSize = CalculateSize(info.ImageSize, LibraryMaxSize, LibraryMaxArea);
resizeConfiguration = new AutoResizeConfiguration(LibraryMaxBytes, compactedSize,
new Size(0, 0), AutoResizeMode.Automatic, 0, ColorSpace.Yuv420);
}
}
var filenameBase = "photoinspector";
if (_original != null)
{
if (_originalPath != null)
{
var originalPathParts = _originalPath.Split(new char[] { '_', '.' }, StringSplitOptions.RemoveEmptyEntries);
filenameBase += '_' + originalPathParts[1];
}
else
{
filenameBase += '_' + DateTime.UtcNow.Ticks.ToString();
using (var store = IsolatedStorageFile.GetUserStoreForApplication())
{
if (!store.DirectoryExists(Mapping.ORIGINALS_PATH))
{
store.CreateDirectory(Mapping.ORIGINALS_PATH);
}
var originalPath = Mapping.ORIGINALS_PATH + @"\" + filenameBase + @".jpg";
using (var file = store.CreateFile(originalPath))
{
_original.Position = 0;
_original.CopyTo(file);
file.Flush();
OriginalPath = originalPath;
}
}
}
}
filenameBase += '_' + DateTime.UtcNow.Ticks.ToString();
if (resizeConfiguration != null)
{
// Store high resolution original to application local storage
using (var store = IsolatedStorageFile.GetUserStoreForApplication())
{
if (!store.DirectoryExists(Mapping.LOCALS_PATH))
{
store.CreateDirectory(Mapping.LOCALS_PATH);
}
var localPath = Mapping.LOCALS_PATH + @"\" + filenameBase + @".jpg";
using (var file = store.CreateFile(localPath))
{
_image.Position = 0;
_image.CopyTo(file);
file.Flush();
LocalPath = localPath;
}
}
// Compact the buffer for saving to the library
buffer = await Nokia.Graphics.Imaging.JpegTools.AutoResizeAsync(buffer, resizeConfiguration);
}
using (var libraryImage = buffer.AsStream())
{
libraryImage.Position = 0;
using (var library = new MediaLibrary())
{
using (var picture = library.SavePictureToCameraRoll(filenameBase, libraryImage))
{
LibraryPath = picture.GetPath();
}
}
}
}
}
/// <summary>
/// Renders current image with applied filters to a buffer and returns it.
/// Meant to be used where the filtered image is for example going to be
/// saved to a file.
/// </summary>
/// <param name="buffer">The buffer containing the original image data.</param>
/// <returns>Buffer containing the filtered image data.</returns>
public async Task<IBuffer> RenderJpegAsync(IBuffer buffer)
{
using (BufferImageSource source = new BufferImageSource(buffer))
using (JpegRenderer renderer = new JpegRenderer(_effect))
{
return await renderer.RenderAsync();
}
}
/// <summary>
/// From IDisposable.
/// </summary>
public void Dispose()
{
System.Diagnostics.Debug.WriteLine("Disposing effect.");
if (_source != null)
{
_source.Dispose();
_source = null;
}
if (_effect != null)
{
_effect.Dispose();
_effect = null;
}
}
public static async Task<IBuffer> Reframe(IBuffer image, Rect area)
{
using (var source = new BufferImageSource(image))
using (var effect = new FilterEffect(source))
{
effect.Filters = new List<IFilter>()
{
new ReframingFilter()
{
ReframingArea = area,
}
};
using (var renderer = new JpegRenderer(effect))
{
return await renderer.RenderAsync();
}
}
}
/// <summary>
/// Renders current image with applied filters to the given bitmap.
/// </summary>
/// <param name="bitmap">Bitmap to render to</param>
public async Task RenderBitmapAsync(WriteableBitmap bitmap)
{
using (BufferImageSource source = new BufferImageSource(_buffer))
using (FilterEffect effect = new FilterEffect(source) { Filters = _components })
using (WriteableBitmapRenderer renderer = new WriteableBitmapRenderer(effect, bitmap))
{
await renderer.RenderAsync();
bitmap.Invalidate();
}
}
/// <summary>
/// Asynchronously saves a low resolution version of the photo to MediaLibrary and if the photo is too large to be saved
/// to MediaLibrary as is also saves the original high resolution photo to application's local storage so that the
/// high resolution version is not lost.
/// </summary>
public async Task SaveAsync()
{
if (_image != null && _image.Length > 0 && LibraryPath == null)
{
var buffer = StreamToBuffer(_image);
AutoResizeConfiguration resizeConfiguration = null;
using (var source = new BufferImageSource(buffer))
{
var info = await source.GetInfoAsync();
if (info.ImageSize.Width * info.ImageSize.Height > LibraryMaxArea)
{
var compactedSize = CalculateSize(info.ImageSize, LibraryMaxSize, LibraryMaxArea);
resizeConfiguration = new AutoResizeConfiguration(LibraryMaxBytes, compactedSize,
new Size(0, 0), AutoResizeMode.Automatic, 0, ColorSpace.Yuv420);
}
}
var filenameBase = "photoinspector";
if (_original != null)
{
if (_originalPath != null)
{
var originalPathParts = _originalPath.Split(new char[] { '_', '.' }, StringSplitOptions.RemoveEmptyEntries);
filenameBase += '_' + originalPathParts[1];
}
else
{
filenameBase += '_' + DateTime.UtcNow.Ticks.ToString();
using (var store = IsolatedStorageFile.GetUserStoreForApplication())
{
if (!store.DirectoryExists(Mapping.ORIGINALS_PATH))
{
store.CreateDirectory(Mapping.ORIGINALS_PATH);
}
var originalPath = Mapping.ORIGINALS_PATH + @"\" + filenameBase + @".jpg";
using (var file = store.CreateFile(originalPath))
{
_original.Position = 0;
_original.CopyTo(file);
file.Flush();
OriginalPath = originalPath;
}
}
}
}
filenameBase += '_' + DateTime.UtcNow.Ticks.ToString();
if (resizeConfiguration != null)
{
// Store high resolution original to application local storage
using (var store = IsolatedStorageFile.GetUserStoreForApplication())
{
if (!store.DirectoryExists(Mapping.LOCALS_PATH))
{
store.CreateDirectory(Mapping.LOCALS_PATH);
}
var localPath = Mapping.LOCALS_PATH + @"\" + filenameBase + @".jpg";
using (var file = store.CreateFile(localPath))
{
_image.Position = 0;
_image.CopyTo(file);
file.Flush();
LocalPath = localPath;
}
}
// Compact the buffer for saving to the library
buffer = await Nokia.Graphics.Imaging.JpegTools.AutoResizeAsync(buffer, resizeConfiguration);
}
using (var libraryImage = buffer.AsStream())
{
libraryImage.Position = 0;
using (var library = new MediaLibrary())
{
using (var picture = library.SavePictureToCameraRoll(filenameBase, libraryImage))
{
LibraryPath = picture.GetPath();
}
}
}
}
}
private async Task<IImageProvider> GetEffectInternal2Async(IImageProvider source, Windows.Foundation.Size sourceSize, Windows.Foundation.Size renderSize)
{
if (m_foregroundSource == null)
{
m_foregroundSource = new BufferImageSource(await PreloadedImages.Man.ConfigureAwait(false));
}
m_blendEffect.Source = source;
m_blendEffect.ForegroundSource = m_foregroundSource;
m_blendEffect.GlobalAlpha = m_globalAlpha;
m_blendEffect.BlendFunction = m_blendFunction;
return m_blendEffect;
}
