diff --git a/src/ImageSharp/Configuration.cs b/src/ImageSharp/Configuration.cs
index 47c7c54ea..17ac8c3fd 100644
--- a/src/ImageSharp/Configuration.cs
+++ b/src/ImageSharp/Configuration.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Net.Http;
 using SixLabors.ImageSharp.Formats;
 using SixLabors.ImageSharp.Formats.Bmp;
 using SixLabors.ImageSharp.Formats.Gif;
@@ -73,6 +74,12 @@ namespace SixLabors.ImageSharp
             }
         }
 
+        /// <summary>
+        /// Gets a set of properties for the Congiguration.
+        /// </summary>
+        /// <remarks>This can be used for storing global settings and defaults to be accessable to processors.</remarks>
+        public IDictionary<object, object> Properties { get; } = new Dictionary<object, object>();
+
         /// <summary>
         /// Gets the currently registered <see cref="IImageFormat"/>s.
         /// </summary>
diff --git a/src/ImageSharp/GraphicOptionsDefaultsExtensions.cs b/src/ImageSharp/GraphicOptionsDefaultsExtensions.cs
new file mode 100644
index 000000000..c8beea8e8
--- /dev/null
+++ b/src/ImageSharp/GraphicOptionsDefaultsExtensions.cs
@@ -0,0 +1,100 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using SixLabors.ImageSharp.Processing;
+
+namespace SixLabors.ImageSharp
+{
+    /// <summary>
+    /// Adds extensions that allow the processing of images to the <see cref="Image{TPixel}"/> type.
+    /// </summary>
+    public static class GraphicOptionsDefaultsExtensions
+    {
+        /// <summary>
+        /// Sets the default options against the image processing context.
+        /// </summary>
+        /// <param name="context">The image processing context to store default against.</param>
+        /// <param name="optionsBuilder">The action to update instance of the default options used.</param>
+        /// <returns>The passed in <paramref name="context"/> to allow chaining.</returns>
+        public static IImageProcessingContext SetGraphicsOptions(this IImageProcessingContext context, Action<GraphicsOptions> optionsBuilder)
+        {
+            var cloned = context.GetGraphicsOptions().DeepClone();
+            optionsBuilder(cloned);
+            context.Properties[typeof(GraphicsOptions)] = cloned;
+            return context;
+        }
+
+        /// <summary>
+        /// Sets the default options against the configuration.
+        /// </summary>
+        /// <param name="configuration">The configuration to store default against.</param>
+        /// <param name="optionsBuilder">The default options to use.</param>
+        public static void SetGraphicsOptions(this Configuration configuration, Action<GraphicsOptions> optionsBuilder)
+        {
+            var cloned = configuration.GetGraphicsOptions().DeepClone();
+            optionsBuilder(cloned);
+            configuration.Properties[typeof(GraphicsOptions)] = cloned;
+        }
+
+        /// <summary>
+        /// Sets the default options against the image processing context.
+        /// </summary>
+        /// <param name="context">The image processing context to store default against.</param>
+        /// <param name="options">The default options to use.</param>
+        /// <returns>The passed in <paramref name="context"/> to allow chaining.</returns>
+        public static IImageProcessingContext SetGraphicsOptions(this IImageProcessingContext context, GraphicsOptions options)
+        {
+            context.Properties[typeof(GraphicsOptions)] = options;
+            return context;
+        }
+
+        /// <summary>
+        /// Sets the default options against the configuration.
+        /// </summary>
+        /// <param name="configuration">The configuration to store default against.</param>
+        /// <param name="options">The default options to use.</param>
+        public static void SetGraphicsOptions(this Configuration configuration, GraphicsOptions options)
+        {
+            configuration.Properties[typeof(GraphicsOptions)] = options;
+        }
+
+        /// <summary>
+        /// Gets the default options against the image processing context.
+        /// </summary>
+        /// <param name="context">The image processing context to retrieve defaults from.</param>
+        /// <returns>The globaly configued default options.</returns>
+        public static GraphicsOptions GetGraphicsOptions(this IImageProcessingContext context)
+        {
+            if (context.Properties.TryGetValue(typeof(GraphicsOptions), out var options) && options is GraphicsOptions go)
+            {
+                return go;
+            }
+
+            var configOptions = context.Configuration.GetGraphicsOptions();
+
+            // do not cache the fall back to config into the the processing context
+            // in case someone want to change the value on the config and expects it re trflow thru
+            return configOptions;
+        }
+
+        /// <summary>
+        /// Gets the default options against the image processing context.
+        /// </summary>
+        /// <param name="configuration">The configuration to retrieve defaults from.</param>
+        /// <returns>The globaly configued default options.</returns>
+        public static GraphicsOptions GetGraphicsOptions(this Configuration configuration)
+        {
+            if (configuration.Properties.TryGetValue(typeof(GraphicsOptions), out var options) && options is GraphicsOptions go)
+            {
+                return go;
+            }
+
+            var configOptions = new GraphicsOptions();
+
+            // capture the fallback so the same instance will always be returned in case its mutated
+            configuration.Properties[typeof(GraphicsOptions)] = configOptions;
+            return configOptions;
+        }
+    }
+}
diff --git a/src/ImageSharp/Processing/DefaultImageProcessorContext{TPixel}.cs b/src/ImageSharp/Processing/DefaultImageProcessorContext{TPixel}.cs
index 2e5919d1e..714a45f5f 100644
--- a/src/ImageSharp/Processing/DefaultImageProcessorContext{TPixel}.cs
+++ b/src/ImageSharp/Processing/DefaultImageProcessorContext{TPixel}.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
+using System.Collections.Generic;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing.Processors;
 
@@ -39,6 +40,9 @@ namespace SixLabors.ImageSharp.Processing
         /// <inheritdoc/>
         public Configuration Configuration { get; }
 
+        /// <inheritdoc/>
+        public IDictionary<object, object> Properties { get; } = new Dictionary<object, object>();
+
         /// <inheritdoc/>
         public Image<TPixel> GetResultImage()
         {
diff --git a/src/ImageSharp/Processing/Extensions/Drawing/DrawImageExtensions.cs b/src/ImageSharp/Processing/Extensions/Drawing/DrawImageExtensions.cs
index 4717c09ea..3c25bb7c4 100644
--- a/src/ImageSharp/Processing/Extensions/Drawing/DrawImageExtensions.cs
+++ b/src/ImageSharp/Processing/Extensions/Drawing/DrawImageExtensions.cs
@@ -23,7 +23,7 @@ namespace SixLabors.ImageSharp.Processing
             Image image,
             float opacity)
         {
-            var options = new GraphicsOptions();
+            var options = source.GetGraphicsOptions();
             return source.ApplyProcessor(
                 new DrawImageProcessor(
                 image,
@@ -51,7 +51,7 @@ namespace SixLabors.ImageSharp.Processing
                     image,
                     Point.Empty,
                     colorBlending,
-                    new GraphicsOptions().AlphaCompositionMode,
+                    source.GetGraphicsOptions().AlphaCompositionMode,
                     opacity));
 
         /// <summary>
@@ -104,7 +104,7 @@ namespace SixLabors.ImageSharp.Processing
             Point location,
             float opacity)
         {
-            var options = new GraphicsOptions();
+            var options = source.GetGraphicsOptions();
             return source.ApplyProcessor(
                 new DrawImageProcessor(
                 image,
@@ -134,7 +134,7 @@ namespace SixLabors.ImageSharp.Processing
                     image,
                     location,
                     colorBlending,
-                    new GraphicsOptions().AlphaCompositionMode,
+                    source.GetGraphicsOptions().AlphaCompositionMode,
                     opacity));
 
         /// <summary>
diff --git a/src/ImageSharp/Processing/Extensions/Filters/LomographExtensions.cs b/src/ImageSharp/Processing/Extensions/Filters/LomographExtensions.cs
index 84b11c5e7..3f8a67feb 100644
--- a/src/ImageSharp/Processing/Extensions/Filters/LomographExtensions.cs
+++ b/src/ImageSharp/Processing/Extensions/Filters/LomographExtensions.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors and contributors.
+// Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
 using SixLabors.ImageSharp.Processing.Processors.Filters;
@@ -17,7 +17,7 @@ namespace SixLabors.ImageSharp.Processing
         /// <param name="source">The image this method extends.</param>
         /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
         public static IImageProcessingContext Lomograph(this IImageProcessingContext source)
-            => source.ApplyProcessor(new LomographProcessor());
+            => source.ApplyProcessor(new LomographProcessor(source.GetGraphicsOptions()));
 
         /// <summary>
         /// Alters the colors of the image recreating an old Lomograph camera effect.
@@ -28,6 +28,6 @@ namespace SixLabors.ImageSharp.Processing
         /// </param>
         /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
         public static IImageProcessingContext Lomograph(this IImageProcessingContext source, Rectangle rectangle)
-            => source.ApplyProcessor(new LomographProcessor(), rectangle);
+            => source.ApplyProcessor(new LomographProcessor(source.GetGraphicsOptions()), rectangle);
     }
-}
\ No newline at end of file
+}
diff --git a/src/ImageSharp/Processing/Extensions/Filters/PolaroidExtensions.cs b/src/ImageSharp/Processing/Extensions/Filters/PolaroidExtensions.cs
index 94ced7108..ab75ea56b 100644
--- a/src/ImageSharp/Processing/Extensions/Filters/PolaroidExtensions.cs
+++ b/src/ImageSharp/Processing/Extensions/Filters/PolaroidExtensions.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors and contributors.
+// Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
 using SixLabors.ImageSharp.Processing.Processors.Filters;
@@ -17,7 +17,7 @@ namespace SixLabors.ImageSharp.Processing
         /// <param name="source">The image this method extends.</param>
         /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
         public static IImageProcessingContext Polaroid(this IImageProcessingContext source)
-            => source.ApplyProcessor(new PolaroidProcessor());
+            => source.ApplyProcessor(new PolaroidProcessor(source.GetGraphicsOptions()));
 
         /// <summary>
         /// Alters the colors of the image recreating an old Polaroid camera effect.
@@ -28,6 +28,6 @@ namespace SixLabors.ImageSharp.Processing
         /// </param>
         /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
         public static IImageProcessingContext Polaroid(this IImageProcessingContext source, Rectangle rectangle)
-            => source.ApplyProcessor(new PolaroidProcessor(), rectangle);
+            => source.ApplyProcessor(new PolaroidProcessor(source.GetGraphicsOptions()), rectangle);
     }
 }
diff --git a/src/ImageSharp/Processing/Extensions/Overlays/BackgroundColorExtensions.cs b/src/ImageSharp/Processing/Extensions/Overlays/BackgroundColorExtensions.cs
index d068ba10b..21e244f0a 100644
--- a/src/ImageSharp/Processing/Extensions/Overlays/BackgroundColorExtensions.cs
+++ b/src/ImageSharp/Processing/Extensions/Overlays/BackgroundColorExtensions.cs
@@ -18,7 +18,7 @@ namespace SixLabors.ImageSharp.Processing
         /// <param name="color">The color to set as the background.</param>
         /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
         public static IImageProcessingContext BackgroundColor(this IImageProcessingContext source, Color color) =>
-            BackgroundColor(source, new GraphicsOptions(), color);
+            BackgroundColor(source, source.GetGraphicsOptions(), color);
 
         /// <summary>
         /// Replaces the background color of image with the given one.
@@ -33,7 +33,7 @@ namespace SixLabors.ImageSharp.Processing
             this IImageProcessingContext source,
             Color color,
             Rectangle rectangle) =>
-            BackgroundColor(source, new GraphicsOptions(), color, rectangle);
+            BackgroundColor(source, source.GetGraphicsOptions(), color, rectangle);
 
         /// <summary>
         /// Replaces the background color of image with the given one.
diff --git a/src/ImageSharp/Processing/Extensions/Overlays/GlowExtensions.cs b/src/ImageSharp/Processing/Extensions/Overlays/GlowExtensions.cs
index d5114e30a..c3ce32e63 100644
--- a/src/ImageSharp/Processing/Extensions/Overlays/GlowExtensions.cs
+++ b/src/ImageSharp/Processing/Extensions/Overlays/GlowExtensions.cs
@@ -17,7 +17,7 @@ namespace SixLabors.ImageSharp.Processing
         /// <param name="source">The image this method extends.</param>
         /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
         public static IImageProcessingContext Glow(this IImageProcessingContext source) =>
-            Glow(source, new GraphicsOptions());
+            Glow(source, source.GetGraphicsOptions());
 
         /// <summary>
         /// Applies a radial glow effect to an image.
@@ -27,7 +27,7 @@ namespace SixLabors.ImageSharp.Processing
         /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
         public static IImageProcessingContext Glow(this IImageProcessingContext source, Color color)
         {
-            return Glow(source, new GraphicsOptions(), color);
+            return Glow(source, source.GetGraphicsOptions(), color);
         }
 
         /// <summary>
@@ -37,7 +37,7 @@ namespace SixLabors.ImageSharp.Processing
         /// <param name="radius">The the radius.</param>
         /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
         public static IImageProcessingContext Glow(this IImageProcessingContext source, float radius) =>
-            Glow(source, new GraphicsOptions(), radius);
+            Glow(source, source.GetGraphicsOptions(), radius);
 
         /// <summary>
         /// Applies a radial glow effect to an image.
@@ -48,7 +48,7 @@ namespace SixLabors.ImageSharp.Processing
         /// </param>
         /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
         public static IImageProcessingContext Glow(this IImageProcessingContext source, Rectangle rectangle) =>
-            source.Glow(new GraphicsOptions(), rectangle);
+            source.Glow(source.GetGraphicsOptions(), rectangle);
 
         /// <summary>
         /// Applies a radial glow effect to an image.
@@ -65,7 +65,7 @@ namespace SixLabors.ImageSharp.Processing
             Color color,
             float radius,
             Rectangle rectangle) =>
-            source.Glow(new GraphicsOptions(), color, ValueSize.Absolute(radius), rectangle);
+            source.Glow(source.GetGraphicsOptions(), color, ValueSize.Absolute(radius), rectangle);
 
         /// <summary>
         /// Applies a radial glow effect to an image.
diff --git a/src/ImageSharp/Processing/Extensions/Overlays/VignetteExtensions.cs b/src/ImageSharp/Processing/Extensions/Overlays/VignetteExtensions.cs
index 799b30e01..b53880fc1 100644
--- a/src/ImageSharp/Processing/Extensions/Overlays/VignetteExtensions.cs
+++ b/src/ImageSharp/Processing/Extensions/Overlays/VignetteExtensions.cs
@@ -17,7 +17,7 @@ namespace SixLabors.ImageSharp.Processing
         /// <param name="source">The image this method extends.</param>
         /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
         public static IImageProcessingContext Vignette(this IImageProcessingContext source) =>
-            Vignette(source, new GraphicsOptions());
+            Vignette(source, source.GetGraphicsOptions());
 
         /// <summary>
         /// Applies a radial vignette effect to an image.
@@ -26,7 +26,7 @@ namespace SixLabors.ImageSharp.Processing
         /// <param name="color">The color to set as the vignette.</param>
         /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
         public static IImageProcessingContext Vignette(this IImageProcessingContext source, Color color) =>
-            Vignette(source, new GraphicsOptions(), color);
+            Vignette(source, source.GetGraphicsOptions(), color);
 
         /// <summary>
         /// Applies a radial vignette effect to an image.
@@ -39,7 +39,7 @@ namespace SixLabors.ImageSharp.Processing
             this IImageProcessingContext source,
             float radiusX,
             float radiusY) =>
-            Vignette(source, new GraphicsOptions(), radiusX, radiusY);
+            Vignette(source, source.GetGraphicsOptions(), radiusX, radiusY);
 
         /// <summary>
         /// Applies a radial vignette effect to an image.
@@ -50,7 +50,7 @@ namespace SixLabors.ImageSharp.Processing
         /// </param>
         /// <returns>The <see cref="IImageProcessingContext"/> to allow chaining of operations.</returns>
         public static IImageProcessingContext Vignette(this IImageProcessingContext source, Rectangle rectangle) =>
-            Vignette(source, new GraphicsOptions(), rectangle);
+            Vignette(source, source.GetGraphicsOptions(), rectangle);
 
         /// <summary>
         /// Applies a radial vignette effect to an image.
@@ -69,7 +69,7 @@ namespace SixLabors.ImageSharp.Processing
             float radiusX,
             float radiusY,
             Rectangle rectangle) =>
-            source.Vignette(new GraphicsOptions(), color, radiusX, radiusY, rectangle);
+            source.Vignette(source.GetGraphicsOptions(), color, radiusX, radiusY, rectangle);
 
         /// <summary>
         /// Applies a radial vignette effect to an image.
diff --git a/src/ImageSharp/Processing/IImageProcessingContext.cs b/src/ImageSharp/Processing/IImageProcessingContext.cs
index 8b57a289d..cb39766a9 100644
--- a/src/ImageSharp/Processing/IImageProcessingContext.cs
+++ b/src/ImageSharp/Processing/IImageProcessingContext.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
+using System.Collections.Generic;
 using SixLabors.ImageSharp.Processing.Processors;
 
 namespace SixLabors.ImageSharp.Processing
@@ -15,6 +16,12 @@ namespace SixLabors.ImageSharp.Processing
         /// </summary>
         Configuration Configuration { get; }
 
+        /// <summary>
+        /// Gets a set of properties for the Image Processing Context.
+        /// </summary>
+        /// <remarks>This can be used for storing global settings and defaults to be accessable to processors.</remarks>
+        IDictionary<object, object> Properties { get; }
+
         /// <summary>
         /// Gets the image dimensions at the current point in the processing pipeline.
         /// </summary>
diff --git a/src/ImageSharp/Processing/Processors/Filters/LomographProcessor.cs b/src/ImageSharp/Processing/Processors/Filters/LomographProcessor.cs
index 3c150d7eb..bb6ea51c1 100644
--- a/src/ImageSharp/Processing/Processors/Filters/LomographProcessor.cs
+++ b/src/ImageSharp/Processing/Processors/Filters/LomographProcessor.cs
@@ -11,11 +11,18 @@ namespace SixLabors.ImageSharp.Processing.Processors.Filters
         /// <summary>
         /// Initializes a new instance of the <see cref="LomographProcessor" /> class.
         /// </summary>
-        public LomographProcessor()
+        /// <param name="graphicsOptions">Graphics options to use within the processor.</param>
+        public LomographProcessor(GraphicsOptions graphicsOptions)
             : base(KnownFilterMatrices.LomographFilter)
         {
+            this.GraphicsOptions = graphicsOptions;
         }
 
+        /// <summary>
+        /// Gets the options effecting blending and composition
+        /// </summary>
+        public GraphicsOptions GraphicsOptions { get; }
+
         /// <inheritdoc />
         public override IImageProcessor<TPixel> CreatePixelSpecificProcessor<TPixel>(Configuration configuration, Image<TPixel> source, Rectangle sourceRectangle) =>
             new LomographProcessor<TPixel>(configuration, this, source, sourceRectangle);
diff --git a/src/ImageSharp/Processing/Processors/Filters/LomographProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Filters/LomographProcessor{TPixel}.cs
index 5a19b7851..0706e9fc8 100644
--- a/src/ImageSharp/Processing/Processors/Filters/LomographProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Filters/LomographProcessor{TPixel}.cs
@@ -13,6 +13,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Filters
         where TPixel : unmanaged, IPixel<TPixel>
     {
         private static readonly Color VeryDarkGreen = Color.FromRgba(0, 10, 0, 255);
+        private readonly LomographProcessor definition;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="LomographProcessor{TPixel}"/> class.
@@ -24,12 +25,13 @@ namespace SixLabors.ImageSharp.Processing.Processors.Filters
         public LomographProcessor(Configuration configuration, LomographProcessor definition, Image<TPixel> source, Rectangle sourceRectangle)
             : base(configuration, definition, source, sourceRectangle)
         {
+            this.definition = definition;
         }
 
         /// <inheritdoc/>
         protected override void AfterImageApply()
         {
-            new VignetteProcessor(VeryDarkGreen).Execute(this.Configuration, this.Source, this.SourceRectangle);
+            new VignetteProcessor(this.definition.GraphicsOptions, VeryDarkGreen).Execute(this.Configuration, this.Source, this.SourceRectangle);
             base.AfterImageApply();
         }
     }
diff --git a/src/ImageSharp/Processing/Processors/Filters/PolaroidProcessor.cs b/src/ImageSharp/Processing/Processors/Filters/PolaroidProcessor.cs
index a5cf26862..965a35be1 100644
--- a/src/ImageSharp/Processing/Processors/Filters/PolaroidProcessor.cs
+++ b/src/ImageSharp/Processing/Processors/Filters/PolaroidProcessor.cs
@@ -11,11 +11,18 @@ namespace SixLabors.ImageSharp.Processing.Processors.Filters
         /// <summary>
         /// Initializes a new instance of the <see cref="PolaroidProcessor" /> class.
         /// </summary>
-        public PolaroidProcessor()
+        /// <param name="graphicsOptions">Graphics options to use within the processor.</param>
+        public PolaroidProcessor(GraphicsOptions graphicsOptions)
             : base(KnownFilterMatrices.PolaroidFilter)
         {
+            this.GraphicsOptions = graphicsOptions;
         }
 
+        /// <summary>
+        /// Gets the options effecting blending and composition
+        /// </summary>
+        public GraphicsOptions GraphicsOptions { get; }
+
         /// <inheritdoc />
         public override IImageProcessor<TPixel> CreatePixelSpecificProcessor<TPixel>(Configuration configuration, Image<TPixel> source, Rectangle sourceRectangle) =>
             new PolaroidProcessor<TPixel>(configuration, this, source, sourceRectangle);
diff --git a/src/ImageSharp/Processing/Processors/Filters/PolaroidProcessor{TPixel}.cs b/src/ImageSharp/Processing/Processors/Filters/PolaroidProcessor{TPixel}.cs
index 9f547be1c..470d553c2 100644
--- a/src/ImageSharp/Processing/Processors/Filters/PolaroidProcessor{TPixel}.cs
+++ b/src/ImageSharp/Processing/Processors/Filters/PolaroidProcessor{TPixel}.cs
@@ -14,6 +14,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Filters
     {
         private static readonly Color LightOrange = Color.FromRgba(255, 153, 102, 128);
         private static readonly Color VeryDarkOrange = Color.FromRgb(102, 34, 0);
+        private readonly PolaroidProcessor definition;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="PolaroidProcessor{TPixel}"/> class.
@@ -25,13 +26,14 @@ namespace SixLabors.ImageSharp.Processing.Processors.Filters
         public PolaroidProcessor(Configuration configuration, PolaroidProcessor definition, Image<TPixel> source, Rectangle sourceRectangle)
             : base(configuration, definition, source, sourceRectangle)
         {
+            this.definition = definition;
         }
 
         /// <inheritdoc/>
         protected override void AfterImageApply()
         {
-            new VignetteProcessor(VeryDarkOrange).Execute(this.Configuration, this.Source, this.SourceRectangle);
-            new GlowProcessor(LightOrange, this.Source.Width / 4F).Execute(this.Configuration, this.Source, this.SourceRectangle);
+            new VignetteProcessor(this.definition.GraphicsOptions, VeryDarkOrange).Execute(this.Configuration, this.Source, this.SourceRectangle);
+            new GlowProcessor(this.definition.GraphicsOptions, LightOrange, this.Source.Width / 4F).Execute(this.Configuration, this.Source, this.SourceRectangle);
             base.AfterImageApply();
         }
     }
diff --git a/src/ImageSharp/Processing/Processors/Overlays/GlowProcessor.cs b/src/ImageSharp/Processing/Processors/Overlays/GlowProcessor.cs
index 87e93ca21..5e0d1cbf7 100644
--- a/src/ImageSharp/Processing/Processors/Overlays/GlowProcessor.cs
+++ b/src/ImageSharp/Processing/Processors/Overlays/GlowProcessor.cs
@@ -10,15 +10,6 @@ namespace SixLabors.ImageSharp.Processing.Processors.Overlays
     /// </summary>
     public sealed class GlowProcessor : IImageProcessor
     {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="GlowProcessor" /> class.
-        /// </summary>
-        /// <param name="color">The color or the glow.</param>
-        public GlowProcessor(Color color)
-            : this(color, 0)
-        {
-        }
-
         /// <summary>
         /// Initializes a new instance of the <see cref="GlowProcessor" /> class.
         /// </summary>
@@ -29,16 +20,6 @@ namespace SixLabors.ImageSharp.Processing.Processors.Overlays
         {
         }
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="GlowProcessor" /> class.
-        /// </summary>
-        /// <param name="color">The color or the glow.</param>
-        /// <param name="radius">The radius of the glow.</param>
-        internal GlowProcessor(Color color, ValueSize radius)
-            : this(new GraphicsOptions(), color, radius)
-        {
-        }
-
         /// <summary>
         /// Initializes a new instance of the <see cref="GlowProcessor" /> class.
         /// </summary>
diff --git a/src/ImageSharp/Processing/Processors/Overlays/VignetteProcessor.cs b/src/ImageSharp/Processing/Processors/Overlays/VignetteProcessor.cs
index 5654eccfa..3b16f8bc8 100644
--- a/src/ImageSharp/Processing/Processors/Overlays/VignetteProcessor.cs
+++ b/src/ImageSharp/Processing/Processors/Overlays/VignetteProcessor.cs
@@ -10,15 +10,6 @@ namespace SixLabors.ImageSharp.Processing.Processors.Overlays
     /// </summary>
     public sealed class VignetteProcessor : IImageProcessor
     {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="VignetteProcessor" /> class.
-        /// </summary>
-        /// <param name="color">The color of the vignette.</param>
-        public VignetteProcessor(Color color)
-            : this(new GraphicsOptions(), color)
-        {
-        }
-
         /// <summary>
         /// Initializes a new instance of the <see cref="VignetteProcessor" /> class.
         /// </summary>
diff --git a/tests/ImageSharp.Tests/Drawing/DrawImageExtensionsTests.cs b/tests/ImageSharp.Tests/Drawing/DrawImageExtensionsTests.cs
new file mode 100644
index 000000000..3f90412ae
--- /dev/null
+++ b/tests/ImageSharp.Tests/Drawing/DrawImageExtensionsTests.cs
@@ -0,0 +1,83 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Linq;
+using Moq;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.Advanced;
+using SixLabors.ImageSharp.Formats.Png;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing;
+using SixLabors.ImageSharp.Processing.Processors.Drawing;
+using SixLabors.ImageSharp.Tests.Processing;
+using SixLabors.ImageSharp.Tests.TestUtilities.ImageComparison;
+
+using Xunit;
+
+namespace SixLabors.ImageSharp.Tests.Drawing
+{
+    public class DrawImageExtensionsTests : BaseImageOperationsExtensionTest
+    {
+
+        [Fact]
+        public void DrawImage_OpacityOnly_VerifyGraphicOptionsTakenFromContext()
+        {
+            // non-default values as we cant easly defect usage otherwise
+            this.options.AlphaCompositionMode = PixelAlphaCompositionMode.Xor;
+            this.options.ColorBlendingMode = PixelColorBlendingMode.Screen;
+
+            this.operations.DrawImage(null, 0.5f);
+            var dip = this.Verify<DrawImageProcessor>();
+
+            Assert.Equal(0.5, dip.Opacity);
+            Assert.Equal(this.options.AlphaCompositionMode, dip.AlphaCompositionMode);
+            Assert.Equal(this.options.ColorBlendingMode, dip.ColorBlendingMode);
+        }
+
+        [Fact]
+        public void DrawImage_OpacityAndBlending_VerifyGraphicOptionsTakenFromContext()
+        {
+            // non-default values as we cant easly defect usage otherwise
+            this.options.AlphaCompositionMode = PixelAlphaCompositionMode.Xor;
+            this.options.ColorBlendingMode = PixelColorBlendingMode.Screen;
+
+            this.operations.DrawImage(null, PixelColorBlendingMode.Multiply, 0.5f);
+            var dip = this.Verify<DrawImageProcessor>();
+
+            Assert.Equal(0.5, dip.Opacity);
+            Assert.Equal(this.options.AlphaCompositionMode, dip.AlphaCompositionMode);
+            Assert.Equal(PixelColorBlendingMode.Multiply, dip.ColorBlendingMode);
+        }
+
+        [Fact]
+        public void DrawImage_LocationAndOpacity_VerifyGraphicOptionsTakenFromContext()
+        {
+            // non-default values as we cant easly defect usage otherwise
+            this.options.AlphaCompositionMode = PixelAlphaCompositionMode.Xor;
+            this.options.ColorBlendingMode = PixelColorBlendingMode.Screen;
+
+            this.operations.DrawImage(null, Point.Empty, 0.5f);
+            var dip = this.Verify<DrawImageProcessor>();
+
+            Assert.Equal(0.5, dip.Opacity);
+            Assert.Equal(this.options.AlphaCompositionMode, dip.AlphaCompositionMode);
+            Assert.Equal(this.options.ColorBlendingMode, dip.ColorBlendingMode);
+        }
+
+        [Fact]
+        public void DrawImage_LocationAndOpacityAndBlending_VerifyGraphicOptionsTakenFromContext()
+        {
+            // non-default values as we cant easly defect usage otherwise
+            this.options.AlphaCompositionMode = PixelAlphaCompositionMode.Xor;
+            this.options.ColorBlendingMode = PixelColorBlendingMode.Screen;
+
+            this.operations.DrawImage(null, Point.Empty, PixelColorBlendingMode.Multiply, 0.5f);
+            var dip = this.Verify<DrawImageProcessor>();
+
+            Assert.Equal(0.5, dip.Opacity);
+            Assert.Equal(this.options.AlphaCompositionMode, dip.AlphaCompositionMode);
+            Assert.Equal(PixelColorBlendingMode.Multiply, dip.ColorBlendingMode);
+        }
+    }
+}
diff --git a/tests/ImageSharp.Tests/GraphicOptionsDefaultsExtensionsTests.cs b/tests/ImageSharp.Tests/GraphicOptionsDefaultsExtensionsTests.cs
new file mode 100644
index 000000000..9c02dd601
--- /dev/null
+++ b/tests/ImageSharp.Tests/GraphicOptionsDefaultsExtensionsTests.cs
@@ -0,0 +1,172 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Tests.Processing;
+using SixLabors.ImageSharp.Tests.TestUtilities;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Tests
+{
+    public class GraphicOptionsDefaultsExtensionsTests
+    {
+        [Fact]
+        public void SetDefaultOptionsOnProcessingContext()
+        {
+            var option = new GraphicsOptions();
+            var config = new Configuration();
+            var context = new FakeImageOperationsProvider.FakeImageOperations<Rgba32>(config, null, true);
+
+            context.SetGraphicsOptions(option);
+
+            // sets the prop on the processing context not on the configuration
+            Assert.Equal(option, context.Properties[typeof(GraphicsOptions)]);
+            Assert.DoesNotContain(typeof(GraphicsOptions), config.Properties.Keys);
+        }
+
+        [Fact]
+        public void UpdateDefaultOptionsOnProcessingContext_AlwaysNewInstance()
+        {
+            var option = new GraphicsOptions()
+            {
+                BlendPercentage = 0.9f
+            };
+            var config = new Configuration();
+            var context = new FakeImageOperationsProvider.FakeImageOperations<Rgba32>(config, null, true);
+            context.SetGraphicsOptions(option);
+
+            context.SetGraphicsOptions(o =>
+            {
+                Assert.Equal(0.9f, o.BlendPercentage); // has origional values
+                o.BlendPercentage = 0.4f;
+            });
+
+            var returnedOption = context.GetGraphicsOptions();
+            Assert.Equal(0.4f, returnedOption.BlendPercentage);
+            Assert.Equal(0.9f, option.BlendPercentage); // hasn't been mutated
+        }
+
+        [Fact]
+        public void SetDefaultOptionsOnConfiguration()
+        {
+            var option = new GraphicsOptions();
+            var config = new Configuration();
+
+            config.SetGraphicsOptions(option);
+
+            Assert.Equal(option, config.Properties[typeof(GraphicsOptions)]);
+        }
+
+        [Fact]
+        public void UpdateDefaultOptionsOnConfiguration_AlwaysNewInstance()
+        {
+            var option = new GraphicsOptions()
+            {
+                BlendPercentage = 0.9f
+            };
+            var config = new Configuration();
+            config.SetGraphicsOptions(option);
+
+            config.SetGraphicsOptions(o =>
+            {
+                Assert.Equal(0.9f, o.BlendPercentage); // has origional values
+                o.BlendPercentage = 0.4f;
+            });
+
+            var returnedOption = config.GetGraphicsOptions();
+            Assert.Equal(0.4f, returnedOption.BlendPercentage);
+            Assert.Equal(0.9f, option.BlendPercentage); // hasn't been mutated
+        }
+
+        [Fact]
+        public void GetDefaultOptionsFromConfiguration_SettingNullThenReturnsNewInstance()
+        {
+            var config = new Configuration();
+
+            var options = config.GetGraphicsOptions();
+            Assert.NotNull(options);
+            config.SetGraphicsOptions((GraphicsOptions)null);
+
+            var options2 = config.GetGraphicsOptions();
+            Assert.NotNull(options2);
+
+            // we set it to null should now be a new instance
+            Assert.NotEqual(options, options2);
+        }
+
+        [Fact]
+        public void GetDefaultOptionsFromConfiguration_IgnoreIncorectlyTypesDictionEntry()
+        {
+            var config = new Configuration();
+
+            config.Properties[typeof(GraphicsOptions)] = "wronge type";
+            var options = config.GetGraphicsOptions();
+            Assert.NotNull(options);
+            Assert.IsType<GraphicsOptions>(options);
+        }
+
+        [Fact]
+        public void GetDefaultOptionsFromConfiguration_AlwaysReturnsInstance()
+        {
+            var config = new Configuration();
+
+            Assert.DoesNotContain(typeof(GraphicsOptions), config.Properties.Keys);
+            var options = config.GetGraphicsOptions();
+            Assert.NotNull(options);
+        }
+
+        [Fact]
+        public void GetDefaultOptionsFromConfiguration_AlwaysReturnsSameValue()
+        {
+            var config = new Configuration();
+
+            var options = config.GetGraphicsOptions();
+            var options2 = config.GetGraphicsOptions();
+            Assert.Equal(options, options2);
+        }
+
+        [Fact]
+        public void GetDefaultOptionsFromProcessingContext_AlwaysReturnsInstance()
+        {
+            var config = new Configuration();
+            var context = new FakeImageOperationsProvider.FakeImageOperations<Rgba32>(config, null, true);
+
+            var ctxOptions = context.GetGraphicsOptions();
+            Assert.NotNull(ctxOptions);
+        }
+
+        [Fact]
+        public void GetDefaultOptionsFromProcessingContext_AlwaysReturnsInstanceEvenIfSetToNull()
+        {
+            var config = new Configuration();
+            var context = new FakeImageOperationsProvider.FakeImageOperations<Rgba32>(config, null, true);
+
+            context.SetGraphicsOptions((GraphicsOptions)null);
+            var ctxOptions = context.GetGraphicsOptions();
+            Assert.NotNull(ctxOptions);
+        }
+
+        [Fact]
+        public void GetDefaultOptionsFromProcessingContext_FallbackToConfigsInstance()
+        {
+            var option = new GraphicsOptions();
+            var config = new Configuration();
+            config.SetGraphicsOptions(option);
+            var context = new FakeImageOperationsProvider.FakeImageOperations<Rgba32>(config, null, true);
+
+            var ctxOptions = context.GetGraphicsOptions();
+            Assert.Equal(option, ctxOptions);
+        }
+
+        [Fact]
+        public void GetDefaultOptionsFromProcessingContext_IgnoreIncorectlyTypesDictionEntry()
+        {
+            var config = new Configuration();
+            var context = new FakeImageOperationsProvider.FakeImageOperations<Rgba32>(config, null, true);
+            context.Properties[typeof(GraphicsOptions)] = "wronge type";
+            var options = context.GetGraphicsOptions();
+            Assert.NotNull(options);
+            Assert.IsType<GraphicsOptions>(options);
+        }
+    }
+}
diff --git a/tests/ImageSharp.Tests/Processing/BaseImageOperationsExtensionTest.cs b/tests/ImageSharp.Tests/Processing/BaseImageOperationsExtensionTest.cs
index 82c22245d..953563006 100644
--- a/tests/ImageSharp.Tests/Processing/BaseImageOperationsExtensionTest.cs
+++ b/tests/ImageSharp.Tests/Processing/BaseImageOperationsExtensionTest.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
+using System.ComponentModel.DataAnnotations;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.PixelFormats;
 using SixLabors.ImageSharp.Processing;
@@ -25,6 +26,7 @@ namespace SixLabors.ImageSharp.Tests.Processing
             this.source = new Image<Rgba32>(91 + 324, 123 + 56);
             this.rect = new Rectangle(91, 123, 324, 56); // make this random?
             this.internalOperations = new FakeImageOperationsProvider.FakeImageOperations<Rgba32>(this.source.GetConfiguration(), this.source, false);
+            this.internalOperations.SetGraphicsOptions(this.options);
             this.operations = this.internalOperations;
         }
 
diff --git a/tests/ImageSharp.Tests/Processing/Effects/BackgroundColorTest.cs b/tests/ImageSharp.Tests/Processing/Effects/BackgroundColorTest.cs
index 37bd2e87a..34b99461d 100644
--- a/tests/ImageSharp.Tests/Processing/Effects/BackgroundColorTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Effects/BackgroundColorTest.cs
@@ -10,15 +10,13 @@ namespace SixLabors.ImageSharp.Tests.Processing.Effects
 {
     public class BackgroundColorTest : BaseImageOperationsExtensionTest
     {
-        private static readonly GraphicsOptionsComparer GraphicsOptionsComparer = new GraphicsOptionsComparer();
-
         [Fact]
         public void BackgroundColor_amount_BackgroundColorProcessorDefaultsSet()
         {
             this.operations.BackgroundColor(Color.BlanchedAlmond);
             BackgroundColorProcessor processor = this.Verify<BackgroundColorProcessor>();
 
-            Assert.Equal(new GraphicsOptions(), processor.GraphicsOptions, GraphicsOptionsComparer);
+            Assert.Equal(this.options, processor.GraphicsOptions);
             Assert.Equal(Color.BlanchedAlmond, processor.Color);
         }
 
@@ -28,7 +26,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Effects
             this.operations.BackgroundColor(Color.BlanchedAlmond, this.rect);
             BackgroundColorProcessor processor = this.Verify<BackgroundColorProcessor>(this.rect);
 
-            Assert.Equal(new GraphicsOptions(), processor.GraphicsOptions, GraphicsOptionsComparer);
+            Assert.Equal(this.options, processor.GraphicsOptions);
             Assert.Equal(Color.BlanchedAlmond, processor.Color);
         }
 
@@ -38,7 +36,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Effects
             this.operations.BackgroundColor(this.options, Color.BlanchedAlmond);
             BackgroundColorProcessor processor = this.Verify<BackgroundColorProcessor>();
 
-            Assert.Equal(this.options, processor.GraphicsOptions, GraphicsOptionsComparer);
+            Assert.Equal(this.options, processor.GraphicsOptions);
             Assert.Equal(Color.BlanchedAlmond, processor.Color);
         }
 
@@ -48,7 +46,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Effects
             this.operations.BackgroundColor(this.options, Color.BlanchedAlmond, this.rect);
             BackgroundColorProcessor processor = this.Verify<BackgroundColorProcessor>(this.rect);
 
-            Assert.Equal(this.options, processor.GraphicsOptions, GraphicsOptionsComparer);
+            Assert.Equal(this.options, processor.GraphicsOptions);
             Assert.Equal(Color.BlanchedAlmond, processor.Color);
         }
     }
diff --git a/tests/ImageSharp.Tests/Processing/FakeImageOperationsProvider.cs b/tests/ImageSharp.Tests/Processing/FakeImageOperationsProvider.cs
index 3f11b4631..cd4d78279 100644
--- a/tests/ImageSharp.Tests/Processing/FakeImageOperationsProvider.cs
+++ b/tests/ImageSharp.Tests/Processing/FakeImageOperationsProvider.cs
@@ -56,6 +56,8 @@ namespace SixLabors.ImageSharp.Tests.Processing
 
             public Configuration Configuration { get; }
 
+            public IDictionary<object, object> Properties { get; } = new Dictionary<object, object>();
+
             public Image<TPixel> GetResultImage()
             {
                 return this.Source;
diff --git a/tests/ImageSharp.Tests/Processing/Filters/ContrastTest.cs b/tests/ImageSharp.Tests/Processing/Filters/ContrastTest.cs
index e55e983da..bf2d6823a 100644
--- a/tests/ImageSharp.Tests/Processing/Filters/ContrastTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Filters/ContrastTest.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors and contributors.
+// Copyright (c) Six Labors and contributors.
 // Licensed under the Apache License, Version 2.0.
 
 using Xunit;
@@ -28,4 +28,4 @@ namespace SixLabors.ImageSharp.Tests.Processing.Effects
             Assert.Equal(1.5F, processor.Amount);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/tests/ImageSharp.Tests/Processing/Filters/LomographTest.cs b/tests/ImageSharp.Tests/Processing/Filters/LomographTest.cs
index 65e04fbcc..6cb38e2fe 100644
--- a/tests/ImageSharp.Tests/Processing/Filters/LomographTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Filters/LomographTest.cs
@@ -16,14 +16,16 @@ namespace SixLabors.ImageSharp.Tests
         public void Lomograph_amount_LomographProcessorDefaultsSet()
         {
             this.operations.Lomograph();
-            this.Verify<LomographProcessor>();
+            var processor = this.Verify<LomographProcessor>();
+            Assert.Equal(processor.GraphicsOptions, this.options);
         }
 
         [Fact]
         public void Lomograph_amount_rect_LomographProcessorDefaultsSet()
         {
             this.operations.Lomograph(this.rect);
-            this.Verify<LomographProcessor>(this.rect);
+            var processor = this.Verify<LomographProcessor>(this.rect);
+            Assert.Equal(processor.GraphicsOptions, this.options);
         }
     }
 }
diff --git a/tests/ImageSharp.Tests/Processing/Filters/PolaroidTest.cs b/tests/ImageSharp.Tests/Processing/Filters/PolaroidTest.cs
index c3e2c3c50..346df0379 100644
--- a/tests/ImageSharp.Tests/Processing/Filters/PolaroidTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Filters/PolaroidTest.cs
@@ -14,14 +14,16 @@ namespace SixLabors.ImageSharp.Tests.Processing.Filters
         public void Polaroid_amount_PolaroidProcessorDefaultsSet()
         {
             this.operations.Polaroid();
-            this.Verify<PolaroidProcessor>();
+            var processor = this.Verify<PolaroidProcessor>();
+            Assert.Equal(processor.GraphicsOptions, this.options);
         }
 
         [Fact]
         public void Polaroid_amount_rect_PolaroidProcessorDefaultsSet()
         {
             this.operations.Polaroid(this.rect);
-            this.Verify<PolaroidProcessor>(this.rect);
+            var processor = this.Verify<PolaroidProcessor>(this.rect);
+            Assert.Equal(processor.GraphicsOptions, this.options);
         }
     }
 }
diff --git a/tests/ImageSharp.Tests/Processing/Overlays/GlowTest.cs b/tests/ImageSharp.Tests/Processing/Overlays/GlowTest.cs
index ea000ae2a..0336b231b 100644
--- a/tests/ImageSharp.Tests/Processing/Overlays/GlowTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Overlays/GlowTest.cs
@@ -11,15 +11,13 @@ namespace SixLabors.ImageSharp.Tests.Processing.Overlays
 {
     public class GlowTest : BaseImageOperationsExtensionTest
     {
-        private static readonly GraphicsOptionsComparer GraphicsOptionsComparer = new GraphicsOptionsComparer();
-
         [Fact]
         public void Glow_GlowProcessorWithDefaultValues()
         {
             this.operations.Glow();
             GlowProcessor p = this.Verify<GlowProcessor>();
 
-            Assert.Equal(new GraphicsOptions(), p.GraphicsOptions, GraphicsOptionsComparer);
+            Assert.Equal(this.options, p.GraphicsOptions);
             Assert.Equal(Color.Black, p.GlowColor);
             Assert.Equal(ValueSize.PercentageOfWidth(.5f), p.Radius);
         }
@@ -30,7 +28,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Overlays
             this.operations.Glow(Color.Aquamarine);
             GlowProcessor p = this.Verify<GlowProcessor>();
 
-            Assert.Equal(new GraphicsOptions(), p.GraphicsOptions, GraphicsOptionsComparer);
+            Assert.Equal(this.options, p.GraphicsOptions);
             Assert.Equal(Color.Aquamarine, p.GlowColor);
             Assert.Equal(ValueSize.PercentageOfWidth(.5f), p.Radius);
         }
@@ -41,7 +39,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Overlays
             this.operations.Glow(3.5f);
             GlowProcessor p = this.Verify<GlowProcessor>();
 
-            Assert.Equal(new GraphicsOptions(), p.GraphicsOptions, GraphicsOptionsComparer);
+            Assert.Equal(this.options, p.GraphicsOptions);
             Assert.Equal(Color.Black, p.GlowColor);
             Assert.Equal(ValueSize.Absolute(3.5f), p.Radius);
         }
@@ -53,7 +51,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Overlays
             this.operations.Glow(rect);
             GlowProcessor p = this.Verify<GlowProcessor>(rect);
 
-            Assert.Equal(new GraphicsOptions(), p.GraphicsOptions, GraphicsOptionsComparer);
+            Assert.Equal(this.options, p.GraphicsOptions);
             Assert.Equal(Color.Black, p.GlowColor);
             Assert.Equal(ValueSize.PercentageOfWidth(.5f), p.Radius);
         }
diff --git a/tests/ImageSharp.Tests/Processing/Overlays/VignetteTest.cs b/tests/ImageSharp.Tests/Processing/Overlays/VignetteTest.cs
index 8e5eb7207..5d41c58ce 100644
--- a/tests/ImageSharp.Tests/Processing/Overlays/VignetteTest.cs
+++ b/tests/ImageSharp.Tests/Processing/Overlays/VignetteTest.cs
@@ -10,15 +10,13 @@ namespace SixLabors.ImageSharp.Tests.Processing.Overlays
 {
     public class VignetteTest : BaseImageOperationsExtensionTest
     {
-        private static readonly GraphicsOptionsComparer GraphicsOptionsComparer = new GraphicsOptionsComparer();
-
         [Fact]
         public void Vignette_VignetteProcessorWithDefaultValues()
         {
             this.operations.Vignette();
             VignetteProcessor p = this.Verify<VignetteProcessor>();
 
-            Assert.Equal(new GraphicsOptions(), p.GraphicsOptions, GraphicsOptionsComparer);
+            Assert.Equal(this.options, p.GraphicsOptions);
             Assert.Equal(Color.Black, p.VignetteColor);
             Assert.Equal(ValueSize.PercentageOfWidth(.5f), p.RadiusX);
             Assert.Equal(ValueSize.PercentageOfHeight(.5f), p.RadiusY);
@@ -30,7 +28,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Overlays
             this.operations.Vignette(Color.Aquamarine);
             VignetteProcessor p = this.Verify<VignetteProcessor>();
 
-            Assert.Equal(new GraphicsOptions(), p.GraphicsOptions, GraphicsOptionsComparer);
+            Assert.Equal(this.options, p.GraphicsOptions);
             Assert.Equal(Color.Aquamarine, p.VignetteColor);
             Assert.Equal(ValueSize.PercentageOfWidth(.5f), p.RadiusX);
             Assert.Equal(ValueSize.PercentageOfHeight(.5f), p.RadiusY);
@@ -42,7 +40,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Overlays
             this.operations.Vignette(3.5f, 12123f);
             VignetteProcessor p = this.Verify<VignetteProcessor>();
 
-            Assert.Equal(new GraphicsOptions(), p.GraphicsOptions, GraphicsOptionsComparer);
+            Assert.Equal(this.options, p.GraphicsOptions);
             Assert.Equal(Color.Black, p.VignetteColor);
             Assert.Equal(ValueSize.Absolute(3.5f), p.RadiusX);
             Assert.Equal(ValueSize.Absolute(12123f), p.RadiusY);
@@ -55,7 +53,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Overlays
             this.operations.Vignette(rect);
             VignetteProcessor p = this.Verify<VignetteProcessor>(rect);
 
-            Assert.Equal(new GraphicsOptions(), p.GraphicsOptions, GraphicsOptionsComparer);
+            Assert.Equal(this.options, p.GraphicsOptions);
             Assert.Equal(Color.Black, p.VignetteColor);
             Assert.Equal(ValueSize.PercentageOfWidth(.5f), p.RadiusX);
             Assert.Equal(ValueSize.PercentageOfHeight(.5f), p.RadiusY);