Add threshold functionality for pdfrender

Author: EvgenyB1001

itext.tests/itext.io.tests/itext/io/util/ImageMagickHelperTest.cs

@@ -304,5 +304,54 @@ public virtual void CompareEqualsImagesAndCheckFuzzinessTest() {
                 StandardOutUtil.RestoreStandardOut(storedPrintStream);
             }
         }
+
+        [NUnit.Framework.Test]
+        public virtual void CompareEqualImagesAndGetResult() {
+            String image = SOURCE_FOLDER + "image.png";
+            String diff = DESTINATION_FOLDER + "diff_equalImages_result.png";
+            ImageMagickCompareResult result = new ImageMagickHelper().RunImageMagickImageCompareAndGetResult(image, image
+                , diff, "1");
+            NUnit.Framework.Assert.IsTrue(result.IsComparingResultSuccessful());
+            NUnit.Framework.Assert.AreEqual(0, result.GetDiffPixels());
+        }
+
+        [NUnit.Framework.Test]
+        public virtual void CompareDifferentImagesAndGetResult() {
+            String image = SOURCE_FOLDER + "image.png";
+            String image2 = SOURCE_FOLDER + "Im1_1.jpg";
+            String diff = DESTINATION_FOLDER + "diff_equalImages.png";
+            ImageMagickCompareResult result = new ImageMagickHelper().RunImageMagickImageCompareAndGetResult(image, image2
+                , diff, "1");
+            NUnit.Framework.Assert.IsFalse(result.IsComparingResultSuccessful());
+        }
+
+        [NUnit.Framework.Test]
+        public virtual void RunImageMagickImageCompareEqualWithThreshold() {
+            String image = SOURCE_FOLDER + "image.png";
+            String image2 = SOURCE_FOLDER + "image.png";
+            String diff = DESTINATION_FOLDER + "diff_equalImages.png";
+            bool result = new ImageMagickHelper().RunImageMagickImageCompareWithThreshold(image, image2, diff, "0", 0);
+            NUnit.Framework.Assert.IsTrue(result);
+        }
+
+        [NUnit.Framework.Test]
+        public virtual void RunImageMagickImageCompareWithEnoughThreshold() {
+            String image = SOURCE_FOLDER + "image.png";
+            String image2 = SOURCE_FOLDER + "Im1_1.jpg";
+            String diff = DESTINATION_FOLDER + "diff_equalImages.png";
+            bool result = new ImageMagickHelper().RunImageMagickImageCompareWithThreshold(image, image2, diff, "20", 2000000
+                );
+            NUnit.Framework.Assert.IsTrue(result);
+        }
+
+        [NUnit.Framework.Test]
+        public virtual void RunImageMagickImageCompareWithNotEnoughThreshold() {
+            String image = SOURCE_FOLDER + "image.png";
+            String image2 = SOURCE_FOLDER + "Im1_1.jpg";
+            String diff = DESTINATION_FOLDER + "diff_equalImages.png";
+            bool result = new ImageMagickHelper().RunImageMagickImageCompareWithThreshold(image, image2, diff, "20", 2000
+                );
+            NUnit.Framework.Assert.IsFalse(result);
+        }
     }
 }

itext.tests/itext.io.tests/itext/io/util/ProcessInfoTest.cs

@@ -0,0 +1,49 @@
+/*
+This file is part of the iText (R) project.
+Copyright (c) 1998-2021 iText Group NV
+Authors: iText Software.
+
+This program is offered under a commercial and under the AGPL license.
+For commercial licensing, contact us at https://itextpdf.com/sales.  For AGPL licensing, see below.
+
+AGPL licensing:
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+using System;
+using iText.Test;
+
+namespace iText.IO.Util {
+    public class ProcessInfoTest : ExtendedITextTest {
+        [NUnit.Framework.Test]
+        public virtual void GetExitCodeTest() {
+            int exitCode = 1;
+            ProcessInfo processInfo = new ProcessInfo(exitCode, null, null);
+            NUnit.Framework.Assert.AreEqual(exitCode, processInfo.GetExitCode());
+        }
+
+        [NUnit.Framework.Test]
+        public virtual void GetProcessStdOutput() {
+            String stdOutput = "output";
+            ProcessInfo processInfo = new ProcessInfo(0, stdOutput, null);
+            NUnit.Framework.Assert.AreEqual(stdOutput, processInfo.GetProcessStdOutput());
+        }
+
+        [NUnit.Framework.Test]
+        public virtual void GetProcessErrOutput() {
+            String stdOutput = "output";
+            ProcessInfo processInfo = new ProcessInfo(0, null, stdOutput);
+            NUnit.Framework.Assert.AreEqual(stdOutput, processInfo.GetProcessErrOutput());
+        }
+    }
+}

itext.tests/itext.io.tests/itext/io/util/SystemUtilTest.cs

@@ -155,5 +155,18 @@ public virtual void RunProcessAndWaitWithWorkingDirectoryTest() {
             NUnit.Framework.Assert.False(result);
             NUnit.Framework.Assert.True(FileUtil.FileExists(diff));
         }
+        
+        [NUnit.Framework.Test]
+        public void RunProcessAndGetProcessInfoTest() {
+            String imageMagickPath = SystemUtil.GetEnvironmentVariable(ImageMagickHelper.MAGICK_COMPARE_ENVIRONMENT_VARIABLE);
+            if (imageMagickPath == null) {
+                imageMagickPath = SystemUtil.GetEnvironmentVariable(ImageMagickHelper.MAGICK_COMPARE_ENVIRONMENT_VARIABLE_LEGACY);
+            }
+
+            ProcessInfo processInfo = SystemUtil.RunProcessAndGetProcessInfo(imageMagickPath,"--version");
+
+            NUnit.Framework.Assert.NotNull(processInfo);
+            NUnit.Framework.Assert.AreEqual(0, processInfo.GetExitCode());
+        }
     }
 }

itext/itext.io/itext/io/IoExceptionMessage.cs

@@ -59,5 +59,9 @@ public sealed class IoExceptionMessage {
         public const String GHOSTSCRIPT_FAILED = "GhostScript failed for <filename>";
 
         public const String CANNOT_OPEN_OUTPUT_DIRECTORY = "Cannot open output directory for <filename>";
+
+        public const String IMAGE_MAGICK_OUTPUT_IS_NULL = "ImageMagick process output is null.";
+
+        public const String IMAGE_MAGICK_PROCESS_EXECUTION_FAILED = "ImageMagick process execution finished with errors: ";
     }
 }

itext/itext.io/itext/io/util/ImageMagickCompareResult.cs

@@ -0,0 +1,53 @@
+/*
+This file is part of the iText (R) project.
+Copyright (c) 1998-2021 iText Group NV
+Authors: iText Software.
+
+This program is offered under a commercial and under the AGPL license.
+For commercial licensing, contact us at https://itextpdf.com/sales.  For AGPL licensing, see below.
+
+AGPL licensing:
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+namespace iText.IO.Util {
+    /// <summary>
+    /// A helper data class, which aggregates true/false result of ImageMagick comparing
+    /// as well as the number of different pixels.
+    /// </summary>
+    public sealed class ImageMagickCompareResult {
+        private readonly bool result;
+
+        private readonly long diffPixels;
+
+        /// <summary>Creates an instance that contains ImageMagick comparing result information.</summary>
+        /// <param name="result">true, if the compared images are equal.</param>
+        /// <param name="diffPixels">number of different pixels.</param>
+        public ImageMagickCompareResult(bool result, long diffPixels) {
+            this.result = result;
+            this.diffPixels = diffPixels;
+        }
+
+        /// <summary>Returns image compare boolean value.</summary>
+        /// <returns>true if the compared images are equal.</returns>
+        public bool IsComparingResultSuccessful() {
+            return result;
+        }
+
+        /// <summary>Getter for a different pixels count.</summary>
+        /// <returns>Returns a a different pixels count.</returns>
+        public long GetDiffPixels() {
+            return diffPixels;
+        }
+    }
+}

itext/itext.io/itext/io/util/ImageMagickHelper.cs

@@ -42,6 +42,7 @@ source product.
 address: [email protected]
 */
 using System;
+using System.Text.RegularExpressions;
 using iText.IO;
 
 namespace iText.IO.Util {
@@ -67,6 +68,10 @@ public class ImageMagickHelper {
 
         private const String TEMP_FILE_PREFIX = "itext_im_io_temp";
 
+        private const String DIFF_PIXELS_OUTPUT_REGEXP = "^\\d+\\.*\\d*(e\\+\\d+)?";
+
+        private static readonly Regex pattern = iText.IO.Util.StringUtil.RegexCompile(DIFF_PIXELS_OUTPUT_REGEXP);
+
         private String compareExec;
 
         /// <summary>
@@ -127,6 +132,59 @@ public virtual bool RunImageMagickImageCompare(String outImageFilePath, String c
         /// <returns>boolean result of comparing: true - images are visually equal</returns>
         public virtual bool RunImageMagickImageCompare(String outImageFilePath, String cmpImageFilePath, String diffImageName
             , String fuzzValue) {
+            ImageMagickCompareResult compareResult = RunImageMagickImageCompareAndGetResult(outImageFilePath, cmpImageFilePath
+                , diffImageName, fuzzValue);
+            return compareResult.IsComparingResultSuccessful();
+        }
+
+        /// <summary>
+        /// Runs imageMagick to visually compare images with the specified fuzziness value and given threshold
+        /// and generate difference output.
+        /// </summary>
+        /// <param name="outImageFilePath">Path to the output image file</param>
+        /// <param name="cmpImageFilePath">Path to the cmp image file</param>
+        /// <param name="diffImageName">Path to the difference output image file</param>
+        /// <param name="fuzzValue">
+        /// String fuzziness value to compare images. Should be formatted as string with integer
+        /// or decimal number. Can be null, if it is not required to use fuzziness
+        /// </param>
+        /// <param name="threshold">Long value of accepted threshold.</param>
+        /// <returns>boolean result of comparing: true - images are visually equal</returns>
+        public virtual bool RunImageMagickImageCompareWithThreshold(String outImageFilePath, String cmpImageFilePath
+            , String diffImageName, String fuzzValue, long threshold) {
+            ImageMagickCompareResult compareResult = RunImageMagickImageCompareAndGetResult(outImageFilePath, cmpImageFilePath
+                , diffImageName, fuzzValue);
+            if (compareResult.IsComparingResultSuccessful()) {
+                return true;
+            }
+            else {
+                return compareResult.GetDiffPixels() <= threshold;
+            }
+        }
+
+        /// <summary>Runs imageMagick to visually compare images with the specified fuzziness value and generate difference output.
+        ///     </summary>
+        /// <remarks>
+        /// Runs imageMagick to visually compare images with the specified fuzziness value and generate difference output.
+        /// This method returns an object of
+        /// <see cref="ImageMagickCompareResult"/>
+        /// , containing comparing result information,
+        /// such as boolean result value and the number of different pixels.
+        /// </remarks>
+        /// <param name="outImageFilePath">Path to the output image file</param>
+        /// <param name="cmpImageFilePath">Path to the cmp image file</param>
+        /// <param name="diffImageName">Path to the difference output image file</param>
+        /// <param name="fuzzValue">
+        /// String fuzziness value to compare images. Should be formatted as string with integer
+        /// or decimal number. Can be null, if it is not required to use fuzziness
+        /// </param>
+        /// <returns>
+        /// an object of
+        /// <see cref="ImageMagickCompareResult"/>
+        /// . containing comparing result information.
+        /// </returns>
+        public virtual ImageMagickCompareResult RunImageMagickImageCompareAndGetResult(String outImageFilePath, String
+             cmpImageFilePath, String diffImageName, String fuzzValue) {
             if (!ValidateFuzziness(fuzzValue)) {
                 throw new ArgumentException("Invalid fuzziness value: " + fuzzValue);
             }
@@ -137,14 +195,19 @@ public virtual bool RunImageMagickImageCompare(String outImageFilePath, String c
             try {
                 replacementOutFile = FileUtil.CreateTempCopy(outImageFilePath, TEMP_FILE_PREFIX, null);
                 replacementCmpFile = FileUtil.CreateTempCopy(cmpImageFilePath, TEMP_FILE_PREFIX, null);
-                replacementDiff = FileUtil.CreateTempFile(TEMP_FILE_PREFIX, null).ToString();
+                // ImageMagick generates difference images in .png format, therefore we can specify it.
+                // For some reason .webp comparison fails if the extension of diff image is not specified.
+                replacementDiff = FileUtil.CreateTempFile(TEMP_FILE_PREFIX, ".png").FullName;
                 String currCompareParams = fuzzValue + " '" + replacementOutFile + "' '" + replacementCmpFile + "' '" + replacementDiff
                      + "'";
-                bool result = SystemUtil.RunProcessAndWait(compareExec, currCompareParams);
+                ProcessInfo processInfo = SystemUtil.RunProcessAndGetProcessInfo(compareExec, currCompareParams);
+                bool comparingResult = processInfo.GetExitCode() == 0;
+                long diffPixels = ParseImageMagickProcessOutput(processInfo.GetProcessErrOutput());
+                ImageMagickCompareResult resultInfo = new ImageMagickCompareResult(comparingResult, diffPixels);
                 if (FileUtil.FileExists(replacementDiff)) {
                     FileUtil.Copy(replacementDiff, diffImageName);
                 }
-                return result;
+                return resultInfo;
             }
             finally {
                 FileUtil.RemoveFiles(new String[] { replacementOutFile, replacementCmpFile, replacementDiff });
@@ -166,5 +229,27 @@ internal static bool ValidateFuzziness(String fuzziness) {
                 }
             }
         }
+
+        private static long ParseImageMagickProcessOutput(String processOutput) {
+            if (null == processOutput) {
+                throw new ArgumentException(IoExceptionMessage.IMAGE_MAGICK_OUTPUT_IS_NULL);
+            }
+            if (String.IsNullOrEmpty(processOutput)) {
+                return 0L;
+            }
+            String[] processOutputLines = iText.IO.Util.StringUtil.Split(processOutput, "\n");
+            foreach (String line in processOutputLines) {
+                try {
+                    Matcher matcher = iText.IO.Util.Matcher.Match(pattern, line);
+                    if (matcher.Find()) {
+                        return (long)Double.Parse(matcher.Group(), System.Globalization.CultureInfo.InvariantCulture);
+                    }
+                }
+                catch (FormatException) {
+                }
+            }
+            // Nothing should be done here because of the exception, that will be thrown later.
+            throw new System.IO.IOException(IoExceptionMessage.IMAGE_MAGICK_PROCESS_EXECUTION_FAILED + processOutput);
+        }
     }
 }

itext/itext.io/itext/io/util/ProcessInfo.cs

@@ -0,0 +1,65 @@
+/*
+This file is part of the iText (R) project.
+Copyright (c) 1998-2021 iText Group NV
+Authors: iText Software.
+
+This program is offered under a commercial and under the AGPL license.
+For commercial licensing, contact us at https://itextpdf.com/sales.  For AGPL licensing, see below.
+
+AGPL licensing:
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+using System;
+
+namespace iText.IO.Util {
+    /// <summary>Class contains a process information, such as process exit code and process output.</summary>
+    public sealed class ProcessInfo {
+        private readonly int exitCode;
+
+        private readonly String processStdOutput;
+
+        private readonly String processErrOutput;
+
+        /// <summary>
+        /// Create a new instance, containing a process information,
+        /// such as process exit code, process standard and error outputs.
+        /// </summary>
+        /// <param name="exitCode">exit code of the process.</param>
+        /// <param name="processStdOutput">the standard output of the process.</param>
+        /// <param name="processErrOutput">the error output of the process.</param>
+        public ProcessInfo(int exitCode, String processStdOutput, String processErrOutput) {
+            this.exitCode = exitCode;
+            this.processStdOutput = processStdOutput;
+            this.processErrOutput = processErrOutput;
+        }
+
+        /// <summary>Getter for a process exit code.</summary>
+        /// <returns>Returns a process exit code.</returns>
+        public int GetExitCode() {
+            return exitCode;
+        }
+
+        /// <summary>Getter for a standard process output.</summary>
+        /// <returns>Returns a process standard output string.</returns>
+        public String GetProcessStdOutput() {
+            return processStdOutput;
+        }
+
+        /// <summary>Getter for an error process output.</summary>
+        /// <returns>Returns a process error output string.</returns>
+        public String GetProcessErrOutput() {
+            return processErrOutput;
+        }
+    }
+}