propane 3.4.0-java → 3.7.0.pre-java

data/src/main/java/processing/opengl/LinePath.java

@@ -1,3 +1,5 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
 /*
  * Copyright 2006 Sun Microsystems, Inc.  All Rights Reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
@@ -22,559 +24,604 @@
  * CA 95054 USA or visit www.sun.com if you need additional information or
  * have any questions.
  */
+
 package processing.opengl;
 
 import processing.core.PMatrix2D;
 
 /**
- * The {@code LinePath} class allows to represent polygonal paths, potentially
- * composed by several disjoint polygonal segments. It can be iterated by the
- * {@link PathIterator} class including all of its segment types and winding
- * rules
+ * The {@code LinePath} class allows to represent polygonal paths,
+ * potentially composed by several disjoint polygonal segments.
+ * It can be iterated by the {@link PathIterator} class including all
+ * of its segment types and winding rules
  *
  */
 public class LinePath {
-
-    /**
-     * The winding rule constant for specifying an even-odd rule for determining
-     * the interior of a path. The even-odd rule specifies that a point lies
-     * inside the path if a ray drawn in any direction from that point to
-     * infinity is crossed by path segments an odd number of times.
-     */
-    public static final int WIND_EVEN_ODD = 0;
-
-    /**
-     * The winding rule constant for specifying a non-zero rule for determining
-     * the interior of a path. The non-zero rule specifies that a point lies
-     * inside the path if a ray drawn in any direction from that point to
-     * infinity is crossed by path segments a different number of times in the
-     * counter-clockwise direction than the clockwise direction.
-     */
-    public static final int WIND_NON_ZERO = 1;
-
-    /**
-     * Starts segment at a given position.
-     */
-    public static final byte SEG_MOVETO = 0;
-
-    /**
-     * Extends segment by adding a line to a given position.
-     */
-    public static final byte SEG_LINETO = 1;
-
-    /**
-     * Closes segment at current position.
-     */
-    public static final byte SEG_CLOSE = 2;
-
-    /**
-     * Joins path segments by extending their outside edges until they meet.
-     */
-    public final static int JOIN_MITER = 0;
-
-    /**
-     * Joins path segments by rounding off the corner at a radius of half the
-     * line width.
-     */
-    public final static int JOIN_ROUND = 1;
-
-    /**
-     * Joins path segments by connecting the outer corners of their wide
-     * outlines with a straight segment.
-     */
-    public final static int JOIN_BEVEL = 2;
-
-    /**
-     * Ends unclosed subpaths and dash segments with no added decoration.
-     */
-    public final static int CAP_BUTT = 0;
-
-    /**
-     * Ends unclosed subpaths and dash segments with a round decoration that has
-     * a radius equal to half of the width of the pen.
-     */
-    public final static int CAP_ROUND = 1;
-
-    /**
-     * Ends unclosed subpaths and dash segments with a square projection that
-     * extends beyond the end of the segment to a distance equal to half of the
-     * line width.
-     */
-    public final static int CAP_SQUARE = 2;
-
-    private static PMatrix2D identity = new PMatrix2D();
-
-    private static float defaultMiterlimit = 10.0f;
-
-    static final int INIT_SIZE = 20;
-
-    static final int EXPAND_MAX = 500;
-
-    protected byte[] pointTypes;
-
-    protected float[] floatCoords;
-
-    protected int[] pointColors;
-
-    protected int numTypes;
-
-    protected int numCoords;
-
-    protected int windingRule;
-
-    /**
-     * Constructs a new empty single precision {@code LinePath} object with a
-     * default winding rule of {@link #WIND_NON_ZERO}.
-     */
-    public LinePath() {
-        this(WIND_NON_ZERO, INIT_SIZE);
+  /**
+   * The winding rule constant for specifying an even-odd rule
+   * for determining the interior of a path.
+   * The even-odd rule specifies that a point lies inside the
+   * path if a ray drawn in any direction from that point to
+   * infinity is crossed by path segments an odd number of times.
+   */
+  public static final int WIND_EVEN_ODD       = 0;
+
+  /**
+   * The winding rule constant for specifying a non-zero rule
+   * for determining the interior of a path.
+   * The non-zero rule specifies that a point lies inside the
+   * path if a ray drawn in any direction from that point to
+   * infinity is crossed by path segments a different number
+   * of times in the counter-clockwise direction than the
+   * clockwise direction.
+   */
+  public static final int WIND_NON_ZERO       = 1;
+
+  /**
+   * Starts segment at a given position.
+   */
+  public static final byte SEG_MOVETO  = 0;
+
+  /**
+   * Extends segment by adding a line to a given position.
+   */
+  public static final byte SEG_LINETO = 1;
+
+  /**
+   * Closes segment at current position.
+   */
+  public static final byte SEG_CLOSE = 2;
+
+  /**
+   * Joins path segments by extending their outside edges until they meet.
+   */
+  public final static int JOIN_MITER = 0;
+
+  /**
+   * Joins path segments by rounding off the corner at a radius of half the line
+   * width.
+   */
+  public final static int JOIN_ROUND = 1;
+
+  /**
+   * Joins path segments by connecting the outer corners of their wide outlines
+   * with a straight segment.
+   */
+  public final static int JOIN_BEVEL = 2;
+
+  /**
+   * Ends unclosed subpaths and dash segments with no added decoration.
+   */
+  public final static int CAP_BUTT = 0;
+
+  /**
+   * Ends unclosed subpaths and dash segments with a round decoration that has a
+   * radius equal to half of the width of the pen.
+   */
+  public final static int CAP_ROUND = 1;
+
+  /**
+   * Ends unclosed subpaths and dash segments with a square projection that
+   * extends beyond the end of the segment to a distance equal to half of the
+   * line width.
+   */
+  public final static int CAP_SQUARE = 2;
+
+  private static PMatrix2D identity = new PMatrix2D();
+
+  private static float defaultMiterlimit = 10.0f;
+
+  static final int INIT_SIZE = 20;
+
+  static final int EXPAND_MAX = 500;
+
+  protected byte[] pointTypes;
+
+  protected float[] floatCoords;
+
+  protected int[] pointColors;
+
+  protected int numTypes;
+
+  protected int numCoords;
+
+  protected int windingRule;
+
+
+  /**
+   * Constructs a new empty single precision {@code LinePath} object with a
+   * default winding rule of {@link #WIND_NON_ZERO}.
+   */
+  public LinePath() {
+    this(WIND_NON_ZERO, INIT_SIZE);
+  }
+
+
+  /**
+   * Constructs a new empty single precision {@code LinePath} object with the
+   * specified winding rule to control operations that require the interior of
+   * the path to be defined.
+   *
+   * @param rule
+   *          the winding rule
+   * @see #WIND_EVEN_ODD
+   * @see #WIND_NON_ZERO
+   */
+  public LinePath(int rule) {
+    this(rule, INIT_SIZE);
+  }
+
+
+  /**
+   * Constructs a new {@code LinePath} object from the given specified initial
+   * values. This method is only intended for internal use and should not be
+   * made public if the other constructors for this class are ever exposed.
+   *
+   * @param rule
+   *          the winding rule
+   * @param initialCapacity
+   *          the size to make the initial array to store the path segment types
+   */
+  public LinePath(int rule, int initialCapacity) {
+    setWindingRule(rule);
+    this.pointTypes = new byte[initialCapacity];
+    floatCoords = new float[initialCapacity * 2];
+    pointColors = new int[initialCapacity];
+  }
+
+
+  void needRoom(boolean needMove, int newPoints) {
+    if (needMove && numTypes == 0) {
+      throw new RuntimeException("missing initial moveto "
+        + "in path definition");
     }
-
-    /**
-     * Constructs a new empty single precision {@code LinePath} object with the
-     * specified winding rule to control operations that require the interior of
-     * the path to be defined.
-     *
-     * @param rule the winding rule
-     * @see #WIND_EVEN_ODD
-     * @see #WIND_NON_ZERO
-     */
-    public LinePath(int rule) {
-        this(rule, INIT_SIZE);
+    int size = pointTypes.length;
+    if (numTypes >= size) {
+      int grow = size;
+      if (grow > EXPAND_MAX) {
+        grow = EXPAND_MAX;
+      }
+      pointTypes = copyOf(pointTypes, size + grow);
     }
-
-    /**
-     * Constructs a new {@code LinePath} object from the given specified initial
-     * values. This method is only intended for internal use and should not be
-     * made public if the other constructors for this class are ever exposed.
-     *
-     * @param rule the winding rule
-     * @param initialCapacity the size to make the initial array to store the
-     * path segment types
-     */
-    public LinePath(int rule, int initialCapacity) {
-        setWindingRule(rule);
-        this.pointTypes = new byte[initialCapacity];
-        floatCoords = new float[initialCapacity * 2];
-        pointColors = new int[initialCapacity];
+    size = floatCoords.length;
+    if (numCoords + newPoints * 2 > size) {
+      int grow = size;
+      if (grow > EXPAND_MAX * 2) {
+        grow = EXPAND_MAX * 2;
+      }
+      if (grow < newPoints * 2) {
+        grow = newPoints * 2;
+      }
+      floatCoords = copyOf(floatCoords, size + grow);
     }
-
-    void needRoom(boolean needMove, int newPoints) {
-        if (needMove && numTypes == 0) {
-            throw new RuntimeException("missing initial moveto "
-                    + "in path definition");
-        }
-        int size = pointTypes.length;
-        if (numTypes >= size) {
-            int grow = size;
-            if (grow > EXPAND_MAX) {
-                grow = EXPAND_MAX;
-            }
-            pointTypes = copyOf(pointTypes, size + grow);
-        }
-        size = floatCoords.length;
-        if (numCoords + newPoints * 2 > size) {
-            int grow = size;
-            if (grow > EXPAND_MAX * 2) {
-                grow = EXPAND_MAX * 2;
-            }
-            if (grow < newPoints * 2) {
-                grow = newPoints * 2;
-            }
-            floatCoords = copyOf(floatCoords, size + grow);
-        }
-        size = pointColors.length;
-        if (numCoords / 2 + newPoints > size) {
-            int grow = size;
-            if (grow > EXPAND_MAX) {
-                grow = EXPAND_MAX;
-            }
-            if (grow < newPoints) {
-                grow = newPoints;
-            }
-            pointColors = copyOf(pointColors, size + grow);
-        }
+    size = pointColors.length;
+    if (numCoords/2 + newPoints > size) {
+      int grow = size;
+      if (grow > EXPAND_MAX) {
+        grow = EXPAND_MAX;
+      }
+      if (grow < newPoints) {
+        grow = newPoints;
+      }
+      pointColors = copyOf(pointColors, size + grow);
     }
-
-    /**
-     * Adds a point to the path by moving to the specified coordinates specified
-     * in float precision.
-     * <p>
-     * 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, int c) {
-        if (numTypes > 0 && pointTypes[numTypes - 1] == SEG_MOVETO) {
-            floatCoords[numCoords - 2] = x;
-            floatCoords[numCoords - 1] = y;
-            pointColors[numCoords / 2 - 1] = c;
-        } else {
-            needRoom(false, 1);
-            pointTypes[numTypes++] = SEG_MOVETO;
-            floatCoords[numCoords++] = x;
-            floatCoords[numCoords++] = y;
-            pointColors[numCoords / 2 - 1] = c;
-        }
+  }
+
+
+  /**
+   * Adds a point to the path by moving to the specified coordinates specified
+   * in float precision.
+   * <p>
+   * 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
+   * @param c
+   * @see LinePath#moveTo
+   */
+  public final void moveTo(float x, float y, int c) {
+    if (numTypes > 0 && pointTypes[numTypes - 1] == SEG_MOVETO) {
+      floatCoords[numCoords - 2] = x;
+      floatCoords[numCoords - 1] = y;
+      pointColors[numCoords/2-1] = c;
+    } else {
+      needRoom(false, 1);
+      pointTypes[numTypes++] = SEG_MOVETO;
+      floatCoords[numCoords++] = x;
+      floatCoords[numCoords++] = y;
+      pointColors[numCoords/2-1] = c;
+    }
+  }
+
+
+  /**
+   * Adds a point to the path by drawing a straight line from the current
+   * coordinates to the new specified coordinates specified in float precision.
+   * <p>
+   * 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
+   * @param c
+   * @see LinePath#lineTo
+   */
+  public final void lineTo(float x, float y, int c) {
+    needRoom(true, 1);
+    pointTypes[numTypes++] = SEG_LINETO;
+    floatCoords[numCoords++] = x;
+    floatCoords[numCoords++] = y;
+    pointColors[numCoords/2-1] = c;
+  }
+
+
+  /**
+   * 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.
+   * @return 
+   */
+  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;
+  }
 
-    /**
-     * Adds a point to the path by drawing a straight line from the current
-     * coordinates to the new specified coordinates specified in float
-     * precision.
-     * <p>
-     * 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, int c) {
-        needRoom(true, 1);
-        pointTypes[numTypes++] = SEG_LINETO;
-        floatCoords[numCoords++] = x;
-        floatCoords[numCoords++] = y;
-        pointColors[numCoords / 2 - 1] = c;
+
+  /**
+   * 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;
+
+    int colorIdx;
+
+    LinePath path;
+
+    static final int[] curvecoords = { 2, 2, 0 };
+
+    PathIterator(LinePath p2df) {
+      this.path = p2df;
+      this.floatCoords = p2df.floatCoords;
+      pointIdx = 0;
+      colorIdx = 0;
     }
 
-    /**
-     * 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);
+    public int currentSegment(float[] coords) {
+      int type = path.pointTypes[typeIdx];
+      int numCoords = curvecoords[type];
+      if (numCoords > 0) {
+        System.arraycopy(floatCoords, pointIdx, coords, 0, numCoords);
+        int color = path.pointColors[colorIdx];
+        coords[numCoords + 0] = (color >> 24) & 0xFF;
+        coords[numCoords + 1] = (color >> 16) & 0xFF;
+        coords[numCoords + 2] = (color >>  8) & 0xFF;
+        coords[numCoords + 3] = (color) & 0xFF;
+      }
+      return type;
     }
 
-    /**
-     * 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;
+    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];
         }
+        int color = path.pointColors[colorIdx];
+        coords[numCoords + 0] = (color >> 24) & 0xFF;
+        coords[numCoords + 1] = (color >> 16) & 0xFF;
+        coords[numCoords + 2] = (color >>  8) & 0xFF;
+        coords[numCoords + 3] = (color) & 0xFF;
+      }
+      return type;
     }
 
-    /**
-     * 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;
+    public int getWindingRule() {
+      return path.getWindingRule();
     }
 
-    /**
-     * 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;
+    public boolean isDone() {
+      return (typeIdx >= path.numTypes);
     }
 
-    /**
-     * 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;
+    public void next() {
+      int type = path.pointTypes[typeIdx++];
+      if (0 < curvecoords[type]) {
+        pointIdx += curvecoords[type];
+        colorIdx++;
+      }
+    }
+  }
+
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // 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 <code>LinePath</code> with the specified attributes.
+   *
+   * @param src
+   *          the original path to be stroked
+   * @param weight
+   *          the weight of the stroked path
+   * @param caps
+   *          the decoration of the ends of the segments in the path
+   * @param join
+   *          the decoration applied where path segments meet
+   * @param miterlimit
+   * @param transform
+   * @return 
+   *
+   */
+  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, int c0) {
+        dest.moveTo(S15_16ToFloat(x0), S15_16ToFloat(y0), c0);
+      }
+
+      @Override
+      public void lineJoin() {
+      }
+
+      @Override
+      public void lineTo(int x1, int y1, int c1) {
+        dest.lineTo(S15_16ToFloat(x1), S15_16ToFloat(y1), c1);
+      }
+
+      @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[6];
+    while (!pi.isDone()) {
+      int color;
+      switch (pi.currentSegment(coords)) {
+      case SEG_MOVETO:
+        color = ((int)coords[2]<<24) |
+                ((int)coords[3]<<16) |
+                ((int)coords[4]<< 8) |
+                 (int)coords[5];
+        lsink.moveTo(FloatToS15_16(coords[0]), FloatToS15_16(coords[1]), color);
+        break;
+      case SEG_LINETO:
+        color = ((int)coords[2]<<24) |
+                ((int)coords[3]<<16) |
+                ((int)coords[4]<< 8) |
+                 (int)coords[5];
+        lsink.lineJoin();
+        lsink.lineTo(FloatToS15_16(coords[0]), FloatToS15_16(coords[1]), color);
+        break;
+      case SEG_CLOSE:
+        lsink.lineJoin();
+        lsink.close();
+        break;
+      default:
+        throw new InternalError("unknown flattened segment type");
+      }
+      pi.next();
     }
+    lsink.end();
+  }
 
-    static public class PathIterator {
 
-        float floatCoords[];
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // Utility methods
 
-        int typeIdx;
 
-        int pointIdx;
+  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;
+  }
 
-        int colorIdx;
 
-        LinePath path;
+  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;
+  }
 
-        static final int curvecoords[] = {2, 2, 0};
 
-        PathIterator(LinePath p2df) {
-            this.path = p2df;
-            this.floatCoords = p2df.floatCoords;
-            pointIdx = 0;
-            colorIdx = 0;
-        }
+  public static int[] copyOf(int[] source, int length) {
+    int[] target = new int[length];
+    for (int i = 0; i < target.length; i++) {
+      if (i > source.length - 1)
+        target[i] = 0;
+      else
+        target[i] = source[i];
+    }
+    return target;
+  }
 
-        public int currentSegment(float[] coords) {
-            int type = path.pointTypes[typeIdx];
-            int numCoords = curvecoords[type];
-            if (numCoords > 0) {
-                System.arraycopy(floatCoords, pointIdx, coords, 0, numCoords);
-                int color = path.pointColors[colorIdx];
-                coords[numCoords + 0] = (color >> 24) & 0xFF;
-                coords[numCoords + 1] = (color >> 16) & 0xFF;
-                coords[numCoords + 2] = (color >> 8) & 0xFF;
-                coords[numCoords + 3] = (color >> 0) & 0xFF;
-            }
-            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];
-                }
-                int color = path.pointColors[colorIdx];
-                coords[numCoords + 0] = (color >> 24) & 0xFF;
-                coords[numCoords + 1] = (color >> 16) & 0xFF;
-                coords[numCoords + 2] = (color >> 8) & 0xFF;
-                coords[numCoords + 3] = (color >> 0) & 0xFF;
-            }
-            return type;
-        }
+  // From Ken Turkowski, _Fixed-Point Square Root_, In Graphics Gems V
+  public static int isqrt(int x) {
+    int fracbits = 16;
 
-        public int getWindingRule() {
-            return path.getWindingRule();
-        }
+    int root = 0;
+    int remHi = 0;
+    int remLo = x;
+    int count = 15 + fracbits / 2;
 
-        public boolean isDone() {
-            return (typeIdx >= path.numTypes);
-        }
+    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);
 
-        public void next() {
-            int type = path.pointTypes[typeIdx++];
-            if (0 < curvecoords[type]) {
-                pointIdx += curvecoords[type];
-                colorIdx++;
-            }
-        }
-    }
+    return root;
+  }
 
-    /////////////////////////////////////////////////////////////////////////////
-    //
-    // 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);
-    }
+  public static long lsqrt(long x) {
+    int fracbits = 16;
 
-    /**
-     * Constructs a solid <code>LinePath</code> with the specified attributes.
-     *
-     * @param src the original path to be stroked
-     * @param weight the weight of the stroked path
-     * @param caps 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, int c0) {
-                dest.moveTo(S15_16ToFloat(x0), S15_16ToFloat(y0), c0);
-            }
-
-            @Override
-            public void lineJoin() {
-            }
-
-            @Override
-            public void lineTo(int x1, int y1, int c1) {
-                dest.lineTo(S15_16ToFloat(x1), S15_16ToFloat(y1), c1);
-            }
-
-            @Override
-            public void close() {
-                dest.closePath();
-            }
-
-            @Override
-            public void end() {
-            }
-        });
-
-        return dest;
-    }
+    long root = 0;
+    long remHi = 0;
+    long remLo = x;
+    int count = 31 + fracbits / 2;
 
-    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);
+    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);
 
-        PathIterator pi = src.getPathIterator();
-        pathTo(pi, lsink);
-    }
+    return root;
+  }
 
-    private static void pathTo(PathIterator pi, LineStroker lsink) {
-        float coords[] = new float[6];
-        while (!pi.isDone()) {
-            int color;
-            switch (pi.currentSegment(coords)) {
-                case SEG_MOVETO:
-                    color = ((int) coords[2] << 24)
-                            | ((int) coords[3] << 16)
-                            | ((int) coords[4] << 8)
-                            | (int) coords[5];
-                    lsink.moveTo(FloatToS15_16(coords[0]), FloatToS15_16(coords[1]), color);
-                    break;
-                case SEG_LINETO:
-                    color = ((int) coords[2] << 24)
-                            | ((int) coords[3] << 16)
-                            | ((int) coords[4] << 8)
-                            | (int) coords[5];
-                    lsink.lineJoin();
-                    lsink.lineTo(FloatToS15_16(coords[0]), FloatToS15_16(coords[1]), color);
-                    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 double hypot(double x, double y) {
+    return Math.sqrt(x * x + y * y);
+  }
 
-    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;
-    }
 
-    public static int[] copyOf(int[] source, int length) {
-        int[] target = new int[length];
-        for (int i = 0; i < target.length; i++) {
-            if (i > source.length - 1) {
-                target[i] = 0;
-            } else {
-                target[i] = source[i];
-            }
-        }
-        return target;
-    }
+  public static int hypot(int x, int y) {
+    return (int) ((lsqrt((long) x * x + (long) y * y) + 128) >> 8);
+  }
 
-    // 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 long hypot(long x, long y) {
+    return (lsqrt(x * x + y * y) + 128) >> 8;
+  }
 
-    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 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);
-    }
+  static float S15_16ToFloat(int fix) {
+    return (fix / 65536f);
+  }
 }