SVG paths: Support smooth curves

Refactor multiple sets of parameters

DEVSIX-2611

Author: Benoit Lagae

svg/src/main/java/com/itextpdf/svg/renderers/impl/PathSvgNodeRenderer.java

@@ -42,7 +42,6 @@ This file is part of the iText (R) project.
  */
 package com.itextpdf.svg.renderers.impl;
 
-import com.itextpdf.io.util.MessageFormatUtil;
 import com.itextpdf.kernel.geom.Point;
 import com.itextpdf.kernel.pdf.canvas.PdfCanvas;
 import com.itextpdf.svg.SvgConstants;
@@ -54,13 +53,12 @@ This file is part of the iText (R) project.
 import com.itextpdf.svg.renderers.path.IPathShape;
 import com.itextpdf.svg.renderers.path.SvgPathShapeFactory;
 import com.itextpdf.svg.renderers.path.impl.ClosePath;
-import com.itextpdf.svg.renderers.path.impl.CurveTo;
+import com.itextpdf.svg.renderers.path.impl.IControlPointCurve;
 import com.itextpdf.svg.renderers.path.impl.MoveTo;
+import com.itextpdf.svg.renderers.path.impl.QuadraticSmoothCurveTo;
 import com.itextpdf.svg.renderers.path.impl.SmoothSCurveTo;
 import com.itextpdf.svg.utils.SvgCssUtils;
 import com.itextpdf.svg.utils.SvgRegexUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -75,9 +73,6 @@ public class PathSvgNodeRenderer extends AbstractSvgNodeRenderer {
 
     private static final String SPACE_CHAR = " ";
 
-    private static final Logger LOGGER = LoggerFactory.getLogger(PathSvgNodeRenderer.class);
-    private static final int MOVETOARGUMENTNR = 2;
-
     /**
      * 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>
@@ -103,7 +98,7 @@ public class PathSvgNodeRenderer extends AbstractSvgNodeRenderer {
 
     /**
      * The {@link ClosePath} shape keeping track of the initial point set by a {@link MoveTo} operation.
-     * The original value is {@code null}, and must be set via a {@link MoveTo} operation before it may drawn.
+     * The original value is {@code null}, and must be set via a {@link MoveTo} operation before it may be drawn.
      */
     private ClosePath zOperator = null;
 
@@ -137,14 +132,13 @@ private String[] getShapeCoordinates(IPathShape shape, IPathShape previousShape,
             return null;
         }
         String[] shapeCoordinates = null;
-        String[] operatorArgs = Arrays.copyOfRange(pathProperties, 1, pathProperties.length);
-        if (shape instanceof SmoothSCurveTo) {
+        if (shape instanceof SmoothSCurveTo || shape instanceof QuadraticSmoothCurveTo) {
             String[] startingControlPoint = new String[2];
             if (previousShape != null) {
                 Point previousEndPoint = previousShape.getEndingPoint();
-                //if the previous command was a C or S use its last control point
-                if (((previousShape instanceof CurveTo))) {
-                    Point lastControlPoint = ((CurveTo) previousShape).getLastControlPoint();
+                //if the previous command was a Bézier curve, use its last control point
+                if (previousShape instanceof IControlPointCurve) {
+                    Point lastControlPoint = ((IControlPointCurve) previousShape).getLastControlPoint();
                     float reflectedX = (float) (2 * previousEndPoint.getX() - lastControlPoint.getX());
                     float reflectedY = (float) (2 * previousEndPoint.getY() - lastControlPoint.getY());
 
@@ -156,13 +150,13 @@ private String[] getShapeCoordinates(IPathShape shape, IPathShape previousShape,
                 }
             } else {
                 // TODO RND-951
-                startingControlPoint[0] = pathProperties[1];
-                startingControlPoint[1] = pathProperties[2];
+                startingControlPoint[0] = pathProperties[0];
+                startingControlPoint[1] = pathProperties[1];
             }
-            shapeCoordinates = concatenate(startingControlPoint, operatorArgs);
+            shapeCoordinates = concatenate(startingControlPoint, pathProperties);
         }
         if (shapeCoordinates == null) {
-            shapeCoordinates = operatorArgs;
+            shapeCoordinates = pathProperties;
         }
         return shapeCoordinates;
     }
@@ -178,34 +172,63 @@ private String[] getShapeCoordinates(IPathShape shape, IPathShape previousShape,
      */
     private List<IPathShape> processPathOperator(String[] pathProperties, IPathShape previousShape) {
         List<IPathShape> shapes = new ArrayList<>();
-        if (pathProperties.length == 0 || pathProperties[0].isEmpty()) {
+        if (pathProperties.length == 0 || pathProperties[0].isEmpty() || SvgPathShapeFactory.getArgumentCount(pathProperties[0]) < 0) {
             return shapes;
         }
-        //Implements (absolute) command value only
-        //TODO implement relative values e. C(absolute), c(relative)
-        IPathShape pathShape = SvgPathShapeFactory.createPathShape(pathProperties[0]);
-        String[] shapeCoordinates = getShapeCoordinates(pathShape, previousShape, pathProperties);
-        if (pathShape instanceof ClosePath) {
-            if (previousShape != null) {
-                pathShape = zOperator;
-            } else {
+
+        int argumentCount = SvgPathShapeFactory.getArgumentCount(pathProperties[0]);
+        if (argumentCount == 0) { // closePath operator
+            if (previousShape == null) {
                 throw new SvgProcessingException(SvgLogMessageConstant.INVALID_CLOSEPATH_OPERATOR_USE);
             }
-        } else if (pathShape instanceof MoveTo) {
-            zOperator = new ClosePath(pathShape.isRelative());
-            if (shapeCoordinates != null && shapeCoordinates.length != MOVETOARGUMENTNR) {
-                LOGGER.warn(MessageFormatUtil.format(SvgLogMessageConstant.PATH_WRONG_NUMBER_OF_ARGUMENTS, pathProperties[0], shapeCoordinates.length, MOVETOARGUMENTNR, MOVETOARGUMENTNR));
+            shapes.add(zOperator);
+            currentPoint = zOperator.getEndingPoint();
+            return shapes;
+        }
+        for (int index = 1; index < pathProperties.length; index += argumentCount) {
+            if (index + argumentCount > pathProperties.length) {
+                break;
+            }
+            IPathShape pathShape = SvgPathShapeFactory.createPathShape(pathProperties[0]);
+            if (pathShape instanceof MoveTo) {
+                shapes.addAll(addMoveToShapes(pathShape, pathProperties));
+                return shapes;
             }
-            zOperator.setCoordinates(shapeCoordinates, currentPoint);
+
+            String[] shapeCoordinates = getShapeCoordinates(pathShape, previousShape, Arrays.copyOfRange(pathProperties, index, index+argumentCount));
+            if (pathShape != null) {
+                if (shapeCoordinates != null) {
+                    pathShape.setCoordinates(shapeCoordinates, currentPoint);
+                }
+                currentPoint = pathShape.getEndingPoint(); // unsupported operators are ignored.
+                shapes.add(pathShape);
+            }
+            previousShape = pathShape;
         }
+        return shapes;
+    }
 
-        if (pathShape != null) {
-            if (shapeCoordinates != null) {
-                // Cast will be removed when the method is introduced in the interface
-                pathShape.setCoordinates(shapeCoordinates, currentPoint);
+    private List<IPathShape> addMoveToShapes(IPathShape pathShape, String[] pathProperties) {
+        List<IPathShape> shapes = new ArrayList<>();
+        int argumentCount = 2;
+        String[] shapeCoordinates = getShapeCoordinates(pathShape, null, Arrays.copyOfRange(pathProperties, 1, 3));
+        zOperator = new ClosePath(pathShape.isRelative());
+        zOperator.setCoordinates(shapeCoordinates, currentPoint);
+        pathShape.setCoordinates(shapeCoordinates, currentPoint);
+        currentPoint = pathShape.getEndingPoint();
+        shapes.add(pathShape);
+        IPathShape previousShape = pathShape;
+        if (pathProperties.length > 3) {
+            for (int index = 3; index < pathProperties.length; index += argumentCount) {
+                if (index + 2 > pathProperties.length) {
+                    break;
+                }
+                pathShape = pathShape.isRelative() ? SvgPathShapeFactory.createPathShape("l") : SvgPathShapeFactory.createPathShape("L");
+                shapeCoordinates = getShapeCoordinates(pathShape, previousShape, Arrays.copyOfRange(pathProperties, index, index + 2));
+                pathShape.setCoordinates(shapeCoordinates, previousShape.getEndingPoint());
+                shapes.add(pathShape);
+                previousShape = pathShape;
             }
-            currentPoint = pathShape.getEndingPoint(); // unsupported operators are ignored.
-            shapes.add(pathShape);
         }
         return shapes;
     }

svg/src/main/java/com/itextpdf/svg/renderers/path/IPathShape.java

@@ -59,11 +59,11 @@ public interface IPathShape {
     /**
      * This method sets the coordinates for the path painting operator and does internal
      * preprocessing, if necessary
-     * @param coordinates an array containing point values for path coordinates
+     * @param inputCoordinates an array containing point values for path coordinates
      * @param startPoint the ending point of the previous operator, or, in broader terms,
      *                   the point that the coordinates should be absolutized against, for relative operators
      */
-    void setCoordinates(String[] coordinates, Point startPoint);
+    void setCoordinates(String[] inputCoordinates, Point startPoint);
 
     /**
      * Gets the ending point on the canvas after the path shape has been drawn

svg/src/main/java/com/itextpdf/svg/renderers/path/IPathShapeMapper.java

@@ -58,4 +58,5 @@ public interface IPathShapeMapper {
      */
     Map<String, IPathShape> getMapping();
 
+    Map<String, Integer> getArgumentCount();
 }

svg/src/main/java/com/itextpdf/svg/renderers/path/SvgPathShapeFactory.java

@@ -44,6 +44,8 @@ This file is part of the iText (R) project.
 
 import com.itextpdf.svg.renderers.path.impl.PathShapeMapper;
 
+import java.util.Map;
+
 /**
  * A factory for creating {@link IPathShape} objects.
  */
@@ -61,4 +63,18 @@ private SvgPathShapeFactory() {
     public static IPathShape createPathShape(String name) {
         return new PathShapeMapper().getMapping().get(name);
     }
+
+    /**
+     * Finds the appropriate number of arguments for a path command, based on the passed Svg path data instruction tag.
+     *
+     * @param name svg path element's path-data instruction name.
+     * @return an integer value with the required number of arguments or null if there is no mapping for the given value
+     */
+    public static int getArgumentCount(String name) {
+        Map<String, Integer> map = new PathShapeMapper().getArgumentCount();
+        if (map.containsKey(name.toUpperCase())) {
+            return (int) map.get(name.toUpperCase());
+        }
+        return -1;
+    }
 }

svg/src/main/java/com/itextpdf/svg/renderers/path/impl/AbstractPathShape.java

@@ -62,6 +62,22 @@ public abstract class AbstractPathShape implements IPathShape {
      * Whether this is a relative operator or not.
      */
     protected boolean relative;
+    protected final IOperatorConverter copier;
+    // Original coordinates from path instruction, according to the (x1 y1 x2 y2 x y)+ spec
+    protected String[] coordinates;
+
+    public AbstractPathShape() {
+        this(false);
+    }
+
+    public AbstractPathShape(boolean relative) {
+        this(relative, new DefaultOperatorConverter());
+    }
+
+    public AbstractPathShape(boolean relative, IOperatorConverter copier) {
+        this.relative = relative;
+        this.copier = copier;
+    }
 
     @Override
     public boolean isRelative() {
@@ -72,4 +88,9 @@ protected Point createPoint(String coordX, String coordY) {
         return new Point((float)CssUtils.parseFloat(coordX), (float)CssUtils.parseFloat(coordY));
     }
 
+    @Override
+    public Point getEndingPoint() {
+        return createPoint(coordinates[coordinates.length - 2], coordinates[coordinates.length - 1]);
+    }
+
 }

svg/src/main/java/com/itextpdf/svg/renderers/path/impl/ClosePath.java

@@ -46,6 +46,7 @@ This file is part of the iText (R) project.
  * Implements closePath(Z) attribute of SVG's path element
  * */
 public class ClosePath extends LineTo {
+    static final int ARGUMENT_SIZE = 0;
 
     public ClosePath() {
         this(false);

svg/src/main/java/com/itextpdf/svg/renderers/path/impl/CurveTo.java

@@ -47,70 +47,55 @@ This file is part of the iText (R) project.
 import com.itextpdf.kernel.pdf.canvas.PdfCanvas;
 import com.itextpdf.styledxmlparser.css.util.CssUtils;
 import com.itextpdf.svg.exceptions.SvgExceptionMessageConstant;
-import com.itextpdf.svg.utils.SvgCoordinateUtils;
 
 import java.util.Arrays;
 
 /***
- * Implements curveTo(L) attribute of SVG's path element
+ * Implements curveTo(C) attribute of SVG's path element
  * */
-public class CurveTo extends AbstractPathShape {
+public class CurveTo extends AbstractPathShape implements IControlPointCurve {
 
-    // Original coordinates from path instruction, according to the (x1 y1 x2 y2 x y)+ spec
-    private String[][] coordinates;
+    static final int ARGUMENT_SIZE = 6;
 
     public CurveTo() {
         this(false);
     }
 
     public CurveTo(boolean relative) {
-        this.relative = relative;
+        this(relative, new DefaultOperatorConverter());
+    }
+
+    public CurveTo(boolean relative, IOperatorConverter copier) {
+        super(relative, copier);
     }
 
     @Override
     public void draw(PdfCanvas canvas) {
-        for (int i = 0; i < coordinates.length; i++) {
-            float x1 = CssUtils.parseAbsoluteLength(coordinates[i][0]);
-            float y1 = CssUtils.parseAbsoluteLength(coordinates[i][1]);
-            float x2 = CssUtils.parseAbsoluteLength(coordinates[i][2]);
-            float y2 = CssUtils.parseAbsoluteLength(coordinates[i][3]);
-            float x = CssUtils.parseAbsoluteLength(coordinates[i][4]);
-            float y = CssUtils.parseAbsoluteLength(coordinates[i][5]);
-            canvas.curveTo(x1, y1, x2, y2, x, y);
-        }
+        float x1 = CssUtils.parseAbsoluteLength(coordinates[0]);
+        float y1 = CssUtils.parseAbsoluteLength(coordinates[1]);
+        float x2 = CssUtils.parseAbsoluteLength(coordinates[2]);
+        float y2 = CssUtils.parseAbsoluteLength(coordinates[3]);
+        float x = CssUtils.parseAbsoluteLength(coordinates[4]);
+        float y = CssUtils.parseAbsoluteLength(coordinates[5]);
+        canvas.curveTo(x1, y1, x2, y2, x, y);
     }
 
     @Override
-    public void setCoordinates(String[] coordinates, Point startPoint) {
-        if (coordinates.length == 0 || coordinates.length % 6 != 0) {
-            throw new IllegalArgumentException(MessageFormatUtil.format(SvgExceptionMessageConstant.CURVE_TO_EXPECTS_FOLLOWING_PARAMETERS_GOT_0, Arrays.toString(coordinates)));
+    public void setCoordinates(String[] inputCoordinates, Point startPoint) {
+        if (inputCoordinates.length < ARGUMENT_SIZE) {
+            throw new IllegalArgumentException(MessageFormatUtil.format(SvgExceptionMessageConstant.CURVE_TO_EXPECTS_FOLLOWING_PARAMETERS_GOT_0, Arrays.toString(inputCoordinates)));
         }
-        this.coordinates = new String[coordinates.length / 6][];
+        coordinates = new String[ARGUMENT_SIZE];
+        System.arraycopy(inputCoordinates, 0, coordinates, 0, ARGUMENT_SIZE);
         double[] initialPoint = new double[] {startPoint.getX(), startPoint.getY()};
-        for (int i = 0; i < coordinates.length; i += 6) {
-            String[] curCoordinates = new String[]{coordinates[i], coordinates[i + 1], coordinates[i + 2],
-                    coordinates[i + 3], coordinates[i + 4], coordinates[i + 5]};
-            if (isRelative()) {
-                curCoordinates = SvgCoordinateUtils.makeRelativeOperatorCoordinatesAbsolute(curCoordinates, initialPoint);
-                initialPoint[0] = (float)CssUtils.parseFloat(curCoordinates[4]);
-                initialPoint[1] = (float)CssUtils.parseFloat(curCoordinates[5]);
-            }
-            this.coordinates[i / 6] = curCoordinates;
+        if (isRelative()) {
+            coordinates = copier.makeCoordinatesAbsolute(coordinates, initialPoint);
         }
     }
 
-    /**
-     * Returns coordinates of the last control point (the one closer to the ending point)
-     * in the series of Bezier curves (possibly, one curve), in SVG space coordinates
-     * @return coordinates of the last control points in SVG space coordinates
-     */
-    public Point getLastControlPoint() {
-        return createPoint(coordinates[coordinates.length - 1][2], coordinates[coordinates.length - 1][3]);
-    }
-
     @Override
-    public Point getEndingPoint() {
-        return createPoint(coordinates[coordinates.length - 1][4], coordinates[coordinates.length - 1][5]);
+    public Point getLastControlPoint() {
+        return createPoint(coordinates[2], coordinates[3]);
     }
 
 }