Add dither tests

8 years ago · a9ae5efedd
4 changed files with 248 additions and 13 deletions
--- a/tests/ImageSharp.Tests/Processing/Binarization/BinaryDitherTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Binarization/BinaryDitherTest.cs
@ -8,19 +8,19 @@ using Xunit;

 namespace SixLabors.ImageSharp.Tests.Processing.Binarization
 {
-    public class DitherTest : BaseImageOperationsExtensionTest
+    public class BinaryDitherTest : BaseImageOperationsExtensionTest
    {
        private readonly IOrderedDither orderedDither;
        private readonly IErrorDiffuser errorDiffuser;

-        public DitherTest()
+        public BinaryDitherTest()
        {
            this.orderedDither = KnownDitherers.BayerDither4x4;
            this.errorDiffuser = KnownDiffusers.FloydSteinberg;
        }

        [Fact]
-        public void Dither_CorrectProcessor()
+        public void BinaryDither_CorrectProcessor()
        {
            this.operations.BinaryDither(this.orderedDither);
            BinaryOrderedDitherProcessor<Rgba32> p = this.Verify<BinaryOrderedDitherProcessor<Rgba32>>();
@ -30,7 +30,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Binarization
        }

        [Fact]
-        public void Dither_rect_CorrectProcessor()
+        public void BinaryDither_rect_CorrectProcessor()
        {
            this.operations.BinaryDither(this.orderedDither, this.rect);
            BinaryOrderedDitherProcessor<Rgba32> p = this.Verify<BinaryOrderedDitherProcessor<Rgba32>>(this.rect);
@ -39,7 +39,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Binarization
            Assert.Equal(NamedColors<Rgba32>.Black, p.LowerColor);
        }
        [Fact]
-        public void Dither_index_CorrectProcessor()
+        public void BinaryDither_index_CorrectProcessor()
        {
            this.operations.BinaryDither(this.orderedDither, NamedColors<Rgba32>.Yellow, NamedColors<Rgba32>.HotPink);
            BinaryOrderedDitherProcessor<Rgba32> p = this.Verify<BinaryOrderedDitherProcessor<Rgba32>>();
@ -49,7 +49,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Binarization
        }

        [Fact]
-        public void Dither_index_rect_CorrectProcessor()
+        public void BinaryDither_index_rect_CorrectProcessor()
        {
            this.operations.BinaryDither(this.orderedDither, NamedColors<Rgba32>.Yellow, NamedColors<Rgba32>.HotPink, this.rect);
            BinaryOrderedDitherProcessor<Rgba32> p = this.Verify<BinaryOrderedDitherProcessor<Rgba32>>(this.rect);
@ -59,7 +59,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Binarization


        [Fact]
-        public void Dither_ErrorDiffuser_CorrectProcessor()
+        public void BinaryDither_ErrorDiffuser_CorrectProcessor()
        {
            this.operations.BinaryDiffuse(this.errorDiffuser, .4F);
            BinaryErrorDiffusionProcessor<Rgba32> p = this.Verify<BinaryErrorDiffusionProcessor<Rgba32>>();
@ -70,7 +70,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Binarization
        }

        [Fact]
-        public void Dither_ErrorDiffuser_rect_CorrectProcessor()
+        public void BinaryDither_ErrorDiffuser_rect_CorrectProcessor()
        {
            this.operations.BinaryDiffuse(this.errorDiffuser, .3F, this.rect);
            BinaryErrorDiffusionProcessor<Rgba32> p = this.Verify<BinaryErrorDiffusionProcessor<Rgba32>>(this.rect);
@ -81,7 +81,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Binarization
        }

        [Fact]
-        public void Dither_ErrorDiffuser_CorrectProcessorWithColors()
+        public void BinaryDither_ErrorDiffuser_CorrectProcessorWithColors()
        {
            this.operations.BinaryDiffuse(this.errorDiffuser, .5F, NamedColors<Rgba32>.HotPink, NamedColors<Rgba32>.Yellow);
            BinaryErrorDiffusionProcessor<Rgba32> p = this.Verify<BinaryErrorDiffusionProcessor<Rgba32>>();
@ -92,7 +92,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Binarization
        }

        [Fact]
-        public void Dither_ErrorDiffuser_rect_CorrectProcessorWithColors()
+        public void BinaryDither_ErrorDiffuser_rect_CorrectProcessorWithColors()
        {
            this.operations.BinaryDiffuse(this.errorDiffuser, .5F, NamedColors<Rgba32>.HotPink, NamedColors<Rgba32>.Yellow, this.rect);
            BinaryErrorDiffusionProcessor<Rgba32> p = this.Verify<BinaryErrorDiffusionProcessor<Rgba32>>(this.rect);
--- a/tests/ImageSharp.Tests/Processing/Dithering/DitherTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Dithering/DitherTest.cs
@ -0,0 +1,104 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using SixLabors.ImageSharp.Dithering;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing.Processors;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Tests.Processing.Binarization
+{
+    public class DitherTest : BaseImageOperationsExtensionTest
+    {
+        private readonly IOrderedDither orderedDither;
+        private readonly IErrorDiffuser errorDiffuser;
+        private readonly Rgba32[] TestPalette =
+        {
+            Rgba32.Red,
+            Rgba32.Green,
+            Rgba32.Blue
+        };
+
+        public DitherTest()
+        {
+            this.orderedDither = KnownDitherers.BayerDither4x4;
+            this.errorDiffuser = KnownDiffusers.FloydSteinberg;
+        }
+
+        [Fact]
+        public void Dither_CorrectProcessor()
+        {
+            this.operations.Dither(this.orderedDither);
+            OrderedDitherPaletteProcessor<Rgba32> p = this.Verify<OrderedDitherPaletteProcessor<Rgba32>>();
+            Assert.Equal(this.orderedDither, p.Dither);
+            Assert.Equal(NamedColors<Rgba32>.WebSafePalette, p.Palette);
+        }
+
+        [Fact]
+        public void Dither_rect_CorrectProcessor()
+        {
+            this.operations.Dither(this.orderedDither, this.rect);
+            OrderedDitherPaletteProcessor<Rgba32> p = this.Verify<OrderedDitherPaletteProcessor<Rgba32>>(this.rect);
+            Assert.Equal(this.orderedDither, p.Dither);
+            Assert.Equal(NamedColors<Rgba32>.WebSafePalette, p.Palette);
+        }
+        [Fact]
+        public void Dither_index_CorrectProcessor()
+        {
+            this.operations.Dither(this.orderedDither, this.TestPalette);
+            OrderedDitherPaletteProcessor<Rgba32> p = this.Verify<OrderedDitherPaletteProcessor<Rgba32>>();
+            Assert.Equal(this.orderedDither, p.Dither);
+            Assert.Equal(this.TestPalette, p.Palette);
+        }
+
+        [Fact]
+        public void Dither_index_rect_CorrectProcessor()
+        {
+            this.operations.Dither(this.orderedDither, this.TestPalette, this.rect);
+            OrderedDitherPaletteProcessor<Rgba32> p = this.Verify<OrderedDitherPaletteProcessor<Rgba32>>(this.rect);
+            Assert.Equal(this.orderedDither, p.Dither);
+            Assert.Equal(this.TestPalette, p.Palette);
+        }
+
+
+        [Fact]
+        public void Dither_ErrorDiffuser_CorrectProcessor()
+        {
+            this.operations.Diffuse(this.errorDiffuser, .4F);
+            ErrorDiffusionPaletteProcessor<Rgba32> p = this.Verify<ErrorDiffusionPaletteProcessor<Rgba32>>();
+            Assert.Equal(this.errorDiffuser, p.Diffuser);
+            Assert.Equal(.4F, p.Threshold);
+            Assert.Equal(NamedColors<Rgba32>.WebSafePalette, p.Palette);
+        }
+
+        [Fact]
+        public void Dither_ErrorDiffuser_rect_CorrectProcessor()
+        {
+            this.operations.Diffuse(this.errorDiffuser, .3F, this.rect);
+            ErrorDiffusionPaletteProcessor<Rgba32> p = this.Verify<ErrorDiffusionPaletteProcessor<Rgba32>>(this.rect);
+            Assert.Equal(this.errorDiffuser, p.Diffuser);
+            Assert.Equal(.3F, p.Threshold);
+            Assert.Equal(NamedColors<Rgba32>.WebSafePalette, p.Palette);
+        }
+
+        [Fact]
+        public void Dither_ErrorDiffuser_CorrectProcessorWithColors()
+        {
+            this.operations.Diffuse(this.errorDiffuser, .5F, this.TestPalette);
+            ErrorDiffusionPaletteProcessor<Rgba32> p = this.Verify<ErrorDiffusionPaletteProcessor<Rgba32>>();
+            Assert.Equal(this.errorDiffuser, p.Diffuser);
+            Assert.Equal(.5F, p.Threshold);
+            Assert.Equal(this.TestPalette, p.Palette);
+        }
+
+        [Fact]
+        public void Dither_ErrorDiffuser_rect_CorrectProcessorWithColors()
+        {
+            this.operations.Diffuse(this.errorDiffuser, .5F, this.TestPalette, this.rect);
+            ErrorDiffusionPaletteProcessor<Rgba32> p = this.Verify<ErrorDiffusionPaletteProcessor<Rgba32>>(this.rect);
+            Assert.Equal(this.errorDiffuser, p.Diffuser);
+            Assert.Equal(.5F, p.Threshold);
+            Assert.Equal(this.TestPalette, p.Palette);
+        }
+    }
+}
--- a/tests/ImageSharp.Tests/Processing/Processors/Binarization/BinaryDitherTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Binarization/BinaryDitherTests.cs
@ -11,7 +11,7 @@ using Xunit;

 namespace SixLabors.ImageSharp.Tests.Processing.Processors.Binarization
 {
-    public class DitherTests : FileTestBase
+    public class BinaryDitherTests : FileTestBase
    {
        public static readonly string[] CommonTestImages =
            {
@ -47,7 +47,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Binarization
        [Theory]
        [WithFileCollection(nameof(CommonTestImages), nameof(Ditherers), DefaultPixelType)]
        [WithTestPatternImages(nameof(Ditherers), 100, 100, DefaultPixelType)]
-        public void DitherFilter_WorksWithAllDitherers<TPixel>(TestImageProvider<TPixel> provider, string name, IOrderedDither ditherer)
+        public void BinaryDitherFilter_WorksWithAllDitherers<TPixel>(TestImageProvider<TPixel> provider, string name, IOrderedDither ditherer)
            where TPixel : struct, IPixel<TPixel>
        {
            using (Image<TPixel> image = provider.GetImage())
@ -72,7 +72,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Binarization

        [Theory]
        [WithFile(TestImages.Png.Bike, CommonNonDefaultPixelTypes)]
-        public void DitherFilter_ShouldNotDependOnSinglePixelType<TPixel>(TestImageProvider<TPixel> provider)
+        public void BinaryDitherFilter_ShouldNotDependOnSinglePixelType<TPixel>(TestImageProvider<TPixel> provider)
            where TPixel : struct, IPixel<TPixel>
        {
            using (Image<TPixel> image = provider.GetImage())
--- a/tests/ImageSharp.Tests/Processing/Processors/Dithering/DitherTests.cs
+++ b/tests/ImageSharp.Tests/Processing/Processors/Dithering/DitherTests.cs
@ -0,0 +1,131 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using SixLabors.ImageSharp.Dithering;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Tests.TestUtilities.ImageComparison;
+
+using SixLabors.Primitives;
+using Xunit;
+// ReSharper disable InconsistentNaming
+
+namespace SixLabors.ImageSharp.Tests.Processing.Processors.Binarization
+{
+    public class DitherTests : FileTestBase
+    {
+        public static readonly string[] CommonTestImages =
+            {
+                TestImages.Png.CalliphoraPartial, TestImages.Png.Bike
+            };
+
+        public static readonly TheoryData<string, IOrderedDither> Ditherers = new TheoryData<string, IOrderedDither>
+        {
+            { "Bayer8x8", KnownDitherers.BayerDither8x8 },
+            { "Bayer4x4", KnownDitherers.BayerDither4x4 },
+            { "Ordered3x3", KnownDitherers.OrderedDither3x3 },
+            { "Bayer2x2", KnownDitherers.BayerDither2x2 }
+        };
+
+        public static readonly TheoryData<string, IErrorDiffuser> ErrorDiffusers = new TheoryData<string, IErrorDiffuser>
+        {
+            { "Atkinson", KnownDiffusers.Atkinson },
+            { "Burks", KnownDiffusers.Burks },
+            { "FloydSteinberg", KnownDiffusers.FloydSteinberg },
+            { "JarvisJudiceNinke", KnownDiffusers.JarvisJudiceNinke },
+            { "Sierra2", KnownDiffusers.Sierra2 },
+            { "Sierra3", KnownDiffusers.Sierra3 },
+            { "SierraLite", KnownDiffusers.SierraLite },
+            { "StevensonArce", KnownDiffusers.StevensonArce },
+            { "Stucki", KnownDiffusers.Stucki },
+        };
+
+
+        private static IOrderedDither DefaultDitherer => KnownDitherers.BayerDither4x4;
+
+        private static IErrorDiffuser DefaultErrorDiffuser => KnownDiffusers.Atkinson;
+
+        [Theory]
+        [WithFileCollection(nameof(CommonTestImages), nameof(Ditherers), DefaultPixelType)]
+        [WithTestPatternImages(nameof(Ditherers), 100, 100, DefaultPixelType)]
+        public void DitherFilter_WorksWithAllDitherers<TPixel>(TestImageProvider<TPixel> provider, string name, IOrderedDither ditherer)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            using (Image<TPixel> image = provider.GetImage())
+            {
+                image.Mutate(x => x.Dither(ditherer));
+                image.DebugSave(provider, name);
+            }
+        }
+
+        [Theory]
+        [WithFileCollection(nameof(CommonTestImages), nameof(ErrorDiffusers), DefaultPixelType)]
+        [WithTestPatternImages(nameof(ErrorDiffusers), 100, 100, DefaultPixelType)]
+        public void DiffusionFilter_WorksWithAllErrorDiffusers<TPixel>(TestImageProvider<TPixel> provider, string name, IErrorDiffuser diffuser)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            using (Image<TPixel> image = provider.GetImage())
+            {
+                image.Mutate(x => x.Diffuse(diffuser, .5F));
+                image.DebugSave(provider, name);
+            }
+        }
+
+        [Theory]
+        [WithFile(TestImages.Png.Bike, CommonNonDefaultPixelTypes)]
+        public void DitherFilter_ShouldNotDependOnSinglePixelType<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            using (Image<TPixel> image = provider.GetImage())
+            {
+                image.Mutate(x => x.Dither(DefaultDitherer));
+                image.DebugSave(provider);
+            }
+        }
+
+        [Theory]
+        [WithFile(TestImages.Png.Bike, CommonNonDefaultPixelTypes)]
+        public void DiffusionFilter_ShouldNotDependOnSinglePixelType<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            using (Image<TPixel> image = provider.GetImage())
+            {
+                image.Mutate(x => x.Diffuse(DefaultErrorDiffuser, 0.5f));
+                image.DebugSave(provider);
+            }
+        }
+
+        [Theory]
+        [WithFile(TestImages.Png.CalliphoraPartial, DefaultPixelType)]
+        public void ApplyDitherFilterInBox<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            using (Image<TPixel> source = provider.GetImage())
+            using (Image<TPixel> image = source.Clone())
+            {
+                var bounds = new Rectangle(10, 10, image.Width / 2, image.Height / 2);
+
+                image.Mutate(x => x.Dither(DefaultDitherer, bounds));
+                image.DebugSave(provider);
+
+                ImageComparer.Tolerant().VerifySimilarityIgnoreRegion(source, image, bounds);
+            }
+        }
+
+        [Theory]
+        [WithFile(TestImages.Png.CalliphoraPartial, DefaultPixelType)]
+        public void ApplyDiffusionFilterInBox<TPixel>(TestImageProvider<TPixel> provider)
+            where TPixel : struct, IPixel<TPixel>
+        {
+            using (Image<TPixel> source = provider.GetImage())
+            using (Image<TPixel> image = source.Clone())
+            {
+                var bounds = new Rectangle(10, 10, image.Width / 2, image.Height / 2);
+
+                image.Mutate(x => x.Diffuse(DefaultErrorDiffuser, .5F, bounds));
+                image.DebugSave(provider);
+
+                ImageComparer.Tolerant().VerifySimilarityIgnoreRegion(source, image, bounds);
+            }
+        }
+    }
+}