geomerative 1.1.0-java → 2.0.0-java

data/src/geomerative/RStrip.java

@@ -1,7 +1,7 @@
 /**
  * Copyright 2004-2008 Ricard Marxer  <email@ricardmarxer.com>
  *
-    This file is part of Geomerative.
+ * 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
@@ -18,208 +18,205 @@
  */
 package geomerative;
 
-
-
 import processing.core.PConstants;
 import processing.core.PGraphics;
 
-
 /**
  * RStrip is a reduced interface for creating, holding and drawing triangle
  * strips. Triangle strips are ordered lists of points (RPoint) which define the
  * vertices of a mesh.
  *
- * @eexample RStrip
- * @usage Geometry
- * @related RPoint
- * @related RMesh
- * @extended
+ RStrip
+ * Geometry
+ * RPoint
+ * RMesh
+
  */
 public class RStrip {
 
-    /**
-     * @invisible
-     */
-    public int type = RGeomElem.TRISTRIP;
-
-    /**
-     * Array of RPoint objects holding the vertices of the strip.
-     *
-     * @eexample vertices
-     * @related RPoint
-     * @related countVertices ( )
-     * @related addVertex ( )
-     */
-    public RPoint vertices[];
-
-  // ----------------------
-    // --- Public Methods ---
-    // ----------------------
-    /**
-     * Use this method to create a new strip.
-     *
-     * @eexample RStrip ( )
-     * @related addVertex ( )
-     * @param s the object of which to make a copy
-     */
-    public RStrip(RStrip s) {
-        for (int i = 0; i < s.countVertices(); i++) {
-            this.append(new RPoint(s.vertices[i]));
-        }
-    }
-
-    public RStrip() {
-        vertices = null;
-    }
+  /**
+   *
+   */
+  public int type = RGeomElem.TRISTRIP;
 
-    /**
-     * Use this method to count the number of vertices in the strip.
-     *
-     * @eexample countVertices
-     * @return int, the number vertices in the strip
-     */
-    public int countVertices() {
-        if (this.vertices == null) {
-            return 0;
-        }
-
-        return this.vertices.length;
-    }
+  /**
+   * Array of RPoint objects holding the vertices of the strip.
+   *
+   vertices
+   * RPoint
+   * countVertices ( )
+   * addVertex ( )
+   */
+  public RPoint vertices[];
 
-    /**
-     * Use this method to draw the strip.
-     *
-     * @eexample drawStrip
-     * @param g PGraphics, the graphics object on which to draw the strip
-     */
-    public void draw(PGraphics g) {
-        int numVertices = countVertices();
-        g.beginShape(PConstants.TRIANGLE_STRIP);
-        for (int i = 0; i < numVertices; i++) {
-            g.vertex(vertices[i].x, vertices[i].y);
-        }
-        g.endShape();
+  // ----------------------
+  // --- Public Methods ---
+  // ----------------------
+  /**
+   * Use this method to create a new strip.
+   *
+   RStrip ( )
+   * addVertex ( )
+   * @param s the object of which to make a copy
+   */
+  public RStrip(RStrip s) {
+    for (int i = 0; i < s.countVertices(); i++) {
+      this.append(new RPoint(s.vertices[i]));
     }
+  }
 
-    /**
-     * Use this method to add new vertices to the strip.
-     *
-     * @param p
-     * @eexample addVertex ( )
-     */
-    public void addVertex(RPoint p) {
-        this.append(p);
-    }
+  public RStrip() {
+    vertices = null;
+  }
 
-    public void addVertex(float x, float y) {
-        this.append(new RPoint(x, y));
+  /**
+   * Use this method to count the number of vertices in the strip.
+   *
+   countVertices
+   * @return int, the number vertices in the strip
+   */
+  public int countVertices() {
+    if (this.vertices == null) {
+      return 0;
     }
 
-    /**
-     * Use this method to get the bounding box of the strip.
-     *
-     * @eexample getBounds
-     * @return RContour, the bounding box of the strip in the form of a
-     * four-point contour
-     * @related draw ( )
-     */
-    public RContour getBounds() {
-        float xmin = Float.MAX_VALUE;
-        float ymin = Float.MAX_VALUE;
-        float xmax = -Float.MAX_VALUE;
-        float ymax = -Float.MAX_VALUE;
-
-        for (int i = 0; i < this.countVertices(); i++) {
-            float x = this.vertices[i].x;
-            float y = this.vertices[i].y;
-            if (x < xmin) {
-                xmin = x;
-            }
-            if (x > xmax) {
-                xmax = x;
-            }
-            if (y < ymin) {
-                ymin = y;
-            }
-            if (y > ymax) {
-                ymax = y;
-            }
-        }
-
-        RContour c = new RContour();
-        c.addPoint(xmin, ymin);
-        c.addPoint(xmin, ymax);
-        c.addPoint(xmax, ymax);
-        c.addPoint(xmax, ymin);
-        return c;
-    }
+    return this.vertices.length;
+  }
 
-    /**
-     * Use this to get the vertices of the strip. It returns the points as an
-     * array of RPoint.
-     *
-     * @eexample RStrip_getHandles
-     * @return RPoint[], the vertices returned in an array.
+  /**
+   * Use this method to draw the strip.
    *
-     */
-    public RPoint[] getHandles() {
-        return vertices;
+   drawStrip
+   * @param g PGraphics, the graphics object on which to draw the strip
+   */
+  public void draw(PGraphics g) {
+    int numVertices = countVertices();
+    g.beginShape(PConstants.TRIANGLE_STRIP);
+    for (int i = 0; i < numVertices; i++) {
+      g.vertex(vertices[i].x, vertices[i].y);
     }
+    g.endShape();
+  }
 
-    /**
-     * Use this to get the vertices of the strip. It returns the points as an
-     * array of RPoint.
-     *
-     * @eexample RStrip_getPoints
-     * @return RPoint[], the vertices returned in an array.
+  /**
+   * Use this method to add new vertices to the strip.
    *
-     */
-    public RPoint[] getPoints() {
-        return vertices;
-    }
-
-    /**
-     * Use this method to transform the strip.
-     *
-     * @eexample transformStrip
-     * @param m RMatrix, the matrix of the affine transformation to apply to the
-     * strip
-     */
-    public void transform(RMatrix m) {
-        int numVertices = countVertices();
-        if (numVertices != 0) {
-            for (int i = 0; i < numVertices; i++) {
-                vertices[i].transform(m);
-            }
-        }
-    }
-
-    void add(RPoint p) {
-        this.append(p);
+   * @param p
+   addVertex ( )
+   */
+  public void addVertex(RPoint p) {
+    this.append(p);
+  }
+
+  public void addVertex(float x, float y) {
+    this.append(new RPoint(x, y));
+  }
+
+  /**
+   * Use this method to get the bounding box of the strip.
+   *
+   getBounds
+   * @return RContour, the bounding box of the strip in the form of a four-point
+   * contour
+   * draw ( )
+   */
+  public RContour getBounds() {
+    float xmin = Float.MAX_VALUE;
+    float ymin = Float.MAX_VALUE;
+    float xmax = -Float.MAX_VALUE;
+    float ymax = -Float.MAX_VALUE;
+
+    for (int i = 0; i < this.countVertices(); i++) {
+      float x = this.vertices[i].x;
+      float y = this.vertices[i].y;
+      if (x < xmin) {
+        xmin = x;
+      }
+      if (x > xmax) {
+        xmax = x;
+      }
+      if (y < ymin) {
+        ymin = y;
+      }
+      if (y > ymax) {
+        ymax = y;
+      }
     }
 
-    void add(float x, float y) {
-        this.append(new RPoint(x, y));
-    }
+    RContour c = new RContour();
+    c.addPoint(xmin, ymin);
+    c.addPoint(xmin, ymax);
+    c.addPoint(xmax, ymax);
+    c.addPoint(xmax, ymin);
+    return c;
+  }
+
+  /**
+   * Use this to get the vertices of the strip. It returns the points as an
+   * array of RPoint.
+   *
+   RStrip_getHandles
+   * @return RPoint[], the vertices returned in an array.
+   *
+   */
+  public RPoint[] getHandles() {
+    return vertices;
+  }
+
+  /**
+   * Use this to get the vertices of the strip. It returns the points as an
+   * array of RPoint.
+   *
+   RStrip_getPoints
+   * @return RPoint[], the vertices returned in an array.
+   *
+   */
+  public RPoint[] getPoints() {
+    return vertices;
+  }
 
-    /**
-     * Remove all of the points. Creates an empty polygon.
-     */
-    void clear() {
-        this.vertices = null;
+  /**
+   * Use this method to transform the strip.
+   *
+   transformStrip
+   * @param m RMatrix, the matrix of the affine transformation to apply to the
+   * strip
+   */
+  public void transform(RMatrix m) {
+    int numVertices = countVertices();
+    if (numVertices != 0) {
+      for (int i = 0; i < numVertices; i++) {
+        vertices[i].transform(m);
+      }
     }
-
-    final void append(RPoint nextvertex) {
-        RPoint[] newvertices;
-        if (vertices == null) {
-            newvertices = new RPoint[1];
-            newvertices[0] = nextvertex;
-        } else {
-            newvertices = new RPoint[this.vertices.length + 1];
-            System.arraycopy(this.vertices, 0, newvertices, 0, this.vertices.length);
-            newvertices[this.vertices.length] = nextvertex;
-        }
-        this.vertices = newvertices;
+  }
+
+  void add(RPoint p) {
+    this.append(p);
+  }
+
+  void add(float x, float y) {
+    this.append(new RPoint(x, y));
+  }
+
+  /**
+   * Remove all of the points. Creates an empty polygon.
+   */
+  void clear() {
+    this.vertices = null;
+  }
+
+  final void append(RPoint nextvertex) {
+    RPoint[] newvertices;
+    if (vertices == null) {
+      newvertices = new RPoint[1];
+      newvertices[0] = nextvertex;
+    } else {
+      newvertices = new RPoint[this.vertices.length + 1];
+      System.arraycopy(this.vertices, 0, newvertices, 0, this.vertices.length);
+      newvertices[this.vertices.length] = nextvertex;
     }
+    this.vertices = newvertices;
+  }
 
 }

data/src/geomerative/RStyle.java

@@ -1,23 +1,22 @@
 /**
-    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;
 import processing.core.PConstants;
@@ -25,11 +24,12 @@ import processing.core.PGraphics;
 import processing.core.PImage;
 
 /**
- * @extended
- */  
-public class RStyle{
+
+ */
+public class RStyle {
+
   public PImage texture = null;
-  
+
   public boolean fillDef = false;
   public boolean fill = false;
   public int fillColor = 0xff000000;
@@ -43,7 +43,7 @@ public class RStyle{
 
   public boolean strokeAlphaDef = false;
   public int strokeAlpha = 0xff000000;
-  
+
   public boolean strokeWeightDef = false;
   public float strokeWeight = 1F;
 
@@ -55,24 +55,25 @@ public class RStyle{
 
   private boolean oldFill = false;
   private int oldFillColor = 0;
-  
+
   private boolean oldStroke = false;
   private int oldStrokeColor = 0;
   private float oldStrokeWeight = 1F;
   private int oldStrokeCap = PConstants.PROJECT;
   private int oldStrokeJoin = PConstants.MITER;
 
-  public RStyle(){}
+  public RStyle() {
+  }
 
-  public RStyle(RStyle p){
+  public RStyle(RStyle p) {
     texture = p.texture;
-    
+
     fillDef = p.fillDef;
     fill = p.fill;
     fillColor = p.fillColor;
     fillAlphaDef = p.fillAlphaDef;
     fillAlpha = p.fillAlpha;
-    
+
     strokeDef = p.strokeDef;
     stroke = p.stroke;
     strokeColor = p.strokeColor;
@@ -89,173 +90,172 @@ public class RStyle{
     strokeJoin = p.strokeJoin;
   }
 
-  protected void setStyle(String styleString){
+  protected void setStyle(String styleString) {
     //RG.parent().println("Style parsing: " + styleString);
     String[] styleTokens = PApplet.splitTokens(styleString, ";");
-    
-      for (String styleToken : styleTokens) {
-          String[] tokens = PApplet.splitTokens(styleToken, ":");
-          tokens[0] = PApplet.trim(tokens[0]);
-        switch (tokens[0]) {
-            case "fill":
-                setFill(tokens[1]);
-                break;
-            case "fill-opacity":
-                setFillAlpha(tokens[1]);
-                break;
-            case "stroke":
-                setStroke(tokens[1]);
-                break;
-            case "stroke-width":
-                setStrokeWeight(tokens[1]);
-                break;
-            case "stroke-linecap":
-                setStrokeCap(tokens[1]);
-                break;
-            case "stroke-linejoin":
-                setStrokeJoin(tokens[1]);
-                break;
-            case "stroke-opacity":
-                setStrokeAlpha(tokens[1]);
-                break;
-            case "opacity":
-                setAlpha(tokens[1]);
-                break;
-            default:
-                PApplet.println("Attribute '" + tokens[0] + "' not known.  Ignoring it.");
-                break;
-        }
+
+    for (String styleToken : styleTokens) {
+      String[] tokens = PApplet.splitTokens(styleToken, ":");
+      tokens[0] = PApplet.trim(tokens[0]);
+      switch (tokens[0]) {
+        case "fill":
+          setFill(tokens[1]);
+          break;
+        case "fill-opacity":
+          setFillAlpha(tokens[1]);
+          break;
+        case "stroke":
+          setStroke(tokens[1]);
+          break;
+        case "stroke-width":
+          setStrokeWeight(tokens[1]);
+          break;
+        case "stroke-linecap":
+          setStrokeCap(tokens[1]);
+          break;
+        case "stroke-linejoin":
+          setStrokeJoin(tokens[1]);
+          break;
+        case "stroke-opacity":
+          setStrokeAlpha(tokens[1]);
+          break;
+        case "opacity":
+          setAlpha(tokens[1]);
+          break;
+        default:
+          PApplet.println("Attribute '" + tokens[0] + "' not known.  Ignoring it.");
+          break;
       }
+    }
   }
 
-  public void setFill(boolean _fill){
+  public void setFill(boolean _fill) {
     fillDef = true;
     fill = _fill;
   }
 
-  public void setFill(int _fillColor){
+  public void setFill(int _fillColor) {
     //RG.parent().println("Setting fill by int: " + RG.parent().hex(_fillColor));
     setFill(true);
     fillColor = (fillColor & 0xff000000) | (_fillColor & 0x00ffffff);
   }
 
-  public void setFill(String str){
+  public void setFill(String str) {
     //RG.parent().println("id: " + id);
     //RG.parent().println("  set fill: " + str);
-    if(str.equals("none")){
+    if (str.equals("none")) {
       setFill(false);
 
-    }else{
+    } else {
       setFill(getColor(str));
 
     }
     //RG.parent().println("  fillColor after: " + RG.parent().hex(fillColor));
   }
 
-  public void setStroke(boolean _stroke){
+  public void setStroke(boolean _stroke) {
     strokeDef = true;
     stroke = _stroke;
   }
 
-  public void setStroke(int _strokeColor){
+  public void setStroke(int _strokeColor) {
     setStroke(true);
     strokeColor = (strokeColor & 0xff000000) | (_strokeColor & 0x00ffffff);
   }
 
-  public void setStroke(String str){
+  public void setStroke(String str) {
     //RG.parent().println("  set stroke: " + str);
-    if(str.equals("none")){
+    if (str.equals("none")) {
       setStroke(false);
 
-    }else{
+    } else {
       setStroke(getColor(str));
-      
+
     }
   }
 
-  public void setStrokeWeight(float value){
+  public void setStrokeWeight(float value) {
     //RG.parent().println("  set strokeWeight by float: " + value);
     strokeWeightDef = true;
     strokeWeight = value;
   }
 
-  public void setStrokeWeight(String str){
+  public void setStrokeWeight(String str) {
     //RG.parent().println("  set strokeWeight by String: " + str);
-    if(str.endsWith("px")){
+    if (str.endsWith("px")) {
       setStrokeWeight(PApplet.parseFloat(str.substring(0, str.length() - 2)));
-    }else{
+    } else {
       setStrokeWeight(PApplet.parseFloat(str));
     }
 
-    
   }
 
-  public void setStrokeCap(String str){
+  public void setStrokeCap(String str) {
     //RG.parent().println("  set stroke-cap: " + str);
     strokeCapDef = true;
 
-      switch (str) {
-          case "butt":
-              strokeCap = PConstants.PROJECT;
-              break;
-          case "round":
-              strokeCap = PConstants.ROUND;
-              break;
-          case "square":
-              strokeCap = PConstants.SQUARE;
-              break;
-      }
+    switch (str) {
+      case "butt":
+        strokeCap = PConstants.PROJECT;
+        break;
+      case "round":
+        strokeCap = PConstants.ROUND;
+        break;
+      case "square":
+        strokeCap = PConstants.SQUARE;
+        break;
+    }
   }
 
-  public void setStrokeJoin(String str){
+  public void setStrokeJoin(String str) {
     //RG.parent().println("  set stroke-cap: " + str);
     strokeJoinDef = true;
 
-      switch (str) {
-          case "miter":
-              strokeJoin = PConstants.MITER;
-              break;
-          case "round":
-              strokeJoin = PConstants.ROUND;
-              break;
-          case "bevel":
-              strokeJoin = PConstants.BEVEL;
-              break;
-      }
+    switch (str) {
+      case "miter":
+        strokeJoin = PConstants.MITER;
+        break;
+      case "round":
+        strokeJoin = PConstants.ROUND;
+        break;
+      case "bevel":
+        strokeJoin = PConstants.BEVEL;
+        break;
+    }
   }
 
-  public void setStrokeAlpha(int opacity){
+  public void setStrokeAlpha(int opacity) {
     strokeAlphaDef = true;
     strokeAlpha = opacity;
   }
 
-  public void setStrokeAlpha(String str){
-    setStrokeAlpha((int)(PApplet.parseFloat(str) * 255F));
+  public void setStrokeAlpha(String str) {
+    setStrokeAlpha((int) (PApplet.parseFloat(str) * 255F));
   }
 
-  public void setFillAlpha(int opacity){
+  public void setFillAlpha(int opacity) {
     fillAlphaDef = true;
     fillAlpha = opacity;
   }
 
-  public void setFillAlpha(String str){
+  public void setFillAlpha(String str) {
     //RG.parent().println("  set fillOpacity: " + str);
-    setFillAlpha((int)(PApplet.parseFloat(str) * 255F));
+    setFillAlpha((int) (PApplet.parseFloat(str) * 255F));
     //RG.parent().println("  fillColor after: " + RG.parent().hex(fillColor));
-  }  
+  }
 
-  public void setAlpha(float opacity){
+  public void setAlpha(float opacity) {
     //RG.parent().println("Setting float opacity: " + opacity);
-    setAlpha((int)(opacity * 100F));
+    setAlpha((int) (opacity * 100F));
   }
 
-  public void setAlpha(int opacity){
+  public void setAlpha(int opacity) {
     /*
     RG.parent().println("setting opacity: " + RG.parent().hex(opacity));    
     
     RG.parent().println("  fillColor before: " + RG.parent().hex(fillColor));
     RG.parent().println("  strokeColor before: " + RG.parent().hex(fillColor));
-    */
+     */
 
     setFillAlpha(opacity);
     setStrokeAlpha(opacity);
@@ -266,15 +266,15 @@ public class RStyle{
     /*    
     RG.parent().println("  fillColor now: " + RG.parent().hex(fillColor));
     RG.parent().println("  strokeColor now: " + RG.parent().hex(fillColor));
-    */
+     */
   }
 
-  public void setAlpha(String str){
+  public void setAlpha(String str) {
     //RG.parent().println("Setting string opacity: " + str);
     setAlpha(PApplet.parseFloat(str));
   }
 
-  protected void saveContext(PGraphics g){
+  protected void saveContext(PGraphics g) {
     oldFill = g.fill;
     oldFillColor = g.fillColor;
     oldStroke = g.stroke;
@@ -284,189 +284,192 @@ public class RStyle{
     oldStrokeJoin = g.strokeJoin;
   }
 
-  protected void saveContext(PApplet p){
+  protected void saveContext(PApplet p) {
     oldFill = p.g.fill;
     oldFillColor = p.g.fillColor;
     oldStroke = p.g.stroke;
     oldStrokeColor = p.g.strokeColor;
-    oldStrokeWeight = p.g.strokeWeight;    
+    oldStrokeWeight = p.g.strokeWeight;
     oldStrokeCap = p.g.strokeCap;
     oldStrokeJoin = p.g.strokeJoin;
   }
 
-  protected void saveContext(){
+  protected void saveContext() {
     saveContext(RG.parent());
   }
 
-  protected void restoreContext(PGraphics g){
+  protected void restoreContext(PGraphics g) {
     g.fill(oldFillColor);
-    if(!oldFill){
+    if (!oldFill) {
       g.noFill();
     }
 
     g.stroke(oldStrokeColor);
     g.strokeWeight(oldStrokeWeight);
 
-    try{
+    try {
       g.strokeCap(oldStrokeCap);
       g.strokeJoin(oldStrokeJoin);
-    }catch(RuntimeException e){}
+    } catch (RuntimeException e) {
+    }
 
-    if(!oldStroke){
+    if (!oldStroke) {
       g.noStroke();
     }
   }
 
-  protected void restoreContext(PApplet p){
+  protected void restoreContext(PApplet p) {
     p.fill(oldFillColor);
-    if(!oldFill){
+    if (!oldFill) {
       p.noFill();
     }
 
     p.stroke(oldStrokeColor);
     p.strokeWeight(oldStrokeWeight);
 
-    try{
+    try {
       p.strokeCap(oldStrokeCap);
       p.strokeJoin(oldStrokeJoin);
-    }catch(RuntimeException e){}
+    } catch (RuntimeException e) {
+    }
 
-    if(!oldStroke){
+    if (!oldStroke) {
       p.noStroke();
-    }    
+    }
   }
 
-  protected void restoreContext(){
+  protected void restoreContext() {
     restoreContext(RG.parent());
   }
 
-  protected void setContext(PGraphics g){
-    if(fillAlphaDef){
-      if(fillDef){
+  protected void setContext(PGraphics g) {
+    if (fillAlphaDef) {
+      if (fillDef) {
         fillColor = ((fillAlpha << 24) & 0xff000000) | (fillColor & 0x00ffffff);
-      }else{
-        if(g.fill){
+      } else {
+        if (g.fill) {
           g.fill(((fillAlpha << 24) & 0xff000000) | (g.fillColor & 0x00ffffff));
         }
       }
     }
 
-    if(fillDef){
+    if (fillDef) {
       g.fill(fillColor);
-      if(!fill){
+      if (!fill) {
         g.noFill();
       }
     }
 
-    if(strokeWeightDef){      
+    if (strokeWeightDef) {
       g.strokeWeight(strokeWeight);
     }
 
-    try{
-      if(strokeCapDef){      
+    try {
+      if (strokeCapDef) {
         g.strokeCap(strokeCap);
       }
-      
-      if(strokeJoinDef){      
+
+      if (strokeJoinDef) {
         g.strokeJoin(strokeJoin);
       }
-    }catch(RuntimeException e){}
+    } catch (RuntimeException e) {
+    }
 
-    if(strokeAlphaDef){
-      if(strokeDef){
+    if (strokeAlphaDef) {
+      if (strokeDef) {
         strokeColor = ((strokeAlpha << 24) & 0xff000000) | (strokeColor & 0x00ffffff);
-      }else{
-        if(g.stroke){
+      } else {
+        if (g.stroke) {
           g.stroke(((strokeAlpha << 24) & 0xff000000) | (g.strokeColor & 0x00ffffff));
         }
       }
     }
-    
-    if(strokeDef){      
+
+    if (strokeDef) {
       g.stroke(strokeColor);
-      if(!stroke){
+      if (!stroke) {
         g.noStroke();
       }
     }
   }
 
-  protected void setContext(PApplet p){
-    
-    if(fillAlphaDef){
-      if(fillDef){
+  protected void setContext(PApplet p) {
+
+    if (fillAlphaDef) {
+      if (fillDef) {
         fillColor = ((fillAlpha << 24) & 0xff000000) | (fillColor & 0x00ffffff);
-      }else{
-        if(p.g.fill){
+      } else {
+        if (p.g.fill) {
           p.fill(((fillAlpha << 24) & 0xff000000) | (p.g.fillColor & 0x00ffffff));
         }
       }
     }
-    
-    if(fillDef){
+
+    if (fillDef) {
       p.fill(fillColor);
-      if(!fill){
+      if (!fill) {
         p.noFill();
       }
     }
 
-    if(strokeWeightDef){      
+    if (strokeWeightDef) {
       p.strokeWeight(strokeWeight);
     }
 
-    try{
-      if(strokeCapDef){      
+    try {
+      if (strokeCapDef) {
         p.strokeCap(strokeCap);
       }
-      
-      if(strokeJoinDef){      
+
+      if (strokeJoinDef) {
         p.strokeJoin(strokeJoin);
       }
-    }catch(RuntimeException e){}
+    } catch (RuntimeException e) {
+    }
 
-    if(strokeAlphaDef){
-      if(strokeDef){
+    if (strokeAlphaDef) {
+      if (strokeDef) {
         strokeColor = ((strokeAlpha << 24) & 0xff000000) | (strokeColor & 0x00ffffff);
-      }else{
-        if(p.g.stroke){
+      } else {
+        if (p.g.stroke) {
           p.stroke(((strokeAlpha << 24) & 0xff000000) | (p.g.strokeColor & 0x00ffffff));
         }
       }
     }
 
-    if(strokeDef){
+    if (strokeDef) {
       p.stroke(strokeColor);
-      if(!stroke){
+      if (!stroke) {
         p.noStroke();
       }
     }
   }
 
-  protected void setContext(){
+  protected void setContext() {
     setContext(RG.parent());
   }
 
-
-  private int getColor(String colorString){
+  private int getColor(String colorString) {
     colorString = PApplet.trim(colorString);
-    
-    if(colorString.startsWith("#")){
-      return PApplet.unhex("FF"+colorString.substring(1));
-    }else if(colorString.startsWith("rgb")){
+
+    if (colorString.startsWith("#")) {
+      return PApplet.unhex("FF" + colorString.substring(1));
+    } else if (colorString.startsWith("rgb")) {
       String[] rgb = PApplet.splitTokens(colorString, "rgb( , )");
-      return (int)RG.parent().color(PApplet.parseInt(rgb[0]), PApplet.parseInt(rgb[1]), PApplet.parseInt(rgb[2]));
-    }else{
-        switch (colorString) {
-            case "black":
-                return 0;
-            case "red":
-                return RG.parent().color(255, 0, 0);
-            case "green":
-                return RG.parent().color(0, 255, 0);
-            case "blue":
-                return RG.parent().color(0, 0, 255);
-            case "yellow":
-                return RG.parent().color(0, 255, 255);
-        }
+      return (int) RG.parent().color(PApplet.parseInt(rgb[0]), PApplet.parseInt(rgb[1]), PApplet.parseInt(rgb[2]));
+    } else {
+      switch (colorString) {
+        case "black":
+          return 0;
+        case "red":
+          return RG.parent().color(255, 0, 0);
+        case "green":
+          return RG.parent().color(0, 255, 0);
+        case "blue":
+          return RG.parent().color(0, 0, 255);
+        case "yellow":
+          return RG.parent().color(0, 255, 255);
+      }
     }
     return 0;
   }