private async void UndoExecute()
{
_buffer = new int[MainImage.PixelWidth * MainImage.PixelHeight];
_maskBuffer = new byte[MainImage.PixelWidth * MainImage.PixelHeight];
_filterApplied = false;
_originalStream.Seek(0, SeekOrigin.Begin);
_editingSession = await EditingSessionFactory.CreateEditingSessionAsync(_originalStream);
await _editingSession.RenderToWriteableBitmapAsync(MainImage);
MainImage.Invalidate();
CanApply = false;
_noChanges = true;
UndoCommand.RaiseCanExecuteChanged();
if (PreviewImage != null)
{
for (var i = 0; i < PreviewImage.Pixels.Length; ++i)
{
PreviewImage.Pixels[i] = 0;
}
PreviewImage.Invalidate();
}
BindTool();
}
private async Task ShowImageAsync()
{
_originalStream.Seek(0, SeekOrigin.Begin);
Helpers.SafeDispose(ref _editingSession);
_editingSession = await EditingSessionFactory.CreateEditingSessionAsync(_originalStream);
ImageWidth = (int)_editingSession.Dimensions.Width;
ImageHeight = (int)_editingSession.Dimensions.Height;
MainImage = new WriteableBitmap(ImageWidth, ImageHeight);
await _editingSession.RenderToWriteableBitmapAsync(MainImage);
_buffer = new int[MainImage.PixelWidth * MainImage.PixelHeight];
_maskBuffer = new byte[MainImage.PixelWidth * MainImage.PixelHeight];
_oldPixels = new int[MainImage.PixelWidth * MainImage.PixelHeight];
MainImage.Pixels.CopyTo(_oldPixels, 0);
MainImage.Invalidate();
PreviewImage = null;
BindTool();
if (_backup == null)
{
_backup = new WriteableBitmap(MainImage.PixelWidth, MainImage.PixelHeight);
MainImage.Pixels.CopyTo(_backup.Pixels, 0);
}
CanApply = false;
HasImage = true;
}
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);
}
}
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);
}
}
private async void ApplyExecute()
{
if (FirstImage == null || SecondImage == null)
{
return;
}
if (_inProgress)
{
_queuedApply = true;
return;
}
FilterApplied = false;
_inProgress = true;
using (var firstStream = FirstImage.ToStream())
using (var secondStream = SecondImage.ToStream())
using (var session = await EditingSessionFactory.CreateEditingSessionAsync(firstStream))
using (var blendingSession = await EditingSessionFactory.CreateEditingSessionAsync(secondStream))
{
session.AddFilter(FilterFactory.CreateBlendFilter(blendingSession, SelectedBlendFunction));
var wb = new WriteableBitmap(FirstImage.PixelWidth, FirstImage.PixelHeight);
await session.RenderToWriteableBitmapAsync(wb);
BlendedImage = wb;
}
_inProgress = false;
FilterApplied = true;
if (_queuedApply)
{
_queuedApply = false;
ApplyExecute();
}
}
async void setInput(Stream s)
{
//Dispose old session ressources.
if (session != null)
{
session.Dispose();
session = null;
}
//reset stream position
s.Seek(0, SeekOrigin.Begin);
//create a session
var tmpsession = await EditingSessionFactory.CreateEditingSessionAsync(s);
tmpsession.AddFilter(FilterFactory.CreateCropFilter(new Rect(0, 0, 1, 1)));
var foo = await tmpsession.RenderToJpegAsync();
tmpsession.UndoAll();
session = tmpsession;
inputSize = new Size()
{
Width = session.Dimensions.Width, Height = session.Dimensions.Height
};
currentPos = new Point(session.Dimensions.Width / 2, session.Dimensions.Height / 2);
if (session.Dimensions.Width > session.Dimensions.Height)
{
currentScale = output.Height / session.Dimensions.Height;
}
else
{
currentScale = output.Width / session.Dimensions.Width;
}
currentAngle = 0.0;
saveLastPossaveLastPositionData();
requestProcessing();
}
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;
}
private async void ChooseExecute()
{
CanChoose = false;
try
{
var chooser = new PhotoChooserTask {
ShowCamera = true
};
var first = await chooser.ShowAsync();
if (first.ChosenPhoto == null)
{
var prompt = new ToastPrompt {
Message = "Gotta choose something man..."
};
prompt.Show();
return;
}
var second = await chooser.ShowAsync();
if (second.ChosenPhoto == null)
{
var prompt = new ToastPrompt {
Message = "Also choose second one..."
};
prompt.Show();
return;
}
var bi1 = new BitmapImage();
bi1.SetSource(first.ChosenPhoto);
var bi2 = new BitmapImage();
bi2.SetSource(second.ChosenPhoto);
WriteableBitmap wb1;
WriteableBitmap wb2;
if (bi2.PixelHeight != bi1.PixelHeight || bi2.PixelWidth != bi1.PixelWidth)
{
// sorry for bad croping
var toast = new ToastPrompt {
Message = "images are not of the same size, lame cropping incoming :/"
};
toast.Show();
EditingSession session1 = null, session2 = null;
using (var stream1 = bi1.ToStream())
using (var stream2 = bi2.ToStream())
try
{
var task1 = EditingSessionFactory.CreateEditingSessionAsync(stream1);
var task2 = EditingSessionFactory.CreateEditingSessionAsync(stream2);
var sessions = await Task.WhenAll(task1, task2);
session1 = task1.Result;
session2 = task2.Result;
var cropRect = new Windows.Foundation.Rect(0, 0,
Math.Min(bi1.PixelWidth, bi2.PixelWidth),
Math.Min(bi1.PixelHeight, bi2.PixelHeight));
sessions[0].AddFilter(FilterFactory.CreateCropFilter(cropRect));
sessions[1].AddFilter(FilterFactory.CreateCropFilter(cropRect));
wb1 = new WriteableBitmap((int)cropRect.Width, (int)cropRect.Height);
wb2 = new WriteableBitmap((int)cropRect.Width, (int)cropRect.Height);
await Task.WhenAll(
sessions[0].RenderToWriteableBitmapAsync(wb1),
sessions[1].RenderToWriteableBitmapAsync(wb2)
);
}
finally
{
Helpers.SafeDispose(ref session1);
Helpers.SafeDispose(ref session2);
}
}
else
{
wb1 = new WriteableBitmap(bi1);
wb2 = new WriteableBitmap(bi2);
}
// save images
using (var isoStore = IsolatedStorageFile.GetUserStoreForApplication())
using (IsolatedStorageFileStream fileStream1 = isoStore.CreateFile(FirstFileName),
fileStream2 = isoStore.CreateFile(SecondFileName))
{
wb1.SaveJpeg(fileStream1, wb1.PixelWidth, wb1.PixelHeight, 0, 100);
wb2.SaveJpeg(fileStream2, wb2.PixelWidth, wb2.PixelHeight, 0, 100);
}
FirstImage = wb1;
SecondImage = wb2;
ApplyExecute();
}
catch (Exception e)
{
MessageBox.Show(e.ToString());
}
finally
{
CanChoose = true;
}
}
