public async Task <WriteableBitmap> LayHinhThuNho(int side)
{
int minSide = Width < Height ? Width : Height;
Rect rect = new Rect()
{
X = (Width - minSide) / 2,
Y = (Height - minSide) / 2,
Height = minSide,
Width = minSide
};
_filters.Add(new CropFilter(rect));
WriteableBitmap bitmap = new WriteableBitmap(side, side);
using (FilterEffect effect = new FilterEffect(ImageSource))
{
effect.Filters = _filters;
using (WriteableBitmapRenderer render = new WriteableBitmapRenderer(effect, bitmap))
{
await render.RenderAsync();
bitmap.Invalidate();
}
}
_filters.RemoveAt(_filters.Count - 1);
return(bitmap);
}
protected override void SetFilters(FilterEffect effect)
{
effect.Filters = new List <IFilter>()
{
_lomoFilter
};
}
private async Task GetNewFrameAndApplyChosenEffectAsync(IBuffer buffer)
{
var lineSize = (uint)frameSize.Width * 4;
var bitmap = new Bitmap(frameSize, ColorMode.Bgra8888, lineSize, buffer);
IFilter[] filters;
if (activeFilter == null)
{
filters = new IFilter[0];
}
else
{
filters = new IFilter[]
{
activeFilter
};
}
using (FilterEffect fe = new FilterEffect(cameraPreviewImageSource)
{
Filters = filters
})
using (BitmapRenderer renderer = new BitmapRenderer(fe, bitmap))
{
await renderer.RenderAsync();
}
}
public async Task <EnhanceResult> EnhanceAsync(Frame frame)
{
using (var bitmap = new Bitmap(new Windows.Foundation.Size(frame.Dimensions.Width, frame.Dimensions.Height), Internal.Utilities.FrameFormatToColorMode(frame.Format), frame.Pitch, frame.Buffer.AsBuffer()))
using (var source = new BitmapImageSource(bitmap))
using (var effect = new FilterEffect(source))
using (var renderer = new BitmapRenderer(effect))
{
effect.Filters = new List <IFilter>()
{
new ContrastFilter(0.5)
};
using (var newBitmap = new Bitmap(new Windows.Foundation.Size(frame.Dimensions.Width, frame.Dimensions.Height), Internal.Utilities.FrameFormatToColorMode(frame.Format)))
{
await effect.GetBitmapAsync(newBitmap, OutputOption.PreserveAspectRatio);
return(new EnhanceResult()
{
Frame = new Frame()
{
Buffer = newBitmap.Buffers[0].Buffer.ToArray(),
Pitch = newBitmap.Buffers[0].Pitch,
Format = frame.Format,
Dimensions = newBitmap.Dimensions
}
});
}
}
}
// Protected implementation of Dispose pattern.
protected override void Dispose(bool disposing)
{
if (disposed)
return;
if (disposing)
{
}
if (filter != null)
{
filter.Dispose();
filter = null;
}
if (delegatingFilter != null)
{
delegatingFilter.Dispose();
delegatingFilter = null;
}
if (effect != null)
{
effect.Dispose();
effect = null;
}
disposed = true;
// Call base class implementation.
base.Dispose(disposing);
}
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));
}
}
}
}
public async Task<EnhanceResult> EnhanceAsync(Frame frame)
{
using (var bitmap = new Bitmap(new Windows.Foundation.Size(frame.Dimensions.Width, frame.Dimensions.Height), Internal.Utilities.FrameFormatToColorMode(frame.Format), frame.Pitch, frame.Buffer.AsBuffer()))
using (var source = new BitmapImageSource(bitmap))
using (var effect = new FilterEffect(source))
using (var renderer = new BitmapRenderer(effect))
{
effect.Filters = new List<IFilter>()
{
new ContrastFilter(0.5)
};
using (var newBitmap = new Bitmap(new Windows.Foundation.Size(frame.Dimensions.Width, frame.Dimensions.Height), Internal.Utilities.FrameFormatToColorMode(frame.Format)))
{
await effect.GetBitmapAsync(newBitmap, OutputOption.PreserveAspectRatio);
return new EnhanceResult()
{
Frame = new Frame()
{
Buffer = newBitmap.Buffers[0].Buffer.ToArray(),
Pitch = newBitmap.Buffers[0].Pitch,
Format = frame.Format,
Dimensions = newBitmap.Dimensions
}
};
}
}
}
private void Uninitialize()
{
_initialized = false;
if (_timer != null)
{
_timer.Stop();
_timer.Tick -= DispatcherTimer_Tick;
_timer = null;
}
if (_renderer != null)
{
_renderer.Dispose();
_renderer = null;
}
if (_effect != null)
{
_effect.Dispose();
_effect = null;
}
_filters = null;
_chromaKeyFilter = null;
_rotationFilter = null;
_bitmap = null;
if (_source != null)
{
_source.Dispose();
_source = null;
}
}
private async void ViewfinderCanvas_Tap(object sender, System.Windows.Input.GestureEventArgs e)
{
var point = e.GetPosition(ViewfinderCanvas);
var bitmap = new WriteableBitmap((int)ViewfinderCanvas.ActualWidth, (int)ViewfinderCanvas.ActualHeight);
using (var source = new CameraPreviewImageSource(App.Camera))
using (var effect = new FilterEffect(source))
using (var renderer = new WriteableBitmapRenderer(effect, bitmap, OutputOption.Stretch))
{
effect.Filters = new List <IFilter>()
{
new RotationFilter(_rotationFilter.RotationAngle)
};
await renderer.RenderAsync();
var picked = bitmap.Pixels[((int)point.Y) * bitmap.PixelWidth + ((int)point.X)];
_color = new Color
{
A = 0xFF,
R = (byte)((picked & 0x00FF0000) >> 16),
G = (byte)((picked & 0x0000FF00) >> 8),
B = (byte)(picked & 0x000000FF)
};
}
ColorBorder.Background = new SolidColorBrush(_color);
}
private void Cleanup()
{
System.Diagnostics.Debug.WriteLine("Cleaning up scanner");
try
{
_Ready = false;
_Done = true;
_Rendering = true;
_Controller = null;
_ImagePreview = null;
_Effects = null;
_Render.Dispose();
_Render = null;
_Image = null;
_Source.StopPreviewAsync();
_Source.PreviewFrameAvailable -= OnPreviewFrameAvailable;
_Source.Dispose();
_Source = null;
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Cleaning up scanner. {0}", ex.Message);
}
}
/// <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);
}
public FilterEffect GetEffect()
{
FilterEffect effect = new FilterEffect(ImageSource);
effect.Filters = _filters;
return(effect);
}
private static IReadOnlyList <IImageProvider> CreateFramedAnimation(IReadOnlyList <IImageProvider> images, Rect animationBounds, int w, int h)
{
List <IImageProvider> framedAnimation = new List <IImageProvider>();
foreach (IImageProvider frame in images)
{
FilterEffect cropFilterEffect = new FilterEffect(frame);
cropFilterEffect.Filters = new List <IFilter>()
{
new CropFilter(animationBounds)
};
FilterEffect blendFilterEffect = new FilterEffect(images[0]);
BlendFilter blendFilter = new BlendFilter();
blendFilter.ForegroundSource = cropFilterEffect;
blendFilter.Level = 1.0;
blendFilter.BlendFunction = BlendFunction.Normal;
blendFilter.TargetArea = new Rect(
animationBounds.Left / w,
animationBounds.Top / h,
animationBounds.Width / w,
animationBounds.Height / h
);
blendFilterEffect.Filters = new List <IFilter>()
{
blendFilter
};
framedAnimation.Add(blendFilterEffect);
}
return(framedAnimation);
}
/// <summary>
/// Initialize and start the camera preview
/// </summary>
public async Task InitializeAsync()
{
Status = "Starting camera...";
// Create a camera preview image source (from Imaging SDK)
_cameraPreviewImageSource = new CameraPreviewImageSource();
await _cameraPreviewImageSource.InitializeAsync(string.Empty);
var properties = await _cameraPreviewImageSource.StartPreviewAsync();
// Create a preview bitmap with the correct aspect ratio
var width = 640.0;
var height = (width / properties.Width) * properties.Height;
var bitmap = new WriteableBitmap((int)width, (int)height);
PreviewBitmap = bitmap;
// Create a filter effect to be used with the source (no filters yet)
_effect = new FilterEffect(_cameraPreviewImageSource);
_writeableBitmapRenderer = new WriteableBitmapRenderer(_effect, _writeableBitmap);
// Attach preview frame delegate
_cameraPreviewImageSource.PreviewFrameAvailable += OnPreviewFrameAvailable;
Status = _filterList[_index].Name;
Initialized = true;
NextFilterCommand.RaiseCanExecuteChanged();
PreviousFilterCommand.RaiseCanExecuteChanged();
}
public async Task ApplyRotationFilterAsync(double value)
{
RotationFilterModel f = new RotationFilterModel(value);
IsChanged = true;
FilterList.Add(f);
foreach (var item in f.Components)
{
_filters.Add(item);
}
int h = Math.Max(OriginalBitmap.PixelHeight, OriginalBitmap.PixelWidth);
int w = Math.Min(OriginalBitmap.PixelHeight, OriginalBitmap.PixelWidth);
OriginalBitmap = new WriteableBitmap(w, h);
using (FilterEffect effect = new FilterEffect(ImageSource)
{
Filters = _filters
})
using (WriteableBitmapRenderer renderer = new WriteableBitmapRenderer(effect, OriginalBitmap))
{
await renderer.RenderAsync();
OriginalBitmap.Invalidate();
}
}
/// <summary>
/// GetImage by Filter
/// </summary>
/// <param name="stream"></param>
/// <param name="filter"></param>
/// <returns></returns>
public async static Task <WriteableBitmap> GetImageByFilter(this IRandomAccessStream stream, IFilter filter)
{
stream.Seek(0);
var imageFormat = ImageFormat.Jpeg;
var imageType = await getImageType(stream);
if (imageType == ImageType.PNG)
{
imageFormat = ImageFormat.Png;
}
using (var source = new RandomAccessStreamImageSource(stream, imageFormat))
{
// Create effect collection with the source stream
using (var filters = new FilterEffect(source))
{
// Initialize the filter and add the filter to the FilterEffect collection
filters.Filters = new IFilter[] { filter };
// Create a target where the filtered image will be rendered to
var target = new WriteableBitmap((int)(Window.Current.Bounds.Width), (int)(Window.Current.Bounds.Height));
// Create a new renderer which outputs WriteableBitmaps
using (var renderer = new WriteableBitmapRenderer(filters, target))
{
// Render the image with the filter(s)
target = await renderer.RenderAsync();
target.Invalidate();
return(target);
}
}
}
}
public RecipeCSharpFilter(IImageProvider source, double factor)
: base(source)
{
effect = new FilterEffect(source);
effect.Filters = new IFilter[]{new CSharp.MyFilter (factor)};
SetPipelineBeginEnd(effect, effect);
}
public void Process(Bitmap input, Bitmap output, TimeSpan time)
{
var effect = new FilterEffect();
effect.Filters = new IFilter[]{ new WatercolorFilter() };
effect.Source = new BitmapImageSource(input);
var renderer = new BitmapRenderer(effect, output);
renderer.RenderAsync().AsTask().Wait(); // Async calls must run sync inside Process()
}
protected override void SetFilters(FilterEffect effect)
{
var antiqueFilter = new AntiqueFilter();
effect.Filters = new List <IFilter> {
antiqueFilter, Filter
};
}
public async Task CS_W_MediaReader_LumiaEffect()
{
using (var mediaReader = await MediaReader.CreateFromPathAsync("ms-appx:///car.mp4", AudioInitialization.Deselected, VideoInitialization.Nv12))
using (var mediaResult = await mediaReader.VideoStream.ReadAsync())
{
var streamProperties = mediaReader.VideoStream.GetCurrentStreamProperties();
int width = (int)streamProperties.Width;
int height = (int)streamProperties.Height;
Assert.AreEqual(320, width);
Assert.AreEqual(240, height);
var inputSample = (MediaSample2D)mediaResult.Sample;
Assert.AreEqual(MediaSample2DFormat.Nv12, inputSample.Format);
Assert.AreEqual(320, inputSample.Width);
Assert.AreEqual(240, inputSample.Height);
using (var outputSample = new MediaSample2D(MediaSample2DFormat.Nv12, width, height))
{
Assert.AreEqual(MediaSample2DFormat.Nv12, outputSample.Format);
Assert.AreEqual(320, outputSample.Width);
Assert.AreEqual(240, outputSample.Height);
using (var inputBuffer = inputSample.LockBuffer(BufferAccessMode.Read))
using (var outputBuffer = outputSample.LockBuffer(BufferAccessMode.Write))
{
// Wrap MediaBuffer2D in Bitmap
var inputBitmap = new Bitmap(
new Size(width, height),
ColorMode.Yuv420Sp,
new uint[] { inputBuffer.Planes[0].Pitch, inputBuffer.Planes[1].Pitch },
new IBuffer[] { inputBuffer.Planes[0].Buffer, inputBuffer.Planes[1].Buffer }
);
var outputBitmap = new Bitmap(
new Size(width, height),
ColorMode.Yuv420Sp,
new uint[] { outputBuffer.Planes[0].Pitch, outputBuffer.Planes[1].Pitch },
new IBuffer[] { outputBuffer.Planes[0].Buffer, outputBuffer.Planes[1].Buffer }
);
// Apply effect
var effect = new FilterEffect();
effect.Filters = new IFilter[] { new WatercolorFilter() };
effect.Source = new BitmapImageSource(inputBitmap);
var renderer = new BitmapRenderer(effect, outputBitmap);
await renderer.RenderAsync();
}
// Save the file
var folder = await KnownFolders.PicturesLibrary.CreateFolderAsync("MediaCaptureReaderTests", CreationCollisionOption.OpenIfExists);
var file = await folder.CreateFileAsync("CS_W_MediaReader_TestLumiaEffect.jpg", CreationCollisionOption.ReplaceExisting);
await outputSample.SaveToFileAsync(file, ImageCompression.Jpeg);
Logger.LogMessage("Saved {0}", file.Path);
}
}
}
private void Dot(FilterEffect filterEffect)
{
Subgraph(filterEffect);
if (filterEffect.Filters != null)
{
Dot(filterEffect.Filters);
}
}
protected override void SetFilters(FilterEffect effect)
{
AntiqueFilter antiqueFilter = new AntiqueFilter();
effect.Filters = new List <IFilter>()
{
antiqueFilter, _lomoFilter
};
}
public void Process(Bitmap input, Bitmap output, TimeSpan time)
{
var effect = new FilterEffect();
effect.Filters = new IFilter[] { new WatercolorFilter() };
effect.Source = new BitmapImageSource(input);
var renderer = new BitmapRenderer(effect, output);
renderer.RenderAsync().AsTask().Wait(); // Async calls must run sync inside Process()
}
public async Task<NormalizeResult> NormalizeAsync(Frame frame, Windows.Foundation.Rect area, double rotation)
{
using (var bitmap = new Bitmap(frame.Dimensions, Internal.Utilities.FrameFormatToColorMode(frame.Format), frame.Pitch, frame.Buffer.AsBuffer()))
using (var source = new BitmapImageSource(bitmap))
using (var effect = new FilterEffect(source))
using (var renderer = new BitmapRenderer(effect))
{
effect.Filters = new List<IFilter>()
{
new ReframingFilter(area, -rotation)
};
using (var newBitmap = new Bitmap(new Windows.Foundation.Size(area.Width, area.Height), Internal.Utilities.FrameFormatToColorMode(frame.Format)))
{
await effect.GetBitmapAsync(newBitmap, OutputOption.PreserveAspectRatio);
return new NormalizeResult()
{
Frame = new Frame()
{
Buffer = newBitmap.Buffers[0].Buffer.ToArray(),
Pitch = newBitmap.Buffers[0].Pitch,
Format = frame.Format,
Dimensions = newBitmap.Dimensions
},
Translate = new Func<Windows.Foundation.Point, Windows.Foundation.Point>((normalizedPoint) =>
{
var rotationRadians = -rotation / 360.0 * 2.0 * Math.PI;
var sin = Math.Sin(rotationRadians);
var cos = Math.Cos(rotationRadians);
var origoX = area.Width / 2.0;
var origoY = area.Height / 2.0;
// Translate point to origo before rotation
var ox = normalizedPoint.X - origoX;
var oy = normalizedPoint.Y - origoY;
// Move area to origo, calculate new point positions, restore area location and add crop margins
var x = ox * cos - oy * sin;
var y = ox * sin + oy * cos;
// Translate point back to area after rotation
x = x + origoX;
y = y + origoY;
// Add margins from original uncropped frame
x = x + area.X;
y = y + area.Y;
return new Windows.Foundation.Point(x, y);
})
};
}
}
}
private async Task InitCamera()
{
var devices = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(Windows.Devices.Enumeration.DeviceClass.VideoCapture);
string deviceId = devices.FirstOrDefault(d => d.EnclosureLocation.Panel != Windows.Devices.Enumeration.Panel.Front).Id;
_Source = new CameraPreviewImageSource();
await _Source.InitializeAsync(deviceId);
_Source.PreviewFrameAvailable += OnPreviewFrameAvailable;
// set auto focus
_Controller = (VideoDeviceController)_Source.VideoDeviceController;
if (_Controller.FocusControl.Supported)
{
try
{
if (_Controller.FocusControl.WaitForFocusSupported)
{
_Controller.FocusControl.Configure(new FocusSettings {
Mode = FocusMode.Continuous
});
}
else
{
_Controller.FocusControl.Configure(new FocusSettings {
Mode = FocusMode.Auto
});
}
}
catch
{
_Controller.FocusControl.Configure(new FocusSettings {
Mode = FocusMode.Auto
});
}
}
if (_Controller.FlashControl.Supported)
{
_Controller.FlashControl.Auto = true;
}
if (_Controller.ExposureControl.Supported)
{
_Controller.ExposureControl.SetAutoAsync(true);
}
_Image = new WriteableBitmap((int)Window.Current.Bounds.Width, (int)Window.Current.Bounds.Height);
// filters
_Effects = new FilterEffect(_Source);
_Effects.Filters = new IFilter[] { new GrayscaleFilter() };
_Render = new WriteableBitmapRenderer(_Effects, _Image);
_Ready = true;
}
public async Task <NormalizeResult> NormalizeAsync(Frame frame, Windows.Foundation.Rect area, double rotation)
{
using (var bitmap = new Bitmap(frame.Dimensions, Internal.Utilities.FrameFormatToColorMode(frame.Format), frame.Pitch, frame.Buffer.AsBuffer()))
using (var source = new BitmapImageSource(bitmap))
using (var effect = new FilterEffect(source))
using (var renderer = new BitmapRenderer(effect))
{
effect.Filters = new List <IFilter>()
{
new ReframingFilter(area, -rotation)
};
using (var newBitmap = new Bitmap(new Windows.Foundation.Size(area.Width, area.Height), Internal.Utilities.FrameFormatToColorMode(frame.Format)))
{
await effect.GetBitmapAsync(newBitmap, OutputOption.PreserveAspectRatio);
return(new NormalizeResult()
{
Frame = new Frame()
{
Buffer = newBitmap.Buffers[0].Buffer.ToArray(),
Pitch = newBitmap.Buffers[0].Pitch,
Format = frame.Format,
Dimensions = newBitmap.Dimensions
},
Translate = new Func <Windows.Foundation.Point, Windows.Foundation.Point>((normalizedPoint) =>
{
var rotationRadians = -rotation / 360.0 * 2.0 * Math.PI;
var sin = Math.Sin(rotationRadians);
var cos = Math.Cos(rotationRadians);
var origoX = area.Width / 2.0;
var origoY = area.Height / 2.0;
// Translate point to origo before rotation
var ox = normalizedPoint.X - origoX;
var oy = normalizedPoint.Y - origoY;
// Move area to origo, calculate new point positions, restore area location and add crop margins
var x = ox * cos - oy * sin;
var y = ox * sin + oy * cos;
// Translate point back to area after rotation
x = x + origoX;
y = y + origoY;
// Add margins from original uncropped frame
x = x + area.X;
y = y + area.Y;
return new Windows.Foundation.Point(x, y);
})
});
}
}
}
public RecipeCPPFilter(IImageProvider source, double factor)
: base(source)
{
filter = new CPP.MyFilter(factor);
delegatingFilter = new DelegatingFilter(filter);
effect = new FilterEffect(source);
effect.Filters = new IFilter[] { delegatingFilter };
SetPipelineBeginEnd(effect, effect);
}
public RecipeDaisyChain(IImageProvider source, double factor)
: base(source)
{
effect_1 = new HdrEffect(source);
effect_2 = new FilterEffect(effect_1);
if(factor>2) factor = 2;
effect_2.Filters = new IFilter[] { new HueSaturationFilter(-1 + factor, 0), new LomoFilter() };
SetPipelineBeginEnd(effect_1, effect_2);
}
public async Task RenderEmptyCustomFilter()
{
var customFilter = new EmptyCustomFilter();
using (var source = KnownImages.MikikoLynn.ImageSource)
using (var filterEffect = new FilterEffect(source) { Filters = new[] { customFilter } })
using (var renderer = new JpegRenderer(filterEffect))
{
var buffer = await renderer.RenderAsync();
ImageResults.Instance.SaveToPicturesLibrary(buffer);
}
}
/// <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>
/// Constructs a high pass effect with the specified parameters.
/// </summary>
/// <param name="kernelSize">The size of the filter kernel. A larger size preserves more of lower frequencies.</param>
/// <param name="isGrayscale">True if the highpass effect should give a grayscale result. Otherwise the individual R, G, B channels are treated separately.</param>
/// <param name="downscaleDivisor">How much to downscale the image to reduce the cost of the internal blur operation, trading speed for some fidelity. Suitable value depends on the kernelSize.</param>
public HighpassEffect(uint kernelSize, bool isGrayscale = false, uint downscaleDivisor = 1)
{
m_kernelSize = kernelSize;
m_downscaleDivisor = downscaleDivisor;
m_isGrayscale = isGrayscale;
if (m_downscaleDivisor > 1)
{
m_downscaleFilterEffect = new FilterEffect(/*source*/)
{
Filters = new IFilter[] { new ScaleFilter(1.0 / m_downscaleDivisor) }
};
m_downscaleCachingEffect = new CachingEffect(m_downscaleFilterEffect);
int blurKernelSize = Math.Max(1, (int)(3.0 * m_kernelSize / m_downscaleDivisor));
m_blurFilter = new BlurFilter(blurKernelSize);
m_blurredFilterEffect = new FilterEffect(m_downscaleCachingEffect)
{
Filters = new IFilter[] { m_blurFilter }
};
m_highPassBlendEffect = new BlendEffect(/*source*/)
{
ForegroundSource = m_blurredFilterEffect,
BlendFunction = BlendFunction.SignedDifference
};
}
else
{
int blurKernelSize = Math.Max(1, (int)(3.0 * m_kernelSize));
m_blurFilter = new BlurFilter(blurKernelSize);
m_blurredFilterEffect = new FilterEffect(/*source*/)
{
Filters = new IFilter[] { m_blurFilter }
};
m_highPassBlendEffect = new BlendEffect(/*source*/)
{
ForegroundSource = m_blurredFilterEffect,
BlendFunction = BlendFunction.SignedDifference
};
}
if (m_isGrayscale)
{
m_highPassGrayscaleFilterEffect = new FilterEffect(m_highPassBlendEffect)
{
Filters = new IFilter[] { new GrayscaleFilter() }
};
}
}
public async static Task <WriteableBitmap> Render(WriteableBitmap actualImage, List <IFilter> filters)
{
var bitmap = actualImage.AsBitmap();
BitmapImageSource bitmapSource = new BitmapImageSource(bitmap);
FilterEffect effects = new FilterEffect(bitmapSource);
effects.Filters = filters;
WriteableBitmapRenderer renderer = new WriteableBitmapRenderer(effects, actualImage);
return(await renderer.RenderAsync());
}
public void CreatesFilterEffectGraph()
{
var bitmap = new Bitmap(new Size(10, 10), ColorMode.Argb8888);
using (var source = new BitmapImageSource(bitmap))
using (var effect = new FilterEffect(source))
{
effect.Filters = new IFilter[] { new BlurFilter(), new MoonlightFilter(), new HueSaturationFilter() };
string result = CreateGraph(effect);
Assert.AreEqual(2, new Regex(Regex.Escape(NodeId(source))).Matches(result).Count);
Assert.AreEqual(3, new Regex(Regex.Escape(NodeId(effect))).Matches(result).Count);
}
}
public async Task RenderBitmapAsync(WriteableBitmap bitmap)
{
using (FilterEffect effect = new FilterEffect(ImageSource)
{
Filters = _filters
})
using (WriteableBitmapRenderer renderer = new WriteableBitmapRenderer(effect, bitmap))
{
await renderer.RenderAsync();
bitmap.Invalidate();
}
}
public async static Task<WriteableBitmap> Render(WriteableBitmap actualImage, List<IFilter> filters)
{
var bitmap = actualImage.AsBitmap();
BitmapImageSource bitmapSource = new BitmapImageSource(bitmap);
FilterEffect effects = new FilterEffect(bitmapSource);
effects.Filters = filters;
WriteableBitmapRenderer renderer = new WriteableBitmapRenderer(effects, actualImage);
return await renderer.RenderAsync();
}
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();
}
/// <summary>
/// Constructs a high pass effect with the specified parameters.
/// </summary>
/// <param name="kernelSize">The size of the filter kernel. A larger size preserves more of lower frequencies.</param>
/// <param name="isGrayscale">True if the highpass effect should give a grayscale result. Otherwise the individual R, G, B channels are treated separately.</param>
/// <param name="downscaleDivisor">How much to downscale the image to reduce the cost of the internal blur operation, trading speed for some fidelity. Suitable value depends on the kernelSize.</param>
public HighpassEffect(uint kernelSize, bool isGrayscale = false, uint downscaleDivisor = 1)
{
m_kernelSize = kernelSize;
m_downscaleDivisor = downscaleDivisor;
m_isGrayscale = isGrayscale;
if (m_downscaleDivisor > 1)
{
m_downscaleFilterEffect = new FilterEffect(/*source*/) { Filters = new IFilter[] { new ScaleFilter(1.0 / m_downscaleDivisor) } };
m_downscaleCachingEffect = new CachingEffect(m_downscaleFilterEffect);
int blurKernelSize = Math.Max(1, (int)(3.0 * m_kernelSize / m_downscaleDivisor));
m_blurFilter = new BlurFilter(blurKernelSize);
m_blurredFilterEffect = new FilterEffect(m_downscaleCachingEffect)
{
Filters = new IFilter[] { m_blurFilter }
};
m_highPassBlendEffect = new BlendEffect( /*source*/)
{
ForegroundSource = m_blurredFilterEffect,
BlendFunction = BlendFunction.SignedDifference
};
}
else
{
int blurKernelSize = Math.Max(1, (int)(3.0 * m_kernelSize));
m_blurFilter = new BlurFilter(blurKernelSize);
m_blurredFilterEffect = new FilterEffect(/*source*/)
{
Filters = new IFilter[] { m_blurFilter }
};
m_highPassBlendEffect = new BlendEffect( /*source*/)
{
ForegroundSource = m_blurredFilterEffect,
BlendFunction = BlendFunction.SignedDifference
};
}
if (m_isGrayscale)
{
m_highPassGrayscaleFilterEffect = new FilterEffect(m_highPassBlendEffect)
{
Filters = new IFilter[] { new GrayscaleFilter() }
};
}
}
/// <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();
}
}
private async Task ApplyOriginalAsync()
{
OriginalBitmap = new WriteableBitmap(OriginalBitmap.PixelWidth, OriginalBitmap.PixelHeight);
using (FilterEffect effect = new FilterEffect(ImageSource)
{
Filters = _filters
})
using (WriteableBitmapRenderer renderer = new WriteableBitmapRenderer(effect, OriginalBitmap))
{
await renderer.RenderAsync();
OriginalBitmap.Invalidate();
}
}
private static IReadOnlyList <IImageProvider> CreateFramedAnimation(IReadOnlyList <IImageProvider> images, Rect animationBounds, int w, int h)
{
List <IImageProvider> framedAnimation = new List <IImageProvider>();
WriteableBitmap maskBitmap = new WriteableBitmap(w, h);
var backgroundRectangle = new Rectangle
{
Fill = new SolidColorBrush(Colors.Black),
Width = w,
Height = h,
};
maskBitmap.Render(backgroundRectangle, new TranslateTransform());
var foregroundRectangle = new Rectangle
{
Fill = new SolidColorBrush(Colors.White),
Width = animationBounds.Width,
Height = animationBounds.Height,
};
TranslateTransform foregroundTranslate = new TranslateTransform
{
X = animationBounds.X,
Y = animationBounds.Y
};
maskBitmap.Render(foregroundRectangle, foregroundTranslate);
maskBitmap.Invalidate();
foreach (IImageProvider frame in images)
{
FilterEffect filterEffect = new FilterEffect(images[0]);
BlendFilter blendFilter = new BlendFilter(frame, BlendFunction.Normal, 1.0)
{
MaskSource = new BitmapImageSource(maskBitmap.AsBitmap())
};
filterEffect.Filters = new List <IFilter>()
{
blendFilter
};
framedAnimation.Add(filterEffect);
}
return(framedAnimation);
}
private void Subgraph(FilterEffect filterEffect)
{
Node(filterEffect, "parallelogram", NodePart.ImageProviderProperties);
m_dotString += String.Format("subgraph cluster_{0} {{ rank = same; label=\"FilterEffect with filters\"; graph[style=dotted]", NodeId(filterEffect));
Node(filterEffect, "parallelogram", NodePart.GeneralProperties);
foreach (var filter in filterEffect.Filters)
{
Node(filter, "box");
}
m_dotString += " } ";
}
public HslAdjustmentEffect()
{
m_filterEffect = new FilterEffect();
m_saturation = new int[ChannelCount];
m_lightness = new int[ChannelCount];
m_hslFilter = new HueSaturationLightnessFilter();
m_masterLightnessCurvesFilter = new CurvesFilter(m_masterLightnessCurve);
m_masterLightnessCurve = new Curve(CurveInterpolation.Linear);
m_tempCurve = new Curve(CurveInterpolation.Linear);
m_filtersWithoutMasterLightness = new IFilter[] { m_hslFilter };
m_allFilters = new IFilter[] { m_hslFilter, m_masterLightnessCurvesFilter };
}
public async Task RenderProviderAndEffect()
{
var tile = KnownImages.MikikoLynn;
using (var tileSource = tile.ImageSource)
using (var source = new RepeatedTileImageSource(new Size(3048, 3048), tileSource, tile.Size))
using (var filterEffect = new FilterEffect(source))
using (var renderer = new JpegRenderer(filterEffect))
{
filterEffect.Filters = new[] { new GrayscaleFilter() };
var buffer = await renderer.RenderAsync();
ImageResults.Instance.SaveToPicturesLibrary(buffer, "RepeatedTileGrayscaleRender.jpg");
}
}
public async Task RenderProviderCreatedFromTileSource()
{
var tile = KnownImages.MikikoLynn;
using (var tileSource = tile.ImageSource)
using (var source = await RepeatedTileImageSource.CreateFromTileSource(new Size(4048, 4048), tileSource))
using (var filterEffect = new FilterEffect(source))
using (var renderer = new JpegRenderer(filterEffect))
{
filterEffect.Filters = new[] { new CartoonFilter() };
var buffer = await renderer.RenderAsync();
ImageResults.Instance.SaveToPicturesLibrary(buffer, "RepeatedTileCartoonRender.jpg");
}
}
private async Task ApplyFilter(ImageFilter imageFilter, Image image)
{
FilterEffect effect = new FilterEffect(new BitmapImageSource(ImageToFilter.AsBitmap()));
effect.Filters = new IFilter[] { imageFilter.Filter };
WriteableBitmap temporaryImage = new WriteableBitmap(MainPage.ImageToFilter);
WriteableBitmapRenderer renderer = new WriteableBitmapRenderer(effect, temporaryImage);
await renderer.RenderAsync();
image.Source = temporaryImage;
// Here we create a new EditingSession based on our selected image and add the selected filter to it
// After the picture gets rendered to our delivered image
//editingSession = new EditingSession(ImageToFilter.AsBitmap());
//editingSession.AddFilter(imageFilter.Filter);
//await editingSession.RenderToImageAsync(image, OutputOption.PreserveAspectRatio);
}
async void FilterView_Loaded(object sender, RoutedEventArgs e)
{
// To edit a picture with the Nokia Imaging SDK we need a FilterEffect
// Such a filter session is based on an image and one or more filters
// Here we create a new FilterEffect that is based on our on the MainPage selected image
FilterEffect effect = new FilterEffect(new BitmapImageSource(MainPage.ImageToFilter.AsBitmap()));
// Add the filter we want to offer to our users to the list
// You can find an overview of mor filters here: http://developer.nokia.com/Resources/Library/Lumia/#!nokia-imaging-sdk.html
filterList = new List<ImageFilter>();
filterList.Add(new ImageFilter("Cartoon", new CartoonFilter(true)));
filterList.Add(new ImageFilter("Antique", new AntiqueFilter()));
filterList.Add(new ImageFilter("Color Boost", new ColorBoostFilter(2)));
filterList.Add(new ImageFilter("Gray Scale", new GrayscaleFilter()));
filterList.Add(new ImageFilter("Negative", new NegativeFilter()));
filterList.Add(new ImageFilter("Sktech", new SketchFilter(SketchMode.Color)));
filterList.Add(new ImageFilter("Mirror", new MirrorFilter()));
// Here we add a new PivotItem for every filter we want to use
// So the user can flip through all offered filters in the PivotControl of this page
foreach (ImageFilter imageFilter in filterList)
{
// Create a new Image that we can add to each PivotItem later as a preview of the filter
Image pivotItemImage = new Image();
pivotItemImage.Width = 400;
pivotItemImage.Height = 400;
// Create the PivotItem that we want to add and set its content to the preview image we created above
PivotItem pivotItem = new PivotItem();
pivotItem.Header = imageFilter.Name;
pivotItem.Content = pivotItemImage;
// Now we add the created PivotItem to the PivotControl on this page
FilterPivot.Items.Add(pivotItem);
// Add the current filter
effect.Filters = new IFilter[] { imageFilter.Filter };
// Last we need to render the preview image
WriteableBitmap temporaryImage = new WriteableBitmap(MainPage.ImageToFilter);
WriteableBitmapRenderer renderer = new WriteableBitmapRenderer(effect, temporaryImage);
await renderer.RenderAsync();
pivotItemImage.Source = temporaryImage;
}
}
public async Task RenderRgbGainCustomFilter()
{
var customFilter = new RgbGainCustomFilter()
{
RedLevel = 1.5f,
GreenLevel = 1.0f,
BlueLevel = 0.75f
};
using (var source = KnownImages.MikikoLynn.ImageSource)
using (var filterEffect = new FilterEffect(source) { Filters = new[] { customFilter } })
using (var renderer = new JpegRenderer(filterEffect))
{
var buffer = await renderer.RenderAsync();
ImageResults.Instance.SaveToPicturesLibrary(buffer);
}
}
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 static IReadOnlyList<IImageProvider> CreateFramedAnimation(IReadOnlyList<IImageProvider> images, Rect animationBounds, int w, int h)
{
List<IImageProvider> framedAnimation = new List<IImageProvider>();
WriteableBitmap maskBitmap = new WriteableBitmap(w, h);
var backgroundRectangle = new Rectangle
{
Fill = new SolidColorBrush(Colors.Black),
Width = w,
Height = h,
};
maskBitmap.Render(backgroundRectangle, new TranslateTransform());
var foregroundRectangle = new Rectangle
{
Fill = new SolidColorBrush(Colors.White),
Width = animationBounds.Width,
Height = animationBounds.Height,
};
TranslateTransform foregroundTranslate = new TranslateTransform
{
X = animationBounds.X,
Y = animationBounds.Y
};
maskBitmap.Render(foregroundRectangle, foregroundTranslate);
maskBitmap.Invalidate();
foreach (IImageProvider frame in images)
{
FilterEffect filterEffect = new FilterEffect(images[0]);
BlendFilter blendFilter = new BlendFilter(frame, BlendFunction.Normal, 1.0)
{
MaskSource = new BitmapImageSource(maskBitmap.AsBitmap())
};
filterEffect.Filters = new List<IFilter>() { blendFilter };
framedAnimation.Add(filterEffect);
}
return framedAnimation;
}
/// <summary>
/// Initialize and start the camera preview
/// </summary>
public async Task InitializeAsync()
{
if (CaptureButton.Content.ToString().Equals("Capture and Canny"))
{
CaptureButton.Content = "Stop";
// Create a camera preview image source (from Imaging SDK)
if (_cameraPreviewImageSource == null)
{
_cameraPreviewImageSource = new CameraPreviewImageSource();
await _cameraPreviewImageSource.InitializeAsync(string.Empty);
}
var properties = await _cameraPreviewImageSource.StartPreviewAsync();
// Create a preview bitmap with the correct aspect ratio
var width = 640.0;
var height = (width / properties.Width) * properties.Height;
var bitmap = new WriteableBitmap((int)width, (int)height);
_writeableBitmap = bitmap;
// Create a filter effect to be used with the source (e.g. used to correct rotation)
_effect = new FilterEffect(_cameraPreviewImageSource);
_effect.Filters = new IFilter[] { new RotationFilter(90.0) };
_writeableBitmapRenderer = new WriteableBitmapRenderer(_effect, _writeableBitmap);
ImageView.Source = _writeableBitmap;
// Attach preview frame delegate
_cameraPreviewImageSource.PreviewFrameAvailable += OnPreviewFrameAvailable;
}
else
{
if (CaptureButton.Content.ToString().Equals("Stop"))
{
await _cameraPreviewImageSource.StopPreviewAsync();
_cameraPreviewImageSource.Dispose();
_cameraPreviewImageSource = null;
}
CaptureButton.Content = "Capture and Canny";
ImageView.Source = null;
}
}
// Protected implementation of Dispose pattern.
protected override void Dispose(bool disposing)
{
if (disposed)
return;
if (disposing)
{
}
if (effect_1 != null)
{
effect_1.Dispose();
effect_1 = null;
}
if (effect_2 != null)
{
effect_2.Dispose();
effect_2 = null;
}
disposed = true;
// Call base class implementation.
base.Dispose(disposing);
}
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;
}
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;
}
}
private bool isRendering; // Used to prevent multiple renderers running at once
public async Task InitializeAsync()
{
// Discover all the cameras
await EnumerateCamerasAsync();
// Create a camera preview image source (from Imaging SDK)
cameraPreviewImageSource = new CameraPreviewImageSource();
await cameraPreviewImageSource.InitializeAsync(backCamera.Id);
var properties = await cameraPreviewImageSource.StartPreviewAsync();
VideoDeviceController controller = (VideoDeviceController)cameraPreviewImageSource.VideoDeviceController;
// Create a preview bitmap with the correct aspect ratio
var width = properties.Width;
var height = properties.Height;
var bitmap = new WriteableBitmap((int)width, (int)height);
outputBitmap = bitmap;
// Create a filter effect to be used with the source (no filters yet)
//effect = new LensBlurEffect(cameraPreviewImageSource, new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Circle, 50));
effect = new FilterEffect(cameraPreviewImageSource);
var blur = new BlurFilter();
blur.KernelSize = 30;
blur.BlurRegionShape = BlurRegionShape.Elliptical;
effect.Filters = new[] { blur };
renderer = new WriteableBitmapRenderer(effect, outputBitmap);
Initialized = true;
CaptureImage.Source = outputBitmap;
// Attach preview frame delegate
cameraPreviewImageSource.PreviewFrameAvailable += OnPreviewFrameAvailable;
}
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;
}
async void GeneratePicture()
{
try
{
var info = await picture.GetInfoAsync();
var bmp = new WriteableBitmap((int)info.ImageSize.Width, (int)info.ImageSize.Height);
rendering = true;
// using (var effect = new CustomEffect.HighlightAlpha(picture,13))
using (var effect = new FilterEffect(picture) { Filters = new IFilter[] { new HighlightAlphaFilter(13) } })
using (var renderer = new WriteableBitmapRenderer(effect, bmp, OutputOption.PreserveAspectRatio))
{
display.Source = await renderer.RenderAsync();
}
}
finally
{
rendering = false;
}
}
protected override void SetFilters(FilterEffect effect)
{
effect.Filters = new List<IFilter>() { _levelFilter, _curvesFilter, _vignettingFilter, _hueSaturationFilter, _colorAdjustFilter };
}
protected override void SetFilters(FilterEffect effect)
{
effect.Filters = new List<IFilter>() { _flipFilter, _mirrorFilter };
}
protected override void SetFilters(FilterEffect effect)
{
effect.Filters = new List<IFilter>() { _rotateLeftFilter, _mirrorFilter, _rotateRightFilter };
}
protected override void SetFilters(FilterEffect effect)
{
effect.Filters = new List<IFilter>() { _colorSwapFilter };
}
