propane 3.4.1-java → 3.7.1-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,40 +24,43 @@
  * 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.
+   * 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;
+  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.
+   * 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;
+  public static final int WIND_NON_ZERO       = 1;
 
   /**
    * Starts segment at a given position.
    */
-  public static final byte SEG_MOVETO = 0;
+  public static final byte SEG_MOVETO  = 0;
 
   /**
    * Extends segment by adding a line to a given position.
@@ -122,6 +127,7 @@ public class LinePath {
 
   protected int windingRule;
 
+
   /**
    * Constructs a new empty single precision {@code LinePath} object with a
    * default winding rule of {@link #WIND_NON_ZERO}.
@@ -130,12 +136,14 @@ public class 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
+   * @param rule
+   *          the winding rule
    * @see #WIND_EVEN_ODD
    * @see #WIND_NON_ZERO
    */
@@ -143,14 +151,16 @@ public class LinePath {
     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
+   * @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);
@@ -159,6 +169,7 @@ public class LinePath {
     pointColors = new int[initialCapacity];
   }
 
+
   void needRoom(boolean needMove, int newPoints) {
     if (needMove && numTypes == 0) {
       throw new RuntimeException("missing initial moveto "
@@ -184,7 +195,7 @@ public class LinePath {
       floatCoords = copyOf(floatCoords, size + grow);
     }
     size = pointColors.length;
-    if (numCoords / 2 + newPoints > size) {
+    if (numCoords/2 + newPoints > size) {
       int grow = size;
       if (grow > EXPAND_MAX) {
         grow = EXPAND_MAX;
@@ -196,6 +207,7 @@ public class LinePath {
     }
   }
 
+
   /**
    * Adds a point to the path by moving to the specified coordinates specified
    * in float precision.
@@ -203,8 +215,10 @@ public class LinePath {
    * 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 x
+   *          the specified X coordinate
+   * @param y
+   *          the specified Y coordinate
    * @param c
    * @see LinePath#moveTo
    */
@@ -212,16 +226,17 @@ public class LinePath {
     if (numTypes > 0 && pointTypes[numTypes - 1] == SEG_MOVETO) {
       floatCoords[numCoords - 2] = x;
       floatCoords[numCoords - 1] = y;
-      pointColors[numCoords / 2 - 1] = c;
+      pointColors[numCoords/2-1] = c;
     } else {
       needRoom(false, 1);
       pointTypes[numTypes++] = SEG_MOVETO;
       floatCoords[numCoords++] = x;
       floatCoords[numCoords++] = y;
-      pointColors[numCoords / 2 - 1] = c;
+      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.
@@ -229,8 +244,10 @@ public class LinePath {
    * 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 x
+   *          the specified X coordinate
+   * @param y
+   *          the specified Y coordinate
    * @param c
    * @see LinePath#lineTo
    */
@@ -239,21 +256,22 @@ public class LinePath {
     pointTypes[numTypes++] = SEG_LINETO;
     floatCoords[numCoords++] = x;
     floatCoords[numCoords++] = y;
-    pointColors[numCoords / 2 - 1] = c;
+    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
+   * 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
@@ -266,6 +284,7 @@ public class LinePath {
     }
   }
 
+
   /**
    * Returns the fill style winding rule.
    *
@@ -278,12 +297,15 @@ public class LinePath {
     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}
+   * @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) {
@@ -294,6 +316,7 @@ public class LinePath {
     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.
@@ -302,9 +325,9 @@ public class LinePath {
     numTypes = numCoords = 0;
   }
 
-  static public class PathIterator {
 
-    float floatCoords[];
+  static public class PathIterator {
+    float[] floatCoords;
 
     int typeIdx;
 
@@ -314,7 +337,7 @@ public class LinePath {
 
     LinePath path;
 
-    static final int[] CURVE_COORDS = {2, 2, 0};
+    static final int[] curvecoords = { 2, 2, 0 };
 
     PathIterator(LinePath p2df) {
       this.path = p2df;
@@ -325,13 +348,13 @@ public class LinePath {
 
     public int currentSegment(float[] coords) {
       int type = path.pointTypes[typeIdx];
-      int numCoords = CURVE_COORDS[type];
+      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 + 2] = (color >>  8) & 0xFF;
         coords[numCoords + 3] = (color) & 0xFF;
       }
       return type;
@@ -339,7 +362,7 @@ public class LinePath {
 
     public int currentSegment(double[] coords) {
       int type = path.pointTypes[typeIdx];
-      int numCoords = CURVE_COORDS[type];
+      int numCoords = curvecoords[type];
       if (numCoords > 0) {
         for (int i = 0; i < numCoords; i++) {
           coords[i] = floatCoords[pointIdx + i];
@@ -347,7 +370,7 @@ public class LinePath {
         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 + 2] = (color >>  8) & 0xFF;
         coords[numCoords + 3] = (color) & 0xFF;
       }
       return type;
@@ -363,41 +386,50 @@ public class LinePath {
 
     public void next() {
       int type = path.pointTypes[typeIdx++];
-      if (0 < CURVE_COORDS[type]) {
-        pointIdx += CURVE_COORDS[type];
+      if (0 < curvecoords[type]) {
+        pointIdx += curvecoords[type];
         colorIdx++;
       }
     }
   }
 
+
   /////////////////////////////////////////////////////////////////////////////
   //
   // Stroked path methods
+
+
   static public LinePath createStrokedPath(LinePath src, float weight,
-    int caps, int join) {
+                                           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) {
+                                           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 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
+   * @return 
    *
    */
   static public LinePath createStrokedPath(LinePath src, float weight,
-    int caps, int join,
-    float miterlimit, PMatrix2D transform) {
+                                           int caps, int join,
+                                           float miterlimit, PMatrix2D transform) {
     final LinePath dest = new LinePath();
 
     strokeTo(src, weight, caps, join, miterlimit, transform, new LineStroker() {
@@ -428,88 +460,93 @@ public class LinePath {
     return dest;
   }
 
+
   private static void strokeTo(LinePath src, float width, int caps, int join,
-    float miterlimit, PMatrix2D transform,
-    LineStroker lsink) {
+                               float miterlimit, PMatrix2D transform,
+                               LineStroker lsink) {
     lsink = new LineStroker(lsink, FloatToS15_16(width), caps, join,
-      FloatToS15_16(miterlimit),
-      transform == null ? identity : transform);
+                            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];
+    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");
+      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) {
+      if (i > source.length - 1)
         target[i] = 0f;
-      } else {
+      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) {
+      if (i > source.length - 1)
         target[i] = 0;
-      } else {
+      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) {
+      if (i > source.length - 1)
         target[i] = 0;
-      } else {
+      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;
@@ -533,6 +570,7 @@ public class LinePath {
     return root;
   }
 
+
   public static long lsqrt(long x) {
     int fracbits = 16;
 
@@ -555,18 +593,22 @@ public class LinePath {
     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)) {
@@ -578,6 +620,7 @@ public class LinePath {
     }
   }
 
+
   static float S15_16ToFloat(int fix) {
     return (fix / 65536f);
   }