示例#1
0
        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;
        }
示例#2
0
        private async void OnImageUrlChanged()
        {
            if (ImageUrl == null)
            {
                return;
            }

            var rass = RandomAccessStreamReference.CreateFromUri(new Uri(ImageUrl, UriKind.Absolute));
            IRandomAccessStream stream = await rass.OpenReadAsync();
            var decoder = await BitmapDecoder.CreateAsync(stream);

            Rect bounds = Window.Current.Bounds;
            //WriteableBitmap bmp = new WriteableBitmap((int)bounds.Width, (int)bounds.Height);
            var displayWidth = Math.Min(decoder.PixelWidth, bounds.Width);
            var displayHeight = Math.Min(decoder.PixelHeight, bounds.Height);
            WriteableBitmap bmp = new WriteableBitmap((int)displayWidth, (int)displayHeight);

            stream.Seek(0);

            //var blurFilter = new BlurFilter(60);
            using (var source = new RandomAccessStreamImageSource(stream))
            using (var blurFilter = new LensBlurEffect(source, new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Circle, 20)))
            //using (var filterEffect = new FilterEffect(source) { Filters = new[] { blurFilter } })
            using (var renderer = new WriteableBitmapRenderer(blurFilter, bmp))
            {
                

                bmp = await renderer.RenderAsync();
                bmp.Invalidate(); 
                BackgroundImage.Source = bmp;
            }
            
        }
示例#3
0
        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 void Dot(LensBlurEffect lensBlurEffect)
            {
                Subgraph(lensBlurEffect);

                if (lensBlurEffect.Kernels != null)
                {
                    Dot(lensBlurEffect, lensBlurEffect.Kernels);
                }
            }
 private async Task<IImageProvider> GetEffectTaskAsync(IImageProvider source, Size sourceSize, Size renderSize)
 {
     var file = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///images/LensBlurMask.jpg"));
     StorageFileImageSource mapSource = new StorageFileImageSource(file);
     var lensBlurEffect = new LensBlurEffect(source, mapSource);
     lensBlurEffect.FocusAreaEdgeMirroring= LensBlurFocusAreaEdgeMirroring.Off;
     lensBlurEffect.PointLightStrength = 10;
     lensBlurEffect.Kernels = new LensBlurPredefinedKernel[] { new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Heart, 15)};
     return lensBlurEffect;
 }
 private void Dot(LensBlurEffect lensBlurEffect, IReadOnlyList <ILensBlurKernel> kernels)
 {
     foreach (var kernel in kernels)
     {
         if (kernel is LensBlurCustomKernel)
         {
             var customKernel = kernel as LensBlurCustomKernel;
             Dot(customKernel.Shape);
         }
     }
 }
        protected override MaybeTask <IImageProvider> GetEffectInternalAsync(IImageProvider source, Size sourceSize, Size renderSize)
        {
            var current = source;

            var gradientImageSource = new GradientImageSource(sourceSize, new RadialGradient(new Point(0.5, 0.3), new EllipseRadius(1.0, 0),
                                                                                             new[] {
                new GradientStop()
                {
                    Color = Color.FromArgb(255, 255, 255, 255), Offset = 0
                },
                new GradientStop()
                {
                    Color = Color.FromArgb(255, 255, 255, 255), Offset = 0.1
                },
                new GradientStop()
                {
                    Color = Color.FromArgb(255, 0, 0, 0), Offset = 0.101
                },
                new GradientStop()
                {
                    Color = Color.FromArgb(255, 16, 16, 16), Offset = 0.8
                },
            }
                                                                                             ));

            var lensblur = new LensBlurEffect(source, gradientImageSource,
                                              new ILensBlurKernel[]
            {
                new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 1),
                new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 2),
                new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 3),
                new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 4),
                new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 5),
                new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 6),
                new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 7),
                new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 8),
                new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 9),
                new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 10),
                new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 11),
                new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 12),
                new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 13),
                new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 14),
                new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 15),
                new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 20),
                new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 25),
            });

            lensblur.BlendKernelWidth       = 10;
            lensblur.FocusAreaEdgeMirroring = LensBlurFocusAreaEdgeMirroring.Off;
            // TODO lower quality in preview mode.
            lensblur.Quality = 1.0;

            return(new MaybeTask <IImageProvider>(lensblur));
        }
示例#8
0
        private async Task <IImageProvider> GetEffectTaskAsync(IImageProvider source, Size sourceSize, Size renderSize)
        {
            var file = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///images/LensBlurMask.jpg"));

            StorageFileImageSource mapSource = new StorageFileImageSource(file);
            var lensBlurEffect = new LensBlurEffect(source, mapSource);

            lensBlurEffect.FocusAreaEdgeMirroring = LensBlurFocusAreaEdgeMirroring.Off;
            lensBlurEffect.PointLightStrength     = 10;
            lensBlurEffect.Kernels = new LensBlurPredefinedKernel[] { new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Heart, 15) };
            return(lensBlurEffect);
        }
        public LensBlurProcessor()          
        {
            CanRenderAtPreviewSize = false;
            Name = "LensBlurEffect";
            List<IImageProvider> list = new List<IImageProvider>();

            byte[] map = new byte[] { 255, 255, 255, 255, 0, 255, 255, 255, 255 };

            Bitmap bitmap = new Bitmap(new Size(3, 3), ColorMode.Gray8, 3, map.AsBuffer());
            BitmapImageSource mapSource = new BitmapImageSource(bitmap);
            list.Add(mapSource);

            map = new byte[] { 255, 0 };
            bitmap = new Bitmap(new Size(2, 1), ColorMode.Gray8, 2, map.AsBuffer());
            mapSource = new BitmapImageSource(bitmap);
            list.Add(mapSource);

            map = new byte[] { 0, 255 };
            bitmap = new Bitmap(new Size(2, 1), ColorMode.Gray8, 2, map.AsBuffer());
            mapSource = new BitmapImageSource(bitmap);
            list.Add(mapSource);

            map = new byte[] { 255, 0 };
            bitmap = new Bitmap(new Size(1, 2), ColorMode.Gray8, 1, map.AsBuffer());
            mapSource = new BitmapImageSource(bitmap);
            list.Add(mapSource);

            map = new byte[] { 0, 255 };
            bitmap = new Bitmap(new Size(1, 2), ColorMode.Gray8, 1, map.AsBuffer());
            mapSource = new BitmapImageSource(bitmap);
            list.Add(mapSource);

            map = new byte[] { 0 };
            bitmap = new Bitmap(new Size(1, 1), ColorMode.Gray8, 1, map.AsBuffer());
            mapSource = new BitmapImageSource(bitmap);
            list.Add(mapSource);

            m_KernelMaps = list.ToArray();

            m_lensBlurEffect = new LensBlurEffect();
            SetupEffectCategory(m_lensBlurEffect);
            m_lensBlurEffect.KernelMap = m_KernelMaps[0];

            m_propertyDescriptions = new Dictionary<string, PropertyDescription>();
            m_propertyDescriptions.Add("BlendKernelWidth", new PropertyDescription(0, 255, 5));
            m_propertyDescriptions.Add("PointLightStrength", new PropertyDescription(1, 10, 7));
            m_propertyDescriptions.Add("Quality", new PropertyDescription(0, 1.0, 1.0));

            AddEditors();
   
        }
示例#10
0
        public LensBlurProcessor()
        {
            CanRenderAtPreviewSize = false;
            Name = "LensBlurEffect";
            List <IImageProvider> list = new List <IImageProvider>();

            byte[] map = new byte[] { 255, 255, 255, 255, 0, 255, 255, 255, 255 };

            Bitmap            bitmap    = new Bitmap(new Size(3, 3), ColorMode.Gray8, 3, map.AsBuffer());
            BitmapImageSource mapSource = new BitmapImageSource(bitmap);

            list.Add(mapSource);

            map       = new byte[] { 255, 0 };
            bitmap    = new Bitmap(new Size(2, 1), ColorMode.Gray8, 2, map.AsBuffer());
            mapSource = new BitmapImageSource(bitmap);
            list.Add(mapSource);

            map       = new byte[] { 0, 255 };
            bitmap    = new Bitmap(new Size(2, 1), ColorMode.Gray8, 2, map.AsBuffer());
            mapSource = new BitmapImageSource(bitmap);
            list.Add(mapSource);

            map       = new byte[] { 255, 0 };
            bitmap    = new Bitmap(new Size(1, 2), ColorMode.Gray8, 1, map.AsBuffer());
            mapSource = new BitmapImageSource(bitmap);
            list.Add(mapSource);

            map       = new byte[] { 0, 255 };
            bitmap    = new Bitmap(new Size(1, 2), ColorMode.Gray8, 1, map.AsBuffer());
            mapSource = new BitmapImageSource(bitmap);
            list.Add(mapSource);

            map       = new byte[] { 0 };
            bitmap    = new Bitmap(new Size(1, 1), ColorMode.Gray8, 1, map.AsBuffer());
            mapSource = new BitmapImageSource(bitmap);
            list.Add(mapSource);

            m_KernelMaps = list.ToArray();

            m_lensBlurEffect = new LensBlurEffect();
            SetupEffectCategory(m_lensBlurEffect);
            m_lensBlurEffect.KernelMap = m_KernelMaps[0];

            m_propertyDescriptions = new Dictionary <string, PropertyDescription>();
            m_propertyDescriptions.Add("BlendKernelWidth", new PropertyDescription(0, 255, 5));
            m_propertyDescriptions.Add("PointLightStrength", new PropertyDescription(1, 10, 7));
            m_propertyDescriptions.Add("Quality", new PropertyDescription(0, 1.0, 1.0));

            AddEditors();
        }
示例#11
0
        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);

            if (LensBlurEffect != null)
            {
                LensBlurEffect.Dispose();
                LensBlurEffect = null;
            }

            if (KernelMapSource != null && KernelMapSource is IDisposable)
            {
                (KernelMapSource as IDisposable).Dispose();
                KernelMapSource = null;
            }
        }
 public void CreatesLensBlurGraph()
 {
     var bitmap = new Bitmap(new Size(10, 10), ColorMode.Argb8888);
     using (var source = new BitmapImageSource(bitmap))
     using (var kernel1 = new BitmapImageSource(bitmap))
     using (var kernel2 = new BitmapImageSource(bitmap))
     using (var kernelMap = new BitmapImageSource(bitmap))
     using (var lensBlur = new LensBlurEffect(source, kernelMap))
     {
         lensBlur.Kernels = new ILensBlurKernel[] { new LensBlurCustomKernel(kernel1, 10), new LensBlurCustomKernel(kernel2, 20), new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Circle, 10) };
         string result = CreateGraph(lensBlur);
         Assert.AreEqual(2, new Regex(Regex.Escape(NodeId(source))).Matches(result).Count);
         Assert.AreEqual(2, new Regex(Regex.Escape(NodeId(kernel1))).Matches(result).Count);
         Assert.AreEqual(2, new Regex(Regex.Escape(NodeId(kernel2))).Matches(result).Count);
         Assert.AreEqual(2, new Regex(Regex.Escape(NodeId(kernelMap))).Matches(result).Count);
         Assert.AreEqual(4, new Regex(Regex.Escape(NodeId(lensBlur))).Matches(result).Count);
     }
 }
        public void CreatesLensBlurGraph()
        {
            var bitmap = new Bitmap(new Size(10, 10), ColorMode.Argb8888);

            using (var source = new BitmapImageSource(bitmap))
                using (var kernel1 = new BitmapImageSource(bitmap))
                    using (var kernel2 = new BitmapImageSource(bitmap))
                        using (var kernelMap = new BitmapImageSource(bitmap))
                            using (var lensBlur = new LensBlurEffect(source, kernelMap))
                            {
                                lensBlur.Kernels = new ILensBlurKernel[] { new LensBlurCustomKernel(kernel1, 10), new LensBlurCustomKernel(kernel2, 20), new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Circle, 10) };
                                string result = CreateGraph(lensBlur);
                                Assert.AreEqual(2, new Regex(Regex.Escape(NodeId(source))).Matches(result).Count);
                                Assert.AreEqual(2, new Regex(Regex.Escape(NodeId(kernel1))).Matches(result).Count);
                                Assert.AreEqual(2, new Regex(Regex.Escape(NodeId(kernel2))).Matches(result).Count);
                                Assert.AreEqual(2, new Regex(Regex.Escape(NodeId(kernelMap))).Matches(result).Count);
                                Assert.AreEqual(4, new Regex(Regex.Escape(NodeId(lensBlur))).Matches(result).Count);
                            }
        }
        protected override MaybeTask<IImageProvider> GetEffectInternalAsync(IImageProvider source, Size sourceSize, Size renderSize)
        {
            var current = source;

           var gradientImageSource =  new GradientImageSource(sourceSize, new RadialGradient(new Point(0.5, 0.3), new EllipseRadius(1.0, 0),
             new[] { 
                            new GradientStop() { Color = Color.FromArgb(255, 255, 255, 255), Offset = 0 }, 
                            new GradientStop() { Color = Color.FromArgb(255, 255, 255, 255), Offset = 0.1 }, 
                            new GradientStop() { Color = Color.FromArgb(255, 0, 0, 0), Offset = 0.101 }, 
                            new GradientStop() { Color = Color.FromArgb(255, 16, 16, 16), Offset = 0.8 }, 
                     }
                 ));

            var lensblur = new LensBlurEffect(source, gradientImageSource,
                new ILensBlurKernel[] 
                { 
                    new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 1), 
                    new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 2), 
                    new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 3), 
                    new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 4), 
                    new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 5), 
                    new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 6), 
                    new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 7), 
                    new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 8),
                    new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 9),                 
                    new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 10),
                    new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 11),
                    new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 12),
                    new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 13),
                    new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 14), 
                    new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 15), 
                    new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 20), 
                    new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 25), 
                    
                });

            lensblur.BlendKernelWidth = 10;
            lensblur.FocusAreaEdgeMirroring = LensBlurFocusAreaEdgeMirroring.Off;
            // TODO lower quality in preview mode.
            lensblur.Quality = 1.0;

            return new MaybeTask<IImageProvider>(lensblur);
        }
            private void Subgraph(LensBlurEffect lensBlurEffect)
            {
                Node(lensBlurEffect, "parallelogram", NodePart.ImageProviderProperties);

                m_dotString += String.Format("subgraph cluster_{0} {{ rank = same; label=\"LensBlurEffect with Kernels\"; graph[style=dotted]", NodeId(lensBlurEffect));

                Node(lensBlurEffect, "parallelogram", NodePart.GeneralProperties);

                foreach (var kernel in lensBlurEffect.Kernels)
                {
                    Node(kernel, "box", NodePart.GeneralProperties);
                }

                m_dotString += " } ";

                foreach (var kernel in lensBlurEffect.Kernels)
                {
                    Node(kernel, "box", NodePart.ImageProviderProperties);
                }
            }
        public void CreatesQuiteComplexGraph()
        {
            var bitmap = new Bitmap(new Size(10, 10), ColorMode.Argb8888);

            using (var source1 = new BitmapImageSource(bitmap))
                using (var source2 = new BitmapImageSource(bitmap))
                    using (var source3 = new BitmapImageSource(bitmap))
                        using (var source4 = new BitmapImageSource(bitmap))
                            using (var segmenter = new InteractiveForegroundSegmenter(source1, Color.FromArgb(255, 255, 0, 0), Color.FromArgb(255, 0, 255, 0), source2))
                                using (var bokeh = new LensBlurEffect(source1, segmenter))
                                    using (var blendEffect = new BlendEffect(bokeh, source3))
                                    {
                                        string result = CreateGraph(blendEffect);
                                        Assert.AreEqual(3, new Regex(Regex.Escape(NodeId(source1))).Matches(result).Count);
                                        Assert.AreEqual(2, new Regex(Regex.Escape(NodeId(source2))).Matches(result).Count);
                                        Assert.AreEqual(2, new Regex(Regex.Escape(NodeId(source3))).Matches(result).Count);
                                        Assert.AreEqual(0, new Regex(Regex.Escape(NodeId(source4))).Matches(result).Count);
                                        Assert.AreEqual(4, new Regex(Regex.Escape(NodeId(segmenter))).Matches(result).Count);
                                        Assert.AreEqual(5, new Regex(Regex.Escape(NodeId(bokeh))).Matches(result).Count);
                                        Assert.AreEqual(3, new Regex(Regex.Escape(NodeId(blendEffect))).Matches(result).Count);
                                    }
        }
        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 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 void CreatesQuiteComplexGraph()
 {
     var bitmap = new Bitmap(new Size(10, 10), ColorMode.Argb8888);
     using (var source1 = new BitmapImageSource(bitmap))
     using (var source2 = new BitmapImageSource(bitmap))
     using (var source3 = new BitmapImageSource(bitmap))
     using (var source4 = new BitmapImageSource(bitmap))
     using (var segmenter = new InteractiveForegroundSegmenter(source1, Color.FromArgb(255, 255, 0, 0), Color.FromArgb(255, 0, 255, 0), source2))
     using (var bokeh = new LensBlurEffect(source1, segmenter))
     using (var blendEffect = new BlendEffect(bokeh, source3))
     {
         string result = CreateGraph(blendEffect);
         Assert.AreEqual(3, new Regex(Regex.Escape(NodeId(source1))).Matches(result).Count);
         Assert.AreEqual(2, new Regex(Regex.Escape(NodeId(source2))).Matches(result).Count);
         Assert.AreEqual(2, new Regex(Regex.Escape(NodeId(source3))).Matches(result).Count);
         Assert.AreEqual(0, new Regex(Regex.Escape(NodeId(source4))).Matches(result).Count);
         Assert.AreEqual(4, new Regex(Regex.Escape(NodeId(segmenter))).Matches(result).Count);
         Assert.AreEqual(5, new Regex(Regex.Escape(NodeId(bokeh))).Matches(result).Count);
         Assert.AreEqual(3, new Regex(Regex.Escape(NodeId(blendEffect))).Matches(result).Count);
     }
 }
示例#20
0
        private async void LensBlurThumb_Tapped(object sender, TappedRoutedEventArgs e)
        {
            FilteredImage.Width = PreviewImage.ActualWidth;
            FilteredImage.Height = PreviewImage.ActualHeight;

            PreviewImage.Visibility = Visibility.Collapsed;
            FilteredImage.Visibility = Visibility.Visible;
            using (_lensblurEffect = new LensBlurEffect())
                await ApplyEffectAsync(fPhotoStream, _lensblurEffect, FilteredImage);


        }
示例#21
0
        private async void OnTap(object sender, TappedRoutedEventArgs e)
        {
            

            ImageEncodingProperties imageProperties = ImageEncodingProperties.CreateJpeg();

            mediaCapture.CapturePhotoToStreamAsync(imageProperties, fPhotoStream).AsTask().Wait();

            fPhotoStream.FlushAsync().AsTask().Wait();
            fPhotoStream.Seek(0);
            WriteableBitmap bitter = new WriteableBitmap(100, 100);
            bitter.SetSource(fPhotoStream);

            await mediaCapture.StopPreviewAsync();
            captureElement.Visibility = Visibility.Collapsed;
            PreviewImage.Visibility = Visibility.Visible;

            PreviewImage.Source = bitter;
            NormalThumb.Source = bitter;

            using (_grayscaleEffect = new GrayscaleEffect())
                await ApplyEffectAsync(fPhotoStream, _grayscaleEffect, GreyScaleThumb);

            using (_colorboostEffect = new ColorBoostEffect())
            {
                _colorboostEffect.Gain = 0.75;
                await ApplyEffectAsync(fPhotoStream, _colorboostEffect, ColorBoostThumb);
            }

            using (_hueSaturationEffect = new HueSaturationEffect())
                await ApplyEffectAsync(fPhotoStream, _hueSaturationEffect, HueSaturationThumb);

            using (_lensblurEffect = new LensBlurEffect())
                await ApplyEffectAsync(fPhotoStream, _lensblurEffect, LensBlurThumb);

            using (_antiqueEffect = new AntiqueEffect())
                await ApplyEffectAsync(fPhotoStream, _antiqueEffect, SepiaThumb);


            
            

            inking_initialization();
            myInkCanvas.Visibility = Visibility.Visible;
        }
示例#22
0
        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 void Subgraph(LensBlurEffect lensBlurEffect)
            {
                Node(lensBlurEffect, "parallelogram", NodePart.ImageProviderProperties);

                m_dotString += String.Format("subgraph cluster_{0} {{ rank = same; label=\"LensBlurEffect with Kernels\"; graph[style=dotted]", NodeId(lensBlurEffect));

                Node(lensBlurEffect, "parallelogram", NodePart.GeneralProperties);

                foreach (var kernel in lensBlurEffect.Kernels)
                {
                    Node(kernel, "box", NodePart.GeneralProperties);
                }

                m_dotString += " } ";

                foreach (var kernel in lensBlurEffect.Kernels)
                {
                    Node(kernel, "box", NodePart.ImageProviderProperties);
                }
            }
		protected DepthOfFieldEffect(IImageProvider source, DepthOfFieldQuality quality)
			: base(source)
		{
			LensBlurEffect = new LensBlurEffect(source);
			Quality = quality;
		}
示例#25
0
        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;
            }
        }
示例#26
0
 private void DrawBlur()
 {
     LensBlurEffect effect = new LensBlurEffect();
 }
            private void Dot(LensBlurEffect lensBlurEffect)
            {
                Subgraph(lensBlurEffect);

                if (lensBlurEffect.Kernels != null)
                {
                    Dot(lensBlurEffect, lensBlurEffect.Kernels);
                }
            }
 private void Dot(LensBlurEffect lensBlurEffect, IReadOnlyList<ILensBlurKernel> kernels)
 {
     foreach (var kernel in kernels)
     {
         if (kernel is LensBlurCustomKernel)
         {
             var customKernel = kernel as LensBlurCustomKernel;
             Dot(customKernel.Shape);
         }
     }
 }
示例#29
0
 protected DepthOfFieldEffect(IImageProvider source, DepthOfFieldQuality quality)
     : base(source)
 {
     LensBlurEffect = new LensBlurEffect(source);
     Quality        = quality;
 }
示例#30
0
        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;
            }
        }