Allow mask image to be supplied when calculating diff mask of two images

Author: stesee

ImageSharpCompare/ImageSharpCompare.cs

@@ -7,7 +7,9 @@
 namespace Codeuctivity.ImageSharpCompare
 {
     /// <summary>
-    /// ImageSharpCompare, compares images. Use this class to compare images using a third image as mask of regions where your two compared images may differ. An alpha channel is ignored.
+    /// ImageSharpCompare, compares images.
+    /// Use this class to compare images using a third image as mask of regions where your two compared images may differ.
+    /// An alpha channel is ignored.
     /// </summary>
 #pragma warning disable CA1724 // Type names should not match namespaces - this is accepted for now to prevent a breaking change
 
@@ -529,6 +531,22 @@ public static Image CalcDiffMaskImage(string pathActualImage, string pathExpecte
             return CalcDiffMaskImage(actual, expected, resizeOption);
         }
 
+        /// <summary>
+        /// Creates a diff mask image of two images
+        /// </summary>
+        /// <param name="pathActualImage"></param>
+        /// <param name="pathExpectedImage"></param>
+        /// <param name="pathMaskImage"></param>
+        /// <param name="resizeOption"></param>
+        /// <returns>Image representing diff, black means no diff between actual image and expected image, white means max diff</returns>
+        public static Image CalcDiffMaskImage(string pathActualImage, string pathExpectedImage, string pathMaskImage, ResizeOption resizeOption = ResizeOption.DontResize)
+        {
+            using var actual = Image.Load(pathActualImage);
+            using var expected = Image.Load(pathExpectedImage);
+            using var mask = Image.Load(pathMaskImage);
+            return CalcDiffMaskImage(actual, expected, mask, resizeOption);
+        }
+
         /// <summary>
         /// Creates a diff mask image of two images
         /// </summary>
@@ -543,6 +561,22 @@ public static Image CalcDiffMaskImage(Stream actualImage, Stream expectedImage,
             return CalcDiffMaskImage(actual, expected, resizeOption);
         }
 
+        /// <summary>
+        /// Creates a diff mask image of two images
+        /// </summary>
+        /// <param name="actualImage"></param>
+        /// <param name="expectedImage"></param>
+        /// <param name="maskImage"></param>
+        /// <param name="resizeOption"></param>
+        /// <returns>Image representing diff, black means no diff between actual image and expected image, white means max diff</returns>
+        public static Image CalcDiffMaskImage(Stream actualImage, Stream expectedImage, Stream maskImage, ResizeOption resizeOption = ResizeOption.DontResize)
+        {
+            using var actual = Image.Load(actualImage);
+            using var expected = Image.Load(expectedImage);
+            using var mask = Image.Load(maskImage);
+            return CalcDiffMaskImage(actual, expected, mask, resizeOption);
+        }
+
         /// <summary>
         /// Creates a diff mask image of two images
         /// </summary>
@@ -587,6 +621,48 @@ public static Image CalcDiffMaskImage(Image actual, Image expected, ResizeOption
             }
         }
 
+        /// <summary>
+        /// Creates a diff mask image of two images
+        /// </summary>
+        /// <param name="actual"></param>
+        /// <param name="expected"></param>
+        /// <param name="mask"></param>
+        /// <param name="resizeOption"></param>
+        /// <returns>Image representing diff, black means no diff between actual image and expected image, white means max diff</returns>
+        public static Image CalcDiffMaskImage(Image actual, Image expected, Image mask, ResizeOption resizeOption = ResizeOption.DontResize)
+        {
+            var ownsActual = false;
+            var ownsExpected = false;
+            var ownsMask = false;
+            Image<Rgb24>? actualRgb24 = null;
+            Image<Rgb24>? expectedRgb24 = null;
+            Image<Rgb24>? maskRgb24 = null;
+
+            try
+            {
+                actualRgb24 = ToRgb24Image(actual, out ownsActual);
+                expectedRgb24 = ToRgb24Image(expected, out ownsExpected);
+                maskRgb24 = ToRgb24Image(mask, out ownsMask);
+
+                return CalcDiffMaskImage(actualRgb24, expectedRgb24, maskRgb24, resizeOption);
+            }
+            finally
+            {
+                if (ownsActual)
+                {
+                    actualRgb24?.Dispose();
+                }
+                if (ownsExpected)
+                {
+                    expectedRgb24?.Dispose();
+                }
+                if (ownsMask)
+                {
+                    maskRgb24?.Dispose();
+                }
+            }
+        }
+
         /// <summary>
         /// Creates a diff mask image of two images
         /// </summary>
@@ -639,6 +715,60 @@ public static Image CalcDiffMaskImage(Image<Rgb24> actual, Image<Rgb24> expected
             }
         }
 
+        /// <summary>
+        /// Creates a diff mask image of two images using a image mask for tolerated difference between the two images.
+        /// </summary>
+        /// <param name="actual"></param>
+        /// <param name="expected"></param>
+        /// <param name="mask"></param>
+        /// <param name="resizeOption"></param>
+        /// <returns>Image representing diff, black means no diff between actual image and expected image, white means max diff</returns>
+        public static Image CalcDiffMaskImage(Image<Rgb24> actual, Image<Rgb24> expected, Image<Rgb24> mask, ResizeOption resizeOption = ResizeOption.DontResize)
+        {
+            var imagesHaveSameDimensions = ImagesHaveSameDimension(actual, expected) && ImagesHaveSameDimension(actual, mask);
+
+            if (!imagesHaveSameDimensions && resizeOption == ResizeOption.DontResize)
+            {
+                throw new ImageSharpCompareException(sizeDiffersExceptionMessage);
+            }
+
+            if (imagesHaveSameDimensions)
+            {
+                var maskImageResult = new Image<Rgb24>(actual.Width, actual.Height);
+
+                for (var x = 0; x < actual.Width; x++)
+                {
+                    for (var y = 0; y < actual.Height; y++)
+                    {
+                        var maskPixel = mask[x, y];
+                        var actualPixel = actual[x, y];
+                        var expectedPixel = expected[x, y];
+
+                        maskImageResult[x, y] = new Rgb24
+                        {
+                            R = (byte)Math.Max(byte.MinValue, Math.Abs(expectedPixel.R - actualPixel.R) - maskPixel.R),
+                            G = (byte)Math.Max(byte.MinValue, Math.Abs(expectedPixel.G - actualPixel.G) - maskPixel.G),
+                            B = (byte)Math.Max(byte.MinValue, Math.Abs(expectedPixel.B - actualPixel.B) - maskPixel.B)
+                        };
+                    }
+                }
+
+                return maskImageResult;
+            }
+
+            var grown = GrowToSameDimension(actual, expected, mask);
+            try
+            {
+                return CalcDiffMaskImage(grown.Item1, grown.Item2, grown.Item3, ResizeOption.DontResize);
+            }
+            finally
+            {
+                grown.Item1?.Dispose();
+                grown.Item2?.Dispose();
+                grown.Item3?.Dispose();
+            }
+        }
+
         private static Image<Rgb24> ToRgb24Image(Image actual, out bool ownsImage)
         {
             if (actual is Image<Rgb24> actualPixelAccessibleImage)

ImageSharpCompareTestNunit/ImageSharpCompareTest.cs

@@ -1,6 +1,7 @@
 using Codeuctivity.ImageSharpCompare;
 using NUnit.Framework;
 using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.PixelFormats;
 using System;
 using System.IO;
 using System.Reflection;
@@ -339,6 +340,70 @@ public void DiffMaskSteams(string pathPic1, string pathPic2, int expectedMeanErr
             Assert.That(maskedDiff.PixelErrorPercentage, Is.EqualTo(expectedPixelErrorPercentage), "PixelErrorPercentage");
         }
 
+        [TestCase(png0Rgba32, png1Rgba32)]
+        public void CalcDiffMaskImage_WhenSupplyingDiffMaskOfTwoImagesByFilePath_NoDifferences(string image1RelativePath, string image2RelativePath)
+        {
+            var image1Path = Path.Combine(AppContext.BaseDirectory, image1RelativePath);
+            var image2Path = Path.Combine(AppContext.BaseDirectory, image2RelativePath);
+            var diffMask1Path = Path.GetTempFileName() + "differenceMask.png";
+
+            using (var diffMask1Stream = File.Create(diffMask1Path))
+            {
+                using var diffMask1Image = ImageSharpCompare.CalcDiffMaskImage(image1Path, image2Path);
+                ImageExtensions.SaveAsPng(diffMask1Image, diffMask1Stream);
+            }
+
+            using var diffMask2Image = ImageSharpCompare.CalcDiffMaskImage(image1Path, image2Path, diffMask1Path);
+            Assert.That(IsImageEntirelyBlack(diffMask2Image), Is.True);
+
+            File.Delete(diffMask1Path);
+        }
+
+        [TestCase(png0Rgba32, png1Rgba32)]
+        public void CalcDiffMaskImage_WhenSupplyingDiffMaskOfTwoImagesByStream_NoDifferences(string image1RelativePath, string image2RelativePath)
+        {
+            var image1Path = Path.Combine(AppContext.BaseDirectory, image1RelativePath);
+            var image2Path = Path.Combine(AppContext.BaseDirectory, image2RelativePath);
+            var diffMask1Path = Path.GetTempFileName() + "differenceMask.png";
+
+            using var image1Stream = new FileStream(image1Path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            using var image2Stream = new FileStream(image2Path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+
+            using (var diffMask1Stream = File.Create(diffMask1Path))
+            {
+                using var diffMask1Image = ImageSharpCompare.CalcDiffMaskImage(image1Stream, image2Stream);
+                ImageExtensions.SaveAsPng(diffMask1Image, diffMask1Stream);
+            }
+
+            image1Stream.Position = 0;
+            image2Stream.Position = 0;
+
+            using (var diffMask1Stream = new FileStream(diffMask1Path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
+            {
+                diffMask1Stream.Position = 0;
+                using var diffMask2Image = ImageSharpCompare.CalcDiffMaskImage(image1Stream, image2Stream, diffMask1Stream);
+                Assert.That(IsImageEntirelyBlack(diffMask2Image), Is.True);
+            }
+
+            File.Delete(diffMask1Path);
+        }
+
+        [TestCase(png0Rgba32, png1Rgba32)]
+        public void CalcDiffMaskImage_WhenSupplyingDiffMaskOfTwoImagesByImage_NoDifferences(string image1RelativePath, string image2RelativePath)
+        {
+            var image1Path = Path.Combine(AppContext.BaseDirectory, image1RelativePath);
+            var image2Path = Path.Combine(AppContext.BaseDirectory, image2RelativePath);
+
+            using var image1 = Image.Load(image1Path);
+            using var image2 = Image.Load(image2Path);
+
+            using var diffMask1Image = ImageSharpCompare.CalcDiffMaskImage(image1, image2);
+
+            using var diffMask2Image = ImageSharpCompare.CalcDiffMaskImage(image1, image2, diffMask1Image);
+
+            Assert.That(IsImageEntirelyBlack(diffMask2Image), Is.True);
+        }
+
         [Test]
         [TestCase(jpg0Rgb24, jpg1Rgb24)]
         [TestCase(png0Rgba32, png1Rgba32)]
@@ -394,5 +459,26 @@ public void ShouldVerifyThatImageWithDifferentSizeThrows(string pathPic1, string
 
             Assert.That(exception?.Message, Is.EqualTo("Size of images differ."));
         }
+
+        private static bool IsImageEntirelyBlack(Image image)
+        {
+            if (!(image is Image<Rgb24> imageRgb24))
+            {
+                throw new ArgumentException("Image must be an RGB 24 one", nameof(image));
+            }
+
+            for (var x = 0; x < imageRgb24.Width; x++)
+            {
+                for (var y = 0; y < imageRgb24.Height; y++)
+                {
+                    if (imageRgb24[x, y] != new Rgb24(byte.MinValue, byte.MinValue, byte.MinValue))
+                    {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        }
     }
 }