Update vector
This commit is contained in:
seven332 committed
1 parent
be9d051d39
commit
de7a5b6395
3 files changed
+670
-631
No files matched your search
@@ -0,0 +1,652 @@
|
||||
/*
|
||||
* Copyright (C) 2014 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 com.hippo.util;
|
||||
|
||||
import android.util.Log;
|
||||
|
||||
import com.hippo.graphics.JPath;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
|
||||
/**
|
||||
* @hide
|
||||
*/
|
||||
public class JPathParser {
|
||||
static final String LOGTAG = JPathParser.class.getSimpleName();
|
||||
|
||||
/**
|
||||
* @param pathData The string representing a path, the same as "d" string in svg file.
|
||||
* @return the generated Path object.
|
||||
*/
|
||||
public static JPath createPathFromPathData(String pathData) {
|
||||
JPath path = new JPath();
|
||||
PathDataNode[] nodes = createNodesFromPathData(pathData);
|
||||
if (nodes != null) {
|
||||
PathDataNode.nodesToPath(nodes, path);
|
||||
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 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);
|
||||
if (((c - 'A') * (c - 'Z') <= 0) || (((c - 'a') * (c - 'z') <= 0))) {
|
||||
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 '-'.
|
||||
int mEndPosition;
|
||||
boolean mEndWithNegSign;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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.mEndWithNegSign) {
|
||||
// Keep the '-' sign with next number.
|
||||
startPosition = endPosition;
|
||||
} else {
|
||||
startPosition = endPosition + 1;
|
||||
}
|
||||
}
|
||||
return Arrays.copyOf(results, count);
|
||||
} catch (NumberFormatException e) {
|
||||
Log.e(LOGTAG, "error in parsing \"" + s + "\"");
|
||||
throw 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.mEndWithNegSign = false;
|
||||
for (; currentIndex < s.length(); currentIndex++) {
|
||||
char currentChar = s.charAt(currentIndex);
|
||||
switch (currentChar) {
|
||||
case ' ':
|
||||
case ',':
|
||||
foundSeparator = true;
|
||||
break;
|
||||
case '-':
|
||||
if (currentIndex != start) {
|
||||
foundSeparator = true;
|
||||
result.mEndWithNegSign = 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 {
|
||||
private char mType;
|
||||
private float[] mParams;
|
||||
|
||||
private PathDataNode(char type, float[] params) {
|
||||
mType = type;
|
||||
mParams = params;
|
||||
}
|
||||
|
||||
private PathDataNode(PathDataNode n) {
|
||||
mType = n.mType;
|
||||
mParams = Arrays.copyOf(n.mParams, 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, JPath path) {
|
||||
float[] current = new float[4];
|
||||
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(JPath 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 reflectiveCtrlPointX;
|
||||
float reflectiveCtrlPointY;
|
||||
|
||||
switch (cmd) {
|
||||
case 'z':
|
||||
case 'Z':
|
||||
path.close();
|
||||
return;
|
||||
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)
|
||||
path.rMoveTo(val[k + 0], val[k + 1]);
|
||||
currentX += val[k + 0];
|
||||
currentY += val[k + 1];
|
||||
break;
|
||||
case 'M': // moveto - Start a new sub-path
|
||||
path.moveTo(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 (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 'z': // closepath - Close the current subpath
|
||||
case 'Z': // closepath - Close the current subpath
|
||||
path.close();
|
||||
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 Bézier 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 Bézier 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 Bézier 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 Bézier 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 Bézier (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 Bézier
|
||||
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 Bézier 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 Bézier 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;
|
||||
}
|
||||
|
||||
private static void drawArc(JPath 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(JPath 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 = Math.abs((int) Math.ceil(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;
|
||||
|
||||
p.cubicTo((float) q1x,
|
||||
(float) q1y,
|
||||
(float) q2x,
|
||||
(float) q2y,
|
||||
(float) e2x,
|
||||
(float) e2y);
|
||||
eta1 = eta2;
|
||||
e1x = e2x;
|
||||
e1y = e2y;
|
||||
ep1x = ep2x;
|
||||
ep1y = ep2y;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user