* This method provides a single precision variant of the double precision * {@code moveTo()} method on the base {@code LinePath} class. * * @param x * the specified X coordinate * @param y * the specified Y coordinate * @see LinePath#moveTo */ public final void moveTo(float x, float y) { if (numTypes > 0 && pointTypes[numTypes - 1] == SEG_MOVETO) { floatCoords[numCoords - 2] = x; floatCoords[numCoords - 1] = y; } else { needRoom(false, 2); pointTypes[numTypes++] = SEG_MOVETO; floatCoords[numCoords++] = x; floatCoords[numCoords++] = y; } } /** * Adds a point to the path by drawing a straight line from the current * coordinates to the new specified coordinates specified in float precision. *
* This method provides a single precision variant of the double precision
* {@code lineTo()} method on the base {@code LinePath} class.
*
* @param x
* the specified X coordinate
* @param y
* the specified Y coordinate
* @see LinePath#lineTo
*/
public final void lineTo(float x, float y) {
needRoom(true, 2);
pointTypes[numTypes++] = SEG_LINETO;
floatCoords[numCoords++] = x;
floatCoords[numCoords++] = y;
}
/**
* The iterator for this class is not multi-threaded safe, which means that
* the {@code LinePath} class does not guarantee that modifications to the
* geometry of this {@code LinePath} object do not affect any iterations of that
* geometry that are already in process.
*/
public PathIterator getPathIterator() {
return new PathIterator(this);
}
/**
* Closes the current subpath by drawing a straight line back to the
* coordinates of the last {@code moveTo}. If the path is already closed then
* this method has no effect.
*/
public final void closePath() {
if (numTypes == 0 || pointTypes[numTypes - 1] != SEG_CLOSE) {
needRoom(false, 0);
pointTypes[numTypes++] = SEG_CLOSE;
}
}
/**
* Returns the fill style winding rule.
*
* @return an integer representing the current winding rule.
* @see #WIND_EVEN_ODD
* @see #WIND_NON_ZERO
* @see #setWindingRule
*/
public final int getWindingRule() {
return windingRule;
}
/**
* Sets the winding rule for this path to the specified value.
*
* @param rule
* an integer representing the specified winding rule
* @exception IllegalArgumentException
* if {@code rule} is not either {@link #WIND_EVEN_ODD} or
* {@link #WIND_NON_ZERO}
* @see #getWindingRule
*/
public final void setWindingRule(int rule) {
if (rule != WIND_EVEN_ODD && rule != WIND_NON_ZERO) {
throw new IllegalArgumentException("winding rule must be "
+ "WIND_EVEN_ODD or " + "WIND_NON_ZERO");
}
windingRule = rule;
}
/**
* Resets the path to empty. The append position is set back to the beginning
* of the path and all coordinates and point types are forgotten.
*/
public final void reset() {
numTypes = numCoords = 0;
}
static public class PathIterator {
float floatCoords[];
int typeIdx;
int pointIdx;
LinePath path;
static final int curvecoords[] = { 2, 2, 0 };
PathIterator(LinePath p2df) {
this.path = p2df;
this.floatCoords = p2df.floatCoords;
}
public int currentSegment(float[] coords) {
int type = path.pointTypes[typeIdx];
int numCoords = curvecoords[type];
if (numCoords > 0) {
System.arraycopy(floatCoords, pointIdx, coords, 0, numCoords);
}
return type;
}
public int currentSegment(double[] coords) {
int type = path.pointTypes[typeIdx];
int numCoords = curvecoords[type];
if (numCoords > 0) {
for (int i = 0; i < numCoords; i++) {
coords[i] = floatCoords[pointIdx + i];
}
}
return type;
}
public int getWindingRule() {
return path.getWindingRule();
}
public boolean isDone() {
return (typeIdx >= path.numTypes);
}
public void next() {
int type = path.pointTypes[typeIdx++];
pointIdx += curvecoords[type];
}
}
/////////////////////////////////////////////////////////////////////////////
//
// Stroked path methods
static public LinePath createStrokedPath(LinePath src, float weight,
int caps, int join) {
return createStrokedPath(src, weight, caps, join, defaultMiterlimit, null);
}
static public LinePath createStrokedPath(LinePath src, float weight,
int caps, int join, float miterlimit) {
return createStrokedPath(src, weight, caps, join, miterlimit, null);
}
/**
* Constructs a solid LinePath with the specified attributes.
*
* @param src
* the original path to be stroked
* @param weight
* the weight of the stroked path
* @param cap
* the decoration of the ends of the segments in the path
* @param join
* the decoration applied where path segments meet
* @param miterlimit
* @param transform
*
*/
static public LinePath createStrokedPath(LinePath src, float weight,
int caps, int join,
float miterlimit, PMatrix2D transform) {
final LinePath dest = new LinePath();
strokeTo(src, weight, caps, join, miterlimit, transform, new LineStroker() {
@Override
public void moveTo(int x0, int y0) {
dest.moveTo(S15_16ToFloat(x0), S15_16ToFloat(y0));
}
@Override
public void lineJoin() {
}
@Override
public void lineTo(int x1, int y1) {
dest.lineTo(S15_16ToFloat(x1), S15_16ToFloat(y1));
}
@Override
public void close() {
dest.closePath();
}
@Override
public void end() {
}
});
return dest;
}
private static void strokeTo(LinePath src, float width, int caps, int join,
float miterlimit, PMatrix2D transform,
LineStroker lsink) {
lsink = new LineStroker(lsink, FloatToS15_16(width), caps, join,
FloatToS15_16(miterlimit),
transform == null ? identity : transform);
PathIterator pi = src.getPathIterator();
pathTo(pi, lsink);
}
private static void pathTo(PathIterator pi, LineStroker lsink) {
float coords[] = new float[2];
while (!pi.isDone()) {
switch (pi.currentSegment(coords)) {
case SEG_MOVETO:
lsink.moveTo(FloatToS15_16(coords[0]), FloatToS15_16(coords[1]));
break;
case SEG_LINETO:
lsink.lineJoin();
lsink.lineTo(FloatToS15_16(coords[0]), FloatToS15_16(coords[1]));
break;
case SEG_CLOSE:
lsink.lineJoin();
lsink.close();
break;
default:
throw new InternalError("unknown flattened segment type");
}
pi.next();
}
lsink.end();
}
/////////////////////////////////////////////////////////////////////////////
//
// Utility methods
public static float[] copyOf(float[] source, int length) {
float[] target = new float[length];
for (int i = 0; i < target.length; i++) {
if (i > source.length - 1)
target[i] = 0f;
else
target[i] = source[i];
}
return target;
}
public static byte[] copyOf(byte[] source, int length) {
byte[] target = new byte[length];
for (int i = 0; i < target.length; i++) {
if (i > source.length - 1)
target[i] = 0;
else
target[i] = source[i];
}
return target;
}
// From Ken Turkowski, _Fixed-Point Square Root_, In Graphics Gems V
public static int isqrt(int x) {
int fracbits = 16;
int root = 0;
int remHi = 0;
int remLo = x;
int count = 15 + fracbits / 2;
do {
remHi = (remHi << 2) | (remLo >>> 30); // N.B. - unsigned shift R
remLo <<= 2;
root <<= 1;
int testdiv = (root << 1) + 1;
if (remHi >= testdiv) {
remHi -= testdiv;
root++;
}
} while (count-- != 0);
return root;
}
public static long lsqrt(long x) {
int fracbits = 16;
long root = 0;
long remHi = 0;
long remLo = x;
int count = 31 + fracbits / 2;
do {
remHi = (remHi << 2) | (remLo >>> 62); // N.B. - unsigned shift R
remLo <<= 2;
root <<= 1;
long testDiv = (root << 1) + 1;
if (remHi >= testDiv) {
remHi -= testDiv;
root++;
}
} while (count-- != 0);
return root;
}
public static double hypot(double x, double y) {
return Math.sqrt(x * x + y * y);
}
public static int hypot(int x, int y) {
return (int) ((lsqrt((long) x * x + (long) y * y) + 128) >> 8);
}
public static long hypot(long x, long y) {
return (lsqrt(x * x + y * y) + 128) >> 8;
}
static int FloatToS15_16(float flt) {
flt = flt * 65536f + 0.5f;
if (flt <= -(65536f * 65536f)) {
return Integer.MIN_VALUE;
} else if (flt >= (65536f * 65536f)) {
return Integer.MAX_VALUE;
} else {
return (int) Math.floor(flt);
}
}
static float S15_16ToFloat(int fix) {
return (fix / 65536f);
}
}