SVG: Support floating numbers with exponent notation in path painting instructions

DEVSIX-2343

Autoported commit.
Original commit hash: [3adb38da4]

Author: Snipx

itext.tests/itext.styledxmlparser.tests/itext/styledxmlparser/css/util/CssUtilTest.cs

@@ -103,6 +103,22 @@ public virtual void ParseAbsoluteLengthFrom10pt() {
             NUnit.Framework.Assert.AreEqual(expected, actual, 0);
         }
 
+        [NUnit.Framework.Test]
+        public virtual void ParseAboluteLengthExponential01() {
+            String value = "1e2pt";
+            float actual = CssUtils.ParseAbsoluteLength(value);
+            float expected = 1e2f;
+            NUnit.Framework.Assert.AreEqual(expected, actual, 0);
+        }
+
+        [NUnit.Framework.Test]
+        public virtual void ParseAboluteLengthExponential02() {
+            String value = "1e2px";
+            float actual = CssUtils.ParseAbsoluteLength(value);
+            float expected = 1e2f * 0.75f;
+            NUnit.Framework.Assert.AreEqual(expected, actual, 0);
+        }
+
         [NUnit.Framework.Test]
         [LogMessage(iText.StyledXmlParser.LogMessageConstant.UNKNOWN_ABSOLUTE_METRIC_LENGTH_PARSED, Count = 1)]
         public virtual void ParseAbsoluteLengthFromUnknownType() {

itext.tests/itext.svg.tests/itext/svg/renderers/impl/PathOperatorSplitTest.cs

@@ -0,0 +1,19 @@
+using System;
+
+namespace iText.Svg.Renderers.Impl {
+    public class PathOperatorSplitTest {
+        [NUnit.Framework.Test]
+        public virtual void TestNumbersContainingExponent01() {
+            String path = "M10,9.999999999999972C203.33333333333334,9.999999999999972,396.6666666666667,1.4210854715202004e-14,590,1.4210854715202004e-14L590,41.666666666666686C396.6666666666667,41.666666666666686,203.33333333333334,51.66666666666664,10,51.66666666666664Z";
+            String[] operators = new String[] { "M10,9.999999999999972", "C203.33333333333334,9.999999999999972,396.6666666666667,1.4210854715202004e-14,590,1.4210854715202004e-14"
+                , "L590,41.666666666666686", "C396.6666666666667,41.666666666666686,203.33333333333334,51.66666666666664,10,51.66666666666664"
+                , "Z" };
+            TestSplitting(path, operators);
+        }
+
+        private void TestSplitting(String originalStr, String[] expectedSplitting) {
+            String[] result = PathSvgNodeRenderer.SplitPathStringIntoOperators(originalStr);
+            NUnit.Framework.Assert.AreEqual(expectedSplitting, result);
+        }
+    }
+}

itext.tests/itext.svg.tests/itext/svg/renderers/impl/PathParsingTest.cs

@@ -201,5 +201,14 @@ public virtual void NegativeAfterPositiveTest() {
             String actual = path.SeparateDecimalPoints(input);
             NUnit.Framework.Assert.AreEqual(expected, actual);
         }
+
+        [NUnit.Framework.Test]
+        public virtual void ExponentInNumberTest01() {
+            PathSvgNodeRenderer path = new PathSvgNodeRenderer();
+            String input = "C 268.88888888888886 67.97916666666663e+10 331.1111111111111 -2.842170943040401e-14 393.3333333333333 -2.842170943040401e-14";
+            String expected = "C 268.88888888888886 67.97916666666663e+10 331.1111111111111 -2.842170943040401e-14 393.3333333333333 -2.842170943040401e-14";
+            String actual = path.SeparateDecimalPoints(input);
+            NUnit.Framework.Assert.AreEqual(expected, actual);
+        }
     }
 }

itext/itext.styledxmlparser/itext/styledxmlparser/css/util/CssUtils.cs

@@ -424,8 +424,8 @@ private static int DeterminePositionBetweenValueAndUnit(String @string) {
             }
             int pos = 0;
             while (pos < @string.Length) {
-                if (@string[pos] == '+' || @string[pos] == '-' || @string[pos] == '.' || @string[pos] >= '0' && @string[pos
-                    ] <= '9') {
+                if (@string[pos] == '+' || @string[pos] == '-' || @string[pos] == '.' || IsDigit(@string[pos]) || IsExponentNotation
+                    (@string, pos)) {
                     pos++;
                 }
                 else {
@@ -630,5 +630,16 @@ private static bool AddRange(RangeBuilder builder, String left, String right) {
             builder.AddRange(l, r);
             return true;
         }
+
+        private static bool IsDigit(char ch) {
+            return ch >= '0' && ch <= '9';
+        }
+
+        private static bool IsExponentNotation(String s, int index) {
+            return index < s.Length && s[index] == 'e' && (index + 1 < s.Length && IsDigit(s[index + 1]) || index + 2 
+                < s.Length && (s[index + 1] == '-' || s[index + 1] == '+') && IsDigit(s[index + 2]));
+        }
+        // e.g. 12e5
+        // e.g. 12e-5, 12e+5
     }
 }

itext/itext.svg/itext/svg/renderers/impl/PathSvgNodeRenderer.cs

@@ -65,7 +65,7 @@ public class PathSvgNodeRenderer : AbstractSvgNodeRenderer {
         /// <summary>
         /// The regular expression to find invalid operators in the <a href="https://www.w3.org/TR/SVG/paths.html#PathData">PathData attribute of the &ltpath&gt element</a>
         /// <p>
-        /// Find any occurence of a letter that is not an operator
+        /// Find any occurrence of a letter that is not an operator
         /// </summary>
         private const String INVALID_OPERATOR_REGEX = "(?:(?![mzlhvcsqtae])\\p{L})";
 
@@ -80,9 +80,16 @@ public class PathSvgNodeRenderer : AbstractSvgNodeRenderer {
         /// is called before the use of this expression in
         /// <see cref="ParsePathOperations()"/>
         /// the attribute to be split is valid.
-        /// The regex splits at each letter.
+        /// SVG defines 6 types of path commands, for a total of 20 commands:
+        /// MoveTo: M, m
+        /// LineTo: L, l, H, h, V, v
+        /// Cubic Bezier Curve: C, c, S, s
+        /// Quadratic Bezier Curve: Q, q, T, t
+        /// Elliptical Arc Curve: A, a
+        /// ClosePath: Z, z
         /// </summary>
-        private const String SPLIT_REGEX = "(?=[\\p{L}])";
+        private static readonly Regex SPLIT_PATTERN = iText.IO.Util.StringUtil.RegexCompile("(?=[mlhvcsqtaz])", System.Text.RegularExpressions.RegexOptions.IgnoreCase
+            );
 
         /// <summary>
         /// The
@@ -149,7 +156,7 @@ private String[] GetShapeCoordinates(IPathShape shape, IPathShape previousShape,
                 String[] startingControlPoint = new String[2];
                 if (previousShape != null) {
                     Point previousEndPoint = previousShape.GetEndingPoint();
-                    //if the previous command was a Bézier curve, use its last control point
+                    //if the previous command was a Bezier curve, use its last control point
                     if (previousShape is IControlPointCurve) {
                         Point lastControlPoint = ((IControlPointCurve)previousShape).GetLastControlPoint();
                         float reflectedX = (float)(2 * previousEndPoint.GetX() - lastControlPoint.GetX());
@@ -319,9 +326,8 @@ internal virtual ICollection<String> ParsePathOperations() {
                 throw new SvgProcessingException(SvgLogMessageConstant.INVALID_PATH_D_ATTRIBUTE_OPERATORS).SetMessageParams
                     (attributes);
             }
-            String[] coordinates = iText.IO.Util.StringUtil.Split(attributes, SPLIT_REGEX);
-            //gets an array attributesAr of {M 100 100, L 300 100, L200, 300, z}
-            foreach (String inst in coordinates) {
+            String[] operators = SplitPathStringIntoOperators(attributes);
+            foreach (String inst in operators) {
                 String instTrim = inst.Trim();
                 if (!String.IsNullOrEmpty(instTrim)) {
                     char instruction = instTrim[0];
@@ -334,38 +340,51 @@ internal virtual ICollection<String> ParsePathOperations() {
             return result;
         }
 
-        /// <summary>Iterate over the input string and to seperate</summary>
+        /// <summary>Iterate over the input string and separate numbers from each other with space chars</summary>
         internal virtual String SeparateDecimalPoints(String input) {
             //If a space or minus sign is found reset
             //If a another point is found, add an extra space on before the point
             StringBuilder res = new StringBuilder();
-            //Iterate over string
-            bool decimalPointEncountered = false;
+            // We are now among the digits to the right of the decimal point
+            bool fractionalPartAfterDecimalPoint = false;
+            // We are now among the exponent magnitude part
+            bool exponentSignMagnitude = false;
             for (int i = 0; i < input.Length; i++) {
                 char c = input[i];
-                //If it's a whitespace or a minus sign and a point was previously found, reset the decimal point flag
-                if (decimalPointEncountered && (c == '-' || iText.IO.Util.TextUtil.IsWhiteSpace(c))) {
-                    decimalPointEncountered = false;
+                // Resetting flags
+                if (c == '-' || iText.IO.Util.TextUtil.IsWhiteSpace(c)) {
+                    fractionalPartAfterDecimalPoint = false;
+                }
+                if (iText.IO.Util.TextUtil.IsWhiteSpace(c)) {
+                    exponentSignMagnitude = false;
+                }
+                // Add extra space before the next number starting from '.', or before the next number starting with '-'
+                if (EndsWithNonWhitespace(res) && (c == '.' && fractionalPartAfterDecimalPoint || c == '-' && !exponentSignMagnitude
+                    )) {
+                    res.Append(" ");
                 }
-                //If a point is found, mark and continue
                 if (c == '.') {
-                    //If it's the second point, add an extra space
-                    if (decimalPointEncountered) {
-                        res.Append(" ");
-                    }
-                    else {
-                        decimalPointEncountered = true;
-                    }
+                    fractionalPartAfterDecimalPoint = true;
                 }
                 else {
-                    if (c == '-') {
-                        // If a minus is found, add an extra space
-                        res.Append(" ");
+                    if (c == 'e') {
+                        exponentSignMagnitude = true;
                     }
                 }
                 res.Append(c);
             }
             return res.ToString();
         }
+
+        /// <summary>Gets an array of strings representing operators with their arguments, e.g.</summary>
+        /// <remarks>Gets an array of strings representing operators with their arguments, e.g. {"M 100 100", "L 300 100", "L200, 300", "z"}
+        ///     </remarks>
+        internal static String[] SplitPathStringIntoOperators(String path) {
+            return iText.IO.Util.StringUtil.Split(SPLIT_PATTERN, path);
+        }
+
+        private static bool EndsWithNonWhitespace(StringBuilder sb) {
+            return sb.Length > 0 && !iText.IO.Util.TextUtil.IsWhiteSpace(sb[sb.Length - 1]);
+        }
     }
 }

port-hash

@@ -1 +1 @@
-6bf0c6b50cd94df0cdeb2b1a9c4af9fca67007d9
+3adb38da4488df5dad06a8f2d0cc91fe569c0e29