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 }; }