picrate 0.0.2-java

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

@@ -0,0 +1,347 @@
+/* -*- 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
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  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;
+
+
+/**
+ * A matrix is used to define graphical transformations. PMatrix is the common
+ * interface for both the 2D and 3D matrix classes in Processing. A matrix is a
+ * grid of numbers, which can be multiplied by a vector to give another vector.
+ * Multiplying a point by a particular matrix might translate it, rotate it,
+ * or carry out a combination of transformations.
+ *
+ * Multiplying matrices by each other combines their effects; use the
+ * {@code apply} and {@code preApply} methods for this.
+ */
+public interface PMatrix {
+  
+  /**
+   * Make this an identity matrix. Multiplying by it will have no effect.
+   */
+  public void reset();
+  
+  /**
+   * Returns a copy of this PMatrix.
+     * @return 
+   */
+  public PMatrix get();  
+
+  /**
+   * Copies the matrix contents into a float array.
+   * If target is null (or not the correct size), a new array will be created.
+     * @param target
+     * @return 
+   */
+  public float[] get(float[] target);
+  
+  
+  /**
+   * Make this matrix become a copy of src.
+     * @param src
+   */
+  public void set(PMatrix src);
+
+  /**
+   * Set the contents of this matrix to the contents of source. Fills the
+   * matrix left-to-right, starting in the top row.
+     * @param source
+   */
+  public void set(float[] source);
+
+  /**
+   * Set the matrix content to this 2D matrix or its 3D equivalent.
+     * @param m00
+     * @param m01
+     * @param m10
+     * @param m02
+     * @param m12
+     * @param m11
+   */
+  public void set(float m00, float m01, float m02, 
+                  float m10, float m11, float m12);
+
+  /**
+   * Set the matrix content to the 3D matrix supplied, if this matrix is 3D.
+     * @param m00
+     * @param m01
+     * @param m20
+     * @param m02
+     * @param m03
+     * @param m10
+     * @param m12
+     * @param m11
+     * @param m22
+     * @param m33
+     * @param m13
+     * @param m23
+     * @param m30
+     * @param m31
+     * @param m21
+     * @param m32
+   */
+  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);
+
+    /**
+     *
+     * @param tx
+     * @param ty
+     */
+    public void translate(float tx, float ty);
+  
+    /**
+     *
+     * @param tx
+     * @param ty
+     * @param tz
+     */
+    public void translate(float tx, float ty, float tz);
+
+    /**
+     *
+     * @param angle
+     */
+    public void rotate(float angle);
+
+    /**
+     *
+     * @param angle
+     */
+    public void rotateX(float angle);
+
+    /**
+     *
+     * @param angle
+     */
+    public void rotateY(float angle);
+
+    /**
+     *
+     * @param angle
+     */
+    public void rotateZ(float angle);
+
+    /**
+     *
+     * @param angle
+     * @param v0
+     * @param v1
+     * @param v2
+     */
+    public void rotate(float angle, float v0, float v1, float v2);
+
+    /**
+     *
+     * @param s
+     */
+    public void scale(float s);
+
+    /**
+     *
+     * @param sx
+     * @param sy
+     */
+    public void scale(float sx, float sy);
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @param z
+     */
+    public void scale(float x, float y, float z);
+  
+    /**
+     *
+     * @param angle
+     */
+    public void shearX(float angle);
+  
+    /**
+     *
+     * @param angle
+     */
+    public void shearY(float angle);
+
+  /**
+   * Multiply this matrix by another.
+     * @param source
+   */
+  public void apply(PMatrix source);
+
+  /**
+   * Multiply this matrix by another.
+     * @param source
+   */
+  public void apply(PMatrix2D source);
+
+  /**
+   * Multiply this matrix by another.
+     * @param source
+   */
+  public void apply(PMatrix3D source);
+
+  /**
+   * Multiply this matrix by another.
+     * @param n00
+     * @param n11
+     * @param n02
+     * @param n10
+     * @param n01
+     * @param n12
+   */
+  public void apply(float n00, float n01, float n02, 
+                    float n10, float n11, float n12);
+
+  /**
+   * Multiply this matrix by another.
+     * @param n00
+     * @param n32
+     * @param n02
+     * @param n01
+     * @param n21
+     * @param n10
+     * @param n03
+     * @param n11
+     * @param n13
+     * @param n23
+     * @param n22
+     * @param n20
+     * @param n12
+     * @param n31
+     * @param n30
+     * @param n33
+   */
+  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);
+
+  /**
+   * Apply another matrix to the left of this one.
+     * @param left
+   */
+  public void preApply(PMatrix left);
+
+  /**
+   * Apply another matrix to the left of this one.
+     * @param left
+   */
+  public void preApply(PMatrix2D left);
+
+  /**
+   * Apply another matrix to the left of this one. 3D only.
+     * @param left
+   */
+  public void preApply(PMatrix3D left);
+
+  /**
+   * Apply another matrix to the left of this one.
+     * @param n00
+     * @param n12
+     * @param n02
+     * @param n10
+     * @param n01
+     * @param n11
+   */
+  public void preApply(float n00, float n01, float n02, 
+                       float n10, float n11, float n12);
+
+  /**
+   * Apply another matrix to the left of this one. 3D only.
+     * @param n00
+     * @param n10
+     * @param n02
+     * @param n01
+     * @param n33
+     * @param n13
+     * @param n11
+     * @param n03
+     * @param n20
+     * @param n21
+     * @param n12
+     * @param n30
+     * @param n23
+     * @param n22
+     * @param n32
+     * @param n31
+   */
+  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);
+
+  
+  /**
+   * Multiply source by this matrix, and return the result.
+   * The result will be stored in target if target is non-null, and target
+   * will then be the matrix returned. This improves performance if you reuse
+   * target, so it's recommended if you call this many times in draw().
+     * @param source
+     * @param target
+     * @return 
+   */
+  public PVector mult(PVector source, PVector target);
+  
+  
+  /**
+   * Multiply a multi-element vector against this matrix.
+   * Supplying and recycling a target array improves performance, so it's
+   * recommended if you call this many times in draw().
+     * @param source
+     * @param target
+     * @return 
+   */
+  public float[] mult(float[] source, float[] target);
+  
+  
+//  public float multX(float x, float y);
+//  public float multY(float x, float y);
+  
+//  public float multX(float x, float y, float z);
+//  public float multY(float x, float y, float z);
+//  public float multZ(float x, float y, float z);  
+  
+  
+  /**
+   * Transpose this matrix; rows become columns and columns rows.
+   */
+  public void transpose();
+
+  
+  /**
+   * Invert this matrix. Will not necessarily succeed, because some matrices
+   * map more than one point to the same image point, and so are irreversible.
+   * @return true if successful
+   */
+  public boolean invert();
+  
+  
+  /**
+   * @return the determinant of the matrix
+   */
+  public float determinant();
+}

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

@@ -0,0 +1,694 @@
+/* -*- 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
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  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()}.
+ * <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.
+ */
+public class PMatrix2D implements PMatrix {
+
+    /**
+     *
+     */
+    public float m00,
+
+    /**
+     *
+     */
+    m01,
+
+    /**
+     *
+     */
+    m02;
+
+    /**
+     *
+     */
+    public float m10,
+
+    /**
+     *
+     */
+    m11,
+
+    /**
+     *
+     */
+    m12;
+
+
+  /**
+   * Create a new matrix, set to the identity matrix.
+   */
+  public PMatrix2D() {
+    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) {
+    set(m00, m01, m02,
+        m10, m11, m12);
+  }
+
+    /**
+     *
+     * @param matrix
+     */
+    public PMatrix2D(PMatrix matrix) {
+    set(matrix);
+  }
+
+
+  public void reset() {
+    set(1, 0, 0,
+        0, 1, 0);
+  }
+
+
+  /**
+   * Returns a copy of this PMatrix.
+     * @return 
+   */
+  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 
+   */
+  public float[] get(float[] target) {
+    if ((target == null) || (target.length != 6)) {
+      target = new float[6];
+    }
+    target[0] = m00;
+    target[1] = m01;
+    target[2] = m02;
+
+    target[3] = m10;
+    target[4] = m11;
+    target[5] = m12;
+
+    return target;
+  }
+
+
+  /**
+   * If matrix is a PMatrix2D, sets this matrix to be a copy of it.
+     * @param matrix
+   * @throws IllegalArgumentException If <tt>matrix</tt> is not 2D.
+   */
+  public 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);
+    } else {
+      throw new IllegalArgumentException("PMatrix2D.set() only accepts PMatrix2D objects.");
+    }
+  }
+
+
+  /**
+   * Unavailable in 2D. Does nothing.
+     * @param src
+   */
+  public void set(PMatrix3D src) {
+  }
+
+
+  public void set(float[] source) {
+    m00 = source[0];
+    m01 = source[1];
+    m02 = source[2];
+
+    m10 = source[3];
+    m11 = source[4];
+    m12 = source[5];
+  }
+
+
+  /**
+   * Sets the matrix content.
+     * @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;
+  }
+
+
+  /**
+   * 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
+   */
+  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) {
+
+  }
+
+    /**
+     *
+     * @param tx
+     * @param ty
+     */
+    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
+   * @throws IllegalArgumentException
+   */
+  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
+     */
+  public void rotate(float angle) {
+    float s = sin(angle);
+    float c = cos(angle);
+
+    float temp1 = m00;
+    float temp2 = m01;
+    m00 =  c * temp1 + s * temp2;
+    m01 = -s * temp1 + c * temp2;
+    temp1 = m10;
+    temp2 = m11;
+    m10 =  c * temp1 + s * temp2;
+    m11 = -s * temp1 + c * temp2;
+  }
+
+
+  /**
+   * Unavailable in 2D.
+     * @param angle
+   * @throws IllegalArgumentException
+   */
+  public void rotateX(float angle) {
+    throw new IllegalArgumentException("Cannot use rotateX() on a PMatrix2D.");
+  }
+
+
+  /**
+   * Unavailable in 2D.
+     * @param angle
+   * @throws IllegalArgumentException
+   */
+  public void rotateY(float angle) {
+    throw new IllegalArgumentException("Cannot use rotateY() on a PMatrix2D.");
+  }
+
+    /**
+     *
+     * @param angle
+     */
+    public void rotateZ(float angle) {
+    rotate(angle);
+  }
+
+
+  /**
+   * Unavailable in 2D.
+     * @param angle
+     * @param v0
+     * @param v1
+     * @param v2
+   * @throws IllegalArgumentException
+   */
+  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) {
+    scale(s, s);
+  }
+
+    /**
+     *
+     * @param sx
+     * @param sy
+     */
+    public void scale(float sx, float sy) {
+    m00 *= sx;  m01 *= sy;
+    m10 *= sx;  m11 *= sy;
+  }
+
+
+  /**
+   * Unavailable in 2D.
+     * @param x
+     * @param y
+     * @param z
+   * @throws IllegalArgumentException
+   */
+  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
+     */
+    public void shearY(float angle) {
+    apply(1, 0, 1,  0, tan(angle), 0);
+  }
+
+
+  public void apply(PMatrix source) {
+    if (source instanceof PMatrix2D) {
+      apply((PMatrix2D) source);
+    } else if (source instanceof PMatrix3D) {
+      apply((PMatrix3D) source);
+    }
+  }
+
+
+  public void apply(PMatrix2D source) {
+    apply(source.m00, source.m01, source.m02,
+          source.m10, source.m11, source.m12);
+  }
+
+
+  /**
+   * Unavailable in 2D.
+     * @param source
+   * @throws IllegalArgumentException
+   */
+  public void apply(PMatrix3D source) {
+    throw new IllegalArgumentException("Cannot use apply(PMatrix3D) on a PMatrix2D.");
+  }
+
+
+  public void apply(float n00, float n01, float n02,
+                    float n10, float n11, float n12) {
+    float t0 = m00;
+    float t1 = m01;
+    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;
+    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
+   * @throws IllegalArgumentException
+   */
+  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) {
+    throw new IllegalArgumentException("Cannot use this version of apply() on a PMatrix2D.");
+  }
+
+
+  /**
+   * Apply another matrix to the left of this one.
+     * @param source
+   */
+  public void preApply(PMatrix source) {
+    if (source instanceof PMatrix2D) {
+      preApply((PMatrix2D) source);
+    } else if (source instanceof PMatrix3D) {
+      preApply((PMatrix3D) source);
+    }
+  }
+
+
+  public void preApply(PMatrix2D left) {
+    preApply(left.m00, left.m01, left.m02,
+             left.m10, left.m11, left.m12);
+  }
+
+
+  /**
+   * Unavailable in 2D.
+     * @param left
+   * @throws IllegalArgumentException
+   */
+  public void preApply(PMatrix3D left) {
+    throw new IllegalArgumentException("Cannot use preApply(PMatrix3D) on a PMatrix2D.");
+  }
+
+
+  public void preApply(float n00, float n01, float n02,
+                       float n10, float n11, float n12) {
+    float t0 = m02;
+    float t1 = m12;
+    n02 += t0 * n00 + t1 * n01;
+    n12 += t0 * n10 + t1 * n11;
+
+    m02 = n02;
+    m12 = n12;
+
+    t0 = m00;
+    t1 = m10;
+    m00 = t0 * n00 + t1 * n01;
+    m10 = t0 * n10 + t1 * n11;
+
+    t0 = m01;
+    t1 = m11;
+    m01 = t0 * n00 + t1 * n01;
+    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
+   * @throws IllegalArgumentException
+   */
+  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) {
+    throw new IllegalArgumentException("Cannot use this version of preApply() on a PMatrix2D.");
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+
+  /**
+   * {@inheritDoc}
+   * Ignores any z component.
+   */
+  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;
+    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 
+   */
+  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;
+
+      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;
+    }
+
+    return out;
+  }
+
+
+  /**
+   * 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;
+  }
+
+
+  /**
+   * 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;
+  }
+
+
+
+  /**
+   * Unavailable in 2D. Does nothing.
+   */
+  public void transpose() {
+  }
+
+
+  /*
+   * Implementation stolen from OpenJDK.
+   */
+  public boolean invert() {
+    float determinant = determinant();
+    if (Math.abs(determinant) <= Float.MIN_VALUE) {
+      return false;
+    }
+
+    float t00 = m00;
+    float t01 = m01;
+    float t02 = m02;
+    float t10 = m10;
+    float t11 = m11;
+    float t12 = m12;
+
+    m00 =  t11 / determinant;
+    m10 = -t10 / determinant;
+    m01 = -t01 / determinant;
+    m11 =  t00 / determinant;
+    m02 = (t01 * t12 - t11 * t02) / determinant;
+    m12 = (t10 * t02 - t00 * t12) / determinant;
+
+    return true;
+  }
+
+
+  /**
+   * @return the determinant of the matrix
+   */
+  public float determinant() {
+    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))));
+
+    int digits = 1;
+    if (Float.isNaN(big) || Float.isInfinite(big)) {  // avoid infinite loop
+      digits = 5;
+    } else {
+      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(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
+     */
+
+
+  protected boolean isIdentity() {
+    return ((m00 == 1) && (m01 == 0) && (m02 == 0) &&
+            (m10 == 0) && (m11 == 1) && (m12 == 0));
+  }
+
+
+  // TODO make this more efficient, or move into PMatrix2D
+
+    /**
+     *
+     * @return
+     */
+  protected boolean isWarped() {
+    return ((m00 != 1) || (m01 != 0) &&
+            (m10 != 0) || (m11 != 1));
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+
+  static private final float max(float a, float b) {
+    return (a > b) ? a : b;
+  }
+
+  static private final float abs(float a) {
+    return (a < 0) ? -a : a;
+  }
+
+  static private final float sin(float angle) {
+    return (float)Math.sin(angle);
+  }
+
+  static private final float cos(float angle) {
+    return (float)Math.cos(angle);
+  }
+
+  static private final float tan(float angle) {
+    return (float)Math.tan(angle);
+  }
+}