private async void AttemptSave()
{
if (Processing)
{
return;
}
Processing = true;
GC.Collect();
var lowMemory = false;
try
{
var result = (long)DeviceExtendedProperties.GetValue("ApplicationWorkingSetLimit");
lowMemory = result / 1024 / 1024 < 300;
}
catch (ArgumentOutOfRangeException)
{
}
IBuffer buffer;
Model.OriginalImage.Position = 0;
using (var source = new StreamImageSource(Model.OriginalImage))
using (var segmenter = new InteractiveForegroundSegmenter(source))
using (var annotationsSource = new BitmapImageSource(Model.AnnotationsBitmap))
{
segmenter.Quality = lowMemory ? 0.5 : 1;
segmenter.AnnotationsSource = annotationsSource;
var foregroundColor = Model.ForegroundBrush.Color;
var backgroundColor = Model.BackgroundBrush.Color;
segmenter.ForegroundColor = Windows.UI.Color.FromArgb(foregroundColor.A, foregroundColor.R, foregroundColor.G, foregroundColor.B);
segmenter.BackgroundColor = Windows.UI.Color.FromArgb(backgroundColor.A, backgroundColor.R, backgroundColor.G, backgroundColor.B);
using (var effect = new LensBlurEffect(source, new LensBlurPredefinedKernel(Shape, (uint)SizeSlider.Value)))
using (var renderer = new JpegRenderer(effect))
{
effect.KernelMap = segmenter;
buffer = await renderer.RenderAsync();
}
}
using (var library = new MediaLibrary())
using (var stream = buffer.AsStream())
{
library.SavePicture("lensblur_" + DateTime.Now.Ticks, stream);
Model.Saved = true;
AdaptButtonsToState();
}
Processing = false;
}
private void SetUIMeasurements(int selectedRoofIndex)
{
try
{
if (_property == null || _image == null)
{
return;
}
// Recalculate roof totals for current property
CalculateCurrentTotals(_property);
// Materialize view
_recalculated = GetViewModelFromProperty(_property, selectedRoofIndex > 0 ?
_property.Roofs.FirstOrDefault(x => x.RoofId == (selectedRoofIndex - 1).ToString()) : null);
// Set GUI and event handlers
var stream = new StreamImageSource();
stream.Stream = (x) =>
{
return(Task.FromResult <Stream>(new MemoryStream(_image.Image)));
};
OrderId = $"Order ID: {_order.OrderId}";
PredominantPitch = $"{_recalculated.CurrentPitch}:12";
NumberOfPitches = $"Number of Distinct Pitches Measured: {_recalculated.PitchCount}";
ImageSource = stream;
Address = StringUtility.RemoveEmptyLines(_property.Address);
Area = $"{Convert.ToInt64(_recalculated.Roofs.Sum(x => x.TotalArea)).ToString()} sq. ft.";
Squares = $"Total Squares: {_recalculated.Roofs.Sum(x => x.TotalSquares).ToString()} squares";
}
catch (Exception ex)
{
_logger.LogError($"Failed to set UI to new measurements.", ex);
}
RefreshTableView(_recalculated.Roofs.Sum(x => x.TotalArea));
}
protected override void OnPaintSurface(SKPaintSurfaceEventArgs e)
{
Trace.WriteLine($"{GetType().Name} OnPaintSurface");
SKImageInfo info = e.Info;
SKSurface surface = e.Surface;
SKCanvas canvas = surface.Canvas;
using (var snap = surface.Snapshot())
{
using (var paint = new SKPaint())
{
Debug.WriteLine($"Source={Source.ToString()}");
if (Source is StreamImageSource)
{
// 一部だけ切り出そうにも土台のサイズがわからない
StreamImageSource streamImageSource = (StreamImageSource)Source;
CancellationToken cancellationToken = CancellationToken.None;
Task <Stream> task = streamImageSource.Stream(cancellationToken);
Stream stream = task.Result;
var sKBitmap = SKBitmap.Decode(stream);
paint.ImageFilter = SKImageFilter.CreateBlur(1, 1);
canvas.DrawBitmap(sKBitmap, info.Rect, paint);
}
}
}
}
public static ImageSource ByteToImage(byte[] imageByte)
{
//! Esse linha de código abaixo só funciona com o '() =>' (Func<T>'
var returnImage = StreamImageSource.FromStream(() => new MemoryStream(imageByte));
return(returnImage);
}
public async Task Add(Media media)
{
DataManager dataManager = DataManager.Instance;
MemoryStream stream = null;
DataObjects.Media dataMedia = null;
FileImageSource fileImageSource = null;
fileImageSource = media.Image as FileImageSource;
Stream downsampleStream = null;
// If this is still from a file downsample it to be stored in the database
if (fileImageSource != null)
{
downsampleStream = await ImageService.Instance.LoadFile(fileImageSource.File).DownSample(width: 300).AsJPGStreamAsync();
}
else
{
StreamImageSource streamsource = media.Image as StreamImageSource;
if (streamsource != null)
{
downsampleStream = await ImageService.Instance.LoadStream(
sct => {
return(((IStreamImageSource)streamsource).GetStreamAsync());
}).DownSample(width: 300).AsJPGStreamAsync();
}
}
if (downsampleStream != null)
{
stream = new MemoryStream();
await downsampleStream.CopyToAsync(stream);
if (Device.RuntimePlatform == Device.iOS)
{
// Lets use the downsample one rather the big-size image selected by user to lower the app memory usage
// (Actually we are using the downsample one from datamanger when the app starts)
stream.Seek(0, SeekOrigin.Begin);
media.Image = ImageSource.FromStream(() => stream);
}
}
if (stream != null)
{
// Add to the Data Manager
dataMedia = new DataObjects.Media()
{
Id = Guid.NewGuid().ToString(),
Type = (byte)MediaType.Image,
Data = stream.ToArray()
};
await dataManager.AddMedia(dataMedia);
media.Id = dataMedia.Id;
_media.Add(media);
}
}
async void pct_Completed(object sender, PhotoResult e)
{
if (e.TaskResult != TaskResult.OK || e.ChosenPhoto == null)
return;
try
{
// Create a source to read the image from PhotoResult stream
using (var source = new StreamImageSource(e.ChosenPhoto))
{
using (var effect = new PixlateEffect(source))
{
_effect = effect;
var target = new WriteableBitmap((int)ResultImage.ActualWidth, (int)ResultImage.ActualHeight);
// Create a new renderer which outputs WriteableBitmaps
using (var renderer = new WriteableBitmapRenderer(effect, target))
{
// Render the image with the filter(s)
await renderer.RenderAsync();
// Set the output image to Image control as a source
ResultImage.Source = target;
}
}
}
}
catch (Exception exception)
{
MessageBox.Show(exception.Message);
return;
}
}
public async Task InitializeAsync()
{
//Using the built-in FileImageSource would be much less code than manually creating
//a StreamImageSource. However, the FileImageSource doesn't appear to release the
//lock on the file that it displays, so attempting to delete the file causes an
//"Access Denied" error in the UWP app. So here we copy the file into memory and
//immediately dispose the FileStream.
byte[] fileBytes;
string fileName = FileReference.FileName;
// we need to reconstruct the path at runtime because on iOS when rebuilding/redeploying the debug
// app due to an actual source change, the OS renames the directory, specifically changing the application GUID part of the directory name.
// So the photo files are there, but nested inside an applicaton directory with a new name.
// Upon starting the new deployment of the rebuilt app, the saved pictures cannot be found and displayed by the app
// using the old directory path because the application directory has changed.
var documentsPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
var fullPath = Path.Combine(documentsPath, fileName);
using (var fileStream = await Task.Run(() => File.OpenRead(fullPath)))
{
fileBytes = new byte[fileStream.Length];
fileStream.Read(fileBytes, 0, (int)(fileStream.Length));
}
Func <System.Threading.CancellationToken, Task <Stream> > getStreamFunc =
ct => Task.FromResult((Stream)(new MemoryStream(fileBytes)));
ImageSource = new StreamImageSource()
{
Stream = getStreamFunc
};
}
public static Task <SKImage?> ToSKImageAsync(this ImageSource imageSource, CancellationToken cancellationToken = default)
{
if (imageSource == null)
{
throw new ArgumentNullException(nameof(imageSource));
}
return(imageSource switch
{
// 1. first try SkiaSharp sources
SKImageImageSource iis => FromSkia(iis.Image),
SKBitmapImageSource bis => FromSkia(SKImage.FromBitmap(bis.Bitmap)),
SKPixmapImageSource xis => FromSkia(SKImage.FromPixels(xis.Pixmap)),
SKPictureImageSource pis => FromSkia(SKImage.FromPicture(pis.Picture, pis.Dimensions)),
// 2. then try Stream sources
StreamImageSource stream => FromStream(stream.Stream.Invoke(cancellationToken)),
UriImageSource uri => FromStream(uri.GetStreamAsync(cancellationToken)),
// 3. finally, use the handlers
FileImageSource file => FromHandler(PlatformToSKImageAsync(file, cancellationToken)),
FontImageSource font => FromHandler(PlatformToSKImageAsync(font, cancellationToken)),
// 4. all is lost
_ => throw new ArgumentException("Unable to determine the type of image source.", nameof(imageSource))
});
public async Task <StorageFile> ApplyFilter(StorageFile file, FilterOption filterOption)
{
IImageProvider source = null;
var properties = await file.Properties.GetImagePropertiesAsync();
this.SelectFilter(filterOption);
using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
source = new StreamImageSource(stream.AsStream(), ImageFormat.Jpeg);
using (var filterEffect = new FilterEffect(source))
{
// Initialize the filter and add the filter to the FilterEffect collection
//var filter = new SketchFilter(SketchMode.Gray);
filterEffect.Filters = new IFilter[] { this.SelectedFilter };
// Create a target where the filtered image will be rendered to
var target = new WriteableBitmap((int)properties.Width, (int)properties.Height);
// Create a new renderer which outputs WriteableBitmaps
using (var renderer = new WriteableBitmapRenderer(filterEffect, target))
{
// Render the image with the filter(s)
await renderer.RenderAsync();
return(await this.WriteableBitmapToStorageFile(target, FileFormat.Jpeg));
}
}
}
}
async void proofButton_Clicked(object sender, System.EventArgs e)
{
try
{
ICameraProvider cameraProvider = DependencyService.Get <ICameraProvider>();
var myImage = await cameraProvider.AcquirePicture();
StreamImageSource streamImageSource = (StreamImageSource)myImage;
System.Threading.CancellationToken cancellationToken = System.Threading.CancellationToken.None;
Task <Stream> task = streamImageSource.Stream(cancellationToken);
Stream stream = task.Result;
var memoryStream = new MemoryStream();
stream.CopyTo(memoryStream);
Console.WriteLine("Wrote The Stream" + memoryStream.ToArray().Length);
base64String = DependencyService.Get <MyImageCompressor>().ImageCompressor(memoryStream.ToArray());
Console.WriteLine("base64 String : " + base64String);
}
catch (Exception CameraException)
{
//No camera presenet or no access provided.So, instead of crashing, let's not get the data.
Console.WriteLine("Exception CameraException : " + CameraException);
await DisplayAlert("No Camera Found!", "I could not get access to your camera.", "Ok");
}
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
if (value != null)
{
var filePath = value as string;
try
{
TagLib.File tagFile = TagLib.File.Create(filePath); //can throw exception: mpeg header not found
//TODO: потрібно доробити щоб закривати стрим
var mStream = new MemoryStream();
var firstPicture = tagFile.Tag.Pictures.FirstOrDefault();
if (firstPicture != null)
{
byte[] pData = firstPicture.Data.Data;
mStream.Write(pData, 0, System.Convert.ToInt32(pData.Length));
System.Diagnostics.Debug.WriteLine("pData.Length: " + pData.Length);
System.Diagnostics.Debug.WriteLine("mStream.Length: " + mStream.Length);
var source = StreamImageSource.FromStream(() => mStream);
return(source);
}
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e.Message);
}
}
return(parameter);
}
private async void RecoverValues(string entry)
{
foreach (WorkModel.WorkEntry e in NewBook.Entries)
{
if (entry == e.Name)
{
NewEntry = e;
break;
}
}
if (NewEntry.ImageChanged)
{
ImageSource = (StreamImageSource)Xamarin.Forms.ImageSource.FromStream(() => new MemoryStream(NewEntry.NewImageData));
}
else
{
NewEntry.OldImagePath = NewEntry.ImagePath;
ImageSource = await FileManager.GetImage(NewEntry.ImagePath);
}
NewName = NewEntry.Name;
Description = NewEntry.Description;
foreach (WorkTag t in NewEntry.Tags)
{
CurrentTags.Add(t);
}
}
public AnalyseImageResultPageViewModel(StreamImageSource photo, IList <DetectedFace> faces)
{
AnalysedPhoto = photo;
var emotions = faces.Select(face => GetEmotion(face));
Description = "Most likely emotion: " + emotions.FirstOrDefault().Key + " with a score of " + emotions.FirstOrDefault().Value.ToString();
}
private void Button_Click(object sender, RoutedEventArgs e)
{
try
{
PhotoChooserTask task = new PhotoChooserTask();
task.Completed += async (s, res) =>
{
if (res.TaskResult == TaskResult.OK)
{
using( var source = new StreamImageSource(res.ChosenPhoto))
using(var renderer = new BitmapRenderer(source,input))
{
await renderer.RenderAsync();
}
if(manager != null)
{
manager.Dispose();
manager = null;
}
manager = new PipelineManager.Manager.PipelineManager(picture);
GeneratePicture();
}
};
task.Show();
}
catch (Exception)
{
}
}
private async void AttemptUpdatePreviewAsync()
{
if (!Processing)
{
Processing = true;
AdaptButtonsToState();
Model.OriginalImage.Position = 0;
using (var source = new StreamImageSource(Model.OriginalImage))
using (var segmenter = new InteractiveForegroundSegmenter(source))
using (var annotationsSource = new BitmapImageSource(Model.AnnotationsBitmap))
{
segmenter.Quality = 0.5;
segmenter.AnnotationsSource = annotationsSource;
var foregroundColor = Model.ForegroundBrush.Color;
var backgroundColor = Model.BackgroundBrush.Color;
segmenter.ForegroundColor = Windows.UI.Color.FromArgb(foregroundColor.A, foregroundColor.R, foregroundColor.G, foregroundColor.B);
segmenter.BackgroundColor = Windows.UI.Color.FromArgb(backgroundColor.A, backgroundColor.R, backgroundColor.G, backgroundColor.B);
do
{
_processingPending = false;
var previewBitmap = new WriteableBitmap((int)Model.AnnotationsBitmap.Dimensions.Width, (int)Model.AnnotationsBitmap.Dimensions.Height);
using (var effect = new LensBlurEffect(source, new LensBlurPredefinedKernel(Model.KernelShape, (uint)Model.KernelSize)))
using (var renderer = new WriteableBitmapRenderer(effect, previewBitmap))
{
effect.KernelMap = segmenter;
try
{
await renderer.RenderAsync();
PreviewImage.Source = previewBitmap;
previewBitmap.Invalidate();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("AttemptUpdatePreviewAsync rendering failed: " + ex.Message);
}
}
}while (_processingPending);
}
Processing = false;
AdaptButtonsToState();
}
else
{
_processingPending = true;
}
}
private static async Task <Stream> GetStreamFromImageSourceAsync(StreamImageSource imageSource, CancellationToken cancellationToken = default(CancellationToken))
{
if (imageSource.Stream != null)
{
return(await imageSource.Stream(cancellationToken));
}
return(null);
}
public static async Task <Stream> GetStreamAsync(this StreamImageSource imageSource, CancellationToken cancellationToken = default(CancellationToken))
{
if (imageSource.Stream != null)
{
return(await imageSource.Stream(cancellationToken));
}
return(null);
}
public static Stream ToStream(this ImageSource img)
{
StreamImageSource streamImageSource = (StreamImageSource)img;
System.Threading.CancellationToken cancellationToken = System.Threading.CancellationToken.None;
Task <Stream> task = streamImageSource.Stream(cancellationToken);
return(task.Result);
}
public static IImageSourceHandler GetImageSourceHandler(this ImageSource source)
{
return(source switch
{
FileImageSource _ => new FileImageSourceHandler(),
StreamImageSource _ => new StreamImagesourceHandler(),
FontImageSource _ => new FontImageSourceHandler(),
_ => new ImageLoaderSourceHandler(),
});
public static AchievementViewModel CreateFrom(IAchievement achievement)
{
var src = new StreamImageSource
{
Stream = token => achievement.LoadImage()
};
return(new AchievementViewModel(achievement, src));
}
private static async Task <Stream> GetStreamFromStreamImageSource(ImageSource imageSource)
{
StreamImageSource streamImageSource = (StreamImageSource)imageSource;
System.Threading.CancellationToken cancellationToken = System.Threading.CancellationToken.None;
var result = await streamImageSource.Stream(cancellationToken);
return(result);
}
public void TestConstructors ()
{
var filesource = new FileImageSource { File = "File.png" };
Assert.AreEqual ("File.png", filesource.File);
Func<CancellationToken, Task<Stream>> stream = token => new Task<Stream> (() => new FileStream ("Foo", System.IO.FileMode.Open), token);
var streamsource = new StreamImageSource { Stream = stream };
Assert.AreEqual (stream, streamsource.Stream);
}
public async Task <ImageSource> SelectPicture()
{
MediaFile mf = await CrossMedia.Current.PickPhotoAsync();
StreamImageSource sis = new StreamImageSource();
sis.Stream = (t => new Task <Stream>(() => mf.GetStream()));
return(sis);
}
public static Stream GetStreamFromImageSource(ImageSource source)
{
StreamImageSource streamImageSource = (StreamImageSource)source;
System.Threading.CancellationToken cancellationToken = System.Threading.CancellationToken.None;
Task <Stream> task = streamImageSource.Stream(cancellationToken);
Stream stream = task.Result;
return(stream);
}
public static byte[] ImageToByte(this ImageSource ImageSource)
{
StreamImageSource streamImageSource = (StreamImageSource)ImageSource;
System.Threading.CancellationToken cancellationToken = System.Threading.CancellationToken.None;
Task <Stream> task = streamImageSource.Stream(cancellationToken);
MemoryStream stream = task.Result as MemoryStream;
return(stream.ToArray());
}
private void EndSession()
{
if (_source != null)
{
_source.Dispose();
_source = null;
}
_info = null;
}
public byte [] ImgToByteArray()
{
StreamImageSource streamImageSource = (StreamImageSource)imgAvatar.Source;
System.Threading.CancellationToken cancellationToken = System.Threading.CancellationToken.None;
Task <Stream> task = streamImageSource.Stream(cancellationToken);
Stream stream = task.Result;
var res = ReadFully(stream);
return(res);
}
public static async Task <ImageSource> AddText(this StreamImageSource source, string text, PointF point, Font font, Color color)
{
var token = new CancellationTokenSource();
var stream = await source.Stream(token.Token);
var image = UIImage.LoadFromData(NSData.FromStream(stream));
var bytes = image.AddText(text, point, font.ToUIFont(), color.ToUIColor()).AsPNG().ToArray();
return(ImageSource.FromStream(new Func <Stream>(() => new MemoryStream(bytes))));
}
/// <summary>
/// Updates the data displayed by the notification.
/// </summary>
/// <param name="achievement">Achievement to be displayed.</param>
/// <returns></returns>
private void UpdateDisplayedData(IAchievement achievement)
{
AchievementTitle = achievement.Title;
AchievementDescription = achievement.Description;
var source = new StreamImageSource
{
Stream = token => achievement.LoadImage()
};
AchievementImage = source;
}
public object ProvideValue(IServiceProvider serviceProvider)
{
if (Source == null)
{
return(null);
}
var imageSource = new StreamImageSource {
Stream = async(ct) => this.GetType().GetTypeInfo().Assembly.GetManifestResourceStream(Source)
};
return(imageSource);
}
private async void OnAddImage()
{
string[] types = { ".jpg", ".png" };
Image = await CrossFilePicker.Current.PickFile(types);
if (Image == null)
{
return;
}
ImageSource = (StreamImageSource)Xamarin.Forms.ImageSource.FromStream(() => Image.GetStream());
}
/// <summary>
/// アイコン画像の変換
/// </summary>
/// <param name="source">画像ソース</param>
/// <returns>画像情報</returns>
public static async Task <BandIcon> ToNativeIcon(StreamImageSource source)
{
var stream = await source.Stream.Invoke(new CancellationToken());
using (var ras = stream.AsRandomAccessStream())
{
var bitmap = new WriteableBitmap(1, 1);
await bitmap.SetSourceAsync(ras);
return(bitmap.ToBandIcon());
}
}
/// <summary>
/// アプリタイルを生成する
/// </summary>
/// <param name="id">ID</param>
/// <param name="name">名称</param>
/// <param name="icon">アイコンの画像ソース（46 x 46 px）</param>
/// <param name="smallIcon">小さいアイコンの画像ソース（24 x 24 px）</param>
/// <param name="theme">テーマカラー</param>
/// <returns>アプリタイル</returns>
public async Task <IBandTile> CreateTile(Guid id, string name, StreamImageSource icon, StreamImageSource smallIcon, BandTheme theme = null)
{
var nativeIcon = await NativeBandImageConvert.ToNativeIcon(icon);
var nativeSmallIcon = await NativeBandImageConvert.ToNativeIcon(smallIcon);
var tile = new NativeBandTile(id, name, nativeIcon, nativeSmallIcon);
tile.Theme = theme;
return(tile);
}
public async Task applyFilter(byte[] imageData, WriteableBitmap processedBitmap, List<IFilter> _components)
{
MemoryStream ms = new MemoryStream(imageData);
var source = new StreamImageSource(ms);
var effect = new FilterEffect(source);
var renderer = new WriteableBitmapRenderer(effect, processedBitmap);
var filters = new List<IFilter>();
filters = _components;
effect.Filters = filters;
await renderer.RenderAsync();
processedBitmap.Invalidate();
}
public async Task SetStreamImage(StreamImageSource streamImage)
{
try
{
m_StreamImageSource = streamImage;
ImageProviderInfo imageInfo = await m_StreamImageSource.GetInfoAsync();
m_FrameSize = imageInfo.ImageSize;
Initialize();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(string.Concat("Error in SetStreamImage() >>> ", ex));
}
}
async public static Task<WriteableBitmap> Render(List<IFilter> filterList, MemoryStream inputStream)
{
BitmapImage bitmapImage = new BitmapImage();
bitmapImage.SetSource(inputStream);
WriteableBitmap outputBitmap = new WriteableBitmap(bitmapImage.PixelWidth, bitmapImage.PixelHeight);
inputStream.Position = 0;
// An effect is initialized with selected image stream as source.
var imageStream = new StreamImageSource(inputStream);
FilterEffect _effect = new FilterEffect(imageStream);
_effect.Filters = filterList;
// Render the image to a WriteableBitmap.
var renderer = new WriteableBitmapRenderer(_effect, outputBitmap, OutputOption.Stretch);
outputBitmap = await renderer.RenderAsync();
return outputBitmap;
}
private async void PickImageCallback(object sender, PhotoResult e)
{
if (e.TaskResult != TaskResult.OK || e.ChosenPhoto == null)
return;
try
{
// Show thumbnail of original image.
_thumbnailImageBitmap.SetSource(e.ChosenPhoto);
OriginalImage.Source = _thumbnailImageBitmap;
// Rewind stream to start.
e.ChosenPhoto.Position = 0;
// A cartoon effect is initialized with selected image stream as source.
var imageStream = new StreamImageSource(e.ChosenPhoto);
_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();
// Set the rendered image as source for the cartoon image control.
CartoonImage.Source = _cartoonImageBitmap;
}
catch (Exception exception)
{
MessageBox.Show(exception.Message);
return;
}
SaveButton.IsEnabled = true;
}
async void setInput(Stream s)
{
//reset stream position
s.Seek(0, SeekOrigin.Begin);
//create a session
using (var source = new StreamImageSource(s))
using (var renderer = new WriteableBitmapRenderer(source))
{
var info = await source.GetInfoAsync();
InputLR = new WriteableBitmap(
(int)( info.ImageSize.Width),
(int)(info.ImageSize.Height)
);
renderer.WriteableBitmap = InputLR;
await renderer.RenderAsync();
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 = outputSize.Height / info.ImageSize.Height;
}
else
{
currentScale = outputSize.Width / info.ImageSize.Width;
}
currentAngle = 0.0;
}
saveLastPossaveLastPositionData();
brush.ImageSource = InputLR;
brush.Stretch = Stretch.None;
brush.AlignmentX = AlignmentX.Left;
brush.AlignmentY = AlignmentY.Top;
processRenderingLR();
}
private async void PickImageCallback(object sender, PhotoResult e)
{
if (e.TaskResult != TaskResult.OK || e.ChosenPhoto == null)
return;
try
{
// mostramos el thumbnail de la imagen original.
_thumbnailImageBitmap.SetSource(e.ChosenPhoto);
ImagenOriginal.Source = _thumbnailImageBitmap;
e.ChosenPhoto.Position = 0;
// inicializamos lo necesario para el filtro de la imagen.
var imageStream = new StreamImageSource(e.ChosenPhoto);
_fotoEffect = new FilterEffect(imageStream);
// agregammos el filtro a la imagen.
var filtro = new AntiqueFilter(); ;
_fotoEffect.Filters = new[] { filtro };
// renderizamos la imagen a un WriteableBitmap.
var renderer = new WriteableBitmapRenderer(_fotoEffect, _effectImageBitmap);
_effectImageBitmap = await renderer.RenderAsync();
// Establecemos la imagen renderizada como fuente para el control de la imagen efecto.
ImagenEfecto.Source = _effectImageBitmap;
rendererefect = _effectImageBitmap;
}
catch (Exception exception)
{
MessageBox.Show(exception.Message);
return;
}
}
async public static Task<WriteableBitmap> Render(List<String> effString, MemoryStream inputStream)
{
BitmapImage bitmapImage = new BitmapImage();
bitmapImage.SetSource(inputStream);
WriteableBitmap outputBitmap = new WriteableBitmap(bitmapImage.PixelWidth, bitmapImage.PixelHeight);
inputStream.Position = 0;
// An effect is initialized with selected image stream as source.
var imageStream = new StreamImageSource(inputStream);
List<IFilter> _effListTmp = new List<IFilter>();
foreach (String effStr in effString)
{
// Add filter
_effListTmp.Add(GetIFilter(effStr));
}
FilterEffect _effect = new FilterEffect(imageStream);
_effect.Filters = _effListTmp;
// Render the image to a WriteableBitmap.
var renderer = new WriteableBitmapRenderer(_effect, outputBitmap, OutputOption.Stretch);
outputBitmap = await renderer.RenderAsync();
return outputBitmap;
}
void selectPicture()
{
try
{
PhotoChooserTask task = new PhotoChooserTask();
task.Completed += async (s, res) =>
{
if (res.TaskResult == TaskResult.OK)
{
if (HRImagesource != null)
{
HRImagesource.Dispose();
HRImagesource = null;
}
HRImagesource = new StreamImageSource(res.ChosenPhoto);
var info = await HRImagesource.GetInfoAsync();
ImageSize = info.ImageSize;
//create LR image
using (var renderer = new WriteableBitmapRenderer(HRImagesource, LRImageSource))
await renderer.RenderAsync();
requestProcessing();
}
};
task.Show();
}
catch (Exception)
{
throw;
}
}
private async void AttemptSaveAsync()
{
if (!Processing)
{
Processing = true;
AdaptButtonsToState();
GC.Collect();
var lowMemory = false;
try
{
long result = (long)DeviceExtendedProperties.GetValue("ApplicationWorkingSetLimit");
lowMemory = result / 1024 / 1024 < 300;
}
catch (ArgumentOutOfRangeException)
{
}
IBuffer buffer = null;
Model.OriginalImage.Position = 0;
using (var source = new StreamImageSource(Model.OriginalImage))
using (var segmenter = new InteractiveForegroundSegmenter(source))
using (var annotationsSource = new BitmapImageSource(Model.AnnotationsBitmap))
{
segmenter.Quality = lowMemory ? 0.5 : 1;
segmenter.AnnotationsSource = annotationsSource;
var foregroundColor = Model.ForegroundBrush.Color;
var backgroundColor = Model.BackgroundBrush.Color;
segmenter.ForegroundColor = Windows.UI.Color.FromArgb(foregroundColor.A, foregroundColor.R, foregroundColor.G, foregroundColor.B);
segmenter.BackgroundColor = Windows.UI.Color.FromArgb(backgroundColor.A, backgroundColor.R, backgroundColor.G, backgroundColor.B);
using (var effect = new LensBlurEffect(source, new LensBlurPredefinedKernel(Model.KernelShape, (uint)Model.KernelSize)))
using (var renderer = new JpegRenderer(effect))
{
effect.KernelMap = segmenter;
try
{
buffer = await renderer.RenderAsync();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("AttemptSave rendering failed: " + ex.Message);
}
}
}
if (buffer != null)
{
using (var library = new MediaLibrary())
using (var stream = buffer.AsStream())
{
library.SavePicture("lensblur_" + DateTime.Now.Ticks, stream);
Model.Saved = true;
AdaptButtonsToState();
}
}
Processing = false;
AdaptButtonsToState();
}
}
private void BeginSession(Stream image)
{
System.Diagnostics.Debug.WriteLine("Begin session");
// Initialize session with image
using (var memoryStream = new MemoryStream())
{
image.Position = 0;
image.CopyTo(memoryStream);
try
{
// Some streams do not support flushing
image.Flush();
}
catch (Exception)
{
}
memoryStream.Position = 0;
// Initialize image source
_source = new StreamImageSource(memoryStream);
// Get image info
Task.Run(async () => { _info = await _source.GetInfoAsync(); }).Wait();
// Create crop filter effect
_reframingFilter = new ReframingFilter();
_filterEffect = new FilterEffect(_source)
{
Filters = new List<IFilter>() { _reframingFilter }
};
// Create renderer
_renderer = new WriteableBitmapRenderer(_filterEffect, _highResolutionCropBitmap);
}
// Set _lowResolutionBitmap decoding to a quite low resolution and initialize it with image
if (_info.ImageSize.Width >= _info.ImageSize.Height)
{
_lowResolutionBitmap.DecodePixelWidth = 1536;
_lowResolutionBitmap.DecodePixelHeight = 0;
}
else
{
_lowResolutionBitmap.DecodePixelWidth = 0;
_lowResolutionBitmap.DecodePixelHeight = 1536;
}
image.Position = 0;
_lowResolutionBitmap.SetSource(image);
// Set LowResolutionCropBrush scaling so that it matches with the pixel perfect HighResolutionCropImage renderings
var screenScaleFactor = App.Current.Host.Content.ScaleFactor / 100.0;
var lowResolutionToHighResolutionCropScale = _info.ImageSize.Width / _lowResolutionBitmap.PixelWidth / screenScaleFactor * DIGITAL_MAGNIFICATION;
_lowResolutionBrushTransform.ScaleX = lowResolutionToHighResolutionCropScale;
_lowResolutionBrushTransform.ScaleY = lowResolutionToHighResolutionCropScale;
// Show photo information in InformationTextBlock
SetupInformationPanel();
}
private void EndSession()
{
if (_renderer != null)
{
_renderer.Dispose();
_renderer = null;
}
if (_filterEffect != null)
{
_filterEffect.Dispose();
_filterEffect = null;
}
if (_source != null)
{
_source.Dispose();
_source = null;
}
_reframingFilter = null;
_info = null;
}
private async void AttemptUpdatePreviewAsync()
{
if (!Processing)
{
Processing = true;
AdaptButtonsToState();
Model.OriginalImage.Position = 0;
using (var source = new StreamImageSource(Model.OriginalImage))
using (var segmenter = new InteractiveForegroundSegmenter(source))
using (var annotationsSource = new BitmapImageSource(Model.AnnotationsBitmap))
{
segmenter.Quality = 0.5;
segmenter.AnnotationsSource = annotationsSource;
var foregroundColor = Model.ForegroundBrush.Color;
var backgroundColor = Model.BackgroundBrush.Color;
segmenter.ForegroundColor = Windows.UI.Color.FromArgb(foregroundColor.A, foregroundColor.R, foregroundColor.G, foregroundColor.B);
segmenter.BackgroundColor = Windows.UI.Color.FromArgb(backgroundColor.A, backgroundColor.R, backgroundColor.G, backgroundColor.B);
do
{
_processingPending = false;
var previewBitmap = new WriteableBitmap((int)Model.AnnotationsBitmap.Dimensions.Width, (int)Model.AnnotationsBitmap.Dimensions.Height);
using (var effect = new LensBlurEffect(source, new LensBlurPredefinedKernel(Model.KernelShape, (uint)Model.KernelSize)))
using (var renderer = new WriteableBitmapRenderer(effect, previewBitmap))
{
effect.KernelMap = segmenter;
try
{
await renderer.RenderAsync();
PreviewImage.Source = previewBitmap;
previewBitmap.Invalidate();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("AttemptUpdatePreviewAsync rendering failed: " + ex.Message);
}
}
}
while (_processingPending);
}
Processing = false;
AdaptButtonsToState();
}
else
{
_processingPending = true;
}
}
public async Task<StorageFile> ApplyFilter(StorageFile file, FilterOption filterOption)
{
IImageProvider source = null;
var properties = await file.Properties.GetImagePropertiesAsync();
this.SelectFilter(filterOption);
using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
source = new StreamImageSource(stream.AsStream(), ImageFormat.Jpeg);
using (var filterEffect = new FilterEffect(source))
{
// Initialize the filter and add the filter to the FilterEffect collection
//var filter = new SketchFilter(SketchMode.Gray);
filterEffect.Filters = new IFilter[] { this.SelectedFilter };
// Create a target where the filtered image will be rendered to
var target = new WriteableBitmap((int)properties.Width, (int)properties.Height);
// Create a new renderer which outputs WriteableBitmaps
using (var renderer = new WriteableBitmapRenderer(filterEffect, target))
{
// Render the image with the filter(s)
await renderer.RenderAsync();
return await this.WriteableBitmapToStorageFile(target, FileFormat.Jpeg);
}
}
}
}
private async void ApplicationBarIconButton_reframing(object sender, EventArgs e)
{
sFace.Position = 0;
sBackground.Position = 0;
IBuffer result;
using (var faceSource = new StreamImageSource(sFace))
using (var faceReframing = new FilterEffect(faceSource))
using (var source = new StreamImageSource(sBackground))
using (var effect = new FilterEffect(source) )
using (var renderer = new JpegRenderer(effect))
{
//face reframing => blend input
faceReframing.Filters = new IFilter[] { gestureFace.CreateReframingFilter() } ;
//face
effect.Filters = new IFilter[] {
gestureBackground.CreateReframingFilter() ,//background reframing
new BlendFilter(faceReframing) //blending
};
result = await renderer.RenderAsync();
}
using (var media = new MediaLibrary())
media.SavePictureToCameraRoll("test", result.ToArray());
}
private async void AttemptUpdateImageAsync()
{
if (!Processing)
{
Processing = true;
GC.Collect();
var lowMemory = false;
try
{
long result = (long)DeviceExtendedProperties.GetValue("ApplicationWorkingSetLimit");
lowMemory = result / 1024 / 1024 < 300;
}
catch (ArgumentOutOfRangeException)
{
}
var maxSide = lowMemory ? 2048.0 : 4096.0;
Model.OriginalImage.Position = 0;
using (var source = new StreamImageSource(Model.OriginalImage))
using (var segmenter = new InteractiveForegroundSegmenter(source))
using (var annotationsSource = new BitmapImageSource(Model.AnnotationsBitmap))
{
segmenter.Quality = lowMemory ? 0.5 : 1;
segmenter.AnnotationsSource = annotationsSource;
var foregroundColor = Model.ForegroundBrush.Color;
var backgroundColor = Model.BackgroundBrush.Color;
segmenter.ForegroundColor = Windows.UI.Color.FromArgb(foregroundColor.A, foregroundColor.R, foregroundColor.G, foregroundColor.B);
segmenter.BackgroundColor = Windows.UI.Color.FromArgb(backgroundColor.A, backgroundColor.R, backgroundColor.G, backgroundColor.B);
var info = await source.GetInfoAsync();
double scaler, rotation;
var width = info.ImageSize.Width;
var height = info.ImageSize.Height;
if (width > height)
{
scaler = maxSide / width;
rotation = 90;
var t = width; // We're rotating the image, so swap width and height
width = height;
height = t;
}
else
{
scaler = maxSide / height;
rotation = 0;
}
scaler = Math.Max(1, scaler);
_bitmap = new WriteableBitmap((int)(width * scaler), (int)(height * scaler));
using (var blurEffect = new LensBlurEffect(source, new LensBlurPredefinedKernel(Model.KernelShape, (uint)Model.KernelSize)))
using (var filterEffect = new FilterEffect(blurEffect) { Filters = new[] { new RotationFilter(rotation) }})
using (var renderer = new WriteableBitmapRenderer(filterEffect, _bitmap))
{
blurEffect.KernelMap = segmenter;
try
{
await renderer.RenderAsync();
Image.Source = _bitmap;
_bitmap.Invalidate();
ConfigureViewport();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("AttemptUpdateImageAsync rendering failed: " + ex.Message);
}
}
}
Processing = false;
}
}
private async void ProcessImage_v1()
{
try
{
// Initialize a WriteableBitmap with the dimensions of the image control in XAML
WriteableBitmap writeableBitmap = new WriteableBitmap((int)FilterEffectImage.Width, (int)FilterEffectImage.Height);
// Example: Accessing an image stream within a standard photo chooser task callback
// http://msdn.microsoft.com/en-us/library/windowsphone/develop/hh394019(v=vs.105).aspx
//using (var imageStream = new StreamImageSource(e.ChosenPhoto))
// Example: Accessing an image stream from a sample picture loaded with the project in a folder called "Pictures"
//m_LocalPictureName = "sample_photo_01.jpg";
m_LocalPictureName = "sample_photo_08.jpg";
var resource = App.GetResourceStream(new Uri(string.Concat("Pictures/", m_LocalPictureName), UriKind.Relative));
using (var imageStream = new StreamImageSource(resource.Stream))
{
// Applying an inbuilt filter and a custom effect to the image stream
//IImageProvider imageEffect = new FilterEffect(imageStream) { Filters = new List<IFilter>() { new WarpFilter(WarpEffect.Twister, 0.50) } };
//using (var customEffect = new PsychedelicEffect(imageEffect, 50))
// Applying the custom filter effect to the image stream
using (var customEffect = new SepiaEffect(imageStream, 0.42))
//using (var customEffect = new MirrorEffect(imageStream, MirrorEffect.MirrorType.Vertical))
//using (var customEffect = new NegativeEffect(imageStream))
//using (var customEffect = new FilterEffect(imageStream) { Filters = new List<IFilter>() { new NegativeFilter() } })
//using (var customEffect = new GrayscaleNegativeEffect(imageStream))
//using (var customEffect = new FilterEffect(imageStream) { Filters = new List<IFilter>() { new GrayscaleNegativeFilter() } })
//using (var customEffect = new BrightnessEffect(imageStream, 0.50))
//using (var customEffect = new FilterEffect(imageStream) { Filters = new List<IFilter>() { new GrayscaleFilter() } })
//using (var customEffect = new GrayscaleEffect(imageStream))
//using (var customEffect = new GrayscaleEffect(imageStream, 0.2126, 0.7152, 0.0722)) // Algorithm 1 - Default
//using (var customEffect = new GrayscaleEffect(imageStream, 0.299, 0.587, 0.114)) // Algorithm 2
//using (var customEffect = new GrayscaleEffect(imageStream, 0.3333, 0.3333, 0.3333))
{
// Rendering the resulting image to a WriteableBitmap
using (var renderer = new WriteableBitmapRenderer(customEffect, writeableBitmap))
{
// Applying the WriteableBitmap to our xaml image control
FilterEffectImage.Source = await renderer.RenderAsync();
}
}
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(string.Concat("Error in ProcessImage_v1() >>> ", ex));
}
}
private async void ApplicationBarIconButton_All(object sender, EventArgs e)
{
sFace.Position = 0;
sBackground.Position = 0;
IBuffer result;
using (var faceSource = new StreamImageSource(sFace))
using (var faceReframing = new FilterEffect(faceSource))
using (var source = new StreamImageSource(sBackground))
using (var effect = new FilterEffect(source))
using (var renderer = new JpegRenderer(effect))
{
var size = gestureBackground.ImageSize;
var Facesize = gestureFace.ImageSize;
//target scale
var scale = gestureFace.Scale / gestureBackground.Scale;
//target angle
var angle = gestureFace.Angle - gestureBackground.Angle;
//translation between image center and background position
var backgroundTranslation = new Point(size.Width / 2 - gestureBackground.Pos.X, size.Height / 2 - gestureBackground.Pos.Y);
//convert translation to Face referential translation
CompositeTransform gestureTransform = new CompositeTransform();
gestureTransform.ScaleX = gestureTransform.ScaleY = scale;
gestureTransform.Rotation = angle;
var translation = gestureTransform.Inverse.Transform(backgroundTranslation);
//target position
var posX = gestureFace.Pos.X + translation.X;
var posY = gestureFace.Pos.Y + translation.Y;
var currentSize = new Windows.Foundation.Size(size.Width / scale, size.Height / scale);
var corner = new Windows.Foundation.Point(posX - currentSize.Width / 2, posY - currentSize.Height / 2);
var reframing = new ReframingFilter(new Windows.Foundation.Rect(corner, currentSize), -angle);
//face reframing => blend input
faceReframing.Filters = new IFilter[] { reframing };
effect.Filters = new IFilter[] { new BlendFilter(faceReframing) };//
result = await renderer.RenderAsync();
}
using (var media = new MediaLibrary())
media.SavePictureToCameraRoll("test", result.ToArray());
}
public async Task<IBuffer> TakePicture()
{
if (_photoCaptureDevice == null && _cameraSemaphore.WaitOne(100))
return null;
if (_cameraSemaphore.WaitOne(100))
{
try
{
int angle = 0;
if (Orientation.HasFlag(PageOrientation.LandscapeLeft))
{
angle = (int)_photoCaptureDevice.SensorRotationInDegrees - 90;
}
else if (Orientation.HasFlag(PageOrientation.LandscapeRight))
{
angle = (int)_photoCaptureDevice.SensorRotationInDegrees + 90;
}
else // PageOrientation.PortraitUp
{
angle = (int)_photoCaptureDevice.SensorRotationInDegrees;
}
if (angle < 0) angle += 360;
if (_cameraLocation == CameraSensorLocation.Back)
{
_photoCaptureDevice.SetProperty(KnownCameraGeneralProperties.EncodeWithOrientation, angle);
}
else
{
_photoCaptureDevice.SetProperty(KnownCameraGeneralProperties.EncodeWithOrientation, -angle);
}
_photoCaptureDevice.SetProperty(KnownCameraGeneralProperties.SpecifiedCaptureOrientation, 0);
var cameraCaptureSequence = _photoCaptureDevice.CreateCaptureSequence(1);
var stream = new MemoryStream();
cameraCaptureSequence.Frames[0].CaptureStream = stream.AsOutputStream();
await _photoCaptureDevice.PrepareCaptureSequenceAsync(cameraCaptureSequence);
await cameraCaptureSequence.StartCaptureAsync();
IBuffer capturedPicture;
if (_cameraLocation == CameraSensorLocation.Back)
{
capturedPicture = stream.GetWindowsRuntimeBuffer();
}
else
{
capturedPicture = await JpegTools.FlipAndRotateAsync(stream.GetWindowsRuntimeBuffer(), FlipMode.Horizontal, Rotation.Rotate0, JpegOperation.AllowLossy);
}
using (var source = new StreamImageSource(capturedPicture.AsStream()))
{
var recipe = RecipeFactory.Current.CreatePipeline(source);
using (var renderer = new JpegRenderer(recipe))
{
capturedPicture = await renderer.RenderAsync();
}
if (recipe is IDisposable)
(recipe as IDisposable).Dispose();
}
return capturedPicture;
}
finally
{
_cameraSemaphore.Release();
}
}
return null;
}
public void TestStreamImageSourcePropertiesChangedTriggerResize ()
{
var source = new StreamImageSource ();
var image = new Image { Source = source };
bool fired = false;
image.MeasureInvalidated += (sender, e) => fired = true;
Assert.Null (source.Stream);
source.Stream = token => Task.FromResult<Stream> (null);
Assert.NotNull (source.Stream);
Assert.True (fired);
}
private async Task LoadLocalImage()
{
try
{
// Example: Accessing an image stream from a sample picture loaded with the project in a folder called "Pictures"
var resource = App.GetResourceStream(new Uri(string.Concat("Pictures/", m_LocalPictureName), UriKind.Relative));
StreamImageSource imageStream = new StreamImageSource(resource.Stream);
await m_SDKCustomEffects.SetStreamImage(imageStream);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(string.Concat("Error in LoadLocalImage() >>> ", ex));
}
}
/// <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;
Stream thumbnailStream = null;
System.Diagnostics.Debug.Assert(item.RequestedSize != StreamItemViewModel.Size.None);
if (item.RequestedSize == StreamItemViewModel.Size.Large)
{
bitmap = new WriteableBitmap(280, 280);
thumbnailStream = item.Model.Picture.GetImage();
}
else if (item.RequestedSize == StreamItemViewModel.Size.Medium)
{
bitmap = new WriteableBitmap(140, 140);
thumbnailStream = item.Model.Picture.GetThumbnail();
}
else
{
bitmap = new WriteableBitmap(70, 70);
thumbnailStream = item.Model.Picture.GetThumbnail();
}
thumbnailStream.Position = 0;
using (StreamImageSource source = new StreamImageSource(thumbnailStream))
using (FilterEffect effect = new FilterEffect(source))
{
List<IFilter> filters = new List<IFilter>();
if (item.RequestedSize == StreamItemViewModel.Size.Large)
{
int width = item.Model.Picture.Width;
int height = item.Model.Picture.Height;
if (width > height)
{
filters.Add(new CropFilter(new Windows.Foundation.Rect()
{
Width = height,
Height = height,
X = width / 2 - height / 2,
Y = 0
}));
}
else
{
filters.Add(new CropFilter(new Windows.Foundation.Rect()
{
Width = width,
Height = width,
X = 0,
Y = height / 2 - width / 2
}));
}
}
if (item.Model.Filter != null)
{
foreach (IFilter f in item.Model.Filter.Components)
{
filters.Add(f);
}
}
effect.Filters = filters;
using (WriteableBitmapRenderer renderer = new WriteableBitmapRenderer(effect, bitmap))
{
await renderer.RenderAsync();
}
}
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;
}
}
private async void ChooseImageButton_Callback(object sender, PhotoResult e)
{
// Example: Accessing an image stream within a standard photo chooser task callback
// http://msdn.microsoft.com/en-us/library/windowsphone/develop/hh394019(v=vs.105).aspx
if (e.TaskResult != TaskResult.OK || e.ChosenPhoto == null)
return;
try
{
if (m_SDKCustomEffects == null)
{
await Initialize();
}
e.ChosenPhoto.Position = 0;
StreamImageSource imageStream = new StreamImageSource(e.ChosenPhoto);
await m_SDKCustomEffects.SetStreamImage(imageStream);
await ProcessImage();
}
catch (Exception ex)
{
Busy = false;
System.Diagnostics.Debug.WriteLine(string.Concat("Error in ChooseImageButton_Callback() >>> ", ex));
}
Busy = false;
}
private void BeginSession(Stream image)
{
// Initialize session with image
using (var memoryStream = new MemoryStream())
{
image.Position = 0;
image.CopyTo(memoryStream);
try
{
// Some streams do not support flushing
image.Flush();
}
catch (Exception ex)
{
}
memoryStream.Position = 0;
// Initialize image source
_source = new StreamImageSource(memoryStream);
// Get image info
Task.Run(async () => { _info = await _source.GetInfoAsync(); }).Wait();
// Set _lowResolutionBitmap decoding to a quite low resolution and initialize it with image
if (_info.ImageSize.Width >= _info.ImageSize.Height)
{
_bitmap.DecodePixelWidth = 1536;
_bitmap.DecodePixelHeight = 0;
}
else
{
_bitmap.DecodePixelWidth = 0;
_bitmap.DecodePixelHeight = 1536;
}
image.Position = 0;
_bitmap.SetSource(image);
}
}
private void EndSession()
{
if (_source != null)
{
_source.Dispose();
_source = null;
}
_info = null;
}
private async void AttemptUpdatePreviewAsync2()
{
if (!Processing)
{
Processing = true;
Model.OriginalImage.Position = 0;
using (var source = new StreamImageSource(Model.OriginalImage))
using (var segmenter = new InteractiveForegroundSegmenter(source))
using (var annotationsSource = new BitmapImageSource(Model.AnnotationsBitmap))
{
segmenter.Quality = 0.5;
segmenter.Source = source;
segmenter.AnnotationsSource = annotationsSource;
var foregroundColor = Model.ForegroundBrush.Color;
var backgroundColor = Model.BackgroundBrush.Color;
segmenter.ForegroundColor = Windows.UI.Color.FromArgb(foregroundColor.A, foregroundColor.R, foregroundColor.G, foregroundColor.B);
segmenter.BackgroundColor = Windows.UI.Color.FromArgb(backgroundColor.A, backgroundColor.R, backgroundColor.G, backgroundColor.B);
do
{
_processingPending = false;
var previewBitmap = new WriteableBitmap((int)Model.AnnotationsBitmap.Dimensions.Width, (int)Model.AnnotationsBitmap.Dimensions.Height);
using (var backgroundSource = new StreamImageSource(Model.OriginalImage2))
using (var filterEffect = new FilterEffect(backgroundSource))
using (var blendFilter = new BlendFilter(source))
using (var renderer = new WriteableBitmapRenderer(filterEffect, previewBitmap))
{
blendFilter.BlendFunction = BlendFunction.Normal;
blendFilter.MaskSource = segmenter;
filterEffect.Filters = new IFilter[] { blendFilter };
try
{
await renderer.RenderAsync();
}
catch
{
}
var wb = previewBitmap;
var fileStream = new MemoryStream();
wb.SaveJpeg(fileStream, wb.PixelWidth, wb.PixelHeight, 100, 100);
fileStream.Seek(0, SeekOrigin.Begin);
var effect = new LensBlurEffect(new StreamImageSource(fileStream), new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Circle, 10));
var renderer2 = new WriteableBitmapRenderer(effect, previewBitmap);
effect.KernelMap = segmenter;
try
{
await renderer2.RenderAsync();
}
catch
{
}
PreviewImage.Source = previewBitmap;
wb = previewBitmap;
fileStream = new MemoryStream();
wb.SaveJpeg(fileStream, wb.PixelWidth, wb.PixelHeight, 100, 100);
fileStream.Seek(0, SeekOrigin.Begin);
// var m = new MediaLibrary();
// m.SavePictureToCameraRoll("test", fileStream);
Model.MixedStream = fileStream;
// Model.MixedStream = ConvertToStream(previewBitmap);
previewBitmap.Invalidate();
}
}
while (_processingPending);
}
Processing = false;
}
else
{
_processingPending = true;
}
}
private List<IImageProvider> CreateImageSequenceFromResources(int sequenceId)
{
List<IImageProvider> imageProviders = new List<IImageProvider>();
try
{
int i = 0;
while (true)
{
Uri uri = new Uri(@"Assets/Sequences/sequence." + sequenceId + "." + i + ".jpg", UriKind.Relative);
Stream stream = Application.GetResourceStream(uri).Stream;
StreamImageSource sis = new StreamImageSource(stream);
imageProviders.Add(new StreamImageSource(stream));
i++;
}
}
catch (NullReferenceException ex)
{
// No more images available
}
return imageProviders;
}
private async void AttemptUpdatePreviewAsync()
{
if (!Processing)
{
Processing = true;
do
{
_processingPending = false;
if (Model.OriginalImage != null && ForegroundAnnotationsDrawn && BackgroundAnnotationsDrawn)
{
Model.OriginalImage.Position = 0;
var maskBitmap = new WriteableBitmap((int)AnnotationsCanvas.ActualWidth, (int)AnnotationsCanvas.ActualHeight);
var annotationsBitmap = new WriteableBitmap((int)AnnotationsCanvas.ActualWidth, (int)AnnotationsCanvas.ActualHeight);
annotationsBitmap.Render(AnnotationsCanvas, new ScaleTransform
{
ScaleX = 1,
ScaleY = 1
});
annotationsBitmap.Invalidate();
Model.OriginalImage.Position = 0;
using (var source = new StreamImageSource(Model.OriginalImage))
using (var segmenter = new InteractiveForegroundSegmenter(source))
using (var renderer = new WriteableBitmapRenderer(segmenter, maskBitmap))
using (var annotationsSource = new BitmapImageSource(annotationsBitmap.AsBitmap()))
{
var foregroundColor = Model.ForegroundBrush.Color;
var backgroundColor = Model.BackgroundBrush.Color;
segmenter.ForegroundColor = Windows.UI.Color.FromArgb(foregroundColor.A, foregroundColor.R, foregroundColor.G, foregroundColor.B);
segmenter.BackgroundColor = Windows.UI.Color.FromArgb(backgroundColor.A, backgroundColor.R, backgroundColor.G, backgroundColor.B);
segmenter.Quality = 0.5;
segmenter.AnnotationsSource = annotationsSource;
await renderer.RenderAsync();
MaskImage.Source = maskBitmap;
maskBitmap.Invalidate();
Model.AnnotationsBitmap = (Bitmap)annotationsBitmap.AsBitmap();
}
}
else
{
MaskImage.Source = null;
}
}
while (_processingPending && !_manipulating);
Processing = false;
}
else
{
_processingPending = true;
}
}
