public async Task PrepareImageSequence(List <IImageProvider> imageProviders)
{
_unalignedImageProviders = imageProviders;
_onScreenImageProviders = _unalignedImageProviders;
IAsyncImageResource asyncImageResource = (IAsyncImageResource)_unalignedImageProviders[0];
var info = await asyncImageResource.LoadAsync();
_unalignedImageWidth = (int)info.ImageSize.Width;
_unalignedImageHeight = (int)info.ImageSize.Height;
using (ImageAligner imageAligner = new ImageAligner())
{
imageAligner.Sources = _unalignedImageProviders;
imageAligner.ReferenceSource = _unalignedImageProviders[0];
try
{
_alignedImageProviders = await imageAligner.AlignAsync();
asyncImageResource = (IAsyncImageResource)_unalignedImageProviders[0];
info = await asyncImageResource.LoadAsync();
_alignedImageWidth = (int)info.ImageSize.Width;
_alignedImageHeight = (int)info.ImageSize.Height;
await EnableAlign();
}
catch (Exception)
{
// If align fails, fail silently but don't enable the align button on UI
}
}
}
private async void OnPreviewFrameAvailable(IAsyncImageResource imageResource)
{
if (!_isRendering)
{
_isRendering = true;
await _writeableBitmapRenderer.RenderAsync();
await
CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(
CoreDispatcherPriority.High,
() =>
{
int bufferSize = _writeableBitmap.PixelWidth *_writeableBitmap.PixelHeight * 4;
if (_buffer == null || _buffer.Length != bufferSize)
{
_buffer = new byte[bufferSize];
}
IBuffer pixelBuffer = _writeableBitmap.PixelBuffer;
pixelBuffer.CopyTo(_buffer);
GCHandle handle = GCHandle.Alloc(_buffer, GCHandleType.Pinned);
using (
Mat m = new Mat(_writeableBitmap.PixelHeight, _writeableBitmap.PixelWidth,
DepthType.Cv8U, 4,
handle.AddrOfPinnedObject(), _writeableBitmap.PixelWidth * 4))
using (Mat gray = new Mat())
using (Mat canny = new Mat())
{
CvInvoke.CvtColor(m, gray, ColorConversion.Bgra2Gray);
CvInvoke.Canny(gray, canny, 40, 60);
CvInvoke.CvtColor(canny, m, ColorConversion.Gray2Bgra);
}
handle.Free();
using (Stream s = pixelBuffer.AsStream())
{
s.Write(_buffer, 0, _buffer.Length);
}
_writeableBitmap.Invalidate();
});
_isRendering = false;
}
}
private async void OnPreviewFrameAvailable(IAsyncImageResource imageResource)
{
if (!_isRendering && (imageResource != null))
{
_isRendering = true;
await _writeableBitmapRenderer.RenderAsync();
await
Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(
CoreDispatcherPriority.High,
() =>
{
int bufferSize = _writeableBitmap.PixelWidth * _writeableBitmap.PixelHeight * 4;
if (_buffer == null || _buffer.Length != bufferSize)
_buffer = new byte[bufferSize];
IBuffer pixelBuffer = _writeableBitmap.PixelBuffer;
pixelBuffer.CopyTo(_buffer);
GCHandle handle = GCHandle.Alloc(_buffer, GCHandleType.Pinned);
using (
Mat m = new Mat(_writeableBitmap.PixelHeight, _writeableBitmap.PixelWidth,
DepthType.Cv8U, 4,
handle.AddrOfPinnedObject(), _writeableBitmap.PixelWidth * 4))
using (Mat gray = new Mat())
using (Mat canny = new Mat())
{
CvInvoke.CvtColor(m, gray, ColorConversion.Bgr2Gray);
CvInvoke.Canny(gray, canny, 40, 60);
CvInvoke.CvtColor(canny, m, ColorConversion.Gray2Bgra);
}
handle.Free();
using (Stream s = pixelBuffer.AsStream())
{
s.Write(_buffer, 0, _buffer.Length);
}
_writeableBitmap.Invalidate();
});
_isRendering = false;
}
}
private void OnPreviewFrameAvailable(IAsyncImageResource asyncImageResource)
{
_renderTask = Render();
}
public static async Task Export(IReadOnlyList <IImageProvider> images, Rect?animatedArea)
{
// List of aligned images may contain Null items if the particular image couldn't be aligned
List <IImageProvider> sanitizedImages = new List <IImageProvider>();
foreach (IImageProvider image in images)
{
if (image != null)
{
sanitizedImages.Add(image);
}
}
IImageResource info = null;
IAsyncImageResource asyncImageResource = sanitizedImages[0] as IAsyncImageResource;
if (asyncImageResource == null)
{
info = sanitizedImages[0] as IImageResource;
}
int w = (int)info.ImageSize.Width;
int h = (int)info.ImageSize.Height;
IReadOnlyList <IImageProvider> gifRendererSources;
if (animatedArea.HasValue)
{
// Ensure the animated area dimensions are smaller than the image dimensions
double rectW = animatedArea.Value.Width;
double rectH = animatedArea.Value.Height;
if ((animatedArea.Value.Width + animatedArea.Value.Left) >= w)
{
rectW = w - animatedArea.Value.Left - 1;
}
if ((animatedArea.Value.Top + animatedArea.Value.Height) >= h)
{
rectH = h - animatedArea.Value.Top - 1;
}
Rect rect = new Rect(animatedArea.Value.Left, animatedArea.Value.Top, rectW, rectH);
gifRendererSources = CreateFramedAnimation(sanitizedImages, rect, w, h);
}
else
{
gifRendererSources = sanitizedImages;
}
using (GifRenderer gifRenderer = new GifRenderer())
{
gifRenderer.Duration = 100;
gifRenderer.NumberOfAnimationLoops = 10000;
gifRenderer.Sources = gifRendererSources;
var buffer = await gifRenderer.RenderAsync();
var filename = "Sequence" + (await GetFileNameRunningNumber()) + ".gif";
var storageFile = await KnownFolders.SavedPictures.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
using (var stream = await storageFile.OpenAsync(FileAccessMode.ReadWrite))
{
await stream.WriteAsync(buffer);
}
}
}
private void OnPreviewFrameAvailable(IAsyncImageResource asyncImageResource)
{
_renderTask = Render();
}
