/// <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)
{
int minSide = (int)Math.Min(Width, Height);
Windows.Foundation.Rect rect = new Windows.Foundation.Rect()
{
Width = minSide,
Height = minSide,
X = (Width - minSide) / 2,
Y = (Height - minSide) / 2,
};
_session.AddFilter(FilterFactory.CreateCropFilter(rect));
Bitmap bitmap = new Bitmap(new Windows.Foundation.Size(side, side), ColorMode.Ayuv4444);
try
{
await _session.RenderToBitmapAsync(bitmap, OutputOption.Stretch);
}
catch (Exception ex)
{
bitmap = null;
}
_session.Undo();
return bitmap;
}
//extract Oriented ROI
public IBuffer GenerateOrientedROIPicture()
{
session.UndoAll();
var currentSize = new Size(
outputSize.Width / currentScale,
outputSize.Height / currentScale);
var corner = new Point(currentPos.X - currentSize.Width / 2, currentPos.Y - currentSize.Height / 2);
session.AddFilter(CreateOrientedROIFilter(new Rect(corner, currentSize), currentAngle));
var task = session.RenderToJpegAsync().AsTask();
task.Wait();
return(task.Result);
}
private async void task_Completed(object sender, PhotoResult e)
{
/* byte[] imageBits = new byte[(int)e.ChosenPhoto.Length];
e.ChosenPhoto.Read(imageBits, 0, imageBits.Length);
e.ChosenPhoto.Seek(0, System.IO.SeekOrigin.Begin);
MemoryStream screenshot = new MemoryStream(imageBits);
BitmapImage imageFromStream = new BitmapImage();
imageFromStream.SetSource(screenshot); */
Stream imgstream = e.ChosenPhoto;
//System.Windows.Media.Imaging.BitmapImage bmp = new System.Windows.Media.Imaging.BitmapImage();
//bmp.SetSource(e.ChosenPhoto);
//img.Source = bmp;
ApplyButton.Visibility = Visibility.Visible;
session = await EditingSessionFactory.CreateEditingSessionAsync(imgstream);
try
{
session.AddFilter(FilterFactory.CreateCartoonFilter(true));
// Save the image as a jpeg to the camera roll
using (MemoryStream stream = new MemoryStream())
{
WriteableBitmap bitmap = new WriteableBitmap(3552, 2448);
await session.RenderToWriteableBitmapAsync(bitmap);
bitmap.SaveJpeg(stream, bitmap.PixelWidth, bitmap.PixelHeight, 0, 100);
img.Source = bitmap;
}
//Force the framework to redraw the Image.
}
catch (Exception exception)
{
MessageBox.Show("Exception:" + exception.Message);
}
}
public async Task ApplyDifficultyToImage(Stream image, Difficulty level, Image resultImage)
{
try
{
using (EditingSession _session = await EditingSessionFactory.CreateEditingSessionAsync(image))
{
switch (level)
{
case Difficulty.Easy:
_session.AddFilter(_easyFilterGroup);
break;
case Difficulty.Moderate:
_session.AddFilter(_moderateFilterGroup);
break;
case Difficulty.Hard:
_session.AddFilter(_hardFilterGroup);
break;
case Difficulty.VeryHard:
_session.AddFilter(_veryHardFilterGroup);
break;
case Difficulty.ReallyHard:
_session.AddFilter(_impossibleFilterGroup);
break;
default:
break;
}
//Render the image to the Image control in the Quiz page
await _session.RenderToImageAsync(resultImage);
}
}
catch (Exception e)
{
MessageBox.Show("An error occurred while processing the image: " + e.Message);
}
}
/// <summary>
/// For the given bitmap renders filtered thumbnails for each filter in given list and populates
/// the given wrap panel with the them.
///
/// For quick rendering, renders 10 thumbnails synchronously and then releases the calling thread.
/// </summary>
/// <param name="bitmap">Source bitmap to be filtered</param>
/// <param name="side">Side length of square thumbnails to be generated</param>
/// <param name="list">List of filters to be used, one per each thumbnail to be generated</param>
/// <param name="panel">Wrap panel to be populated with the generated thumbnails</param>
private async Task RenderThumbnailsAsync(Bitmap bitmap, int side, List <FilterModel> list, WrapPanel panel)
{
using (EditingSession session = new EditingSession(bitmap))
{
int i = 0;
foreach (FilterModel filter in list)
{
WriteableBitmap writeableBitmap = new WriteableBitmap(side, side);
foreach (IFilter f in filter.Components)
{
session.AddFilter(f);
}
Windows.Foundation.IAsyncAction action = session.RenderToBitmapAsync(writeableBitmap.AsBitmap());
i++;
if (i % 10 == 0)
{
// async, give control back to UI before proceeding.
await action;
}
else
{
// synchroneous, we keep the CPU for ourselves.
Task task = action.AsTask();
task.Wait();
}
PhotoThumbnail photoThumbnail = new PhotoThumbnail()
{
Bitmap = writeableBitmap,
Text = filter.Name,
Width = side,
Margin = new Thickness(6)
};
photoThumbnail.Tap += (object sender, System.Windows.Input.GestureEventArgs e) =>
{
App.PhotoModel.ApplyFilter(filter);
App.PhotoModel.Dirty = true;
NavigationService.GoBack();
};
panel.Children.Add(photoThumbnail);
session.UndoAll();
}
}
}
private async void UpdatePreviewAsync()
{
using (EditingSession session = new EditingSession(previewBuffer))
{
// Add all previous filters
foreach (FilterBase filterContainer in filterManager.AppliedFilters)
{
if (filterContainer.IsFilterEnabled)
{
session.AddFilter(filterContainer.Filter);
}
}
await session.RenderToWriteableBitmapAsync(currentPreviewBitmap, OutputOption.PreserveAspectRatio);
currentPreviewBitmap.Invalidate();
}
}
private async void ApplyFilterToBackgroundImageAsync()
{
MemoryStream bitmapStream = new MemoryStream();
Source.SaveJpeg(bitmapStream, Source.PixelWidth, Source.PixelHeight, 0, 50);
IBuffer bmpBuffer = bitmapStream.GetWindowsRuntimeBuffer();
// Output buffer
WriteableBitmap outputImage = new WriteableBitmap(Source.PixelWidth, Source.PixelHeight);
using (EditingSession editsession = new EditingSession(bmpBuffer))
{
// First add an antique effect
editsession.AddFilter(FilterFactory.CreateBlurFilter(BlurLevel.Blur6));
// Finally, execute the filtering and render to a bitmap
await editsession.RenderToBitmapAsync(outputImage.AsBitmap());
outputImage.Invalidate();
FadeInNewImage(outputImage);
}
}
public async Task GetNewFrameAndApplyEffect(IBuffer processedBuffer)
{
if (captureDevice == null)
{
return;
}
captureDevice.GetPreviewBufferArgb(cameraBitmap.Pixels);
Bitmap outputBtm = new Bitmap(
outputBufferSize,
ColorMode.Bgra8888,
(uint)outputBufferSize.Width * 4, // 4 bytes per pixel in BGRA888 mode
processedBuffer);
EditingSession session = new EditingSession(cameraBitmap.AsBitmap());
session.AddFilter(FilterFactory.CreateSketchFilter(SketchMode.Gray));
await session.RenderToBitmapAsync(outputBtm);
}
private async void task_Completed(object sender, PhotoResult e)
{
/* byte[] imageBits = new byte[(int)e.ChosenPhoto.Length];
* e.ChosenPhoto.Read(imageBits, 0, imageBits.Length);
* e.ChosenPhoto.Seek(0, System.IO.SeekOrigin.Begin);
* MemoryStream screenshot = new MemoryStream(imageBits);
* BitmapImage imageFromStream = new BitmapImage();
* imageFromStream.SetSource(screenshot); */
Stream imgstream = e.ChosenPhoto;
//System.Windows.Media.Imaging.BitmapImage bmp = new System.Windows.Media.Imaging.BitmapImage();
//bmp.SetSource(e.ChosenPhoto);
//img.Source = bmp;
ApplyButton.Visibility = Visibility.Visible;
session = await EditingSessionFactory.CreateEditingSessionAsync(imgstream);
try
{
session.AddFilter(FilterFactory.CreateCartoonFilter(true));
// Save the image as a jpeg to the camera roll
using (MemoryStream stream = new MemoryStream())
{
WriteableBitmap bitmap = new WriteableBitmap(3552, 2448);
await session.RenderToWriteableBitmapAsync(bitmap);
bitmap.SaveJpeg(stream, bitmap.PixelWidth, bitmap.PixelHeight, 0, 100);
img.Source = bitmap;
}
//Force the framework to redraw the Image.
}
catch (Exception exception)
{
MessageBox.Show("Exception:" + exception.Message);
}
}
/// <summary>
/// Begins a photo stream item rendering process loop. Loop is executed asynchronously item by item
/// until there are no more items in the queue.
/// </summary>
private async void Process()
{
_processingNow++;
while (_enabled && Count > 0)
{
StreamItemViewModel item;
if (_priorityQueue.Count > 0)
{
Busy = true;
item = _priorityQueue[0];
_priorityQueue.RemoveAt(0);
}
else
{
item = _standardQueue[0];
_standardQueue.RemoveAt(0);
}
try
{
WriteableBitmap bitmap = null;
using (MemoryStream thumbnailStream = new MemoryStream())
{
System.Diagnostics.Debug.Assert(item.RequestedSize != StreamItemViewModel.Size.None);
if (item.RequestedSize == StreamItemViewModel.Size.Large)
{
bitmap = new WriteableBitmap(280, 280);
item.Model.Picture.GetImage().CopyTo(thumbnailStream);
}
else if (item.RequestedSize == StreamItemViewModel.Size.Medium)
{
bitmap = new WriteableBitmap(140, 140);
item.Model.Picture.GetThumbnail().CopyTo(thumbnailStream);
}
else
{
bitmap = new WriteableBitmap(70, 70);
item.Model.Picture.GetThumbnail().CopyTo(thumbnailStream);
}
using (EditingSession session = new EditingSession(thumbnailStream.GetWindowsRuntimeBuffer()))
{
Windows.Foundation.Rect rect;
if (session.Dimensions.Width > session.Dimensions.Height)
{
rect = new Windows.Foundation.Rect()
{
Width = session.Dimensions.Height,
Height = session.Dimensions.Height,
X = session.Dimensions.Width / 2 - session.Dimensions.Height / 2,
Y = 0
};
}
else
{
rect = new Windows.Foundation.Rect()
{
Width = session.Dimensions.Width,
Height = session.Dimensions.Width,
X = 0,
Y = session.Dimensions.Height / 2 - session.Dimensions.Width / 2
};
}
session.AddFilter(FilterFactory.CreateCropFilter(rect));
if (item.Model.Filter != null)
{
foreach (IFilter f in item.Model.Filter.Components)
{
session.AddFilter(f);
}
}
await session.RenderToBitmapAsync(bitmap.AsBitmap());
}
}
item.TransitionToImage(bitmap);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Rendering stream item failed:" + ex.Message);
item.TransitionToImage(null);
}
}
_processingNow--;
if (_processingNow == 0)
{
Busy = false;
}
}
public async void PrepareImageForUploadAsync()
{
WriteableBitmap bmp = new WriteableBitmap(OriginalImage);
bitmapStream = new MemoryStream();
bmp.SaveJpeg(bitmapStream, bmp.PixelWidth, bmp.PixelHeight, 0, 100);
IBuffer bmpBuffer = bitmapStream.GetWindowsRuntimeBuffer();
// Output buffer
bitmapForUpload = new WriteableBitmap(bmp.PixelWidth, bmp.PixelHeight);
using (EditingSession editsession = new EditingSession(bmpBuffer))
{
// First add an antique effect
foreach (FilterBase fx in FilterManager.AppliedFilters)
{
editsession.AddFilter(fx.FinalOutputFilter);
}
// Finally, execute the filtering and render to a bitmap
await editsession.RenderToBitmapAsync(bitmapForUpload.AsBitmap());
bitmapForUpload.Invalidate();
bitmapStream.Close();
bitmapStream = null;
}
Dispatcher.BeginInvoke(() => {
BeginUpload();
});
}
private async void ApplyExecute()
{
IsWorking = true;
if (_editingSession == null || _noChanges)
{
return;
}
if (!CanApply)
{
_queued = true;
return;
}
CanApply = false;
_filterApplied = true;
if (_filterApplied && _editingSession.CanUndo())
{
try { _editingSession.Undo(); }
catch (Exception e)
{
App.LogError(e);
}
}
// apply filter to selected pixels only
PreviewImage = new WriteableBitmap(ImageWidth, ImageHeight);
_buffer.CopyTo(PreviewImage.Pixels, 0);
using (var ms = PreviewImage.ToStream())
{
var editingSession = await EditingSessionFactory.CreateEditingSessionAsync(ms);
editingSession.AddFilter(SelectedFilter.Creator());
await editingSession.RenderToWriteableBitmapAsync(PreviewImage);
}
// remove unnecessary pixels
//var removal = ClearTransparent ? Constants.White & 0xFFFFFF : Constants.White;
// transparent white
var removal = (0xFF << 24) |
(Grayscale << 16) |
(Grayscale << 8) |
(Grayscale);
for (var i = 0; i < PreviewImage.Pixels.Length; ++i)
{
if (_maskBuffer[i] == 0)
{
PreviewImage.Pixels[i] = removal;
}
if (_maskBuffer[i] != 0)
{
MainImage.Pixels[i] = ((Grayscale2 << 16) | (Grayscale2 << 8) | Grayscale2) | ((255 - _maskBuffer[i]) << 24);
}
else
{
MainImage.Pixels[i] = _backup.Pixels[i];
}
}
#if DEBUG
try
{
using (var fileStream = _isoStore.CreateFile("MainImage.jpg"))
MainImage.SaveJpeg(fileStream, ImageWidth, ImageHeight, 0, 100);
using (var fileStream = _isoStore.CreateFile("PreviewImage.jpg"))
PreviewImage.SaveJpeg(fileStream, ImageWidth, ImageHeight, 0, 100);
}
catch (Exception e)
{
App.LogError(e);
}
#endif
using (var ms = MainImage.ToStream())
{
Helpers.SafeDispose(ref _editingSession);
_editingSession = await EditingSessionFactory.CreateEditingSessionAsync(ms);
}
using (var ms = PreviewImage.ToStream())
using (var blendingSession = await EditingSessionFactory.CreateEditingSessionAsync(ms))
{
PreviewImage.Invalidate();
_editingSession.AddFilter(FilterFactory.CreateBlendFilter(blendingSession, SelectedBlendFunction));
var temp = new WriteableBitmap(MainImage.PixelWidth, MainImage.PixelHeight);
await _editingSession.RenderToWriteableBitmapAsync(temp);
MainImage = temp;
if (SelectedTool != null)
{
SelectedTool.TargetImage = MainImage;
}
UndoCommand.RaiseCanExecuteChanged();
CanApply = true;
}
if (_queued)
{
_queued = false;
ApplyExecute();
}
IsWorking = false;
}
/// <summary>
/// For the given bitmap renders filtered thumbnails for each filter in given list and populates
/// the given wrap panel with the them.
///
/// For quick rendering, renders 10 thumbnails synchronously and then releases the calling thread.
/// </summary>
/// <param name="bitmap">Source bitmap to be filtered</param>
/// <param name="side">Side length of square thumbnails to be generated</param>
/// <param name="list">List of filters to be used, one per each thumbnail to be generated</param>
/// <param name="panel">Wrap panel to be populated with the generated thumbnails</param>
private async Task RenderThumbnailsAsync(Bitmap bitmap, int side, List <FilterModel> list, WrapPanel FiltersWrapPanel)
{
using (EditingSession session = new EditingSession(bitmap))
{
//render filtered photo
int i = 0;
foreach (FilterModel filter in list)
{
WriteableBitmap writeableBitmap = new WriteableBitmap(side, side);
//crop the bitmap
foreach (IFilter f in filter.Components)
{
session.AddFilter(f);
}
Windows.Foundation.IAsyncAction action = session.RenderToBitmapAsync(writeableBitmap.AsBitmap());
i++;
if (i % 10 == 0)
{
// async, give control back to UI before proceeding.
await action;
}
else
{
// synchroneous, we keep the CPU for ourselves.
Task task = action.AsTask();
task.Wait();
}
PhotoThumbnail photoThumbnail = new PhotoThumbnail()
{
Bitmap = writeableBitmap,
Text = filter.Name,
Width = side,
Margin = new Thickness(6)
};
photoThumbnail.Tap += async delegate
{
ProgressIndicator.IsRunning = true;
SetScreenButtonsEnabled(false);
App.ThumbnailModel.UndoAllFilters();
App.ThumbnailModel.ApplyFilter(filter, _shouldCrop);
App.ThumbnailModel.Dirty = true;
WriteableBitmap photo = new WriteableBitmap((int)App.ThumbnailModel.Width, (int)App.ThumbnailModel.Height);
await App.ThumbnailModel.RenderBitmapAsync(photo);
PhotoViewer.Source = photo;
SetScreenButtonsEnabled(true);
ProgressIndicator.IsRunning = false;
};
FiltersWrapPanel.Children.Add(photoThumbnail);
session.UndoAll();
}
}
ProgressIndicator.IsRunning = false;
}
public async Task GetNewFrameAndApplyEffect(IBuffer processedBuffer)
{
if (captureDevice == null)
{
return;
}
captureDevice.GetPreviewBufferArgb(cameraBitmap.Pixels);
var outputBtm = new Bitmap(
outputBufferSize,
ColorMode.Bgra8888,
(uint)outputBufferSize.Width * 4, // 4 bytes per pixel in BGRA888 mode
processedBuffer);
using (var session = new EditingSession(cameraBitmap.AsBitmap()))
{
switch (effectIndex)
{
case 0:
session.AddFilter(FilterFactory.CreateLomoFilter(0.5, 0.5, LomoVignetting.High, LomoStyle.Yellow));
break;
case 1:
session.AddFilter(FilterFactory.CreateMagicPenFilter());
break;
case 2:
session.AddFilter(FilterFactory.CreateGrayscaleFilter());
break;
case 3:
session.AddFilter(FilterFactory.CreateAntiqueFilter());
break;
case 4:
session.AddFilter(FilterFactory.CreateStampFilter(5, 100));
break;
case 5:
session.AddFilter(FilterFactory.CreateCartoonFilter(false));
break;
}
await session.RenderToBitmapAsync(outputBtm);
}
}
private async void SplitImageFromBitmap(WriteableBitmap bmp)
{
_session = new EditingSession(bmp.AsBitmap());
if (playMode == PlayMode.CameraVideo) _session.AddFilter(FilterFactory.CreateStepRotationFilter(Rotation.Rotate90));
if (playMode == PlayMode.CameraVideo) _session.AddFilter(FilterFactory.CreateCropFilter(new Windows.Foundation.Rect(15, 20, 450, 600)));
IFilter selectedFilter = GetFilter();
try
{
if (Utils.IsChallengeMode())
{
foreach (Image img in images)
{
_session.AddFilter(FilterFactory.CreateCropFilter(new Windows.Foundation.Rect(images.IndexOf(img) % 3 * 150, images.IndexOf(img) / 3 * 150, 150, 150)));
if (selectedFilter != null ) _session.AddFilter(selectedFilter);
await _session.RenderToImageAsync(img, OutputOption.PreserveAspectRatio);
if (selectedFilter != null && _session.CanUndo()) _session.Undo();
if (_session.CanUndo()) _session.Undo();
}
}
else
{
foreach (Image img in images)
{
_session.AddFilter(FilterFactory.CreateCropFilter(new Windows.Foundation.Rect(images.IndexOf(img) % 6 * 75, images.IndexOf(img) / 6 * 75, 75, 75)));
if (selectedFilter != null) _session.AddFilter(selectedFilter);
await _session.RenderToImageAsync(img, OutputOption.PreserveAspectRatio);
if (selectedFilter != null && _session.CanUndo()) _session.Undo();
if (_session.CanUndo()) _session.Undo();
}
}
}
catch (Exception exception)
{
MessageBox.Show("Exception:" + exception.Message);
return;
}
if (playMode == PlayMode.CameraVideo) { processNextFrame(); }
}
private async void SplitImage(Stream stream)
{
int dimension;
_session = await EditingSessionFactory.CreateEditingSessionAsync(stream);
IFilter selectedFilter = GetFilter();
if (Utils.IsChallengeMode())
{
dimension = 150;
}
else
{
dimension = 75;
}
try
{
stream.Position = 0;
foreach (Image img in images)
{
_session.UndoAll();
_session.AddFilter(FilterFactory.CreateCropFilter(new Windows.Foundation.Rect(Canvas.GetLeft(img), Canvas.GetTop(img), dimension, dimension)));
if (selectedFilter != null) _session.AddFilter(selectedFilter);
await _session.RenderToImageAsync(img, OutputOption.PreserveAspectRatio);
}
progressbarIndeterminateDownload.Visibility = System.Windows.Visibility.Collapsed;
progressbarDescription.Visibility = System.Windows.Visibility.Collapsed;
isLoading = false;
playButton.Visibility = System.Windows.Visibility.Visible;
}
catch (Exception exception)
{
MessageBox.Show("Exception:" + exception.Message);
return;
}
}
private async System.Threading.Tasks.Task Capture()
{
try
{
await camera.FocusAsync();
MemoryStream imageStream = new MemoryStream();
imageStream.Seek(0, SeekOrigin.Begin);
CameraCaptureSequence sequence = camera.CreateCaptureSequence(1);
sequence.Frames[0].CaptureStream = imageStream.AsOutputStream();
await camera.PrepareCaptureSequenceAsync(sequence);
await sequence.StartCaptureAsync();
camera.SetProperty(
KnownCameraPhotoProperties.LockedAutoFocusParameters,
AutoFocusParameters.None);
MediaLibrary library = new MediaLibrary();
EditingSession session = new EditingSession(imageStream.GetWindowsRuntimeBuffer());
using (session)
{
session.AddFilter(FilterFactory.CreateSketchFilter(SketchMode.Gray));
IBuffer data = await session.RenderToJpegAsync();
library.SavePictureToCameraRoll(FileNamePrefix
+ DateTime.Now.ToString() + ".jpg",
data.AsStream());
}
}
catch (Exception ex)
{
Debug.WriteLine("Failed to save the image to camera roll: " + ex.ToString());
}
}
/// <summary>
/// For the given bitmap renders filtered thumbnails for each filter in given list and populates
/// the given wrap panel with the them.
///
/// For quick rendering, renders 10 thumbnails synchronously and then releases the calling thread.
/// </summary>
/// <param name="bitmap">Source bitmap to be filtered</param>
/// <param name="side">Side length of square thumbnails to be generated</param>
/// <param name="list">List of filters to be used, one per each thumbnail to be generated</param>
/// <param name="panel">Wrap panel to be populated with the generated thumbnails</param>
private async Task RenderThumbnailsAsync(Bitmap bitmap, int side, List<FilterModel> list, WrapPanel panel)
{
using (EditingSession session = new EditingSession(bitmap))
{
int i = 0;
foreach (FilterModel filter in list)
{
WriteableBitmap writeableBitmap = new WriteableBitmap(side, side);
foreach (IFilter f in filter.Components)
{
session.AddFilter(f);
}
Windows.Foundation.IAsyncAction action = session.RenderToBitmapAsync(writeableBitmap.AsBitmap());
i++;
if (i % 10 == 0)
{
// async, give control back to UI before proceeding.
await action;
}
else
{
// synchroneous, we keep the CPU for ourselves.
Task task = action.AsTask();
task.Wait();
}
PhotoThumbnail photoThumbnail = new PhotoThumbnail()
{
Bitmap = writeableBitmap,
Text = filter.Name,
Width = side,
Margin = new Thickness(6)
};
photoThumbnail.Tap += (object sender, System.Windows.Input.GestureEventArgs e) =>
{
App.PhotoModel.ApplyFilter(filter);
App.PhotoModel.Dirty = true;
NavigationService.GoBack();
};
panel.Children.Add(photoThumbnail);
session.UndoAll();
}
}
}
/// <summary>
/// Begins a photo stream item rendering process loop. Loop is executed asynchronously item by item
/// until there are no more items in the queue.
/// </summary>
private async void Process()
{
_processingNow++;
while (_enabled && Count > 0)
{
StreamItemViewModel item;
if (_priorityQueue.Count > 0)
{
Busy = true;
item = _priorityQueue[0];
_priorityQueue.RemoveAt(0);
}
else
{
item = _standardQueue[0];
_standardQueue.RemoveAt(0);
}
try
{
WriteableBitmap bitmap = null;
using (MemoryStream thumbnailStream = new MemoryStream())
{
System.Diagnostics.Debug.Assert(item.RequestedSize != StreamItemViewModel.Size.None);
if (item.RequestedSize == StreamItemViewModel.Size.Large)
{
bitmap = new WriteableBitmap(280, 280);
item.Model.Picture.GetImage().CopyTo(thumbnailStream);
}
else if (item.RequestedSize == StreamItemViewModel.Size.Medium)
{
bitmap = new WriteableBitmap(140, 140);
item.Model.Picture.GetThumbnail().CopyTo(thumbnailStream);
}
else
{
bitmap = new WriteableBitmap(70, 70);
item.Model.Picture.GetThumbnail().CopyTo(thumbnailStream);
}
using (EditingSession session = new EditingSession(thumbnailStream.GetWindowsRuntimeBuffer()))
{
Windows.Foundation.Rect rect;
if (session.Dimensions.Width > session.Dimensions.Height)
{
rect = new Windows.Foundation.Rect()
{
Width = session.Dimensions.Height,
Height = session.Dimensions.Height,
X = session.Dimensions.Width / 2 - session.Dimensions.Height / 2,
Y = 0
};
}
else
{
rect = new Windows.Foundation.Rect()
{
Width = session.Dimensions.Width,
Height = session.Dimensions.Width,
X = 0,
Y = session.Dimensions.Height / 2 - session.Dimensions.Width / 2
};
}
session.AddFilter(FilterFactory.CreateCropFilter(rect));
if (item.Model.Filter != null)
{
foreach (IFilter f in item.Model.Filter.Components)
{
session.AddFilter(f);
}
}
await session.RenderToBitmapAsync(bitmap.AsBitmap());
}
}
item.TransitionToImage(bitmap);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Rendering stream item failed:" + ex.Message);
item.TransitionToImage(null);
}
}
_processingNow--;
if (_processingNow == 0)
{
Busy = false;
}
}
