diff --git a/src/ImageSharp/Processing/Processors/Effects/PixelateProcessor.cs b/src/ImageSharp/Processing/Processors/Effects/PixelateProcessor.cs index 7a57daa4eb..0287eaab8e 100644 --- a/src/ImageSharp/Processing/Processors/Effects/PixelateProcessor.cs +++ b/src/ImageSharp/Processing/Processors/Effects/PixelateProcessor.cs @@ -66,51 +66,46 @@ namespace ImageSharp.Processing.Processors // Get the range on the y-plane to choose from. IEnumerable range = EnumerableExtensions.SteppedRange(minY, i => i < maxY, size); - using (PixelAccessor targetPixels = new PixelAccessor(source.Width, source.Height)) + using (PixelAccessor sourcePixels = source.Lock()) { - using (PixelAccessor sourcePixels = source.Lock()) - { - Parallel.ForEach( - range, - this.ParallelOptions, - y => + Parallel.ForEach( + range, + this.ParallelOptions, + y => + { + int offsetY = y - startY; + int offsetPy = offset; + + for (int x = minX; x < maxX; x += size) { - int offsetY = y - startY; - int offsetPy = offset; + int offsetX = x - startX; + int offsetPx = offset; - for (int x = minX; x < maxX; x += size) + // Make sure that the offset is within the boundary of the image. + while (offsetY + offsetPy >= maxY) { - int offsetX = x - startX; - int offsetPx = offset; - - // Make sure that the offset is within the boundary of the image. - while (offsetY + offsetPy >= maxY) - { - offsetPy--; - } + offsetPy--; + } - while (x + offsetPx >= maxX) - { - offsetPx--; - } + while (x + offsetPx >= maxX) + { + offsetPx--; + } - // Get the pixel color in the centre of the soon to be pixelated area. - // ReSharper disable AccessToDisposedClosure - TPixel pixel = sourcePixels[offsetX + offsetPx, offsetY + offsetPy]; + // Get the pixel color in the centre of the soon to be pixelated area. + // ReSharper disable AccessToDisposedClosure + TPixel pixel = sourcePixels[offsetX + offsetPx, offsetY + offsetPy]; - // For each pixel in the pixelate size, set it to the centre color. - for (int l = offsetY; l < offsetY + size && l < maxY; l++) + // For each pixel in the pixelate size, set it to the centre color. + for (int l = offsetY; l < offsetY + size && l < maxY; l++) + { + for (int k = offsetX; k < offsetX + size && k < maxX; k++) { - for (int k = offsetX; k < offsetX + size && k < maxX; k++) - { - targetPixels[k, l] = pixel; - } + sourcePixels[k, l] = pixel; } } - }); - - source.SwapPixelsBuffers(targetPixels); - } + } + }); } } } diff --git a/tests/ImageSharp.Tests/Formats/Png/PngSmokeTests.cs b/tests/ImageSharp.Tests/Formats/Png/PngSmokeTests.cs index 46ade9f9a6..be965160ce 100644 --- a/tests/ImageSharp.Tests/Formats/Png/PngSmokeTests.cs +++ b/tests/ImageSharp.Tests/Formats/Png/PngSmokeTests.cs @@ -20,7 +20,7 @@ namespace ImageSharp.Tests.Formats.Png public class PngSmokeTests { [Theory] - [WithTestPatternImages(300, 300, PixelTypes.All)] + [WithTestPatternImages(300, 300, PixelTypes.StandardImageClass)] public void GeneralTest(TestImageProvider provider) where TPixel : struct, IPixel { @@ -41,7 +41,7 @@ namespace ImageSharp.Tests.Formats.Png } [Theory] - [WithTestPatternImages(100, 100, PixelTypes.All)] + [WithTestPatternImages(100, 100, PixelTypes.StandardImageClass)] public void CanSaveIndexedPng(TestImageProvider provider) where TPixel : struct, IPixel { @@ -56,7 +56,7 @@ namespace ImageSharp.Tests.Formats.Png using (Image img2 = Image.Load(ms, new PngDecoder())) { // img2.Save(provider.Utility.GetTestOutputFileName("bmp", "_loaded"), new BmpEncoder()); - ImageComparer.CheckSimilarity(image, img2); + ImageComparer.CheckSimilarity(image, img2, 0.03f); } } } @@ -105,7 +105,7 @@ namespace ImageSharp.Tests.Formats.Png //} [Theory] - [WithTestPatternImages(300, 300, PixelTypes.All)] + [WithTestPatternImages(300, 300, PixelTypes.StandardImageClass)] public void Resize(TestImageProvider provider) where TPixel : struct, IPixel { diff --git a/tests/ImageSharp.Tests/ImageComparer.cs b/tests/ImageSharp.Tests/ImageComparer.cs index 7d0a8377d3..9b8a51fde8 100644 --- a/tests/ImageSharp.Tests/ImageComparer.cs +++ b/tests/ImageSharp.Tests/ImageComparer.cs @@ -73,7 +73,7 @@ if (b > segmentThreshold) { diffPixels++; } } - return diffPixels / (scalingFactor * scalingFactor); + return (float)diffPixels / (float)(scalingFactor * scalingFactor); } private static Fast2DArray GetDifferences(Image source, Image target, int scalingFactor) @@ -88,7 +88,8 @@ { for (int x = 0; x < scalingFactor; x++) { - differences[x, y] = (byte)Math.Abs(firstGray[x, y] - secondGray[x, y]); + var diff = firstGray[x, y] - secondGray[x, y]; + differences[x, y] = (byte)Math.Abs(diff); } } diff --git a/tests/ImageSharp.Tests/Processors/Filters/PixelateTest.cs b/tests/ImageSharp.Tests/Processors/Filters/PixelateTest.cs index 3a5fbc5567..b21a8c969c 100644 --- a/tests/ImageSharp.Tests/Processors/Filters/PixelateTest.cs +++ b/tests/ImageSharp.Tests/Processors/Filters/PixelateTest.cs @@ -6,10 +6,10 @@ namespace ImageSharp.Tests { using System.IO; - + using ImageSharp.PixelFormats; using Xunit; - public class PixelateTest : FileTestBase + public class PixelateTest { public static readonly TheoryData PixelateValues = new TheoryData @@ -19,37 +19,74 @@ namespace ImageSharp.Tests }; [Theory] - [MemberData(nameof(PixelateValues))] - public void ImageShouldApplyPixelateFilter(int value) + [WithTestPatternImages(nameof(PixelateValues), 320, 240, PixelTypes.StandardImageClass)] + public void ImageShouldApplyPixelateFilter(TestImageProvider provider, int value) + where TPixel : struct, IPixel { - string path = CreateOutputDirectory("Pixelate"); - - foreach (TestFile file in Files) + using (Image image = provider.GetImage()) { - string filename = file.GetFileName(value); - Image image = file.CreateImage(); + image.Pixelate(value) + .DebugSave(provider, new + { + size = value + }); - using (FileStream output = File.OpenWrite($"{path}/{filename}")) + using (PixelAccessor pixels = image.Lock()) { - image.Pixelate(value) - .Save(output); + for (int y = 0; y < pixels.Height; y += value) + { + for (int x = 0; x < pixels.Width; x += value) + { + TPixel source = pixels[x, y]; + for (int pixY = y; pixY < y + value && pixY < pixels.Height; pixY++) + { + for (int pixX = x; pixX < x + value && pixX < pixels.Width; pixX++) + { + Assert.Equal(source, pixels[pixX, pixY]); + } + } + } + } } } } [Theory] - [MemberData(nameof(PixelateValues))] - public void ImageShouldApplyPixelateFilterInBox(int value) + [WithTestPatternImages(nameof(PixelateValues), 320, 240, PixelTypes.StandardImageClass)] + public void ImageShouldApplyPixelateFilterInBox(TestImageProvider provider, int value) + where TPixel : struct, IPixel { - string path = this.CreateOutputDirectory("Pixelate"); - - foreach (TestFile file in Files) + using (Image source = provider.GetImage()) + using (Image image = new Image(source)) { - string filename = file.GetFileName(value + "-InBox"); - using (Image image = file.CreateImage()) - using (FileStream output = File.OpenWrite($"{path}/{filename}")) + Rectangle rect = new Rectangle(image.Width/4, image.Height / 4, image.Width / 2, image.Height / 2); + + image.Pixelate(value, rect) + .DebugSave(provider, new + { + size = value + }); + + using (PixelAccessor pixels = image.Lock()) + using (PixelAccessor sourcePixels = source.Lock()) { - image.Pixelate(value, new Rectangle(10, 10, image.Width / 2, image.Height / 2)).Save(output); + for (int y = 0; y < pixels.Height; y++) + { + for (int x = 0; x < pixels.Width; x++) + { + var tx = x; + var ty = y; + TPixel sourceColor = sourcePixels[tx, ty]; + if (rect.Contains(tx, ty)) + { + var sourceX = tx - ((tx - rect.Left) % value) + (value / 2); + var sourceY = ty - ((ty - rect.Top) % value) + (value / 2); + + sourceColor = pixels[sourceX, sourceY]; + } + Assert.Equal(sourceColor, pixels[tx, ty]); + } + } } } } diff --git a/tests/ImageSharp.Tests/TestUtilities/Attributes/ImageDataAttributeBase.cs b/tests/ImageSharp.Tests/TestUtilities/Attributes/ImageDataAttributeBase.cs index ffbd1b888e..379ce3d054 100644 --- a/tests/ImageSharp.Tests/TestUtilities/Attributes/ImageDataAttributeBase.cs +++ b/tests/ImageSharp.Tests/TestUtilities/Attributes/ImageDataAttributeBase.cs @@ -21,26 +21,72 @@ namespace ImageSharp.Tests protected readonly PixelTypes PixelTypes; - protected ImageDataAttributeBase(PixelTypes pixelTypes, object[] additionalParameters) + protected ImageDataAttributeBase(string memberName, PixelTypes pixelTypes, object[] additionalParameters) { this.PixelTypes = pixelTypes; this.AdditionalParameters = additionalParameters; + this.MemberName = memberName; + } + public string MemberName { get; private set; } + + public Type MemberType { get; set; } + public override IEnumerable GetData(MethodInfo testMethod) { - TypeInfo type = testMethod.GetParameters().First().ParameterType.GetTypeInfo(); - if (!type.IsGenericType || type.GetGenericTypeDefinition() != typeof(TestImageProvider<>)) + IEnumerable addedRows = Enumerable.Empty(); + if (!string.IsNullOrWhiteSpace(this.MemberName)) + { + Type type = this.MemberType ?? testMethod.DeclaringType; + Func accessor = GetPropertyAccessor(type) ?? GetFieldAccessor(type);// ?? GetMethodAccessor(type); + + if (accessor != null) + { + object obj = accessor(); + if (obj is IEnumerable memberItems) + { + addedRows = memberItems.Select(x => x as object[]); + if (addedRows.Any(x => x == null)) + { + throw new ArgumentException($"Property {MemberName} on {MemberType ?? testMethod.DeclaringType} yielded an item that is not an object[]"); + } + } + } + } + + if (!addedRows.Any()) { - yield return this.AdditionalParameters; + addedRows = new[] { new object[0] }; + } + + bool firstIsprovider = FirstIsProvider(testMethod); + IEnumerable dataItems = Enumerable.Empty(); + if (firstIsprovider) + { + return InnerGetData(testMethod, addedRows); } else { - foreach (KeyValuePair kv in this.PixelTypes.ExpandAllTypes()) - { - Type factoryType = typeof(TestImageProvider<>).MakeGenericType(kv.Value); + return addedRows.Select(x => x.Concat(this.AdditionalParameters).ToArray()); + } + } + + private bool FirstIsProvider(MethodInfo testMethod) + { + TypeInfo dataType = testMethod.GetParameters().First().ParameterType.GetTypeInfo(); + return dataType.IsGenericType && dataType.GetGenericTypeDefinition() == typeof(TestImageProvider<>); + } + + private IEnumerable InnerGetData(MethodInfo testMethod, IEnumerable memberData) + { + foreach (KeyValuePair kv in this.PixelTypes.ExpandAllTypes()) + { + Type factoryType = typeof(TestImageProvider<>).MakeGenericType(kv.Value); - foreach (object[] originalFacoryMethodArgs in this.GetAllFactoryMethodArgs(testMethod, factoryType)) + foreach (object[] originalFacoryMethodArgs in this.GetAllFactoryMethodArgs(testMethod, factoryType)) + { + foreach (object[] row in memberData) { object[] actualFactoryMethodArgs = new object[originalFacoryMethodArgs.Length + 2]; Array.Copy(originalFacoryMethodArgs, actualFactoryMethodArgs, originalFacoryMethodArgs.Length); @@ -50,9 +96,10 @@ namespace ImageSharp.Tests object factory = factoryType.GetMethod(this.GetFactoryMethodName(testMethod)) .Invoke(null, actualFactoryMethodArgs); - object[] result = new object[this.AdditionalParameters.Length + 1]; + object[] result = new object[this.AdditionalParameters.Length + 1 + row.Length]; result[0] = factory; - Array.Copy(this.AdditionalParameters, 0, result, 1, this.AdditionalParameters.Length); + Array.Copy(row, 0, result, 1, row.Length); + Array.Copy(this.AdditionalParameters, 0, result, 1 + row.Length, this.AdditionalParameters.Length); yield return result; } } @@ -71,5 +118,56 @@ namespace ImageSharp.Tests } protected abstract string GetFactoryMethodName(MethodInfo testMethod); + + Func GetFieldAccessor(Type type) + { + FieldInfo fieldInfo = null; + for (Type reflectionType = type; reflectionType != null; reflectionType = reflectionType.GetTypeInfo().BaseType) + { + fieldInfo = reflectionType.GetRuntimeField(MemberName); + if (fieldInfo != null) + break; + } + + if (fieldInfo == null || !fieldInfo.IsStatic) + return null; + + return () => fieldInfo.GetValue(null); + } + + //Func GetMethodAccessor(Type type) + //{ + // MethodInfo methodInfo = null; + // var parameterTypes = Parameters == null ? new Type[0] : Parameters.Select(p => p?.GetType()).ToArray(); + // for (var reflectionType = type; reflectionType != null; reflectionType = reflectionType.GetTypeInfo().BaseType) + // { + // methodInfo = reflectionType.GetRuntimeMethods() + // .FirstOrDefault(m => m.Name == MemberName && ParameterTypesCompatible(m.GetParameters(), parameterTypes)); + // if (methodInfo != null) + // break; + // } + + // if (methodInfo == null || !methodInfo.IsStatic) + // return null; + + // return () => methodInfo.Invoke(null, Parameters); + //} + + Func GetPropertyAccessor(Type type) + { + PropertyInfo propInfo = null; + for (Type reflectionType = type; reflectionType != null; reflectionType = reflectionType.GetTypeInfo().BaseType) + { + propInfo = reflectionType.GetRuntimeProperty(MemberName); + if (propInfo != null) + break; + } + + if (propInfo == null || propInfo.GetMethod == null || !propInfo.GetMethod.IsStatic) + return null; + + return () => propInfo.GetValue(null, null); + } + } } \ No newline at end of file diff --git a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithBlankImageAttribute.cs b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithBlankImageAttribute.cs index 25d3c8cac1..32278d7558 100644 --- a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithBlankImageAttribute.cs +++ b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithBlankImageAttribute.cs @@ -22,7 +22,21 @@ namespace ImageSharp.Tests /// The requested parameter /// Additional theory parameter values public WithBlankImagesAttribute(int width, int height, PixelTypes pixelTypes, params object[] additionalParameters) - : base(pixelTypes, additionalParameters) + : base(null, pixelTypes, additionalParameters) + { + this.Width = width; + this.Height = height; + } + + /// + /// Triggers passing an that produces a blank image of size width * height + /// + /// The required width + /// The required height + /// The requested parameter + /// Additional theory parameter values + public WithBlankImagesAttribute(string memberData, int width, int height, PixelTypes pixelTypes, params object[] additionalParameters) + : base(memberData, pixelTypes, additionalParameters) { this.Width = width; this.Height = height; diff --git a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithFileAttribute.cs b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithFileAttribute.cs index 752c114e56..ec8421853e 100644 --- a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithFileAttribute.cs +++ b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithFileAttribute.cs @@ -24,7 +24,20 @@ namespace ImageSharp.Tests /// The requested pixel types /// Additional theory parameter values public WithFileAttribute(string fileName, PixelTypes pixelTypes, params object[] additionalParameters) - : base(pixelTypes, additionalParameters) + : base(null, pixelTypes, additionalParameters) + { + this.fileName = fileName; + } + + /// + /// Triggers passing instances which read an image from the given file + /// One instance will be passed for each the pixel format defined by the pixelTypes parameter + /// + /// The name of the file + /// The requested pixel types + /// Additional theory parameter values + public WithFileAttribute(string fileName, string dataMemberName, PixelTypes pixelTypes, params object[] additionalParameters) + : base(dataMemberName, pixelTypes, additionalParameters) { this.fileName = fileName; } diff --git a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithFileCollectionAttribute.cs b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithFileCollectionAttribute.cs index 3bd93e6096..df8f8d0909 100644 --- a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithFileCollectionAttribute.cs +++ b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithFileCollectionAttribute.cs @@ -29,7 +29,24 @@ namespace ImageSharp.Tests string enumeratorMemberName, PixelTypes pixelTypes, params object[] additionalParameters) - : base(pixelTypes, additionalParameters) + : base(null, pixelTypes, additionalParameters) + { + this.enumeratorMemberName = enumeratorMemberName; + } + + /// + /// Triggers passing instances which read an image for each file being enumerated by the (static) test class field/property defined by enumeratorMemberName + /// instances will be passed for each the pixel format defined by the pixelTypes parameter + /// + /// The name of the static test class field/property enumerating the files + /// The requested pixel types + /// Additional theory parameter values + public WithFileCollectionAttribute( + string enumeratorMemberName, + string DataMemberName, + PixelTypes pixelTypes, + params object[] additionalParameters) + : base(DataMemberName, pixelTypes, additionalParameters) { this.enumeratorMemberName = enumeratorMemberName; } diff --git a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithMemberFactoryAttribute.cs b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithMemberFactoryAttribute.cs index 661640f661..6c6198c38d 100644 --- a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithMemberFactoryAttribute.cs +++ b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithMemberFactoryAttribute.cs @@ -26,7 +26,7 @@ namespace ImageSharp.Tests /// The requested pixel types /// Additional theory parameter values public WithMemberFactoryAttribute(string memberMethodName, PixelTypes pixelTypes, params object[] additionalParameters) - : base(pixelTypes, additionalParameters) + : base(null, pixelTypes, additionalParameters) { this.memberMethodName = memberMethodName; } diff --git a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithTestPatternImageAttribute.cs b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithTestPatternImageAttribute.cs index f2d2aeb88d..77c60a9433 100644 --- a/tests/ImageSharp.Tests/TestUtilities/Attributes/WithTestPatternImageAttribute.cs +++ b/tests/ImageSharp.Tests/TestUtilities/Attributes/WithTestPatternImageAttribute.cs @@ -22,7 +22,19 @@ namespace ImageSharp.Tests /// The requested parameter /// Additional theory parameter values public WithTestPatternImagesAttribute(int width, int height, PixelTypes pixelTypes, params object[] additionalParameters) - : base(pixelTypes, additionalParameters) + : this(null, width, height, pixelTypes,additionalParameters) + { + } + + /// + /// Triggers passing an that produces a test pattern image of size width * height + /// + /// The required width + /// The required height + /// The requested parameter + /// Additional theory parameter values + public WithTestPatternImagesAttribute(string memberData, int width, int height, PixelTypes pixelTypes, params object[] additionalParameters) + : base(memberData, pixelTypes, additionalParameters) { this.Width = width; this.Height = height; diff --git a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/TestImageProvider.cs b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/TestImageProvider.cs index 9d6f46b72e..bf30d48474 100644 --- a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/TestImageProvider.cs +++ b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/TestImageProvider.cs @@ -11,12 +11,16 @@ namespace ImageSharp.Tests using ImageSharp.PixelFormats; using Xunit.Abstractions; - + public interface ITestImageProvider + { + PixelTypes PixelType { get; } + ImagingTestCaseUtility Utility { get; } + } /// /// Provides instances for parametric unit tests. /// /// The pixel format of the image - public abstract partial class TestImageProvider + public abstract partial class TestImageProvider : ITestImageProvider where TPixel : struct, IPixel { public PixelTypes PixelType { get; private set; } = typeof(TPixel).GetPixelType(); diff --git a/tests/ImageSharp.Tests/TestUtilities/ImagingTestCaseUtility.cs b/tests/ImageSharp.Tests/TestUtilities/ImagingTestCaseUtility.cs index 6476c4ecf9..2901238856 100644 --- a/tests/ImageSharp.Tests/TestUtilities/ImagingTestCaseUtility.cs +++ b/tests/ImageSharp.Tests/TestUtilities/ImagingTestCaseUtility.cs @@ -97,10 +97,10 @@ namespace ImageSharp.Tests /// The requested extension /// Optional encoder /// Optional encoder options - public void SaveTestOutputFile(Image image, string extension = null, IImageEncoder encoder = null, IEncoderOptions options = null) + public void SaveTestOutputFile(Image image, string extension = null, IImageEncoder encoder = null, IEncoderOptions options = null, string tag = null) where TPixel : struct, IPixel { - string path = this.GetTestOutputFileName(extension); + string path = this.GetTestOutputFileName(extension: extension, tag:tag); extension = Path.GetExtension(path); IImageFormat format = GetImageFormatByExtension(extension); diff --git a/tests/ImageSharp.Tests/TestUtilities/TestImageExtensions.cs b/tests/ImageSharp.Tests/TestUtilities/TestImageExtensions.cs index 5408d5362b..dbd316423a 100644 --- a/tests/ImageSharp.Tests/TestUtilities/TestImageExtensions.cs +++ b/tests/ImageSharp.Tests/TestUtilities/TestImageExtensions.cs @@ -3,19 +3,32 @@ namespace ImageSharp.Tests { using System; using System.Collections.Generic; + using System.Linq; + using System.Reflection; using System.Text; using ImageSharp.PixelFormats; public static class TestImageExtensions { - public static void DebugSave(this Image img, TestImageProvider provider, string extension = "png") + public static void DebugSave(this Image img, ITestImageProvider provider, object settings = null, string extension = "png") where TPixel : struct, IPixel { + string tag = null; + if (settings is string) + { + tag = (string)settings; + } + else if (settings != null) + { + var properties = settings.GetType().GetRuntimeProperties(); + + tag = string.Join("_", properties.ToDictionary(x => x.Name, x => x.GetValue(settings)).Select(x => $"{x.Key}-{x.Value}")); + } if(!bool.TryParse(Environment.GetEnvironmentVariable("CI"), out bool isCI) || !isCI) { // we are running locally then we want to save it out - provider.Utility.SaveTestOutputFile(img, extension); + provider.Utility.SaveTestOutputFile(img, extension, tag: tag); } } }