geomerative 1.1.0-java → 2.0.0-java

data/src/geomerative/RMatrix.java

@@ -1,397 +1,412 @@
 /**
-    Copyright 2004-2008 Ricard Marxer  <email@ricardmarxer.com>
-
-    This file is part of Geomerative.
-
-    Geomerative is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    Geomerative 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 General Public License for more details.
-    
-    You should have received a copy of the GNU General Public License
-    along with Geomerative.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package geomerative ;
+ * Copyright 2004-2008 Ricard Marxer  <email@ricardmarxer.com>
+ *
+ * This file is part of Geomerative.
+ *
+ * Geomerative is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later
+ * version.
+ *
+ * Geomerative 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 General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * Geomerative. If not, see <http://www.gnu.org/licenses/>.
+ */
+package geomerative;
 
 import processing.core.PApplet;
 
 /**
- * RMatrix is a very simple interface for creating, holding 3x3 matrices with the most common 2D affine transformations such as translation, rotation, scaling and shearing.  We only have access to the first to rows of the matrix the last row is considered a constant 0, 0, 1 in order to have better performance.
- * @eexample RMatrix
- * @usage Geometry
- * @extended
+ * RMatrix is a very simple interface for creating, holding 3x3 matrices with
+ * the most common 2D affine transformations such as translation, rotation,
+ * scaling and shearing. We only have access to the first to rows of the matrix
+ * the last row is considered a constant 0, 0, 1 in order to have better
+ * performance.
+ *
+ RMatrix
+ * Geometry
+
  */
-public class RMatrix
-{
-  
+public class RMatrix {
+
   float m00 = 1F;
   float m01 = 0F;
   float m02 = 0F;
-  
+
   float m10 = 0F;
   float m11 = 1F;
   float m12 = 0F;
-  
+
   float m20 = 0F;
   float m21 = 0F;
   float m22 = 1F;
-  
+
   /**
    * Create a new matrix given the coefficients.
-   * @eexample RMatrix
-   * @param m00  coefficient 00 of the matrix
-   * @param m01  coefficient 01 of the matrix
-   * @param m02  coefficient 02 of the matrix
-   * @param m10  coefficient 10 of the matrix
-   * @param m11  coefficient 11 of the matrix
-   * @param m12  coefficient 12 of the matrix
-   * @usage Geometry
-   * @related apply ( )
-   * @related translate ( )
-   * @related rotate ( )
-   * @related scale ( )
-   * @related shear ( )
+   *
+   RMatrix
+   * @param m00 coefficient 00 of the matrix
+   * @param m01 coefficient 01 of the matrix
+   * @param m02 coefficient 02 of the matrix
+   * @param m10 coefficient 10 of the matrix
+   * @param m11 coefficient 11 of the matrix
+   * @param m12 coefficient 12 of the matrix
+   * Geometry
+   * apply ( )
+   * translate ( )
+   * rotate ( )
+   * scale ( )
+   * shear ( )
    */
   public RMatrix(float m00, float m01, float m02,
-		 float m10, float m11, float m12)
-  {
+    float m10, float m11, float m12) {
     set(m00, m01, m02,
-        m10, m11, m12);
+      m10, m11, m12);
   }
 
   /**
    * Create a new identity matrix.
-   * @eexample RMatrix
-   * @usage Geometry
-   * @related apply ( )
-   * @related translate ( )
-   * @related rotate ( )
-   * @related scale ( )
-   * @related shear ( )
+   *
+   RMatrix
+   * Geometry
+   * apply ( )
+   * translate ( )
+   * rotate ( )
+   * scale ( )
+   * shear ( )
    */
-  public RMatrix()
-  {
+  public RMatrix() {
     m00 = 1F;
     m01 = 0F;
     m02 = 0F;
-    
+
     m10 = 0F;
     m11 = 1F;
     m12 = 0F;
-  } 
-  
+  }
+
   /**
    * Copy a matrix.
-   * @eexample RMatrix
-   * @param src  source matrix from where to copy the matrix
-   * @usage Geometry
-   * @related apply ( )
-   * @related translate ( )
-   * @related rotate ( )
-   * @related scale ( )
-   * @related shear ( )
+   *
+   RMatrix
+   * @param src source matrix from where to copy the matrix
+   * Geometry
+   * apply ( )
+   * translate ( )
+   * rotate ( )
+   * scale ( )
+   * shear ( )
    */
-  public RMatrix(RMatrix src)
-  {
+  public RMatrix(RMatrix src) {
     set(src.m00, src.m01, src.m02,
-        src.m10, src.m11, src.m12);
+      src.m10, src.m11, src.m12);
   }
-  
-  public RMatrix(String transformationString){
+
+  public RMatrix(String transformationString) {
     String[] transfTokens = PApplet.splitTokens(transformationString, ")");
-    
-      // Loop through all transformations
-      for (String transfToken : transfTokens) {
-          // Check the transformation and the parameters
-          String[] transf = PApplet.splitTokens(transfToken, "(");
-          String[] params = PApplet.splitTokens(transf[1], ", ");
-          float[] fparams = new float[params.length];
-          for(int j=0; j<params.length; j++){
-              fparams[j] = PApplet.parseFloat(params[j]);
-          }   transf[0] = PApplet.trim(transf[0]);
-        switch (transf[0]) {
-            case "translate":
-                if(params.length == 1){
-                    this.translate(fparams[0]);
-                    
-                }else if(params.length == 2){
-                    this.translate(fparams[0], fparams[1]);
-                    
-                } break;
-            case "rotate":
-                if(params.length == 1){
-                    this.rotate(PApplet.radians(fparams[0]));
-                    
-                }else if(params.length == 3){
-                    this.rotate(PApplet.radians(fparams[0]), fparams[1], fparams[2]);
-                    
-                } break;
-            case "scale":
-                if(params.length == 1){
-                    this.scale(fparams[0]);
-                    
-                }else if(params.length == 2){
-                    this.scale(fparams[0], fparams[1]);
-              } break;
-            case "skewX":
-                this.skewX(PApplet.radians(fparams[0]));
-                break;
-            case "skewY":
-                this.skewY(PApplet.radians(fparams[0]));
-                break;
-            case "matrix":
-                this.apply(fparams[0], fparams[2], fparams[4], fparams[1], fparams[3], fparams[5]);
-                break;
-            default:
-                throw new RuntimeException("Transformation unknown. '"+ transf[0]  +"'");
-        }
+
+    // Loop through all transformations
+    for (String transfToken : transfTokens) {
+      // Check the transformation and the parameters
+      String[] transf = PApplet.splitTokens(transfToken, "(");
+      String[] params = PApplet.splitTokens(transf[1], ", ");
+      float[] fparams = new float[params.length];
+      for (int j = 0; j < params.length; j++) {
+        fparams[j] = PApplet.parseFloat(params[j]);
+      }
+      transf[0] = PApplet.trim(transf[0]);
+      switch (transf[0]) {
+        case "translate":
+          if (params.length == 1) {
+            this.translate(fparams[0]);
+
+          } else if (params.length == 2) {
+            this.translate(fparams[0], fparams[1]);
+
+          }
+          break;
+        case "rotate":
+          if (params.length == 1) {
+            this.rotate(PApplet.radians(fparams[0]));
+
+          } else if (params.length == 3) {
+            this.rotate(PApplet.radians(fparams[0]), fparams[1], fparams[2]);
+
+          }
+          break;
+        case "scale":
+          if (params.length == 1) {
+            this.scale(fparams[0]);
+
+          } else if (params.length == 2) {
+            this.scale(fparams[0], fparams[1]);
+          }
+          break;
+        case "skewX":
+          this.skewX(PApplet.radians(fparams[0]));
+          break;
+        case "skewY":
+          this.skewY(PApplet.radians(fparams[0]));
+          break;
+        case "matrix":
+          this.apply(fparams[0], fparams[2], fparams[4], fparams[1], fparams[3], fparams[5]);
+          break;
+        default:
+          throw new RuntimeException("Transformation unknown. '" + transf[0] + "'");
       }
+    }
   }
-  
+
   private void set(float m00, float m01, float m02,
-		   float m10, float m11, float m12)
-  {
+    float m10, float m11, float m12) {
     this.m00 = m00;
     this.m01 = m01;
     this.m02 = m02;
-    
+
     this.m10 = m10;
     this.m11 = m11;
     this.m12 = m12;
   }
-  
+
   /**
-   * Multiply the matrix with another matrix.  This is mostly use to chain transformations.
-   * @eexample RMatrix_apply
-   * @param n00  coefficient 00 of the matrix to be applied
-   * @param n01  coefficient 01 of the matrix to be applied
-   * @param n02  coefficient 02 of the matrix to be applied
-   * @param n10  coefficient 10 of the matrix to be applied
-   * @param n11  coefficient 11 of the matrix to be applied
-   * @param n12  coefficient 12 of the matrix to be applied
-   * @usage Geometry
-   * @related translate ( )
-   * @related rotate ( )
-   * @related scale ( )
-   * @related shear ( )
-   */ 
+   * Multiply the matrix with another matrix. This is mostly use to chain
+   * transformations.
+   *
+   RMatrix_apply
+   * @param n00 coefficient 00 of the matrix to be applied
+   * @param n01 coefficient 01 of the matrix to be applied
+   * @param n02 coefficient 02 of the matrix to be applied
+   * @param n10 coefficient 10 of the matrix to be applied
+   * @param n11 coefficient 11 of the matrix to be applied
+   * @param n12 coefficient 12 of the matrix to be applied
+   * Geometry
+   * translate ( )
+   * rotate ( )
+   * scale ( )
+   * shear ( )
+   */
   public final void apply(float n00, float n01, float n02,
-                    float n10, float n11, float n12) {
-    
-    float r00 = m00*n00 + m01*n10;
-    float r01 = m00*n01 + m01*n11;
-    float r02 = m00*n02 + m01*n12 + m02;
-    
-    float r10 = m10*n00 + m11*n10;
-    float r11 = m10*n01 + m11*n11 ;
-    float r12 = m10*n02 + m11*n12 + m12;
-    
-    m00 = r00; m01 = r01; m02 = r02;
-    m10 = r10; m11 = r11; m12 = r12;
+    float n10, float n11, float n12) {
+
+    float r00 = m00 * n00 + m01 * n10;
+    float r01 = m00 * n01 + m01 * n11;
+    float r02 = m00 * n02 + m01 * n12 + m02;
+
+    float r10 = m10 * n00 + m11 * n10;
+    float r11 = m10 * n01 + m11 * n11;
+    float r12 = m10 * n02 + m11 * n12 + m12;
+
+    m00 = r00;
+    m01 = r01;
+    m02 = r02;
+    m10 = r10;
+    m11 = r11;
+    m12 = r12;
   }
 
   /**
-   * Multiply the matrix with another matrix.  This is mostly use to chain transformations.
-   * @eexample RMatrix_apply
-   * @param rhs  right hand side matrix
-   * @usage Geometry
-   * @related translate ( )
-   * @related rotate ( )
-   * @related scale ( )
-   * @related shear ( )
+   * Multiply the matrix with another matrix. This is mostly use to chain
+   * transformations.
+   *
+   RMatrix_apply
+   * @param rhs right hand side matrix
+   * Geometry
+   * translate ( )
+   * rotate ( )
+   * scale ( )
+   * shear ( )
    */
   public void apply(RMatrix rhs) {
     apply(rhs.m00, rhs.m01, rhs.m02,
-          rhs.m10, rhs.m11, rhs.m12);
-  }  
+      rhs.m10, rhs.m11, rhs.m12);
+  }
 
   /**
    * Apply a translation to the matrix, given the coordinates.
-   * @eexample RMatrix_translate
-   * @param tx  x coordinate translation
-   * @param ty  y coordinate translation
-   * @usage Geometry
-   * @related rotate ( )
-   * @related scale ( )
-   * @related shear ( )
+   *
+   RMatrix_translate
+   * @param tx x coordinate translation
+   * @param ty y coordinate translation
+   * Geometry
+   * rotate ( )
+   * scale ( )
+   * shear ( )
    */
-  public final void translate(float tx, float ty)
-  {
+  public final void translate(float tx, float ty) {
     apply(1, 0, tx, 0, 1, ty);
   }
 
-  public final void translate(float tx)
-  {
+  public final void translate(float tx) {
     translate(tx, 0);
   }
-  
+
   /**
    * Apply a translation to the matrix, given a point.
-   * @eexample RMatrix_translate
-   * @param t  vector translation
-   * @usage Geometry
-   * @related rotate ( )
-   * @related scale ( )
-   * @related shear ( )
+   *
+   RMatrix_translate
+   * @param t vector translation
+   * Geometry
+   * rotate ( )
+   * scale ( )
+   * shear ( )
    */
-  public void translate(RPoint t)
-  {
+  public void translate(RPoint t) {
     translate(t.x, t.y);
   }
-  
+
   /**
-   * Apply a rotation to the matrix, given an angle and optionally a rotation center.
-   * @eexample RPoint_rotate
-   * @usage Geometry
-   * @param angle  the angle of rotation to be applied
-   * @param vx  the x coordinate of the center of rotation
-   * @param vy  the y coordinate of the center of rotation
-   * @related transform ( )
-   * @related translate ( )
-   * @related scale ( )
-   */ 
-  public final void rotate(float angle, float vx, float vy)
-  {
-    translate(vx,vy);
+   * Apply a rotation to the matrix, given an angle and optionally a rotation
+   * center.
+   *
+   RPoint_rotate
+   * Geometry
+   * @param angle the angle of rotation to be applied
+   * @param vx the x coordinate of the center of rotation
+   * @param vy the y coordinate of the center of rotation
+   * transform ( )
+   * translate ( )
+   * scale ( )
+   */
+  public final void rotate(float angle, float vx, float vy) {
+    translate(vx, vy);
     rotate(angle);
-    translate(-vx,-vy);
+    translate(-vx, -vy);
   }
 
-  public final void rotate(float angle)
-  {
-    float c = (float)Math.cos(angle);
-    float s = (float)Math.sin(angle);
-    apply(c, -s, 0,  s, c, 0);
+  public final void rotate(float angle) {
+    float c = (float) Math.cos(angle);
+    float s = (float) Math.sin(angle);
+    apply(c, -s, 0, s, c, 0);
   }
 
   /**
-   * Apply a rotation to the matrix, given an angle and optionally a rotation center.
-   * @eexample RPoint_rotate
-   * @usage Geometry
-   * @param angle  the angle of rotation to be applied
-   * @param v  the position vector of the center of rotation
-   * @related transform ( )
-   * @related translate ( )
-   * @related scale ( )
-   */    
-  public void rotate(float angle, RPoint v)
-  {
+   * Apply a rotation to the matrix, given an angle and optionally a rotation
+   * center.
+   *
+   RPoint_rotate
+   * Geometry
+   * @param angle the angle of rotation to be applied
+   * @param v the position vector of the center of rotation
+   * transform ( )
+   * translate ( )
+   * scale ( )
+   */
+  public void rotate(float angle, RPoint v) {
     rotate(angle, v.x, v.y);
   }
-  
+
   /**
-   * Apply a scale to the matrix, given scaling factors and optionally a scaling center.
-   * @eexample RPoint_scale
-   * @usage Geometry
-   * @param sx  the scaling coefficient over the x axis
-   * @param sy  the scaling coefficient over the y axis
-   * @param x  x coordinate of the position vector of the center of the scaling
-   * @param y  y coordinate of the position vector of the center of the scaling
-   * @related transform ( )
-   * @related translate ( )
-   * @related rotate ( )
+   * Apply a scale to the matrix, given scaling factors and optionally a scaling
+   * center.
+   *
+   RPoint_scale
+   * Geometry
+   * @param sx the scaling coefficient over the x axis
+   * @param sy the scaling coefficient over the y axis
+   * @param x x coordinate of the position vector of the center of the scaling
+   * @param y y coordinate of the position vector of the center of the scaling
+   * transform ( )
+   * translate ( )
+   * rotate ( )
    */
-  public void scale(float sx, float sy, float x, float y)
-  {
-    translate(x,y);
-    scale(sx,sy);
-    translate(-x,-y);
+  public void scale(float sx, float sy, float x, float y) {
+    translate(x, y);
+    scale(sx, sy);
+    translate(-x, -y);
   }
 
-  public final void scale(float sx, float sy)
-  {
-    apply(sx, 0, 0,  0, sy, 0);
+  public final void scale(float sx, float sy) {
+    apply(sx, 0, 0, 0, sy, 0);
   }
-   
+
   /**
-   * Apply a scale to the matrix, given scaling factors and optionally a scaling center.
-   * @eexample RPoint_scale
-   * @usage Geometry
-   * @param s  the scaling coefficient for a uniform scaling
-   * @param x  x coordinate of the position vector of the center of the scaling
-   * @param y  y coordinate of the position vector of the center of the scaling
-   * @related transform ( )
-   * @related translate ( )
-   * @related rotate ( )
+   * Apply a scale to the matrix, given scaling factors and optionally a scaling
+   * center.
+   *
+   RPoint_scale
+   * Geometry
+   * @param s the scaling coefficient for a uniform scaling
+   * @param x x coordinate of the position vector of the center of the scaling
+   * @param y y coordinate of the position vector of the center of the scaling
+   * transform ( )
+   * translate ( )
+   * rotate ( )
    */
-  public void scale(float s, float x, float y)
-  {
+  public void scale(float s, float x, float y) {
     scale(s, s, x, y);
   }
-  
+
   /**
-   * Apply a scale to the matrix, given scaling factors and optionally a scaling center.
-   * @eexample RPoint_scale
-   * @usage Geometry
-   * @param sx  the scaling coefficient over the x axis
-   * @param sy  the scaling coefficient over the y axis
-   * @param p  the position vector of the center of the scaling
-   * @related transform ( )
-   * @related translate ( )
-   * @related rotate ( )
+   * Apply a scale to the matrix, given scaling factors and optionally a scaling
+   * center.
+   *
+   RPoint_scale
+   * Geometry
+   * @param sx the scaling coefficient over the x axis
+   * @param sy the scaling coefficient over the y axis
+   * @param p the position vector of the center of the scaling
+   * transform ( )
+   * translate ( )
+   * rotate ( )
    */
-  public void scale(float sx, float sy, RPoint p)
-  {
+  public void scale(float sx, float sy, RPoint p) {
     scale(sx, sy, p.x, p.y);
   }
 
   /**
-   * Apply a scale to the matrix, given scaling factors and optionally a scaling center.
-   * @eexample RPoint_scale
-   * @usage Geometry
-   * @param s  the scaling coefficient for a uniform scaling
-   * @param p  the position vector of the center of the scaling
-   * @related transform ( )
-   * @related translate ( )
-   * @related rotate ( )
-   */  
-  public void scale(float s, RPoint p)
-  {
+   * Apply a scale to the matrix, given scaling factors and optionally a scaling
+   * center.
+   *
+   RPoint_scale
+   * Geometry
+   * @param s the scaling coefficient for a uniform scaling
+   * @param p the position vector of the center of the scaling
+   * transform ( )
+   * translate ( )
+   * rotate ( )
+   */
+  public void scale(float s, RPoint p) {
     scale(s, s, p.x, p.y);
   }
-  
-  public final void scale(float s)
-  {
+
+  public final void scale(float s) {
     scale(s, s);
   }
 
   /**
    * Use this to apply a skewing to the matrix.
-   * @eexample RMatrix_skewing
-   * @param angle  skewing angle
-   * @usage Geometry
-   * @related rotate ( )
-   * @related scale ( )
-   * @related translate ( )
+   *
+   RMatrix_skewing
+   * @param angle skewing angle
+   * Geometry
+   * rotate ( )
+   * scale ( )
+   * translate ( )
    */
-  public final void skewX(float angle)
-  {
-    apply(1, (float)Math.tan(angle), 0,  0, 1, 0);
+  public final void skewX(float angle) {
+    apply(1, (float) Math.tan(angle), 0, 0, 1, 0);
   }
-  
-  public final void skewY(float angle)
-  {
-    apply(1, 0, 0, (float)Math.tan(angle), 1, 0);
+
+  public final void skewY(float angle) {
+    apply(1, 0, 0, (float) Math.tan(angle), 1, 0);
   }
-  
+
   /**
    * Use this to apply a shearing to the matrix.
-   * @eexample RMatrix_translate
-   * @param shx  x coordinate shearing
-   * @param shy  y coordinate shearing
-   * @usage Geometry
-   * @related rotate ( )
-   * @related scale ( )
-   * @related translate ( )
+   *
+   RMatrix_translate
+   * @param shx x coordinate shearing
+   * @param shy y coordinate shearing
+   * Geometry
+   * rotate ( )
+   * scale ( )
+   * translate ( )
    */
-  public void shear(float shx, float shy)
-  {
-    apply(1, -shx, 0,  shy, 1, 0);
+  public void shear(float shx, float shy) {
+    apply(1, -shx, 0, shy, 1, 0);
   }
 }