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

 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 RecipeCSharpFilter(IImageProvider source, double factor)
            : base(source)
        {
            effect = new FilterEffect(source);
            effect.Filters = new IFilter[]{new CSharp.MyFilter (factor)};

             SetPipelineBeginEnd(effect, effect);
        }

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

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

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

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

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

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

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