geomerative 0.1.0-java

data/src/geomerative/RMatrix.java

@@ -0,0 +1,401 @@
+/**
+    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
+ */
+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 ( )
+   */
+  public RMatrix(float m00, float m01, float m02,
+		 float m10, float m11, float m12)
+  {
+    set(m00, m01, m02,
+        m10, m11, m12);
+  }
+
+  /**
+   * Create a new identity matrix.
+   * @eexample RMatrix
+   * @usage Geometry
+   * @related apply ( )
+   * @related translate ( )
+   * @related rotate ( )
+   * @related scale ( )
+   * @related shear ( )
+   */
+  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 ( )
+   */
+  public RMatrix(RMatrix src)
+  {
+    set(src.m00, src.m01, src.m02,
+        src.m10, src.m11, src.m12);
+  }
+  
+  public RMatrix(String transformationString){
+    String[] transfTokens = PApplet.splitTokens(transformationString, ")");
+    
+    // Loop through all transformations
+    for(int i=0; i<transfTokens.length; i++){
+      // Check the transformation and the parameters
+      String[] transf = PApplet.splitTokens(transfTokens[i], "(");
+      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]);
+      
+      if(transf[0].equals("translate")){
+        if(params.length == 1){
+          this.translate(fparams[0]);
+          
+        }else if(params.length == 2){
+          this.translate(fparams[0], fparams[1]);
+          
+        }
+      }else if(transf[0].equals("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]);
+          
+        }
+        
+      }else if(transf[0].equals("scale")){
+        if(params.length == 1){
+          this.scale(fparams[0]);
+          
+        }else if(params.length == 2){
+          this.scale(fparams[0], fparams[1]);
+        }
+        
+      }else if(transf[0].equals("skewX")){
+        this.skewX(PApplet.radians(fparams[0]));
+        
+      }else if(transf[0].equals("skewY")){
+        this.skewY(PApplet.radians(fparams[0]));
+        
+      }else if(transf[0].equals("matrix")){
+        this.apply(fparams[0], fparams[2], fparams[4], fparams[1], fparams[3], fparams[5]);
+        
+      }else{
+        throw new RuntimeException("Transformation unknown. '"+ transf[0]  +"'");
+      }
+    }
+  }
+  
+  private 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;
+  }
+  
+  /**
+   * 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 ( )
+   */ 
+  public 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;
+  }
+
+  /**
+   * 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 ( )
+   */
+  public void apply(RMatrix rhs) {
+    apply(rhs.m00, rhs.m01, rhs.m02,
+          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 ( )
+   */
+  public void translate(float tx, float ty)
+  {
+    apply(1, 0, tx, 0, 1, ty);
+  }
+
+  public 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 ( )
+   */
+  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 void rotate(float angle, float vx, float vy)
+  {
+    translate(vx,vy);
+    rotate(angle);
+    translate(-vx,-vy);
+  }
+
+  public 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)
+  {
+    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 ( )
+   */
+  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)
+  {
+    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 ( )
+   */
+  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 ( )
+   */
+  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)
+  {
+    scale(s, s, p.x, p.y);
+  }
+  
+  public 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 ( )
+   */
+  public void skewX(float angle)
+  {
+    apply(1, (float)Math.tan(angle), 0,  0, 1, 0);
+  }
+  
+  public 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 ( )
+   */
+  public void shear(float shx, float shy)
+  {
+    apply(1, -shx, 0,  shy, 1, 0);
+  }
+}

data/src/geomerative/RMesh.java

@@ -0,0 +1,420 @@
+/**
+    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.*;
+
+/**
+ * RMesh is a reduced interface for creating, holding and drawing meshes. A mesh is a group of triangular strips (RStrip).
+ * @eexample RMesh
+ * @usage Geometry
+ * @related RStrip
+ * @extended
+ */
+public class RMesh extends RGeomElem
+{
+  /**
+   * @invisible
+   */
+  public int type = RGeomElem.MESH;
+  
+  /**
+   * Array of RStrip objects holding the contours of the polygon. 
+   * @eexample strips
+   * @related RStrip
+   * @related countStrips ( )
+   * @related addStrip ( )
+   */
+  public RStrip[] strips;
+  int currentStrip=0;
+  // ----------------------
+  // --- Public Methods ---
+  // ----------------------
+  
+  /**
+   * Create a new empty mesh. 
+   * @eexample createaMesh
+   */
+  public RMesh(){
+    strips = null;
+    type = RGeomElem.MESH;
+  }
+
+  /**
+   * Copy a mesh. 
+   * @eexample createaMesh
+   * @param m  the object of which to make a copy
+   */  
+  public RMesh(RMesh m){
+    if(m == null){
+      return;
+    }
+    
+    for(int i=0;i<m.countStrips();i++){
+      this.append(new RStrip(m.strips[i]));
+    }
+    type = RGeomElem.MESH;
+
+    setStyle(m);
+  }
+  
+  /**
+   * Use this method to count the number of strips in the mesh. 
+   * @eexample countStrips
+   * @return int, the number strips in the mesh
+   * @related addStrip ( )
+   */
+  public int countStrips(){
+    if(this.strips==null){
+      return 0;
+    }
+    
+    return this.strips.length;
+  }
+  
+  /**
+   * Add a new strip. 
+   * @eexample addStrip
+   * @param s  the strip to be added
+   * @related addPoint ( )
+   */  
+  public void addStrip(RStrip s){
+    this.append(s);
+  }
+
+  public void addStrip(){
+    this.append(new RStrip());
+  }
+  
+  /**
+   * Use this method to set the current strip to which append points. 
+     * @param indStrip
+   * @eexample addStrip
+   * @related addPoint ( )
+   * @invisible
+   */
+  public void setCurrent(int indStrip){
+    this.currentStrip = indStrip;
+  }
+  
+  /**
+   * Add a new point to the current strip. 
+   * @eexample addPoint
+   * @param p  the point to be added
+   * @related addStrip ( )
+   * @related setCurrent ( )
+   * @invisible
+   */
+  public void addPoint(RPoint p){
+    if (strips == null) {
+      this.append(new RStrip());
+    }
+    this.strips[currentStrip].append(p);
+  }
+
+  /**
+   * Add a new point to the current strip. 
+   * @eexample addPoint
+   * @param x  the x coordinate of the point to be added
+   * @param y  the y coordinate of the point to be added
+   * @related addStrip ( )
+   * @related setCurrent ( )
+   * @invisible
+   */  
+  public void addPoint(float x, float y){
+    if (strips == null) {
+      this.append(new RStrip());
+    }
+    this.strips[currentStrip].append(new RPoint(x,y));
+  }
+  
+  /**
+   * Add a new point to the given strip. 
+   * @eexample addPoint
+   * @param indStrip  the index of the strip to which the point will be added
+   * @param p  the point to be added
+   * @related addStrip ( )
+   * @related setCurrent ( )
+   * @invisible
+   */
+  public void addPoint(int indStrip, RPoint p){
+    if (strips == null) {
+      this.append(new RStrip());
+    }
+    this.strips[indStrip].append(p);
+  }
+  
+  /**
+   * Add a new point to the given strip. 
+   * @eexample addPoint
+   * @param indStrip  the index of the strip to which the point will be added
+   * @param x  the x coordinate of the point to be added
+   * @param y  the y coordinate of the point to be added
+   * @related addStrip ( )
+   * @related setCurrent ( )
+   * @invisible
+   */
+  public void addPoint(int indStrip, float x, float y){
+    if (strips == null) {
+      this.append(new RStrip());
+    }
+    this.strips[indStrip].append(new RPoint(x,y));
+  }
+  
+  /**
+   * Use this method to draw the mesh.
+   * @eexample drawMesh
+   * @param g PGraphics, the graphics object on which to draw the mesh
+   */
+  @Override
+  public void draw(PGraphics g){
+    for(int i=0;i<this.countStrips();i++){
+      g.beginShape(PConstants.TRIANGLE_STRIP);
+      if(this.style.texture != null)
+        {
+          g.texture(this.style.texture);
+          for (RPoint vertice : this.strips[i].vertices) {
+              float x = vertice.x;
+              float y = vertice.y;
+              /*
+              float u = (x - minx)/(maxx-minx) * this.style.texture.width;
+              float v = (y - miny)/(maxy-miny) * this.style.texture.height;
+              */
+              g.vertex(x, y, x, y);
+          }
+        }else{
+          for (RPoint vertice : this.strips[i].vertices) {
+              float x = vertice.x;
+              float y = vertice.y;
+              g.vertex(x, y);
+          }
+      }
+      g.endShape(PConstants.CLOSE);
+    }
+    
+    
+  }
+  
+  @Override
+  public void draw(PApplet g){
+    for(int i=0;i<this.countStrips();i++){
+      g.beginShape(PConstants.TRIANGLE_STRIP);
+      if(this.style.texture != null)
+        {
+          g.texture(this.style.texture);
+        }
+        for (RPoint vertice : this.strips[i].vertices) {
+            g.vertex(vertice.x, vertice.y);
+        }
+      g.endShape(PConstants.CLOSE);
+    }
+  }		
+  
+  /**
+   * Use this to get the vertices of the mesh.  It returns the points as an array of RPoint.
+   * @eexample RMesh_getHandles
+   * @return RPoint[], the vertices returned in an array.
+   * */
+  @Override
+  public RPoint[] getHandles(){
+    int numStrips = countStrips();
+    if(numStrips == 0){
+      return null;
+    }
+    
+    RPoint[] result=null;
+    RPoint[] newresult=null;
+    for(int i=0;i<numStrips;i++){
+      RPoint[] newPoints = strips[i].getHandles();
+      if(newPoints!=null){
+        if(result==null){
+          result = new RPoint[newPoints.length];
+          System.arraycopy(newPoints,0,result,0,newPoints.length);
+        }else{
+          newresult = new RPoint[result.length + newPoints.length];
+          System.arraycopy(result,0,newresult,0,result.length);
+          System.arraycopy(newPoints,0,newresult,result.length,newPoints.length);
+          result = newresult;
+        }
+      }
+    }
+    return result;
+  }
+  
+  /**
+   * Use this to get the vertices of the mesh.  It returns the points as an array of RPoint.
+   * @eexample RMesh_getPoints
+   * @return RPoint[], the vertices returned in an array.
+   * */
+  @Override
+  public RPoint[] getPoints(){
+    int numStrips = countStrips();
+    if(numStrips == 0){
+      return null;
+    }
+    
+    RPoint[] result=null;
+    RPoint[] newresult=null;
+    for(int i=0;i<numStrips;i++){
+      RPoint[] newPoints = strips[i].getPoints();
+      if(newPoints!=null){
+        if(result==null){
+          result = new RPoint[newPoints.length];
+          System.arraycopy(newPoints,0,result,0,newPoints.length);
+        }else{
+          newresult = new RPoint[result.length + newPoints.length];
+          System.arraycopy(result,0,newresult,0,result.length);
+          System.arraycopy(newPoints,0,newresult,result.length,newPoints.length);
+          result = newresult;
+        }
+      }
+    }
+    return result;
+  }
+  
+  @Override
+  public RPoint getPoint(float t){
+    PApplet.println("Feature not yet implemented for this class.");
+    return null;
+  }
+
+  @Override
+  public RPoint getTangent(float t){
+    PApplet.println("Feature not yet implemented for this class.");
+    return null;
+  }
+  
+  @Override
+  public RPoint[] getTangents(){
+    PApplet.println("Feature not yet implemented for this class.");
+    return null;
+  }
+
+  @Override
+  public RPoint[][] getPointsInPaths(){
+    PApplet.println("Feature not yet implemented for this class.");
+    return null;
+  }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+  public RPoint[][] getHandlesInPaths(){
+    PApplet.println("Feature not yet implemented for this class.");
+    return null;
+  }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+  public RPoint[][] getTangentsInPaths(){
+    PApplet.println("Feature not yet implemented for this class.");
+    return null;
+  }
+
+    /**
+     *
+     * @param p
+     * @return
+     */
+    @Override
+  public boolean contains(RPoint p){
+    PApplet.println("Feature not yet implemented for this class.");
+    return false;
+  }
+  
+  /**
+   * Use this method to get the type of element this is.
+   * @eexample RMesh_getType
+   * @return int, will allways return RGeomElem.MESH
+   */
+  @Override
+  public int getType(){
+    return type;
+  }
+  
+  /**
+   * Use this method to transform the mesh.
+   * @eexample transformMesh
+   * @param m RMatrix, the matrix of the affine transformation to apply to the mesh
+   */
+  @Override
+  public void transform(RMatrix m){
+    int numStrips = countStrips();
+    if(numStrips!=0){
+      for(int i=0;i<numStrips;i++){
+        strips[i].transform(m);
+      }
+    }
+  }
+  
+  /**
+     * @return 
+   * @invisible
+   */
+  @Override
+  public RMesh toMesh(){
+    return this;
+  }
+  
+  /**
+     * @return 
+   * @invisible
+   */
+  @Override
+  public RPolygon toPolygon() throws RuntimeException{
+    throw new RuntimeException("Transforming a Mesh to a Polygon is not yet implemented.");
+  }
+  
+  /**
+     * @return 
+   * @invisible
+   */
+  @Override
+  public RShape toShape() throws RuntimeException{
+    throw new RuntimeException("Transforming a Mesh to a Shape is not yet implemented.");
+  }
+  
+  /**
+   * Remove all of the points.  Creates an empty polygon.
+   */
+  void clear(){
+    this.strips = null;
+  }
+  
+  final void append(RStrip nextstrip)
+  {
+    RStrip[] newstrips;
+    if(strips==null){
+      newstrips = new RStrip[1];
+      newstrips[0] = nextstrip;
+      currentStrip = 0;
+    }else{
+      newstrips = new RStrip[this.strips.length+1];
+      System.arraycopy(this.strips,0,newstrips,0,this.strips.length);
+      newstrips[this.strips.length]=nextstrip;
+      currentStrip++;
+    }
+    this.strips=newstrips; 
+  }
+}