Add possibility to return the number of different pixels in ImageMagickHelper class

EvgenyB1001 · EvgenyB1001 · commit f3ad7a2a6ba7 · 2021-12-14T23:11:40.000+03:00
DEVSIX-5870

Autoported commit.
Original commit hash: [9be9e3d23]
diff --git a/itext.tests/itext.commons.tests/itext/commons/utils/ProcessInfoTest.cs b/itext.tests/itext.commons.tests/itext/commons/utils/ProcessInfoTest.cs
@@ -0,0 +1,27 @@
+using System;
+using iText.Test;
+
+namespace iText.Commons.Utils {
+    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());
+        }
+    }
+}
diff --git a/itext.tests/itext.commons.tests/itext/commons/utils/SystemUtilTest.cs b/itext.tests/itext.commons.tests/itext/commons/utils/SystemUtilTest.cs
@@ -158,5 +158,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(MAGICK_COMPARE_ENVIRONMENT_VARIABLE);
+            if (imageMagickPath == null) {
+                imageMagickPath = SystemUtil.GetEnvironmentVariable(MAGICK_COMPARE_ENVIRONMENT_VARIABLE_LEGACY);
+            }
+
+            ProcessInfo processInfo = SystemUtil.RunProcessAndGetProcessInfo(imageMagickPath,"--version");
+
+            NUnit.Framework.Assert.NotNull(processInfo);
+            NUnit.Framework.Assert.AreEqual(0, processInfo.GetExitCode());
+        }
     }
 }
diff --git a/itext.tests/itext.io.tests/itext/io/util/ImageMagickHelperTest.cs b/itext.tests/itext.io.tests/itext/io/util/ImageMagickHelperTest.cs
@@ -305,5 +305,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);
+        }
     }
 }
diff --git a/itext/itext.commons/itext/commons/utils/ProcessInfo.cs b/itext/itext.commons/itext/commons/utils/ProcessInfo.cs
@@ -0,0 +1,43 @@
+using System;
+
+namespace iText.Commons.Utils {
+    /// <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;
+        }
+    }
+}
diff --git a/itext/itext.commons/itext/commons/utils/SystemUtil.cs b/itext/itext.commons/itext/commons/utils/SystemUtil.cs
@@ -56,6 +56,9 @@ namespace iText.Commons.Utils {
     public class SystemUtil {
         private const String SPLIT_REGEX = "((\".+?\"|[^'\\s]|'.+?')+)\\s*";
 
+        private const int STD_OUTPUT_INDEX = 0;
+        private const int ERR_OUTPUT_INDEX = 1;
+
         public static long GetTimeBasedSeed() {
             return DateTime.Now.Ticks + Environment.TickCount;
         }
@@ -120,6 +123,18 @@ public static String RunProcessAndGetOutput(String exec, String @params) {
 
             return processOutput;
         }
+        
+        public static ProcessInfo RunProcessAndGetProcessInfo(String exec, String @params) {
+            using (Process proc = new Process()) {
+                SetProcessStartInfo(proc, exec, @params, null);
+                proc.Start();
+                StringBuilder[] outputStreamStrings = GetProcessOutputBuilders(proc);
+                String processStdOutput = outputStreamStrings[STD_OUTPUT_INDEX].ToString();
+                String processErrOutput = outputStreamStrings[ERR_OUTPUT_INDEX].ToString();
+                proc.WaitForExit();
+                return new ProcessInfo(proc.ExitCode, processStdOutput, processErrOutput);
+            }
+        }
 
         public static StringBuilder RunProcessAndCollectErrors(String exec, String @params) {
             StringBuilder errorsBuilder;
@@ -186,15 +201,25 @@ internal static String[] SplitIntoProcessArguments(String command, String @param
         }
 
         internal static String GetProcessOutput(Process p) {
+            StringBuilder[] builders = GetProcessOutputBuilders(p);
+
+            return builders[STD_OUTPUT_INDEX].ToString() 
+                   + '\n' 
+                   + builders[ERR_OUTPUT_INDEX].ToString();
+        }
+        
+        internal static StringBuilder[] GetProcessOutputBuilders(Process p) {
             StringBuilder bri = new StringBuilder();
             StringBuilder bre = new StringBuilder();
-            do
-            {
+            do {
                 bri.Append(p.StandardOutput.ReadToEnd());
                 bre.Append(p.StandardError.ReadToEnd());
             } while (!p.HasExited);
+            
+            Console.Out.WriteLine(bre.ToString());
 
-            return bri.ToString() + '\n' + bre.ToString();
+            StringBuilder[] resultOutputArray = new[] { bri, bre };
+            return resultOutputArray;
         }
 
         internal static StringBuilder GetProcessErrorsOutput(Process p) {
diff --git a/itext/itext.io/itext/io/exceptions/IoExceptionMessage.cs b/itext/itext.io/itext/io/exceptions/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: ";
     }
 }
diff --git a/itext/itext.io/itext/io/util/ImageMagickCompareResult.cs b/itext/itext.io/itext/io/util/ImageMagickCompareResult.cs
@@ -0,0 +1,31 @@
+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;
+        }
+    }
+}
diff --git a/itext/itext.io/itext/io/util/ImageMagickHelper.cs b/itext/itext.io/itext/io/util/ImageMagickHelper.cs
@@ -42,6 +42,7 @@ source product.
 address: sales@itextpdf.com
 */
 using System;
+using System.Text.RegularExpressions;
 using iText.Commons.Utils;
 using iText.IO.Exceptions;
 
@@ -68,6 +69,11 @@ 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.Commons.Utils.StringUtil.RegexCompile(DIFF_PIXELS_OUTPUT_REGEXP
+            );
+
         private String compareExec;
 
         /// <summary>
@@ -128,6 +134,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);
             }
@@ -143,11 +202,14 @@ public virtual bool RunImageMagickImageCompare(String outImageFilePath, String c
                 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 });
@@ -169,5 +231,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.Commons.Utils.StringUtil.Split(processOutput, "\n");
+            foreach (String line in processOutputLines) {
+                try {
+                    Matcher matcher = iText.Commons.Utils.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);
+        }
     }
 }
diff --git a/port-hash b/port-hash
@@ -1 +1 @@
-0c457d47891c1d9215a7cbc24200e7dd6638594f 
+9be9e3d23515ea9b1cb417b29b520371f691e1b8

Original file line number	Diff line number	Diff line change
`@@ -158,5 +158,18 @@ public virtual void RunProcessAndWaitWithWorkingDirectoryTest() {`
`158`	`158`	`NUnit.Framework.Assert.False(result);`
`159`	`159`	`NUnit.Framework.Assert.True(FileUtil.FileExists(diff));`
`160`	`160`	`}`
	`161`	`+`
	`162`	`+ [NUnit.Framework.Test]`
	`163`	`+ public void RunProcessAndGetProcessInfoTest() {`
	`164`	`+ String imageMagickPath = SystemUtil.GetEnvironmentVariable(MAGICK_COMPARE_ENVIRONMENT_VARIABLE);`
	`165`	`+ if (imageMagickPath == null) {`
	`166`	`+ imageMagickPath = SystemUtil.GetEnvironmentVariable(MAGICK_COMPARE_ENVIRONMENT_VARIABLE_LEGACY);`
	`167`	`+ }`
	`168`	`+`
	`169`	`+ ProcessInfo processInfo = SystemUtil.RunProcessAndGetProcessInfo(imageMagickPath,"--version");`
	`170`	`+`
	`171`	`+ NUnit.Framework.Assert.NotNull(processInfo);`
	`172`	`+ NUnit.Framework.Assert.AreEqual(0, processInfo.GetExitCode());`
	`173`	`+ }`
`161`	`174`	`}`
`162`	`175`	`}`
Original file line number	Diff line number	Diff line change
`@@ -59,5 +59,9 @@ public sealed class IoExceptionMessage {`
`59`	`59`	`public const String GHOSTSCRIPT_FAILED = "GhostScript failed for <filename>";`
`60`	`60`
`61`	`61`	`public const String CANNOT_OPEN_OUTPUT_DIRECTORY = "Cannot open output directory for <filename>";`
	`62`	`+`
	`63`	`+ public const String IMAGE_MAGICK_OUTPUT_IS_NULL = "ImageMagick process output is null.";`
	`64`	`+`
	`65`	`+ public const String IMAGE_MAGICK_PROCESS_EXECUTION_FAILED = "ImageMagick process execution finished with errors: ";`
`62`	`66`	`}`
`63`	`67`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-0c457d47891c1d9215a7cbc24200e7dd6638594f`
	`1`	`+9be9e3d23515ea9b1cb417b29b520371f691e1b8`