public void ApplyNegativeFilterFromFileTest()
        {
            // preperation

            FileStream inputFile          = new FileStream("..\\..\\..\\Resources\\OriginalCat.bmp", FileMode.Open, FileAccess.Read);
            FileStream expectedOutputFile = new FileStream("..\\..\\..\\Resources\\NegativeFilterCat.bmp", FileMode.Open, FileAccess.Read);

            byte[] temp = new byte[54];
            inputFile.Read(temp, 0, 54);
            BMPFileHeader  bmpInfo = new BMPFileHeader(temp);
            NegativeFilter image   = new NegativeFilter(bmpInfo, inputFile);

            // checking

            image.ApplyNegativeFilter();
            byte[] outputFile = new byte[bmpInfo.FileSize];
            image.WriteImage(outputFile);

            for (uint i = 0; i < bmpInfo.FileSize; i++)
            {
                Assert.IsTrue(outputFile[i] == (byte)expectedOutputFile.ReadByte());
            }

            inputFile.Close();
            expectedOutputFile.Close();
        }
Exemplo n.º 2
0
        public void GetNegativePixel()
        {
            originalPicture[0, 0] = new Pixel(100, 100, 100);
            resultPicture         = new NegativeFilter().ChangeImage(originalPicture, 100);

            Assert.IsTrue(resultPicture[0, 0].Equals(new Pixel(155, 155, 155)));
        }
        private void buildChainOfFilters(out FilterChain o_ImageFilter)
        {
            NegativeFilter negativeFilter = new NegativeFilter();
            RedFilter      redFilter      = new RedFilter();
            GreenFilter    greenFilter    = new GreenFilter();
            BlueFilter     blueFilter     = new BlueFilter();

            negativeFilter.SetNextChain(redFilter);
            redFilter.SetNextChain(greenFilter);
            greenFilter.SetNextChain(blueFilter);
            o_ImageFilter = negativeFilter;
        }
Exemplo n.º 4
0
        public static void DoSomething(string path)
        {
            var image = Image.Load(path);

            // Here you can select any pixel shader type in ColorInversionPixelShaderType enum
            var filter = new NegativeFilter(image, ColorInversionPixelShaderType.FullInversionByBlue);

            AdaptiveWorkflow workflow = new AdaptiveWorkflow();

            image = workflow.AddFilter(filter);

            using (FileStream fs = new FileStream(@"C:\Users\r_bon\Pictures\Camera Roll\" + Guid.NewGuid() + ".png", FileMode.OpenOrCreate))
            {
                image.SaveAsPng(fs);
            }
        }
        protected override async void Render()
        {
            try
            {
                if (Source != null)
                {
                    Debug.WriteLine(DebugTag + Name + ": Rendering...");

                    foreach (var change in Changes)
                    {
                        change();
                    }

                    Changes.Clear();

                    //blend source layer with mode overlay
                    var blendEffect = new BlendEffect();
                    blendEffect.Source = Source;// new StreamImageSource(new MemoryStream());
                    blendEffect.ForegroundSource = Source;
                    blendEffect.BlendFunction = BlendFunction.Overlay;
                    blendEffect.GlobalAlpha = 0.0;

                    var renderer = new JpegRenderer(blendEffect);
                    var outBuffer = await renderer.RenderAsync();

                    blendEffect.Dispose();

                    var highPassSource = new BufferImageSource(outBuffer);
                    var highPassFilter = new HighpassEffect(6, false, 1);
                    highPassFilter.Source = highPassSource;
                    var highPassRenderer = new JpegRenderer(highPassFilter);

                    var highPassOutBuffer = await highPassRenderer.RenderAsync();

                    highPassFilter.Dispose();

                    var negativeFilter = new NegativeFilter();
                    var filterEffect = new FilterEffect();
                    filterEffect.Filters = new List<IFilter>() { negativeFilter };

                    filterEffect.Source = new BufferImageSource(highPassOutBuffer);
                    var invertRenderer = new JpegRenderer(filterEffect);
                    var invertOutBuffer = await invertRenderer.RenderAsync();


                    blendEffect = new BlendEffect(Source, new BufferImageSource(invertOutBuffer), BlendFunction.Overlay, 0.5);
                    using (var bmpRender = new WriteableBitmapRenderer(blendEffect, TmpBitmap))
                    {
                        await bmpRender.RenderAsync();
                    }

                    TmpBitmap.Pixels.CopyTo(PreviewBitmap.Pixels, 0);
                    PreviewBitmap.Invalidate(); // Force a redraw
                }
                else
                {
                    Debug.WriteLine(DebugTag + Name + ": Render(): No buffer set!");
                }
            }
            catch (Exception e)
            {
                Debug.WriteLine(DebugTag + Name + ": Render(): " + e.Message);
            }
            finally
            {
                switch (State)
                {
                    case States.Apply:
                        State = States.Wait;
                        break;
                    case States.Schedule:
                        State = States.Apply;
                        Render();
                        break;
                    default:
                        break;
                }
            }
        }