Cueing up optimization work

Author: jessetrana

src/ImageHash/HashAlgorithms/PerceptualHashOptimized.cs

@@ -0,0 +1,114 @@
+namespace CoenM.ImageHash.HashAlgorithms
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Linq;
+    using System.Runtime.CompilerServices;
+
+    using SixLabors.ImageSharp;
+    using SixLabors.ImageSharp.PixelFormats;
+    using SixLabors.ImageSharp.Processing;
+
+    /// <summary>
+    /// Perceptual hash; Calculate a hash of an image by first transforming the image to an 64x64 grayscale bitmap and then using the Discrete cosine transform to remove the high frequencies.
+    /// </summary>
+    public class PerceptualHashOptimized : IImageHash
+    {
+        private const int Size = 64;
+        private static readonly double Sqrt2DivSize = Math.Sqrt(2D / Size);
+        private static readonly double Sqrt2 = 1 / Math.Sqrt(2);
+
+        /// <inheritdoc />
+        public ulong Hash(Image<Rgba32> image)
+        {
+            if (image == null)
+                throw new ArgumentNullException(nameof(image));
+
+            var rows = new double[Size][];
+            var sequence = new double[Size];
+            var matrix = new double[Size][];
+
+            image.Mutate(ctx => ctx
+                                .Resize(Size, Size)
+                                .Grayscale(GrayscaleMode.Bt601)
+                                .AutoOrient());
+
+            // Calculate the DCT for each row.
+            for (var y = 0; y < Size; y++)
+            {
+                for (var x = 0; x < Size; x++)
+                    sequence[x] = image[x, y].R;
+
+                rows[y] = Dct1D(sequence);
+            }
+
+            // Calculate the DCT for each column.
+            for (var x = 0; x < Size; x++)
+            {
+                for (var y = 0; y < Size; y++)
+                    sequence[y] = rows[y][x];
+
+                matrix[x] = Dct1D(sequence);
+            }
+
+            // Only use the top 8x8 values.
+            var top8X8 = new List<double>(Size);
+            for (var y = 0; y < 8; y++)
+            {
+                for (var x = 0; x < 8; x++)
+                    top8X8.Add(matrix[y][x]);
+            }
+
+            var topRight = top8X8.ToArray();
+
+            // Get Median.
+            var median = CalculateMedian64Values(topRight);
+
+            // Calculate hash.
+            var mask = 1UL << (Size - 1);
+            var hash = 0UL;
+
+            for (var i = 0; i < Size; i++)
+            {
+                if (topRight[i] > median)
+                    hash |= mask;
+
+                mask = mask >> 1;
+            }
+
+            return hash;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static double CalculateMedian64Values(IReadOnlyCollection<double> values)
+        {
+            Debug.Assert(values.Count == 64, "This DCT method works with 64 doubles.");
+            return values.OrderBy(value => value).Skip(31).Take(2).Average();
+        }
+
+        /// <summary>
+        /// One dimensional Discrete Cosine Transformation.
+        /// </summary>
+        /// <param name="values">Should be an array of doubles of length 64.</param>
+        /// <returns>array of doubles of length 64.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static double[] Dct1D(IReadOnlyList<double> values)
+        {
+            Debug.Assert(values.Count == 64, "This DCT method works with 64 doubles.");
+            var coefficients = new double[Size];
+
+            for (var coef = 0; coef < Size; coef++)
+            {
+                for (var i = 0; i < Size; i++)
+                    coefficients[coef] += values[i] * Math.Cos(((2.0 * i) + 1.0) * coef * Math.PI / (2.0 * Size));
+
+                coefficients[coef] *= Sqrt2DivSize;
+                if (coef == 0)
+                    coefficients[coef] *= Sqrt2;
+            }
+
+            return coefficients;
+        }
+    }
+}

tests/ImageHash.Test/Algorithms/PerceptualHashOptimizedTest.cs

@@ -0,0 +1,136 @@
+namespace CoenM.ImageHash.Test.Algorithms
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+
+    using CoenM.ImageHash.HashAlgorithms;
+    using CoenM.ImageHash.Test.Internal;
+    using FluentAssertions;
+    using Xunit;
+
+    public class PerceptualHashOptimizedTest
+    {
+        private readonly PerceptualHashOptimized sut;
+
+        private readonly Dictionary<string, ulong> expectedHashes = new Dictionary<string, ulong>
+        {
+            { "Alyson_Hannigan_500x500_0.jpg", 17839858461443178030 },
+            { "Alyson_Hannigan_500x500_1.jpg", 17839823311430827566 },
+            { "Alyson_Hannigan_200x200_0.jpg", 17839858461443178030 },
+            { "Alyson_Hannigan_4x4_0.jpg", 17409736169497899465 },
+            { "github_1.jpg", 13719320793338945348 },
+            { "github_2.jpg", 13783795072850083657 },
+        };
+
+        public PerceptualHashOptimizedTest()
+        {
+            sut = new PerceptualHashOptimized();
+        }
+
+        [Theory]
+        [InlineData("Alyson_Hannigan_500x500_0.jpg", 17839823311430827566)]
+        [InlineData("Alyson_Hannigan_500x500_1.jpg", 17839823311430827566)]
+        [InlineData("Alyson_Hannigan_200x200_0.jpg", 17839823311430827566)]
+        [InlineData("Alyson_Hannigan_4x4_0.jpg", 17409736169531453642)]
+        [InlineData("github_1.jpg", 13719320793338945348)]
+        [InlineData("github_2.jpg", 13783795072850083657)]
+        public void HashImagesTest(string filename, ulong expectedHash)
+        {
+            // arrange
+            ulong result;
+
+            // act
+            using (var stream = TestHelper.OpenStream(filename))
+                result = sut.Hash(stream);
+
+            // assert
+            result.Should().Be(expectedHash);
+        }
+
+        [Fact]
+        [SuppressMessage("ReSharper", "AccessToDisposedClosure", Justification = "Manually reviewed")]
+        public void NotAnImageShouldThrowExceptionTest()
+        {
+            // arrange
+            const string filename = "Not_an_image.txt";
+
+            // act
+            using (var stream = TestHelper.OpenStream(filename))
+            {
+                Action act = () => sut.Hash(stream);
+
+                // assert
+                act.Should().Throw<SixLabors.ImageSharp.UnknownImageFormatException>();
+            }
+        }
+
+        [Fact]
+        public void NullArgumentShouldThrowArgumentNullExceptionTest()
+        {
+            // arrange
+
+            // act
+            Action act = () => sut.Hash(null);
+
+            // assert
+            act.Should().Throw<ArgumentNullException>();
+        }
+
+        [Fact]
+        public void ImageWithFilterShouldHaveAlmostOrExactly100Similarity1Test()
+        {
+            // arrange
+            var hash1 = expectedHashes["Alyson_Hannigan_500x500_0.jpg"];
+            var hash2 = expectedHashes["Alyson_Hannigan_500x500_1.jpg"];
+
+            // act
+            var result = CompareHash.Similarity(hash1, hash2);
+
+            // assert
+            result.Should().Be(96.875);
+        }
+
+        [Fact]
+        public void ResizedImageShouldHaveAlmostOrExactly100Similarity2Test()
+        {
+            // arrange
+            var hash1 = expectedHashes["Alyson_Hannigan_500x500_0.jpg"];
+            var hash2 = expectedHashes["Alyson_Hannigan_200x200_0.jpg"];
+
+            // act
+            var result = CompareHash.Similarity(hash1, hash2);
+
+            // assert
+            result.Should().Be(100);
+        }
+
+        [Fact]
+        public void ComparingExtreamlySmallImageShouldDecreaseSimilarityTest()
+        {
+            // arrange
+            var hash1 = expectedHashes["Alyson_Hannigan_4x4_0.jpg"];
+            var hash2 = expectedHashes["Alyson_Hannigan_500x500_0.jpg"];
+
+            // act
+            var result = CompareHash.Similarity(hash1, hash2);
+
+            // assert
+            result.Should().Be(59.375);
+        }
+
+        [Fact]
+        public void TwoDifferentImagesOfGithubArePrettySimilarTests()
+        {
+            // arrange
+            var hash1 = expectedHashes["github_1.jpg"];
+            var hash2 = expectedHashes["github_2.jpg"];
+
+            // act
+            var result = CompareHash.Similarity(hash1, hash2);
+
+            // assert
+            result.Should().Be(71.875);
+        }
+    }
+}