picrate 0.7.0-java → 0.8.0-java

data/src/main/java/processing/core/PMatrix2D.java

@@ -1,6 +1,6 @@
 /* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
 
-/*
+ /*
   Part of the Processing project - http://processing.org
 
   Copyright (c) 2005-08 Ben Fry and Casey Reas
@@ -19,56 +19,48 @@
   Public License along with this library; if not, write to the
   Free Software Foundation, Inc., 59 Temple Place, Suite 330,
   Boston, MA  02111-1307  USA
-*/
-
+ */
 package processing.core;
 
-
 /**
- * 3x2 affine matrix implementation.
- * Matrices are used to describe a transformation; see {@link PMatrix} for a
- * general description. This matrix looks like the following when multiplying
- * a vector (x, y) in {@code mult()}.
+ * 3x2 affine matrix implementation. Matrices are used to describe a
+ * transformation; see {@link PMatrix} for a general description. This matrix
+ * looks like the following when multiplying a vector (x, y) in {@code mult()}.
  * <pre>
  * [m00 m01 m02][x]   [m00*x + m01*y + m02*1]   [x']
  * [m10 m11 m12][y] = [m10*x + m11*y + m12*1] = [y']
- * [ 0   0   1 ][1]   [ 0*x  +  0*y  +  1*1 ]   [ 1]</pre>
- * (x', y') is returned. The values in the matrix determine the transformation.
- * They are modified by the various transformation functions.
+ * [ 0   0   1 ][1]   [ 0*x  +  0*y  +  1*1 ]   [ 1]</pre> (x', y') is returned. The values
+ * in the matrix determine the transformation. They are modified by the various
+ * transformation functions.
  */
 public class PMatrix2D implements PMatrix {
 
-    /**
-     *
-     */
-    public float m00,
-
+  /**
+   *
+   */
+  public float m00,
     /**
      *
      */
     m01,
-
     /**
      *
      */
     m02;
 
-    /**
-     *
-     */
-    public float m10,
-
+  /**
+   *
+   */
+  public float m10,
     /**
      *
      */
     m11,
-
     /**
      *
      */
     m12;
 
-
   /**
    * Create a new matrix, set to the identity matrix.
    */
@@ -76,54 +68,56 @@ public class PMatrix2D implements PMatrix {
     reset();
   }
 
-    /**
-     *
-     * @param m00
-     * @param m01
-     * @param m02
-     * @param m10
-     * @param m11
-     * @param m12
-     */
-    public PMatrix2D(float m00, float m01, float m02,
-                   float m10, float m11, float m12) {
+  /**
+   *
+   * @param m00
+   * @param m01
+   * @param m02
+   * @param m10
+   * @param m11
+   * @param m12
+   */
+  public PMatrix2D(float m00, float m01, float m02,
+    float m10, float m11, float m12) {
     set(m00, m01, m02,
-        m10, m11, m12);
+      m10, m11, m12);
   }
 
-    /**
-     *
-     * @param matrix
-     */
-    public PMatrix2D(PMatrix matrix) {
+  /**
+   *
+   * @param matrix
+   */
+  public PMatrix2D(PMatrix matrix) {
     set(matrix);
   }
 
-
-  public void reset() {
+  @Override
+  public final void reset() {
     set(1, 0, 0,
-        0, 1, 0);
+      0, 1, 0);
   }
 
-
   /**
    * Returns a copy of this PMatrix.
-     * @return 
+   *
+   * @return
    */
+  @Override
   public PMatrix2D get() {
     PMatrix2D outgoing = new PMatrix2D();
     outgoing.set(this);
     return outgoing;
   }
 
-
   /**
-   * Copies the matrix contents into a 6 entry float array.
-   * If target is null (or not the correct size), a new array will be created.
-   * Returned in the order {@code {m00, m01, m02, m10, m11, m12}}.
-     * @param target
-     * @return 
+   * Copies the matrix contents into a 6 entry float array. If target is null
+   * (or not the correct size), a new array will be created. Returned in the
+   * order {@code {m00, m01, m02, m10, m11, m12}}.
+   *
+   * @param target
+   * @return
    */
+  @Override
   public float[] get(float[] target) {
     if ((target == null) || (target.length != 6)) {
       target = new float[6];
@@ -139,31 +133,32 @@ public class PMatrix2D implements PMatrix {
     return target;
   }
 
-
   /**
    * If matrix is a PMatrix2D, sets this matrix to be a copy of it.
-     * @param matrix
+   *
+   * @param matrix
    * @throws IllegalArgumentException If <tt>matrix</tt> is not 2D.
    */
-  public void set(PMatrix matrix) {
+  @Override
+  public final void set(PMatrix matrix) {
     if (matrix instanceof PMatrix2D) {
       PMatrix2D src = (PMatrix2D) matrix;
       set(src.m00, src.m01, src.m02,
-          src.m10, src.m11, src.m12);
+        src.m10, src.m11, src.m12);
     } else {
       throw new IllegalArgumentException("PMatrix2D.set() only accepts PMatrix2D objects.");
     }
   }
 
-
   /**
    * Unavailable in 2D. Does nothing.
-     * @param src
+   *
+   * @param src
    */
   public void set(PMatrix3D src) {
   }
 
-
+  @Override
   public void set(float[] source) {
     m00 = source[0];
     m01 = source[1];
@@ -174,180 +169,198 @@ public class PMatrix2D implements PMatrix {
     m12 = source[5];
   }
 
-
   /**
    * Sets the matrix content.
-     * @param m00
-     * @param m01
-     * @param m02
-     * @param m11
-     * @param m10
-     * @param m12
+   *
+   * @param m00
+   * @param m01
+   * @param m02
+   * @param m11
+   * @param m10
+   * @param m12
    */
-  public void set(float m00, float m01, float m02,
-                  float m10, float m11, float m12) {
-    this.m00 = m00; this.m01 = m01; this.m02 = m02;
-    this.m10 = m10; this.m11 = m11; this.m12 = m12;
+  @Override
+  public final void set(float m00, float m01, float m02,
+    float m10, float m11, float m12) {
+    this.m00 = m00;
+    this.m01 = m01;
+    this.m02 = m02;
+    this.m10 = m10;
+    this.m11 = m11;
+    this.m12 = m12;
   }
 
-
   /**
    * Unavailable in 2D. Does nothing.
-     * @param m00
-     * @param m23
-     * @param m02
-     * @param m01
-     * @param m10
-     * @param m12
-     * @param m03
-     * @param m11
-     * @param m20
-     * @param m21
-     * @param m13
-     * @param m31
-     * @param m33
-     * @param m22
-     * @param m30
-     * @param m32
+   *
+   * @param m00
+   * @param m23
+   * @param m02
+   * @param m01
+   * @param m10
+   * @param m12
+   * @param m03
+   * @param m11
+   * @param m20
+   * @param m21
+   * @param m13
+   * @param m31
+   * @param m33
+   * @param m22
+   * @param m30
+   * @param m32
    */
+  @Override
   public void set(float m00, float m01, float m02, float m03,
-                  float m10, float m11, float m12, float m13,
-                  float m20, float m21, float m22, float m23,
-                  float m30, float m31, float m32, float m33) {
+    float m10, float m11, float m12, float m13,
+    float m20, float m21, float m22, float m23,
+    float m30, float m31, float m32, float m33) {
 
   }
 
-    /**
-     *
-     * @param tx
-     * @param ty
-     */
-    public void translate(float tx, float ty) {
-    m02 = tx*m00 + ty*m01 + m02;
-    m12 = tx*m10 + ty*m11 + m12;
+  /**
+   *
+   * @param tx
+   * @param ty
+   */
+  @Override
+  public void translate(float tx, float ty) {
+    m02 = tx * m00 + ty * m01 + m02;
+    m12 = tx * m10 + ty * m11 + m12;
   }
 
-
   /**
    * Unavailable in 2D.
-     * @param x
-     * @param y
-     * @param z
+   *
+   * @param x
+   * @param y
+   * @param z
    * @throws IllegalArgumentException
    */
+  @Override
   public void translate(float x, float y, float z) {
     throw new IllegalArgumentException("Cannot use translate(x, y, z) on a PMatrix2D.");
   }
 
-
   // Implementation roughly based on AffineTransform.
-
-    /**
-     *
-     * @param angle
-     */
+  /**
+   *
+   * @param angle
+   */
+  @Override
   public void rotate(float angle) {
     float s = sin(angle);
     float c = cos(angle);
 
     float temp1 = m00;
     float temp2 = m01;
-    m00 =  c * temp1 + s * temp2;
+    m00 = c * temp1 + s * temp2;
     m01 = -s * temp1 + c * temp2;
     temp1 = m10;
     temp2 = m11;
-    m10 =  c * temp1 + s * temp2;
+    m10 = c * temp1 + s * temp2;
     m11 = -s * temp1 + c * temp2;
   }
 
-
   /**
    * Unavailable in 2D.
-     * @param angle
+   *
+   * @param angle
    * @throws IllegalArgumentException
    */
+  @Override
   public void rotateX(float angle) {
     throw new IllegalArgumentException("Cannot use rotateX() on a PMatrix2D.");
   }
 
-
   /**
    * Unavailable in 2D.
-     * @param angle
+   *
+   * @param angle
    * @throws IllegalArgumentException
    */
+  @Override
   public void rotateY(float angle) {
     throw new IllegalArgumentException("Cannot use rotateY() on a PMatrix2D.");
   }
 
-    /**
-     *
-     * @param angle
-     */
-    public void rotateZ(float angle) {
+  /**
+   *
+   * @param angle
+   */
+  @Override
+  public void rotateZ(float angle) {
     rotate(angle);
   }
 
-
   /**
    * Unavailable in 2D.
-     * @param angle
-     * @param v0
-     * @param v1
-     * @param v2
+   *
+   * @param angle
+   * @param v0
+   * @param v1
+   * @param v2
    * @throws IllegalArgumentException
    */
+  @Override
   public void rotate(float angle, float v0, float v1, float v2) {
     throw new IllegalArgumentException("Cannot use this version of rotate() on a PMatrix2D.");
   }
 
-    /**
-     *
-     * @param s
-     */
-    public void scale(float s) {
+  /**
+   *
+   * @param s
+   */
+  @Override
+  public void scale(float s) {
     scale(s, s);
   }
 
-    /**
-     *
-     * @param sx
-     * @param sy
-     */
-    public void scale(float sx, float sy) {
-    m00 *= sx;  m01 *= sy;
-    m10 *= sx;  m11 *= sy;
+  /**
+   *
+   * @param sx
+   * @param sy
+   */
+  @Override
+  public void scale(float sx, float sy) {
+    m00 *= sx;
+    m01 *= sy;
+    m10 *= sx;
+    m11 *= sy;
   }
 
-
   /**
    * Unavailable in 2D.
-     * @param x
-     * @param y
-     * @param z
+   *
+   * @param x
+   * @param y
+   * @param z
    * @throws IllegalArgumentException
    */
+  @Override
   public void scale(float x, float y, float z) {
     throw new IllegalArgumentException("Cannot use this version of scale() on a PMatrix2D.");
   }
 
-    /**
-     *
-     * @param angle
-     */
-    public void shearX(float angle) {
-    apply(1, 0, 1,  tan(angle), 0, 0);
+  /**
+   *
+   * @param angle
+   */
+  @Override
+  public void shearX(float angle) {
+    apply(1, 0, 1, tan(angle), 0, 0);
   }
 
-    /**
-     *
-     * @param angle
-     */
-    public void shearY(float angle) {
-    apply(1, 0, 1,  0, tan(angle), 0);
+  /**
+   *
+   * @param angle
+   */
+  @Override
+  public void shearY(float angle) {
+    apply(1, 0, 1, 0, tan(angle), 0);
   }
 
-
+  @Override
   public void apply(PMatrix source) {
     if (source instanceof PMatrix2D) {
       apply((PMatrix2D) source);
@@ -356,71 +369,74 @@ public class PMatrix2D implements PMatrix {
     }
   }
 
-
+  @Override
   public void apply(PMatrix2D source) {
     apply(source.m00, source.m01, source.m02,
-          source.m10, source.m11, source.m12);
+      source.m10, source.m11, source.m12);
   }
 
-
   /**
    * Unavailable in 2D.
-     * @param source
+   *
+   * @param source
    * @throws IllegalArgumentException
    */
+  @Override
   public void apply(PMatrix3D source) {
     throw new IllegalArgumentException("Cannot use apply(PMatrix3D) on a PMatrix2D.");
   }
 
-
+  @Override
   public void apply(float n00, float n01, float n02,
-                    float n10, float n11, float n12) {
+    float n10, float n11, float n12) {
     float t0 = m00;
     float t1 = m01;
-    m00  = n00 * t0 + n10 * t1;
-    m01  = n01 * t0 + n11 * t1;
+    m00 = n00 * t0 + n10 * t1;
+    m01 = n01 * t0 + n11 * t1;
     m02 += n02 * t0 + n12 * t1;
 
     t0 = m10;
     t1 = m11;
-    m10  = n00 * t0 + n10 * t1;
-    m11  = n01 * t0 + n11 * t1;
+    m10 = n00 * t0 + n10 * t1;
+    m11 = n01 * t0 + n11 * t1;
     m12 += n02 * t0 + n12 * t1;
   }
 
-
   /**
    * Unavailable in 2D.
-     * @param n00
-     * @param n21
-     * @param n02
-     * @param n01
-     * @param n03
-     * @param n11
-     * @param n10
-     * @param n30
-     * @param n23
-     * @param n13
-     * @param n12
-     * @param n22
-     * @param n32
-     * @param n20
-     * @param n31
-     * @param n33
+   *
+   * @param n00
+   * @param n21
+   * @param n02
+   * @param n01
+   * @param n03
+   * @param n11
+   * @param n10
+   * @param n30
+   * @param n23
+   * @param n13
+   * @param n12
+   * @param n22
+   * @param n32
+   * @param n20
+   * @param n31
+   * @param n33
    * @throws IllegalArgumentException
    */
+  @Override
   public void apply(float n00, float n01, float n02, float n03,
-                    float n10, float n11, float n12, float n13,
-                    float n20, float n21, float n22, float n23,
-                    float n30, float n31, float n32, float n33) {
+    float n10, float n11, float n12, float n13,
+    float n20, float n21, float n22, float n23,
+    float n30, float n31, float n32, float n33) {
     throw new IllegalArgumentException("Cannot use this version of apply() on a PMatrix2D.");
   }
 
-
   /**
    * Apply another matrix to the left of this one.
-     * @param source
+   *
+   * @param source
    */
+  @Override
   public void preApply(PMatrix source) {
     if (source instanceof PMatrix2D) {
       preApply((PMatrix2D) source);
@@ -429,25 +445,26 @@ public class PMatrix2D implements PMatrix {
     }
   }
 
-
+  @Override
   public void preApply(PMatrix2D left) {
     preApply(left.m00, left.m01, left.m02,
-             left.m10, left.m11, left.m12);
+      left.m10, left.m11, left.m12);
   }
 
-
   /**
    * Unavailable in 2D.
-     * @param left
+   *
+   * @param left
    * @throws IllegalArgumentException
    */
+  @Override
   public void preApply(PMatrix3D left) {
     throw new IllegalArgumentException("Cannot use preApply(PMatrix3D) on a PMatrix2D.");
   }
 
-
+  @Override
   public void preApply(float n00, float n01, float n02,
-                       float n10, float n11, float n12) {
+    float n10, float n11, float n12) {
     float t0 = m02;
     float t1 = m12;
     n02 += t0 * n00 + t1 * n01;
@@ -467,109 +484,107 @@ public class PMatrix2D implements PMatrix {
     m11 = t0 * n10 + t1 * n11;
   }
 
-
   /**
    * Unavailable in 2D.
-     * @param n00
-     * @param n01
-     * @param n03
-     * @param n02
-     * @param n10
-     * @param n12
-     * @param n21
-     * @param n13
-     * @param n11
-     * @param n30
-     * @param n23
-     * @param n20
-     * @param n32
-     * @param n22
-     * @param n31
-     * @param n33
+   *
+   * @param n00
+   * @param n01
+   * @param n03
+   * @param n02
+   * @param n10
+   * @param n12
+   * @param n21
+   * @param n13
+   * @param n11
+   * @param n30
+   * @param n23
+   * @param n20
+   * @param n32
+   * @param n22
+   * @param n31
+   * @param n33
    * @throws IllegalArgumentException
    */
+  @Override
   public void preApply(float n00, float n01, float n02, float n03,
-                       float n10, float n11, float n12, float n13,
-                       float n20, float n21, float n22, float n23,
-                       float n30, float n31, float n32, float n33) {
+    float n10, float n11, float n12, float n13,
+    float n20, float n21, float n22, float n23,
+    float n30, float n31, float n32, float n33) {
     throw new IllegalArgumentException("Cannot use this version of preApply() on a PMatrix2D.");
   }
 
-
   //////////////////////////////////////////////////////////////
-
-
   /**
-   * {@inheritDoc}
-   * Ignores any z component.
+   * {@inheritDoc} Ignores any z component.
    */
+  @Override
   public PVector mult(PVector source, PVector target) {
     if (target == null) {
       target = new PVector();
     }
-    target.x = m00*source.x + m01*source.y + m02;
-    target.y = m10*source.x + m11*source.y + m12;
+    target.x = m00 * source.x + m01 * source.y + m02;
+    target.y = m10 * source.x + m11 * source.y + m12;
     return target;
   }
 
-
   /**
-   * Multiply a two element vector against this matrix.
-   * If out is null or not length four, a new float array will be returned.
-   * The values for vec and out can be the same (though that's less efficient).
-     * @param vec
-     * @param out
-     * @return 
+   * Multiply a two element vector against this matrix. If out is null or not
+   * length four, a new float array will be returned. The values for vec and out
+   * can be the same (though that's less efficient).
+   *
+   * @param vec
+   * @param out
+   * @return
    */
+  @Override
   public float[] mult(float vec[], float out[]) {
     if (out == null || out.length != 2) {
       out = new float[2];
     }
 
     if (vec == out) {
-      float tx = m00*vec[0] + m01*vec[1] + m02;
-      float ty = m10*vec[0] + m11*vec[1] + m12;
+      float tx = m00 * vec[0] + m01 * vec[1] + m02;
+      float ty = m10 * vec[0] + m11 * vec[1] + m12;
 
       out[0] = tx;
       out[1] = ty;
 
     } else {
-      out[0] = m00*vec[0] + m01*vec[1] + m02;
-      out[1] = m10*vec[0] + m11*vec[1] + m12;
+      out[0] = m00 * vec[0] + m01 * vec[1] + m02;
+      out[1] = m10 * vec[0] + m11 * vec[1] + m12;
     }
 
     return out;
   }
 
-
   /**
-   * Returns the x-coordinate of the result of multiplying the point (x, y)
-   * by this matrix.
-     * @param x
-     * @param y
-     * @return 
+   * Returns the x-coordinate of the result of multiplying the point (x, y) by
+   * this matrix.
+   *
+   * @param x
+   * @param y
+   * @return
    */
   public float multX(float x, float y) {
-    return m00*x + m01*y + m02;
+    return m00 * x + m01 * y + m02;
   }
 
-
   /**
-   * Returns the y-coordinate of the result of multiplying the point (x, y)
-   * by this matrix.
-     * @param x
-     * @param y
-     * @return 
+   * Returns the y-coordinate of the result of multiplying the point (x, y) by
+   * this matrix.
+   *
+   * @param x
+   * @param y
+   * @return
    */
   public float multY(float x, float y) {
-    return m10*x + m11*y + m12;
+    return m10 * x + m11 * y + m12;
   }
 
-
-
   /**
    * Unavailable in 2D. Does nothing.
    */
+  @Override
   public void transpose() {
   }
 
@@ -577,6 +592,7 @@ public class PMatrix2D implements PMatrix {
   /*
    * Implementation stolen from OpenJDK.
    */
+  @Override
   public boolean invert() {
     float determinant = determinant();
     if (Math.abs(determinant) <= Float.MIN_VALUE) {
@@ -590,17 +606,16 @@ public class PMatrix2D implements PMatrix {
     float t11 = m11;
     float t12 = m12;
 
-    m00 =  t11 / determinant;
+    m00 = t11 / determinant;
     m10 = -t10 / determinant;
     m01 = -t01 / determinant;
-    m11 =  t00 / determinant;
+    m11 = t00 / determinant;
     m02 = (t01 * t12 - t11 * t02) / determinant;
     m12 = (t10 * t02 - t00 * t12) / determinant;
 
     return true;
   }
 
-
   /**
    * @return the determinant of the matrix
    */
@@ -608,87 +623,75 @@ public class PMatrix2D implements PMatrix {
     return m00 * m11 - m01 * m10;
   }
 
-
   //////////////////////////////////////////////////////////////
-
-    /**
-     *
-     */
-
-
+  /**
+   *
+   */
   public void print() {
     int big = (int) abs(max(PApplet.max(abs(m00), abs(m01), abs(m02)),
-                            PApplet.max(abs(m10), abs(m11), abs(m12))));
+      PApplet.max(abs(m10), abs(m11), abs(m12))));
 
     int digits = 1;
     if (Float.isNaN(big) || Float.isInfinite(big)) {  // avoid infinite loop
       digits = 5;
     } else {
-      while ((big /= 10) != 0) digits++;  // cheap log()
+      while ((big /= 10) != 0) {
+        digits++;  // cheap log()
+      }
     }
 
-    System.out.println(PApplet.nfs(m00, digits, 4) + " " +
-                       PApplet.nfs(m01, digits, 4) + " " +
-                       PApplet.nfs(m02, digits, 4));
+    System.out.println(PApplet.nfs(m00, digits, 4) + " "
+      + PApplet.nfs(m01, digits, 4) + " "
+      + PApplet.nfs(m02, digits, 4));
 
-    System.out.println(PApplet.nfs(m10, digits, 4) + " " +
-                       PApplet.nfs(m11, digits, 4) + " " +
-                       PApplet.nfs(m12, digits, 4));
+    System.out.println(PApplet.nfs(m10, digits, 4) + " "
+      + PApplet.nfs(m11, digits, 4) + " "
+      + PApplet.nfs(m12, digits, 4));
 
     System.out.println();
   }
 
-
   //////////////////////////////////////////////////////////////
-
   // TODO these need to be added as regular API, but the naming and
   // implementation needs to be improved first. (e.g. actually keeping track
   // of whether the matrix is in fact identity internally.)
-
-    /**
-     *
-     * @return
-     */
-
-
+  /**
+   *
+   * @return
+   */
   protected boolean isIdentity() {
-    return ((m00 == 1) && (m01 == 0) && (m02 == 0) &&
-            (m10 == 0) && (m11 == 1) && (m12 == 0));
+    return ((m00 == 1) && (m01 == 0) && (m02 == 0)
+      && (m10 == 0) && (m11 == 1) && (m12 == 0));
   }
 
-
   // TODO make this more efficient, or move into PMatrix2D
-
-    /**
-     *
-     * @return
-     */
+  /**
+   *
+   * @return
+   */
   protected boolean isWarped() {
-    return ((m00 != 1) || (m01 != 0) &&
-            (m10 != 0) || (m11 != 1));
+    return ((m00 != 1) || (m01 != 0)
+      && (m10 != 0) || (m11 != 1));
   }
 
-
   //////////////////////////////////////////////////////////////
-
-
-  static private final float max(float a, float b) {
+  private static float max(float a, float b) {
     return (a > b) ? a : b;
   }
 
-  static private final float abs(float a) {
+  private static float abs(float a) {
     return (a < 0) ? -a : a;
   }
 
-  static private final float sin(float angle) {
-    return (float)Math.sin(angle);
+  private static float sin(float angle) {
+    return (float) Math.sin(angle);
   }
 
-  static private final float cos(float angle) {
-    return (float)Math.cos(angle);
+  private static float cos(float angle) {
+    return (float) Math.cos(angle);
   }
 
-  static private final float tan(float angle) {
-    return (float)Math.tan(angle);
+  private static float tan(float angle) {
+    return (float) Math.tan(angle);
   }
 }