Merge branch 'master' into bp/tiff24bit

Author: brianpopow

src/ImageSharp/Processing/Processors/Dithering/ErrorDither.cs

@@ -27,6 +27,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Dithering
         [MethodImpl(InliningOptions.ShortMethod)]
         public ErrorDither(in DenseMatrix<float> matrix, int offset)
         {
+            Guard.MustBeGreaterThan(offset, 0, nameof(offset));
+
             this.matrix = matrix;
             this.offset = offset;
         }
@@ -95,6 +97,11 @@ public void ApplyQuantizationDither<TFrameQuantizer, TPixel>(
             where TFrameQuantizer : struct, IQuantizer<TPixel>
             where TPixel : unmanaged, IPixel<TPixel>
         {
+            if (this == default)
+            {
+                ThrowDefaultInstance();
+            }
+
             int offsetY = bounds.Top;
             int offsetX = bounds.Left;
             float scale = quantizer.Options.DitherScale;
@@ -122,6 +129,11 @@ public void ApplyPaletteDither<TPaletteDitherImageProcessor, TPixel>(
             where TPaletteDitherImageProcessor : struct, IPaletteDitherImageProcessor<TPixel>
             where TPixel : unmanaged, IPixel<TPixel>
         {
+            if (this == default)
+            {
+                ThrowDefaultInstance();
+            }
+
             float scale = processor.DitherScale;
             for (int y = bounds.Top; y < bounds.Bottom; y++)
             {
@@ -210,5 +222,9 @@ public bool Equals(IDither other)
         /// <inheritdoc/>
         public override int GetHashCode()
             => HashCode.Combine(this.offset, this.matrix);
+
+        [MethodImpl(InliningOptions.ColdPath)]
+        private static void ThrowDefaultInstance()
+            => throw new ImageProcessingException("Cannot use the default value type instance to dither.");
     }
 }

src/ImageSharp/Processing/Processors/Dithering/OrderedDither.cs

@@ -24,6 +24,8 @@ namespace SixLabors.ImageSharp.Processing.Processors.Dithering
         [MethodImpl(InliningOptions.ShortMethod)]
         public OrderedDither(uint length)
         {
+            Guard.MustBeGreaterThan(length, 0, nameof(length));
+
             DenseMatrix<uint> ditherMatrix = OrderedDitherFactory.CreateDitherMatrix(length);
 
             // Create a new matrix to run against, that pre-thresholds the values.
@@ -109,6 +111,11 @@ public void ApplyQuantizationDither<TFrameQuantizer, TPixel>(
             where TFrameQuantizer : struct, IQuantizer<TPixel>
             where TPixel : unmanaged, IPixel<TPixel>
         {
+            if (this == default)
+            {
+                ThrowDefaultInstance();
+            }
+
             int spread = CalculatePaletteSpread(destination.Palette.Length);
             float scale = quantizer.Options.DitherScale;
 
@@ -134,6 +141,11 @@ public void ApplyPaletteDither<TPaletteDitherImageProcessor, TPixel>(
             where TPaletteDitherImageProcessor : struct, IPaletteDitherImageProcessor<TPixel>
             where TPixel : unmanaged, IPixel<TPixel>
         {
+            if (this == default)
+            {
+                ThrowDefaultInstance();
+            }
+
             int spread = CalculatePaletteSpread(processor.Palette.Length);
             float scale = processor.DitherScale;
 
@@ -201,5 +213,9 @@ public bool Equals(IDither other)
         [MethodImpl(InliningOptions.ShortMethod)]
         public override int GetHashCode()
             => HashCode.Combine(this.thresholdMatrix, this.modulusX, this.modulusY);
+
+        [MethodImpl(InliningOptions.ColdPath)]
+        private static void ThrowDefaultInstance()
+            => throw new ImageProcessingException("Cannot use the default value type instance to dither.");
     }
 }

src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer.cs

@@ -11,14 +11,12 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
     /// </summary>
     public class OctreeQuantizer : IQuantizer
     {
-        private static readonly QuantizerOptions DefaultOptions = new QuantizerOptions();
-
         /// <summary>
         /// Initializes a new instance of the <see cref="OctreeQuantizer"/> class
         /// using the default <see cref="QuantizerOptions"/>.
         /// </summary>
         public OctreeQuantizer()
-            : this(DefaultOptions)
+            : this(new QuantizerOptions())
         {
         }
 

src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer.cs

@@ -11,15 +11,14 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
     /// </summary>
     public class PaletteQuantizer : IQuantizer
     {
-        private static readonly QuantizerOptions DefaultOptions = new QuantizerOptions();
         private readonly ReadOnlyMemory<Color> colorPalette;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="PaletteQuantizer"/> class.
         /// </summary>
         /// <param name="palette">The color palette.</param>
         public PaletteQuantizer(ReadOnlyMemory<Color> palette)
-            : this(palette, DefaultOptions)
+            : this(palette, new QuantizerOptions())
         {
         }
 

src/ImageSharp/Processing/Processors/Quantization/WebSafePaletteQuantizer.cs

@@ -1,22 +1,18 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-using SixLabors.ImageSharp.Processing.Processors.Dithering;
-
 namespace SixLabors.ImageSharp.Processing.Processors.Quantization
 {
     /// <summary>
     /// A palette quantizer consisting of web safe colors as defined in the CSS Color Module Level 4.
     /// </summary>
     public class WebSafePaletteQuantizer : PaletteQuantizer
     {
-        private static readonly QuantizerOptions DefaultOptions = new QuantizerOptions();
-
         /// <summary>
         /// Initializes a new instance of the <see cref="WebSafePaletteQuantizer" /> class.
         /// </summary>
         public WebSafePaletteQuantizer()
-            : this(DefaultOptions)
+            : this(new QuantizerOptions())
         {
         }
 

src/ImageSharp/Processing/Processors/Quantization/WernerPaletteQuantizer.cs

@@ -9,13 +9,11 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
     /// </summary>
     public class WernerPaletteQuantizer : PaletteQuantizer
     {
-        private static readonly QuantizerOptions DefaultOptions = new QuantizerOptions();
-
         /// <summary>
         /// Initializes a new instance of the <see cref="WernerPaletteQuantizer" /> class.
         /// </summary>
         public WernerPaletteQuantizer()
-            : this(DefaultOptions)
+            : this(new QuantizerOptions())
         {
         }
 

src/ImageSharp/Processing/Processors/Quantization/WuQuantizer.cs

@@ -10,14 +10,12 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
     /// </summary>
     public class WuQuantizer : IQuantizer
     {
-        private static readonly QuantizerOptions DefaultOptions = new QuantizerOptions();
-
         /// <summary>
         /// Initializes a new instance of the <see cref="WuQuantizer"/> class
         /// using the default <see cref="QuantizerOptions"/>.
         /// </summary>
         public WuQuantizer()
-            : this(DefaultOptions)
+            : this(new QuantizerOptions())
         {
         }
 

tests/ImageSharp.Tests/Processing/Processors/Dithering/DitherTests.cs

@@ -43,6 +43,13 @@ public static readonly TheoryData<IDither, string> OrderedDitherers
                 { KnownDitherings.Ordered3x3, nameof(KnownDitherings.Ordered3x3) }
             };
 
+        public static readonly TheoryData<IDither> DefaultInstanceDitherers
+            = new TheoryData<IDither>
+            {
+                default(ErrorDither),
+                default(OrderedDither)
+            };
+
         private static readonly ImageComparer ValidatorComparer = ImageComparer.TolerantPercentage(0.05f);
 
         private static IDither DefaultDitherer => KnownDitherings.Bayer4x4;
@@ -175,5 +182,18 @@ public void CommonDitherers_WorkWithDiscoBuffers<TPixel>(
                 c => c.Dither(dither),
                 name);
         }
+
+        [Theory]
+        [MemberData(nameof(DefaultInstanceDitherers))]
+        public void ShouldThrowForDefaultDitherInstance(IDither dither)
+        {
+            void Command()
+            {
+                using var image = new Image<Rgba32>(10, 10);
+                image.Mutate(x => x.Dither(dither));
+            }
+
+            Assert.Throws<ImageProcessingException>(Command);
+        }
     }
 }

tests/ImageSharp.Tests/Processing/Processors/Quantization/QuantizerTests.cs

@@ -5,6 +5,7 @@
 
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
+using SixLabors.ImageSharp.Processing.Processors.Dithering;
 using SixLabors.ImageSharp.Processing.Processors.Quantization;
 using SixLabors.ImageSharp.Tests.TestUtilities.ImageComparison;
 using Xunit;
@@ -152,6 +153,13 @@ public static readonly TheoryData<IQuantizer> DitherScaleQuantizers
             new WuQuantizer(OrderedDitherOptions),
         };
 
+        public static readonly TheoryData<IDither> DefaultInstanceDitherers
+            = new TheoryData<IDither>
+            {
+                default(ErrorDither),
+                default(OrderedDither)
+            };
+
         private static readonly ImageComparer ValidatorComparer = ImageComparer.TolerantPercentage(0.05F);
 
         [Theory]
@@ -217,5 +225,20 @@ public void ApplyQuantizationWithDitheringScale<TPixel>(TestImageProvider<TPixel
                 testOutputDetails: testOutputDetails,
                 appendPixelTypeToFileName: false);
         }
+
+        [Theory]
+        [MemberData(nameof(DefaultInstanceDitherers))]
+        public void ShouldThrowForDefaultDitherInstance(IDither dither)
+        {
+            void Command()
+            {
+                using var image = new Image<Rgba32>(10, 10);
+                var quantizer = new WebSafePaletteQuantizer();
+                quantizer.Options.Dither = dither;
+                image.Mutate(x => x.Quantize(quantizer));
+            }
+
+            Assert.Throws<ImageProcessingException>(Command);
+        }
     }
 }