Java tutorial
/* * Copyright (C) 2017 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package android.support.v4.graphics; import static android.support.annotation.RestrictTo.Scope.LIBRARY_GROUP; import android.graphics.Path; import android.support.annotation.RestrictTo; import android.util.Log; import java.util.ArrayList; /** * This class is a duplicate from the PathParser.java of frameworks/base, with slight * update on incompatible API like copyOfRange(). * * @hide */ @RestrictTo(LIBRARY_GROUP) public class PathParser { private static final String LOGTAG = "PathParser"; // Copy from Arrays.copyOfRange() which is only available from API level 9. /** * Copies elements from {@code original} into a new array, from indexes start (inclusive) to * end (exclusive). The original order of elements is preserved. * If {@code end} is greater than {@code original.length}, the result is padded * with the value {@code 0.0f}. * * @param original the original array * @param start the start index, inclusive * @param end the end index, exclusive * @return the new array * @throws ArrayIndexOutOfBoundsException if {@code start < 0 || start > original.length} * @throws IllegalArgumentException if {@code start > end} * @throws NullPointerException if {@code original == null} */ static float[] copyOfRange(float[] original, int start, int end) { if (start > end) { throw new IllegalArgumentException(); } int originalLength = original.length; if (start < 0 || start > originalLength) { throw new ArrayIndexOutOfBoundsException(); } int resultLength = end - start; int copyLength = Math.min(resultLength, originalLength - start); float[] result = new float[resultLength]; System.arraycopy(original, start, result, 0, copyLength); return result; } /** * @param pathData The string representing a path, the same as "d" string in svg file. * @return the generated Path object. */ public static Path createPathFromPathData(String pathData) { Path path = new Path(); PathDataNode[] nodes = createNodesFromPathData(pathData); if (nodes != null) { try { PathDataNode.nodesToPath(nodes, path); } catch (RuntimeException e) { throw new RuntimeException("Error in parsing " + pathData, e); } return path; } return null; } /** * @param pathData The string representing a path, the same as "d" string in svg file. * @return an array of the PathDataNode. */ public static PathDataNode[] createNodesFromPathData(String pathData) { if (pathData == null) { return null; } int start = 0; int end = 1; ArrayList<PathDataNode> list = new ArrayList<PathDataNode>(); while (end < pathData.length()) { end = nextStart(pathData, end); String s = pathData.substring(start, end).trim(); if (s.length() > 0) { float[] val = getFloats(s); addNode(list, s.charAt(0), val); } start = end; end++; } if ((end - start) == 1 && start < pathData.length()) { addNode(list, pathData.charAt(start), new float[0]); } return list.toArray(new PathDataNode[list.size()]); } /** * @param source The array of PathDataNode to be duplicated. * @return a deep copy of the <code>source</code>. */ public static PathDataNode[] deepCopyNodes(PathDataNode[] source) { if (source == null) { return null; } PathDataNode[] copy = new PathParser.PathDataNode[source.length]; for (int i = 0; i < source.length; i++) { copy[i] = new PathDataNode(source[i]); } return copy; } /** * @param nodesFrom The source path represented in an array of PathDataNode * @param nodesTo The target path represented in an array of PathDataNode * @return whether the <code>nodesFrom</code> can morph into <code>nodesTo</code> */ public static boolean canMorph(PathDataNode[] nodesFrom, PathDataNode[] nodesTo) { if (nodesFrom == null || nodesTo == null) { return false; } if (nodesFrom.length != nodesTo.length) { return false; } for (int i = 0; i < nodesFrom.length; i++) { if (nodesFrom[i].mType != nodesTo[i].mType || nodesFrom[i].mParams.length != nodesTo[i].mParams.length) { return false; } } return true; } /** * Update the target's data to match the source. * Before calling this, make sure canMorph(target, source) is true. * * @param target The target path represented in an array of PathDataNode * @param source The source path represented in an array of PathDataNode */ public static void updateNodes(PathDataNode[] target, PathDataNode[] source) { for (int i = 0; i < source.length; i++) { target[i].mType = source[i].mType; for (int j = 0; j < source[i].mParams.length; j++) { target[i].mParams[j] = source[i].mParams[j]; } } } private static int nextStart(String s, int end) { char c; while (end < s.length()) { c = s.charAt(end); // Note that 'e' or 'E' are not valid path commands, but could be // used for floating point numbers' scientific notation. // Therefore, when searching for next command, we should ignore 'e' // and 'E'. if ((((c - 'A') * (c - 'Z') <= 0) || ((c - 'a') * (c - 'z') <= 0)) && c != 'e' && c != 'E') { return end; } end++; } return end; } private static void addNode(ArrayList<PathDataNode> list, char cmd, float[] val) { list.add(new PathDataNode(cmd, val)); } private static class ExtractFloatResult { // We need to return the position of the next separator and whether the // next float starts with a '-' or a '.'. int mEndPosition; boolean mEndWithNegOrDot; ExtractFloatResult() { } } /** * Parse the floats in the string. * This is an optimized version of parseFloat(s.split(",|\\s")); * * @param s the string containing a command and list of floats * @return array of floats */ private static float[] getFloats(String s) { if (s.charAt(0) == 'z' || s.charAt(0) == 'Z') { return new float[0]; } try { float[] results = new float[s.length()]; int count = 0; int startPosition = 1; int endPosition = 0; ExtractFloatResult result = new ExtractFloatResult(); int totalLength = s.length(); // The startPosition should always be the first character of the // current number, and endPosition is the character after the current // number. while (startPosition < totalLength) { extract(s, startPosition, result); endPosition = result.mEndPosition; if (startPosition < endPosition) { results[count++] = Float.parseFloat(s.substring(startPosition, endPosition)); } if (result.mEndWithNegOrDot) { // Keep the '-' or '.' sign with next number. startPosition = endPosition; } else { startPosition = endPosition + 1; } } return copyOfRange(results, 0, count); } catch (NumberFormatException e) { throw new RuntimeException("error in parsing \"" + s + "\"", e); } } /** * Calculate the position of the next comma or space or negative sign * * @param s the string to search * @param start the position to start searching * @param result the result of the extraction, including the position of the * the starting position of next number, whether it is ending with a '-'. */ private static void extract(String s, int start, ExtractFloatResult result) { // Now looking for ' ', ',', '.' or '-' from the start. int currentIndex = start; boolean foundSeparator = false; result.mEndWithNegOrDot = false; boolean secondDot = false; boolean isExponential = false; for (; currentIndex < s.length(); currentIndex++) { boolean isPrevExponential = isExponential; isExponential = false; char currentChar = s.charAt(currentIndex); switch (currentChar) { case ' ': case ',': foundSeparator = true; break; case '-': // The negative sign following a 'e' or 'E' is not a separator. if (currentIndex != start && !isPrevExponential) { foundSeparator = true; result.mEndWithNegOrDot = true; } break; case '.': if (!secondDot) { secondDot = true; } else { // This is the second dot, and it is considered as a separator. foundSeparator = true; result.mEndWithNegOrDot = true; } break; case 'e': case 'E': isExponential = true; break; } if (foundSeparator) { break; } } // When there is nothing found, then we put the end position to the end // of the string. result.mEndPosition = currentIndex; } /** * Each PathDataNode represents one command in the "d" attribute of the svg * file. * An array of PathDataNode can represent the whole "d" attribute. */ public static class PathDataNode { /** * @hide */ @RestrictTo(LIBRARY_GROUP) public char mType; /** * @hide */ @RestrictTo(LIBRARY_GROUP) public float[] mParams; PathDataNode(char type, float[] params) { this.mType = type; this.mParams = params; } PathDataNode(PathDataNode n) { mType = n.mType; mParams = copyOfRange(n.mParams, 0, n.mParams.length); } /** * Convert an array of PathDataNode to Path. * * @param node The source array of PathDataNode. * @param path The target Path object. */ public static void nodesToPath(PathDataNode[] node, Path path) { float[] current = new float[6]; char previousCommand = 'm'; for (int i = 0; i < node.length; i++) { addCommand(path, current, previousCommand, node[i].mType, node[i].mParams); previousCommand = node[i].mType; } } /** * The current PathDataNode will be interpolated between the * <code>nodeFrom</code> and <code>nodeTo</code> according to the * <code>fraction</code>. * * @param nodeFrom The start value as a PathDataNode. * @param nodeTo The end value as a PathDataNode * @param fraction The fraction to interpolate. */ public void interpolatePathDataNode(PathDataNode nodeFrom, PathDataNode nodeTo, float fraction) { for (int i = 0; i < nodeFrom.mParams.length; i++) { mParams[i] = nodeFrom.mParams[i] * (1 - fraction) + nodeTo.mParams[i] * fraction; } } private static void addCommand(Path path, float[] current, char previousCmd, char cmd, float[] val) { int incr = 2; float currentX = current[0]; float currentY = current[1]; float ctrlPointX = current[2]; float ctrlPointY = current[3]; float currentSegmentStartX = current[4]; float currentSegmentStartY = current[5]; float reflectiveCtrlPointX; float reflectiveCtrlPointY; switch (cmd) { case 'z': case 'Z': path.close(); // Path is closed here, but we need to move the pen to the // closed position. So we cache the segment's starting position, // and restore it here. currentX = currentSegmentStartX; currentY = currentSegmentStartY; ctrlPointX = currentSegmentStartX; ctrlPointY = currentSegmentStartY; path.moveTo(currentX, currentY); break; case 'm': case 'M': case 'l': case 'L': case 't': case 'T': incr = 2; break; case 'h': case 'H': case 'v': case 'V': incr = 1; break; case 'c': case 'C': incr = 6; break; case 's': case 'S': case 'q': case 'Q': incr = 4; break; case 'a': case 'A': incr = 7; break; } for (int k = 0; k < val.length; k += incr) { switch (cmd) { case 'm': // moveto - Start a new sub-path (relative) currentX += val[k + 0]; currentY += val[k + 1]; if (k > 0) { // According to the spec, if a moveto is followed by multiple // pairs of coordinates, the subsequent pairs are treated as // implicit lineto commands. path.rLineTo(val[k + 0], val[k + 1]); } else { path.rMoveTo(val[k + 0], val[k + 1]); currentSegmentStartX = currentX; currentSegmentStartY = currentY; } break; case 'M': // moveto - Start a new sub-path currentX = val[k + 0]; currentY = val[k + 1]; if (k > 0) { // According to the spec, if a moveto is followed by multiple // pairs of coordinates, the subsequent pairs are treated as // implicit lineto commands. path.lineTo(val[k + 0], val[k + 1]); } else { path.moveTo(val[k + 0], val[k + 1]); currentSegmentStartX = currentX; currentSegmentStartY = currentY; } break; case 'l': // lineto - Draw a line from the current point (relative) path.rLineTo(val[k + 0], val[k + 1]); currentX += val[k + 0]; currentY += val[k + 1]; break; case 'L': // lineto - Draw a line from the current point path.lineTo(val[k + 0], val[k + 1]); currentX = val[k + 0]; currentY = val[k + 1]; break; case 'h': // horizontal lineto - Draws a horizontal line (relative) path.rLineTo(val[k + 0], 0); currentX += val[k + 0]; break; case 'H': // horizontal lineto - Draws a horizontal line path.lineTo(val[k + 0], currentY); currentX = val[k + 0]; break; case 'v': // vertical lineto - Draws a vertical line from the current point (r) path.rLineTo(0, val[k + 0]); currentY += val[k + 0]; break; case 'V': // vertical lineto - Draws a vertical line from the current point path.lineTo(currentX, val[k + 0]); currentY = val[k + 0]; break; case 'c': // curveto - Draws a cubic Bzier curve (relative) path.rCubicTo(val[k + 0], val[k + 1], val[k + 2], val[k + 3], val[k + 4], val[k + 5]); ctrlPointX = currentX + val[k + 2]; ctrlPointY = currentY + val[k + 3]; currentX += val[k + 4]; currentY += val[k + 5]; break; case 'C': // curveto - Draws a cubic Bzier curve path.cubicTo(val[k + 0], val[k + 1], val[k + 2], val[k + 3], val[k + 4], val[k + 5]); currentX = val[k + 4]; currentY = val[k + 5]; ctrlPointX = val[k + 2]; ctrlPointY = val[k + 3]; break; case 's': // smooth curveto - Draws a cubic Bzier curve (reflective cp) reflectiveCtrlPointX = 0; reflectiveCtrlPointY = 0; if (previousCmd == 'c' || previousCmd == 's' || previousCmd == 'C' || previousCmd == 'S') { reflectiveCtrlPointX = currentX - ctrlPointX; reflectiveCtrlPointY = currentY - ctrlPointY; } path.rCubicTo(reflectiveCtrlPointX, reflectiveCtrlPointY, val[k + 0], val[k + 1], val[k + 2], val[k + 3]); ctrlPointX = currentX + val[k + 0]; ctrlPointY = currentY + val[k + 1]; currentX += val[k + 2]; currentY += val[k + 3]; break; case 'S': // shorthand/smooth curveto Draws a cubic Bzier curve(reflective cp) reflectiveCtrlPointX = currentX; reflectiveCtrlPointY = currentY; if (previousCmd == 'c' || previousCmd == 's' || previousCmd == 'C' || previousCmd == 'S') { reflectiveCtrlPointX = 2 * currentX - ctrlPointX; reflectiveCtrlPointY = 2 * currentY - ctrlPointY; } path.cubicTo(reflectiveCtrlPointX, reflectiveCtrlPointY, val[k + 0], val[k + 1], val[k + 2], val[k + 3]); ctrlPointX = val[k + 0]; ctrlPointY = val[k + 1]; currentX = val[k + 2]; currentY = val[k + 3]; break; case 'q': // Draws a quadratic Bzier (relative) path.rQuadTo(val[k + 0], val[k + 1], val[k + 2], val[k + 3]); ctrlPointX = currentX + val[k + 0]; ctrlPointY = currentY + val[k + 1]; currentX += val[k + 2]; currentY += val[k + 3]; break; case 'Q': // Draws a quadratic Bzier path.quadTo(val[k + 0], val[k + 1], val[k + 2], val[k + 3]); ctrlPointX = val[k + 0]; ctrlPointY = val[k + 1]; currentX = val[k + 2]; currentY = val[k + 3]; break; case 't': // Draws a quadratic Bzier curve(reflective control point)(relative) reflectiveCtrlPointX = 0; reflectiveCtrlPointY = 0; if (previousCmd == 'q' || previousCmd == 't' || previousCmd == 'Q' || previousCmd == 'T') { reflectiveCtrlPointX = currentX - ctrlPointX; reflectiveCtrlPointY = currentY - ctrlPointY; } path.rQuadTo(reflectiveCtrlPointX, reflectiveCtrlPointY, val[k + 0], val[k + 1]); ctrlPointX = currentX + reflectiveCtrlPointX; ctrlPointY = currentY + reflectiveCtrlPointY; currentX += val[k + 0]; currentY += val[k + 1]; break; case 'T': // Draws a quadratic Bzier curve (reflective control point) reflectiveCtrlPointX = currentX; reflectiveCtrlPointY = currentY; if (previousCmd == 'q' || previousCmd == 't' || previousCmd == 'Q' || previousCmd == 'T') { reflectiveCtrlPointX = 2 * currentX - ctrlPointX; reflectiveCtrlPointY = 2 * currentY - ctrlPointY; } path.quadTo(reflectiveCtrlPointX, reflectiveCtrlPointY, val[k + 0], val[k + 1]); ctrlPointX = reflectiveCtrlPointX; ctrlPointY = reflectiveCtrlPointY; currentX = val[k + 0]; currentY = val[k + 1]; break; case 'a': // Draws an elliptical arc // (rx ry x-axis-rotation large-arc-flag sweep-flag x y) drawArc(path, currentX, currentY, val[k + 5] + currentX, val[k + 6] + currentY, val[k + 0], val[k + 1], val[k + 2], val[k + 3] != 0, val[k + 4] != 0); currentX += val[k + 5]; currentY += val[k + 6]; ctrlPointX = currentX; ctrlPointY = currentY; break; case 'A': // Draws an elliptical arc drawArc(path, currentX, currentY, val[k + 5], val[k + 6], val[k + 0], val[k + 1], val[k + 2], val[k + 3] != 0, val[k + 4] != 0); currentX = val[k + 5]; currentY = val[k + 6]; ctrlPointX = currentX; ctrlPointY = currentY; break; } previousCmd = cmd; } current[0] = currentX; current[1] = currentY; current[2] = ctrlPointX; current[3] = ctrlPointY; current[4] = currentSegmentStartX; current[5] = currentSegmentStartY; } private static void drawArc(Path p, float x0, float y0, float x1, float y1, float a, float b, float theta, boolean isMoreThanHalf, boolean isPositiveArc) { /* Convert rotation angle from degrees to radians */ double thetaD = Math.toRadians(theta); /* Pre-compute rotation matrix entries */ double cosTheta = Math.cos(thetaD); double sinTheta = Math.sin(thetaD); /* Transform (x0, y0) and (x1, y1) into unit space */ /* using (inverse) rotation, followed by (inverse) scale */ double x0p = (x0 * cosTheta + y0 * sinTheta) / a; double y0p = (-x0 * sinTheta + y0 * cosTheta) / b; double x1p = (x1 * cosTheta + y1 * sinTheta) / a; double y1p = (-x1 * sinTheta + y1 * cosTheta) / b; /* Compute differences and averages */ double dx = x0p - x1p; double dy = y0p - y1p; double xm = (x0p + x1p) / 2; double ym = (y0p + y1p) / 2; /* Solve for intersecting unit circles */ double dsq = dx * dx + dy * dy; if (dsq == 0.0) { Log.w(LOGTAG, " Points are coincident"); return; /* Points are coincident */ } double disc = 1.0 / dsq - 1.0 / 4.0; if (disc < 0.0) { Log.w(LOGTAG, "Points are too far apart " + dsq); float adjust = (float) (Math.sqrt(dsq) / 1.99999); drawArc(p, x0, y0, x1, y1, a * adjust, b * adjust, theta, isMoreThanHalf, isPositiveArc); return; /* Points are too far apart */ } double s = Math.sqrt(disc); double sdx = s * dx; double sdy = s * dy; double cx; double cy; if (isMoreThanHalf == isPositiveArc) { cx = xm - sdy; cy = ym + sdx; } else { cx = xm + sdy; cy = ym - sdx; } double eta0 = Math.atan2((y0p - cy), (x0p - cx)); double eta1 = Math.atan2((y1p - cy), (x1p - cx)); double sweep = (eta1 - eta0); if (isPositiveArc != (sweep >= 0)) { if (sweep > 0) { sweep -= 2 * Math.PI; } else { sweep += 2 * Math.PI; } } cx *= a; cy *= b; double tcx = cx; cx = cx * cosTheta - cy * sinTheta; cy = tcx * sinTheta + cy * cosTheta; arcToBezier(p, cx, cy, a, b, x0, y0, thetaD, eta0, sweep); } /** * Converts an arc to cubic Bezier segments and records them in p. * * @param p The target for the cubic Bezier segments * @param cx The x coordinate center of the ellipse * @param cy The y coordinate center of the ellipse * @param a The radius of the ellipse in the horizontal direction * @param b The radius of the ellipse in the vertical direction * @param e1x E(eta1) x coordinate of the starting point of the arc * @param e1y E(eta2) y coordinate of the starting point of the arc * @param theta The angle that the ellipse bounding rectangle makes with horizontal plane * @param start The start angle of the arc on the ellipse * @param sweep The angle (positive or negative) of the sweep of the arc on the ellipse */ private static void arcToBezier(Path p, double cx, double cy, double a, double b, double e1x, double e1y, double theta, double start, double sweep) { // Taken from equations at: http://spaceroots.org/documents/ellipse/node8.html // and http://www.spaceroots.org/documents/ellipse/node22.html // Maximum of 45 degrees per cubic Bezier segment int numSegments = (int) Math.ceil(Math.abs(sweep * 4 / Math.PI)); double eta1 = start; double cosTheta = Math.cos(theta); double sinTheta = Math.sin(theta); double cosEta1 = Math.cos(eta1); double sinEta1 = Math.sin(eta1); double ep1x = (-a * cosTheta * sinEta1) - (b * sinTheta * cosEta1); double ep1y = (-a * sinTheta * sinEta1) + (b * cosTheta * cosEta1); double anglePerSegment = sweep / numSegments; for (int i = 0; i < numSegments; i++) { double eta2 = eta1 + anglePerSegment; double sinEta2 = Math.sin(eta2); double cosEta2 = Math.cos(eta2); double e2x = cx + (a * cosTheta * cosEta2) - (b * sinTheta * sinEta2); double e2y = cy + (a * sinTheta * cosEta2) + (b * cosTheta * sinEta2); double ep2x = -a * cosTheta * sinEta2 - b * sinTheta * cosEta2; double ep2y = -a * sinTheta * sinEta2 + b * cosTheta * cosEta2; double tanDiff2 = Math.tan((eta2 - eta1) / 2); double alpha = Math.sin(eta2 - eta1) * (Math.sqrt(4 + (3 * tanDiff2 * tanDiff2)) - 1) / 3; double q1x = e1x + alpha * ep1x; double q1y = e1y + alpha * ep1y; double q2x = e2x - alpha * ep2x; double q2y = e2y - alpha * ep2y; // Adding this no-op call to workaround a proguard related issue. p.rLineTo(0, 0); p.cubicTo((float) q1x, (float) q1y, (float) q2x, (float) q2y, (float) e2x, (float) e2y); eta1 = eta2; e1x = e2x; e1y = e2y; ep1x = ep2x; ep1y = ep2y; } } } }