Use test pattern files for tests

src/ImageSharp/Processing/ColorMatrix/Grayscale.cs

@@ -103,7 +103,7 @@ namespace SixLabors.ImageSharp
         /// <returns>The <see cref="Image{TPixel}"/>.</returns>
         public static IImageProcessingContext<TPixel> Grayscale<TPixel>(this IImageProcessingContext<TPixel> source, GrayscaleMode mode, Rectangle rectangle)
             where TPixel : struct, IPixel<TPixel>
-        => Grayscale(source, GrayscaleMode.Bt709, 1F, rectangle);
+        => Grayscale(source, mode, 1F, rectangle);
 
         /// <summary>
         /// Applies Grayscale toning to the image using the given amount.

tests/ImageSharp.Tests/Processing/Processors/ColorMatrix/BlackWhiteTest.cs → tests/ImageSharp.Tests/Processing/Processors/Filters/BlackWhiteTest.cs

@@ -12,7 +12,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters
     public class BlackWhiteTest : FileTestBase
     {
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), DefaultPixelType)]
+        [WithTestPatternImages(100, 100, DefaultPixelType)]
         public void ImageShouldApplyBlackWhiteFilter<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : struct, IPixel<TPixel>
         {
@@ -24,14 +24,14 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters
         }
 
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), DefaultPixelType)]
+        [WithTestPatternImages(100, 100, DefaultPixelType)]
         public void ImageShouldApplyBlackWhiteFilterInBox<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : struct, IPixel<TPixel>
         {
             using (Image<TPixel> source = provider.GetImage())
-            using (var image = source.Clone())
+            using (Image<TPixel> image = source.Clone())
             {
-                var bounds = new Rectangle(10, 10, image.Width / 2, image.Height / 2);
+                var bounds = new Rectangle(image.Width / 4, image.Width / 4, image.Width / 2, image.Height / 2);
 
                 image.Mutate(x => x.BlackWhite(bounds));
                 image.DebugSave(provider);

tests/ImageSharp.Tests/Processing/Processors/ColorMatrix/BrightnessTest.cs → tests/ImageSharp.Tests/Processing/Processors/Filters/BrightnessTest.cs

@@ -19,7 +19,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Effects
         };
 
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), nameof(BrightnessValues), DefaultPixelType)]
+        [WithTestPatternImages(nameof(BrightnessValues), 100, 100, DefaultPixelType)]
         public void ImageShouldApplyBrightnessFilter<TPixel>(TestImageProvider<TPixel> provider, float value)
             where TPixel : struct, IPixel<TPixel>
         {
@@ -31,14 +31,14 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Effects
         }
 
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), nameof(BrightnessValues), DefaultPixelType)]
+        [WithTestPatternImages(nameof(BrightnessValues), 100, 100, DefaultPixelType)]
         public void ImageShouldApplyBrightnessFilterInBox<TPixel>(TestImageProvider<TPixel> provider, float value)
             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);
+                var bounds = new Rectangle(image.Width / 4, image.Width / 4, image.Width / 2, image.Height / 2);
 
                 image.Mutate(x => x.Brightness(value, bounds));
                 image.DebugSave(provider, value);

tests/ImageSharp.Tests/Processing/Processors/ColorMatrix/ColorBlindnessTest.cs → tests/ImageSharp.Tests/Processing/Processors/Filters/ColorBlindnessTest.cs

@@ -26,7 +26,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters
         };
 
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), nameof(ColorBlindnessFilters), DefaultPixelType)]
+        [WithTestPatternImages(nameof(ColorBlindnessFilters), 100, 100, DefaultPixelType)]
         public void ImageShouldApplyColorBlindnessFilter<TPixel>(TestImageProvider<TPixel> provider, ColorBlindness colorBlindness)
             where TPixel : struct, IPixel<TPixel>
         {
@@ -38,14 +38,14 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters
         }
 
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), nameof(ColorBlindnessFilters), DefaultPixelType)]
+        [WithTestPatternImages(nameof(ColorBlindnessFilters), 100, 100, DefaultPixelType)]
         public void ImageShouldApplyColorBlindnessFilterInBox<TPixel>(TestImageProvider<TPixel> provider, ColorBlindness colorBlindness)
             where TPixel : struct, IPixel<TPixel>
         {
             using (Image<TPixel> source = provider.GetImage())
-            using (var image = source.Clone())
+            using (Image<TPixel> image = source.Clone())
             {
-                var bounds = new Rectangle(10, 10, image.Width / 2, image.Height / 2);
+                var bounds = new Rectangle(image.Width / 4, image.Width / 4, image.Width / 2, image.Height / 2);
 
                 image.Mutate(x => x.ColorBlindness(colorBlindness, bounds));
                 image.DebugSave(provider, colorBlindness.ToString());

tests/ImageSharp.Tests/Processing/Processors/ColorMatrix/ContrastTest.cs → tests/ImageSharp.Tests/Processing/Processors/Filters/ContrastTest.cs

@@ -19,7 +19,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Effects
         };
 
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), nameof(ContrastValues), DefaultPixelType)]
+        [WithTestPatternImages(nameof(ContrastValues), 100, 100, DefaultPixelType)]
         public void ImageShouldApplyContrastFilter<TPixel>(TestImageProvider<TPixel> provider, float value)
             where TPixel : struct, IPixel<TPixel>
         {
@@ -31,14 +31,14 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Effects
         }
 
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), nameof(ContrastValues), DefaultPixelType)]
+        [WithTestPatternImages(nameof(ContrastValues), 100, 100, DefaultPixelType)]
         public void ImageShouldApplyContrastFilterInBox<TPixel>(TestImageProvider<TPixel> provider, float value)
             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);
+                var bounds = new Rectangle(image.Width / 4, image.Width / 4, image.Width / 2, image.Height / 2);
 
                 image.Mutate(x => x.Contrast(value, bounds));
                 image.DebugSave(provider, value);

tests/ImageSharp.Tests/Processing/Processors/ColorMatrix/FilterTest.cs → tests/ImageSharp.Tests/Processing/Processors/Filters/FilterTest.cs

@@ -14,31 +14,34 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters
     public class FilterTest : FileTestBase
     {
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), DefaultPixelType)]
+        [WithTestPatternImages(100, 100, DefaultPixelType)]
         public void ImageShouldApplyFilter<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : struct, IPixel<TPixel>
         {
             using (Image<TPixel> image = provider.GetImage())
             {
                 Matrix4x4 brightness = MatrixFilters.CreateBrightnessFilter(0.9F);
-                Matrix4x4 contrast = MatrixFilters.CreateContrastFilter(1.2F);
+                Matrix4x4 hue = MatrixFilters.CreateHueFilter(180F);
                 Matrix4x4 saturation = MatrixFilters.CreateSaturateFilter(1.5F);
-                image.Mutate(x => x.Filter(brightness * contrast * saturation));
+                image.Mutate(x => x.Filter(brightness * hue * saturation));
                 image.DebugSave(provider);
             }
         }
 
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), DefaultPixelType)]
+        [WithTestPatternImages(100, 100, DefaultPixelType)]
         public void ImageShouldApplyFilterInBox<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);
+                var bounds = new Rectangle(image.Width / 4, image.Width / 4, image.Width / 2, image.Height / 2);
 
-                image.Mutate(x => x.Filter(MatrixFilters.CreateBrightnessFilter(1.2F) * MatrixFilters.CreateContrastFilter(1.2F), bounds));
+                Matrix4x4 brightness = MatrixFilters.CreateBrightnessFilter(0.9F);
+                Matrix4x4 hue = MatrixFilters.CreateHueFilter(180F);
+                Matrix4x4 saturation = MatrixFilters.CreateSaturateFilter(1.5F);
+                image.Mutate(x => x.Filter(brightness * hue * saturation, bounds));
                 image.DebugSave(provider);
 
                 ImageComparer.Tolerant().VerifySimilarityIgnoreRegion(source, image, bounds);

tests/ImageSharp.Tests/Processing/Processors/ColorMatrix/GrayscaleTest.cs → tests/ImageSharp.Tests/Processing/Processors/Filters/GrayscaleTest.cs

@@ -24,8 +24,8 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters
         /// Use test patterns over loaded images to save decode time.
         /// </summary>
         [Theory]
-        [WithTestPatternImages(nameof(GrayscaleModeTypes), 50, 50, DefaultPixelType)]
-        public void ImageShouldApplyGrayscaleFilterAll<TPixel>(TestImageProvider<TPixel> provider, GrayscaleMode value)
+        [WithTestPatternImages(nameof(GrayscaleModeTypes), 100, 100, DefaultPixelType)]
+        public void ImageShouldApplyGrayscaleFilter<TPixel>(TestImageProvider<TPixel> provider, GrayscaleMode value)
             where TPixel : struct, IPixel<TPixel>
         {
             using (Image<TPixel> image = provider.GetImage())
@@ -45,7 +45,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters
         }
 
         [Theory]
-        [WithTestPatternImages(nameof(GrayscaleModeTypes), 50, 50, DefaultPixelType)]
+        [WithTestPatternImages(nameof(GrayscaleModeTypes), 100, 100, DefaultPixelType)]
         public void ImageShouldApplyGrayscaleFilterInBox<TPixel>(TestImageProvider<TPixel> provider, GrayscaleMode value)
             where TPixel : struct, IPixel<TPixel>
         {
@@ -53,6 +53,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters
             using (Image<TPixel> image = source.Clone())
             {
                 var bounds = new Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2);
+
                 image.Mutate(x => x.Grayscale(value, bounds));
                 image.DebugSave(provider, value.ToString());
 

tests/ImageSharp.Tests/Processing/Processors/ColorMatrix/HueTest.cs → tests/ImageSharp.Tests/Processing/Processors/Filters/HueTest.cs

@@ -19,7 +19,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters
         };
 
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), nameof(HueValues), DefaultPixelType)]
+        [WithTestPatternImages(nameof(HueValues), 100, 100, DefaultPixelType)]
         public void ImageShouldApplyHueFilter<TPixel>(TestImageProvider<TPixel> provider, int value)
             where TPixel : struct, IPixel<TPixel>
         {
@@ -31,14 +31,14 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters
         }
 
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), nameof(HueValues), DefaultPixelType)]
+        [WithTestPatternImages(nameof(HueValues), 100, 100, DefaultPixelType)]
         public void ImageShouldApplyHueFilterInBox<TPixel>(TestImageProvider<TPixel> provider, int value)
             where TPixel : struct, IPixel<TPixel>
         {
             using (Image<TPixel> source = provider.GetImage())
-            using (var image = source.Clone())
+            using (Image<TPixel> image = source.Clone())
             {
-                var bounds = new Rectangle(10, 10, image.Width / 2, image.Height / 2);
+                var bounds = new Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2);
 
                 image.Mutate(x => x.Hue(value, bounds));
                 image.DebugSave(provider, value);

tests/ImageSharp.Tests/Processing/Processors/ColorMatrix/InvertTest.cs → tests/ImageSharp.Tests/Processing/Processors/Filters/InvertTest.cs

@@ -12,7 +12,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Effects
     public class InvertTest : FileTestBase
     {
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), DefaultPixelType)]
+        [WithTestPatternImages(100, 100, DefaultPixelType)]
         public void ImageShouldApplyInvertFilter<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : struct, IPixel<TPixel>
         {
@@ -24,14 +24,14 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Effects
         }
 
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), DefaultPixelType)]
+        [WithTestPatternImages(100, 100, DefaultPixelType)]
         public void ImageShouldApplyInvertFilterInBox<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);
+                var bounds = new Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2);
 
                 image.Mutate(x => x.Invert(bounds));
                 image.DebugSave(provider);

tests/ImageSharp.Tests/Processing/Processors/ColorMatrix/KodachromeTest.cs → tests/ImageSharp.Tests/Processing/Processors/Filters/KodachromeTest.cs

@@ -12,7 +12,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters
     public class KodachromeTest : FileTestBase
     {
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), DefaultPixelType)]
+        [WithTestPatternImages(100, 100, DefaultPixelType)]
         public void ImageShouldApplyKodachromeFilter<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : struct, IPixel<TPixel>
         {
@@ -24,14 +24,14 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters
         }
 
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), DefaultPixelType)]
+        [WithTestPatternImages(100, 100, DefaultPixelType)]
         public void ImageShouldApplyKodachromeFilterInBox<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : struct, IPixel<TPixel>
         {
             using (Image<TPixel> source = provider.GetImage())
-            using (var image = source.Clone())
+            using (Image<TPixel> image = source.Clone())
             {
-                var bounds = new Rectangle(10, 10, image.Width / 2, image.Height / 2);
+                var bounds = new Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2);
 
                 image.Mutate(x => x.Kodachrome(bounds));
                 image.DebugSave(provider);

tests/ImageSharp.Tests/Processing/Processors/ColorMatrix/LomographTest.cs → tests/ImageSharp.Tests/Processing/Processors/Filters/LomographTest.cs

@@ -12,7 +12,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters
     public class LomographTest : FileTestBase
     {
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), DefaultPixelType)]
+        [WithTestPatternImages(100, 100, DefaultPixelType)]
         public void ImageShouldApplyLomographFilter<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : struct, IPixel<TPixel>
         {
@@ -24,14 +24,14 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters
         }
 
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), DefaultPixelType)]
+        [WithTestPatternImages(100, 100, DefaultPixelType)]
         public void ImageShouldApplyLomographFilterInBox<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : struct, IPixel<TPixel>
         {
             using (Image<TPixel> source = provider.GetImage())
-            using (var image = source.Clone())
+            using (Image<TPixel> image = source.Clone())
             {
-                var bounds = new Rectangle(10, 10, image.Width / 2, image.Height / 2);
+                var bounds = new Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2);
 
                 image.Mutate(x => x.Lomograph(bounds));
                 image.DebugSave(provider);

tests/ImageSharp.Tests/Processing/Processors/ColorMatrix/OpacityTest.cs → tests/ImageSharp.Tests/Processing/Processors/Filters/OpacityTest.cs

@@ -19,7 +19,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Effects
         };
 
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), nameof(AlphaValues), DefaultPixelType)]
+        [WithTestPatternImages(nameof(AlphaValues), 100, 100, DefaultPixelType)]
         public void ImageShouldApplyAlphaFilter<TPixel>(TestImageProvider<TPixel> provider, float value)
             where TPixel : struct, IPixel<TPixel>
         {
@@ -31,14 +31,14 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Effects
         }
 
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), nameof(AlphaValues), DefaultPixelType)]
+        [WithTestPatternImages(nameof(AlphaValues), 100, 100, DefaultPixelType)]
         public void ImageShouldApplyAlphaFilterInBox<TPixel>(TestImageProvider<TPixel> provider, float value)
             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);
+                var bounds = new Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2);
 
                 image.Mutate(x => x.Opacity(value, bounds));
                 image.DebugSave(provider, value);

tests/ImageSharp.Tests/Processing/Processors/ColorMatrix/PolaroidTest.cs → tests/ImageSharp.Tests/Processing/Processors/Filters/PolaroidTest.cs

@@ -12,7 +12,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters
     public class PolaroidTest : FileTestBase
     {
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), DefaultPixelType)]
+        [WithTestPatternImages(100, 100, DefaultPixelType)]
         public void ImageShouldApplyPolaroidFilter<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : struct, IPixel<TPixel>
         {
@@ -24,14 +24,14 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters
         }
 
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), DefaultPixelType)]
+        [WithTestPatternImages(100, 100, DefaultPixelType)]
         public void ImageShouldApplyPolaroidFilterInBox<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : struct, IPixel<TPixel>
         {
             using (Image<TPixel> source = provider.GetImage())
-            using (var image = source.Clone())
+            using (Image<TPixel> image = source.Clone())
             {
-                var bounds = new Rectangle(10, 10, image.Width / 2, image.Height / 2);
+                var bounds = new Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2);
 
                 image.Mutate(x => x.Polaroid(bounds));
                 image.DebugSave(provider);

tests/ImageSharp.Tests/Processing/Processors/ColorMatrix/SaturateTest.cs → tests/ImageSharp.Tests/Processing/Processors/Filters/SaturateTest.cs

@@ -14,12 +14,12 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters
         public static readonly TheoryData<float> SaturationValues
         = new TheoryData<float>
         {
-            .5f,
+            .5F,
            1.5F,
         };
 
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), nameof(SaturationValues), DefaultPixelType)]
+        [WithTestPatternImages(nameof(SaturationValues), 100, 100, DefaultPixelType)]
         public void ImageShouldApplySaturationFilter<TPixel>(TestImageProvider<TPixel> provider, float value)
             where TPixel : struct, IPixel<TPixel>
         {
@@ -31,14 +31,14 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters
         }
 
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), nameof(SaturationValues), DefaultPixelType)]
+        [WithTestPatternImages(nameof(SaturationValues), 100, 100, DefaultPixelType)]
         public void ImageShouldApplySaturationFilterInBox<TPixel>(TestImageProvider<TPixel> provider, float value)
             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);
+                var bounds = new Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2);
 
                 image.Mutate(x => x.Saturate(value, bounds));
                 image.DebugSave(provider, value);

tests/ImageSharp.Tests/Processing/Processors/ColorMatrix/SepiaTest.cs → tests/ImageSharp.Tests/Processing/Processors/Filters/SepiaTest.cs

@@ -12,7 +12,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters
     public class SepiaTest : FileTestBase
     {
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), DefaultPixelType)]
+        [WithTestPatternImages(100, 100, DefaultPixelType)]
         public void ImageShouldApplySepiaFilter<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : struct, IPixel<TPixel>
         {
@@ -24,14 +24,14 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.Filters
         }
 
         [Theory]
-        [WithFileCollection(nameof(DefaultFiles), DefaultPixelType)]
+        [WithTestPatternImages(100, 100, DefaultPixelType)]
         public void ImageShouldApplySepiaFilterInBox<TPixel>(TestImageProvider<TPixel> provider)
             where TPixel : struct, IPixel<TPixel>
         {
             using (Image<TPixel> source = provider.GetImage())
-            using (var image = source.Clone())
+            using (Image<TPixel> image = source.Clone())
             {
-                var bounds = new Rectangle(10, 10, image.Width / 2, image.Height / 2);
+                var bounds = new Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2);
 
                 image.Mutate(x => x.Sepia(bounds));
                 image.DebugSave(provider);