geomerative 1.1.0-java → 2.0.0-java

data/src/geomerative/RGroup.java

@@ -1,433 +1,471 @@
 /**
-    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/>.
-*/
+ * 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;
 
-package geomerative ;
-import processing.core.*;
+import processing.core.PApplet;
+import processing.core.PGraphics;
 
 
 /**
- * RGroup is a holder for a group of geometric elements that can be drawn and transformed, such as shapes, polygons or meshes.
- * @usage geometry
- * @extended
+ * RGroup is a holder for a group of geometric elements that can be drawn and
+ * transformed, such as shapes, polygons or meshes.
+ *
+ * geometry
+
  */
-public class RGroup extends RGeomElem
-{
+public class RGroup extends RGeomElem {
+
   /**
-   * @invisible
+   *
    */
   public int type = RGeomElem.GROUP;
-    
+
   /**
-   * Array of RGeomElem objects holding the elements of the group. When accessing theses elements we must cast them to their class in order to get all the functionalities of each representation. e.g. RShape s = group.elements[i].toShape()  If the element cannot be converted to the target class it will throw a RuntimeException, to ignore these, use try-catch syntax.
-   * @eexample RGroup_elements
-   * @related RShape
-   * @related RPolygon
-   * @related RMesh
-   * @related countElements ( )
-   * @related addElement ( )
-   * @related removeElement ( )
+   * Array of RGeomElem objects holding the elements of the group. When
+   * accessing theses elements we must cast them to their class in order to get
+   * all the functionalities of each representation. e.g. RShape s =
+   * group.elements[i].toShape() If the element cannot be converted to the
+   * target class it will throw a RuntimeException, to ignore these, use
+   * try-catch syntax.
+   *
+   RGroup_elements
+   * RShape
+   * RPolygon
+   * RMesh
+   * countElements ( )
+   * addElement ( )
+   * removeElement ( )
    */
   public RGeomElem[] elements;
-  
+
   /**
    * Use this method to create a new empty group.
-   * @eexample RGroup
+   *
+   RGroup
    */
-  public RGroup(){
+  public RGroup() {
     elements = null;
   }
 
   /**
    * Use this method to create a copy of a group.
-     * @param grp
-   * @eexample RGroup
+   *
+   * @param grp
+   RGroup
    */
-  public RGroup(RGroup grp){
-    for(int i=0;i<grp.countElements();i++){
+  public RGroup(RGroup grp) {
+    for (int i = 0; i < grp.countElements(); i++) {
       //System.out.println(grp.elements[i].getType());
-      switch(grp.elements[i].getType()){
-      case RGeomElem.MESH:
-        this.addElement(new RMesh((RMesh)grp.elements[i]));
-        break;
-        
-      case RGeomElem.GROUP:
-        this.addElement(new RGroup((RGroup)grp.elements[i]));
-        break;
-        
-      case RGeomElem.POLYGON:
-        this.addElement(new RPolygon((RPolygon)grp.elements[i]));
-        break;
-        
-      case RGeomElem.SHAPE:
-        this.addElement(new RShape((RShape)grp.elements[i]));
-        break;
-        
+      switch (grp.elements[i].getType()) {
+        case RGeomElem.MESH:
+          this.addElement(new RMesh((RMesh) grp.elements[i]));
+          break;
+
+        case RGeomElem.GROUP:
+          this.addElement(new RGroup((RGroup) grp.elements[i]));
+          break;
+
+        case RGeomElem.POLYGON:
+          this.addElement(new RPolygon((RPolygon) grp.elements[i]));
+          break;
+
+        case RGeomElem.SHAPE:
+          this.addElement(new RShape((RShape) grp.elements[i]));
+          break;
+
       }
     }
-    
+
     setStyle(grp);
   }
-  
-  
+
   /**
    * Use this method to get the centroid of the element.
-   * @eexample RGroup_getCentroid
+   *
+   RGroup_getCentroid
    * @return RPoint, the centroid point of the element
-   * @related getBounds ( )
-   * @related getCenter ( )
+   * getBounds ( )
+   * getCenter ( )
    */
   @Override
-  public RPoint getCentroid(){
+  public RPoint getCentroid() {
     RPoint bestCentroid = new RPoint();
     float bestArea = Float.NEGATIVE_INFINITY;
-    if(elements != null){
-      for(int i=0;i<elements.length-1;i++)
-        {
-          float area = elements[i].getArea();
-          if(area > bestArea){
-            bestArea = area;
-            bestCentroid = elements[i].getCentroid();
-          }
+    if (elements != null) {
+      for (int i = 0; i < elements.length - 1; i++) {
+        float area = elements[i].getArea();
+        if (area > bestArea) {
+          bestArea = area;
+          bestCentroid = elements[i].getCentroid();
         }
+      }
       return bestCentroid;
     }
     return null;
   }
-  
+
   /**
    * Use this method to count the number of elements in the group.
-   * @eexample RGroup_countElements
+   *
+   RGroup_countElements
    * @return int, the number elements in the group.
-   * @related addElement ( )
-   * @related removeElement ( )
+   * addElement ( )
+   * removeElement ( )
    */
-  public int countElements(){
-    if(elements==null) return 0;
+  public int countElements() {
+    if (elements == null) {
+      return 0;
+    }
     return elements.length;
   }
-  
+
   @Override
-  public void print(){
+  public void print() {
     System.out.println("group: ");
-    for(int i=0;i<countElements();i++)
-      {
-        System.out.println("---  "+i+" ---");
-        elements[i].print();
-        System.out.println("---------------");
-      }
+    for (int i = 0; i < countElements(); i++) {
+      System.out.println("---  " + i + " ---");
+      elements[i].print();
+      System.out.println("---------------");
+    }
   }
-    
+
   /**
-   * Use this method to draw the group.  This will draw each element at a time, without worrying about intersections or holes.  This is the main difference between having a shape with multiple paths and having a group with multiple shapes.
-   * @eexample RGroup_draw
+   * Use this method to draw the group. This will draw each element at a time,
+   * without worrying about intersections or holes. This is the main difference
+   * between having a shape with multiple paths and having a group with multiple
+   * shapes.
+   *
+   RGroup_draw
    * @param g PGraphics, the graphics object on which to draw the group
    */
   @Override
-  public void draw(PGraphics g){
-    if(!RG.ignoreStyles){
+  public void draw(PGraphics g) {
+    if (!RG.ignoreStyles) {
       saveContext(g);
       setContext(g);
     }
 
-    for(int i=0; i<countElements(); i++){
+    for (int i = 0; i < countElements(); i++) {
       elements[i].draw(g);
     }
 
-    if(!RG.ignoreStyles){
+    if (!RG.ignoreStyles) {
       restoreContext(g);
     }
   }
-  
+
   @Override
-  public void draw(PApplet a){
-    if(!RG.ignoreStyles){
+  public void draw(PApplet a) {
+    if (!RG.ignoreStyles) {
       saveContext(a);
       setContext(a);
     }
 
-    for(int i=0; i<countElements(); i++){
+    for (int i = 0; i < countElements(); i++) {
       elements[i].draw(a);
     }
-    
-    if(!RG.ignoreStyles){
+
+    if (!RG.ignoreStyles) {
       restoreContext(a);
     }
   }
-  
+
   /**
    * Use this method to add a new element.
-   * @eexample RGroup_addElement
-   * @param elem RGeomElem, any kind of RGeomElem to add.  It accepts the classes RShape, RPolygon and RMesh.
-   * @related removeElement ( )
+   *
+   RGroup_addElement
+   * @param elem RGeomElem, any kind of RGeomElem to add. It accepts the classes
+   * RShape, RPolygon and RMesh.
+   * removeElement ( )
    */
-  public final void addElement(RGeomElem elem){
+  public final void addElement(RGeomElem elem) {
     this.append(elem);
   }
-  
+
   /**
    * Use this method to add a new element.
-   * @eexample RGroup_addGroup
+   *
+   RGroup_addGroup
    * @param grupo RGroup, A group of elements to add to this group.
-   * @related removeElement ( )
+   * removeElement ( )
    */
-  public void addGroup(RGroup grupo){
-    for(int i=0;i<grupo.countElements();i++){
+  public void addGroup(RGroup grupo) {
+    for (int i = 0; i < grupo.countElements(); i++) {
       this.addElement(grupo.elements[i]);
     }
   }
-  
+
   /**
    * Use this method to remove an element.
-   * @eexample RGroup_removeElement
+   *
+   RGroup_removeElement
    * @param i int, the index of the element to remove from the group.
-   * @related addElement ( )
+   * addElement ( )
    */
-  public void removeElement(int i) throws RuntimeException{
+  public void removeElement(int i) throws RuntimeException {
     this.extract(i);
   }
-  
+
   /**
-   * Use this method to get a new group whose elements are the corresponding meshes of the elements in the current group.  This can be used for increasing performance in exchange of losing abstraction.
-   * @eexample RGroup_toMeshGroup
+   * Use this method to get a new group whose elements are the corresponding
+   * meshes of the elements in the current group. This can be used for
+   * increasing performance in exchange of losing abstraction.
+   *
+   RGroup_toMeshGroup
    * @return RGroup, the new group made of RMeshes
-   * @related toPolygonGroup ( )
-   * @related toShapeGroup ( )
+   * toPolygonGroup ( )
+   * toShapeGroup ( )
    */
-  public RGroup toMeshGroup() throws RuntimeException{
+  public RGroup toMeshGroup() throws RuntimeException {
     RGroup result = new RGroup();
-    for(int i=0;i<countElements();i++){
+    for (int i = 0; i < countElements(); i++) {
       result.addElement(elements[i].toMesh());
     }
     return result;
   }
-  
+
   /**
-   * Use this method to get a new group whose elements are the corresponding polygons of the elements in the current group.  At this moment there is no implementation for transforming a mesh to a polygon so applying this method to groups holding mesh elements will generate an exception.
-   * @eexample RGroup_toPolygonGroup
+   * Use this method to get a new group whose elements are the corresponding
+   * polygons of the elements in the current group. At this moment there is no
+   * implementation for transforming a mesh to a polygon so applying this method
+   * to groups holding mesh elements will generate an exception.
+   *
+   RGroup_toPolygonGroup
    * @return RGroup, the new group made of RPolygons
-   * @related toMeshGroup ( )
-   * @related toShapeGroup ( )
+   * toMeshGroup ( )
+   * toShapeGroup ( )
    */
-  public RGroup toPolygonGroup() throws RuntimeException{
+  public RGroup toPolygonGroup() throws RuntimeException {
     RGroup result = new RGroup();
-    for(int i=0;i<countElements();i++){
+    for (int i = 0; i < countElements(); i++) {
       RGeomElem element = elements[i];
-      if(element.getType() == RGeomElem.GROUP){
-        RGeomElem newElement = ((RGroup)(element)).toPolygonGroup();
+      if (element.getType() == RGeomElem.GROUP) {
+        RGeomElem newElement = ((RGroup) (element)).toPolygonGroup();
         result.addElement(newElement);
-      }else{
+      } else {
         result.addElement(element.toPolygon());
       }
     }
     result.setStyle(this);
     return result;
   }
-  
+
   /**
-   * Use this method to get a new group whose elements are all the corresponding shapes of the elements in the current group.  At this moment there is no implementation for transforming a mesh or a polygon to a shape so applying this method to groups holding mesh or polygon elements will generate an exception.
-   * @eexample RGroup_toShapeGroup
+   * Use this method to get a new group whose elements are all the corresponding
+   * shapes of the elements in the current group. At this moment there is no
+   * implementation for transforming a mesh or a polygon to a shape so applying
+   * this method to groups holding mesh or polygon elements will generate an
+   * exception.
+   *
+   RGroup_toShapeGroup
    * @return RGroup, the new group made of RShapes
-   * @related toMeshGroup ( )
-   * @related toPolygonGroup ( )
+   * toMeshGroup ( )
+   * toPolygonGroup ( )
    */
-  public RGroup toShapeGroup() throws RuntimeException{
+  public RGroup toShapeGroup() throws RuntimeException {
     RGroup result = new RGroup();
-    for(int i=0;i<countElements();i++){
+    for (int i = 0; i < countElements(); i++) {
       RGeomElem element = elements[i];
-      if(element.getType() == RGeomElem.GROUP){
-        RGeomElem newElement = ((RGroup)(element)).toShapeGroup();
+      if (element.getType() == RGeomElem.GROUP) {
+        RGeomElem newElement = ((RGroup) (element)).toShapeGroup();
         result.addElement(newElement);
-      }else{
+      } else {
         result.addElement(element.toShape());
       }
     }
     result.setStyle(this);
     return result;
   }
-  
+
   /**
-     * @return 
-   * @invisible
+   * @return
    */
   @Override
-  public RMesh toMesh() throws RuntimeException{
+  public RMesh toMesh() throws RuntimeException {
     //throw new RuntimeException("Transforming a Group to a Mesh is not yet implemented.");
     RGroup meshGroup = toMeshGroup();
     RMesh result = new RMesh();
-    for(int i=0;i<countElements();i++){
-      RMesh currentMesh = (RMesh)(meshGroup.elements[i]);
-      for(int j=0;j<currentMesh.countStrips();j++){
+    for (int i = 0; i < countElements(); i++) {
+      RMesh currentMesh = (RMesh) (meshGroup.elements[i]);
+      for (int j = 0; j < currentMesh.countStrips(); j++) {
         result.addStrip(currentMesh.strips[j]);
       }
     }
     result.setStyle(this);
     return result;
   }
-  
+
   /**
-     * @return 
-   * @invisible
+   * @return
    */
   @Override
-  public RPolygon toPolygon() throws RuntimeException{
+  public RPolygon toPolygon() throws RuntimeException {
     //throw new RuntimeException("Transforming a Group to a Polygon is not yet implemented.");
     //RGroup polygonGroup = toPolygonGroup();
     RPolygon result = new RPolygon();
-    for(int i=0;i<countElements();i++){
+    for (int i = 0; i < countElements(); i++) {
       RPolygon currentPolygon = elements[i].toPolygon();
-      for(int j=0;j<currentPolygon.countContours();j++){
+      for (int j = 0; j < currentPolygon.countContours(); j++) {
         result.addContour(currentPolygon.contours[j]);
       }
     }
     result.setStyle(this);
     return result;
   }
-  
+
   /**
-     * @return 
-   * @invisible
+   * @return
    */
   @Override
-  public RShape toShape() throws RuntimeException{
+  public RShape toShape() throws RuntimeException {
     //throw new RuntimeException("Transforming a Group to a Shape is not yet implemented.");
     RShape result = new RShape();
-    for(int i=0;i<countElements();i++){
+    for (int i = 0; i < countElements(); i++) {
       RShape currentShape = elements[i].toShape();
-      for(int j=0;j<currentShape.countPaths();j++){
+      for (int j = 0; j < currentShape.countPaths(); j++) {
         result.addPath(currentShape.paths[j]);
       }
     }
     result.setStyle(this);
     return result;
   }
-  
+
   /**
-   * Use this to return the points of the group.  It returns the points as an array of RPoint.
-   * @eexample RGroup_getHandles
+   * Use this to return the points of the group. It returns the points as an
+   * array of RPoint.
+   *
+   RGroup_getHandles
    * @return RPoint[], the points returned in an array.
-   * */
+   *
+   */
   @Override
-  public RPoint[] getHandles(){
+  public RPoint[] getHandles() {
     int numElements = countElements();
-    if(numElements == 0){
+    if (numElements == 0) {
       return null;
     }
-    
-    RPoint[] result=null;
+
+    RPoint[] result = null;
     RPoint[] newresult;
-    for(int i=0;i<numElements;i++){
+    for (int i = 0; i < numElements; i++) {
       RPoint[] newPoints = elements[i].getHandles();
-      if(newPoints!=null){
-        if(result==null){
+      if (newPoints != null) {
+        if (result == null) {
           result = new RPoint[newPoints.length];
-          System.arraycopy(newPoints,0,result,0,newPoints.length);
-        }else{
+          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);
+          System.arraycopy(result, 0, newresult, 0, result.length);
+          System.arraycopy(newPoints, 0, newresult, result.length, newPoints.length);
           result = newresult;
         }
       }
     }
     return result;
-  }  
-  
-    /**
-     *
-     * @param t
-     * @return
-     */
-    @Override
-  public RPoint getPoint(float t){
+  }
+
+  /**
+   *
+   * @param t
+   * @return
+   */
+  @Override
+  public RPoint getPoint(float t) {
     float[] indAndAdv = indAndAdvAt(t);
-    int indOfElement = (int)(indAndAdv[0]);
+    int indOfElement = (int) (indAndAdv[0]);
     float advOfElement = indAndAdv[1];
 
     return elements[indOfElement].getPoint(advOfElement);
   }
 
   /**
-   * Use this to return the points of the group.  It returns the points as an array of RPoint.
-   * @eexample RGroup_getPoints
+   * Use this to return the points of the group. It returns the points as an
+   * array of RPoint.
+   *
+   RGroup_getPoints
    * @return RPoint[], the points returned in an array.
-   * */
+   *
+   */
   @Override
-  public RPoint[] getPoints(){
+  public RPoint[] getPoints() {
     int numElements = countElements();
-    if(numElements == 0){
+    if (numElements == 0) {
       return null;
     }
 
-    RCommand.segmentAccOffset = RCommand.segmentOffset;    
-    RPoint[] result=null;
+    RCommand.segmentAccOffset = RCommand.segmentOffset;
+    RPoint[] result = null;
     RPoint[] newresult;
-    for(int i=0;i<numElements;i++){
+    for (int i = 0; i < numElements; i++) {
       RPoint[] newPoints = elements[i].getPoints();
-      if(newPoints!=null){
-        if(result==null){
+      if (newPoints != null) {
+        if (result == null) {
           result = new RPoint[newPoints.length];
-          System.arraycopy(newPoints,0,result,0,newPoints.length);
-        }else{
+          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);
+          System.arraycopy(result, 0, newresult, 0, result.length);
+          System.arraycopy(newPoints, 0, newresult, result.length, newPoints.length);
           result = newresult;
         }
       }
     }
-    
+
     return result;
   }
 
   @Override
-  public RPoint getTangent(float t){
+  public RPoint getTangent(float t) {
     float[] indAndAdv = indAndAdvAt(t);
-    int indOfElement = (int)(indAndAdv[0]);
+    int indOfElement = (int) (indAndAdv[0]);
     float advOfElement = indAndAdv[1];
 
     return elements[indOfElement].getTangent(advOfElement);
   }
 
   /**
-   * Use this to return the points of the group.  It returns the points as an array of RPoint.
-   * @eexample RGroup_getPoints
+   * Use this to return the points of the group. It returns the points as an
+   * array of RPoint.
+   *
+   RGroup_getPoints
    * @return RPoint[], the points returned in an array.
-   * */
+   *
+   */
   @Override
-  public RPoint[] getTangents(){
+  public RPoint[] getTangents() {
     int numElements = countElements();
-    if(numElements == 0){
+    if (numElements == 0) {
       return null;
     }
-    
-    RPoint[] result=null;
+
+    RPoint[] result = null;
     RPoint[] newresult;
-    for(int i=0;i<numElements;i++){
+    for (int i = 0; i < numElements; i++) {
       RPoint[] newPoints = elements[i].getTangents();
-      if(newPoints!=null){
-        if(result==null){
+      if (newPoints != null) {
+        if (result == null) {
           result = new RPoint[newPoints.length];
-          System.arraycopy(newPoints,0,result,0,newPoints.length);
-        }else{
+          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);
+          System.arraycopy(result, 0, newresult, 0, result.length);
+          System.arraycopy(newPoints, 0, newresult, result.length, newPoints.length);
           result = newresult;
         }
       }
@@ -436,93 +474,99 @@ public class RGroup extends RGeomElem
   }
 
   /**
-   * Use this to return the points of each path of the group.  It returns the points as an array of arrays of RPoint.
-   * @eexample RGroup_getPoints
+   * Use this to return the points of each path of the group. It returns the
+   * points as an array of arrays of RPoint.
+   *
+   RGroup_getPoints
    * @return RPoint[], the points returned in an array.
-   * */
+   *
+   */
   @Override
-  public RPoint[][] getPointsInPaths(){
+  public RPoint[][] getPointsInPaths() {
     int numElements = countElements();
-    if(numElements == 0){
+    if (numElements == 0) {
       return null;
     }
-    
-    RPoint[][] result=null;
+
+    RPoint[][] result = null;
     RPoint[][] newresult;
-    for(int i=0;i<numElements;i++){
+    for (int i = 0; i < numElements; i++) {
       RPoint[][] newPointPaths = elements[i].getPointsInPaths();
-      if(newPointPaths != null){
-        if(result == null){
+      if (newPointPaths != null) {
+        if (result == null) {
           result = new RPoint[newPointPaths.length][];
-          System.arraycopy(newPointPaths,0,result,0,newPointPaths.length);
-        }else{
+          System.arraycopy(newPointPaths, 0, result, 0, newPointPaths.length);
+        } else {
           newresult = new RPoint[result.length + newPointPaths.length][];
-          System.arraycopy(result,0,newresult,0,result.length);
-          System.arraycopy(newPointPaths,0,newresult,result.length,newPointPaths.length);
+          System.arraycopy(result, 0, newresult, 0, result.length);
+          System.arraycopy(newPointPaths, 0, newresult, result.length, newPointPaths.length);
           result = newresult;
         }
       }
     }
-    return result;    
+    return result;
   }
 
   @Override
-  public RPoint[][] getHandlesInPaths(){
+  public RPoint[][] getHandlesInPaths() {
     int numElements = countElements();
-    if(numElements == 0){
+    if (numElements == 0) {
       return null;
-    }    
-    RPoint[][] result=null;
+    }
+    RPoint[][] result = null;
     RPoint[][] newresult;
-    for(int i=0;i<numElements;i++){
+    for (int i = 0; i < numElements; i++) {
       RPoint[][] newHandlePaths = elements[i].getHandlesInPaths();
-      if(newHandlePaths != null){
-        if(result == null){
+      if (newHandlePaths != null) {
+        if (result == null) {
           result = new RPoint[newHandlePaths.length][];
-          System.arraycopy(newHandlePaths,0,result,0,newHandlePaths.length);
-        }else{
+          System.arraycopy(newHandlePaths, 0, result, 0, newHandlePaths.length);
+        } else {
           newresult = new RPoint[result.length + newHandlePaths.length][];
-          System.arraycopy(result,0,newresult,0,result.length);
-          System.arraycopy(newHandlePaths,0,newresult,result.length,newHandlePaths.length);
+          System.arraycopy(result, 0, newresult, 0, result.length);
+          System.arraycopy(newHandlePaths, 0, newresult, result.length, newHandlePaths.length);
           result = newresult;
         }
       }
     }
-    return result;    
+    return result;
   }
 
   @Override
-  public RPoint[][] getTangentsInPaths(){
+  public RPoint[][] getTangentsInPaths() {
     int numElements = countElements();
-    if(numElements == 0){
+    if (numElements == 0) {
       return null;
-    }    
-    RPoint[][] result=null;
+    }
+    RPoint[][] result = null;
     RPoint[][] newresult;
-    for(int i=0;i<numElements;i++){
+    for (int i = 0; i < numElements; i++) {
       RPoint[][] newTangentPaths = elements[i].getTangentsInPaths();
-      if(newTangentPaths != null){
-        if(result == null){
+      if (newTangentPaths != null) {
+        if (result == null) {
           result = new RPoint[newTangentPaths.length][];
-          System.arraycopy(newTangentPaths,0,result,0,newTangentPaths.length);
-        }else{
+          System.arraycopy(newTangentPaths, 0, result, 0, newTangentPaths.length);
+        } else {
           newresult = new RPoint[result.length + newTangentPaths.length][];
-          System.arraycopy(result,0,newresult,0,result.length);
-          System.arraycopy(newTangentPaths,0,newresult,result.length,newTangentPaths.length);
+          System.arraycopy(result, 0, newresult, 0, result.length);
+          System.arraycopy(newTangentPaths, 0, newresult, result.length, newTangentPaths.length);
           result = newresult;
         }
       }
     }
-    return result;    
+    return result;
   }
 
   /**
-   * Use this to return a specific tangent on the curve.  It returns true if the point passed as a parameter is inside the group.
-   * @param p  the point for which to test containment..
+   * Use this to return a specific tangent on the curve. It returns true if the
+   * point passed as a parameter is inside the group.
+   *
+   * @param p the point for which to test containment..
    * @return boolean, true if the point is in the path.
-   * */
+   *
+   */
   @Override
-  public boolean contains(RPoint p){
+  public boolean contains(RPoint p) {
     float testx = p.x;
     float testy = p.y;
 
@@ -533,63 +577,62 @@ public class RGroup extends RGeomElem
 
     float ymin = bbox.getMinY();
     float ymax = bbox.getMaxY();
-    
-    if( (testx < xmin) || (testx > xmax) || (testy < ymin) || (testy > ymax)){
+
+    if ((testx < xmin) || (testx > xmax) || (testy < ymin) || (testy > ymax)) {
       return false;
     }
-    
+
     // Test for containment in elements
     boolean result = false;
-    for(int i = 0;i<countElements();i++){
+    for (int i = 0; i < countElements(); i++) {
       result |= elements[i].contains(p);
     }
     return result;
   }
 
-  
   /**
    * Use this method to get the type of element this is.
-   * @eexample RPolygon_getType
+   *
+   RPolygon_getType
    * @return int, will allways return RGeomElem.POLYGON
    */
   @Override
-  public int getType(){
+  public int getType() {
     return type;
   }
 
-  private float[] indAndAdvAt(float t){
+  private float[] indAndAdvAt(float t) {
     int indOfElement = 0;
     float[] lengthsCurves = getCurveLengths();
     float lengthCurve = getCurveLength();
 
     /* Calculate the amount of advancement t mapped to each command */
-    /* We use a simple algorithm where we give to each command the same amount of advancement */
-    /* A more useful way would be to give to each command an advancement proportional to the length of the command */
-    
+ /* We use a simple algorithm where we give to each command the same amount of advancement */
+ /* A more useful way would be to give to each command an advancement proportional to the length of the command */
     float accumulatedAdvancement = lengthsCurves[indOfElement] / lengthCurve;
     float prevAccumulatedAdvancement = 0F;
-    
+
     /* Find in what command the advancement point is  */
-    while(t > accumulatedAdvancement){
+    while (t > accumulatedAdvancement) {
       indOfElement++;
       prevAccumulatedAdvancement = accumulatedAdvancement;
       accumulatedAdvancement += (lengthsCurves[indOfElement] / lengthCurve);
     }
-    
-    float advOfElement = (t-prevAccumulatedAdvancement) / (lengthsCurves[indOfElement] / lengthCurve);
+
+    float advOfElement = (t - prevAccumulatedAdvancement) / (lengthsCurves[indOfElement] / lengthCurve);
 
     float[] indAndAdv = new float[2];
 
     indAndAdv[0] = indOfElement;
     indAndAdv[1] = advOfElement;
-    
+
     return indAndAdv;
   }
 
-  public RGroup[] split(float t){
+  public RGroup[] split(float t) {
     RGroup[] result = new RGroup[2];
 
-    if(t == 0.0F){ 
+    if (t == 0.0F) {
       result[0] = new RGroup();
       result[1] = new RGroup(this);
       result[0].setStyle(this);
@@ -597,8 +640,8 @@ public class RGroup extends RGeomElem
 
       return result;
     }
-    
-    if(t == 1.0F){
+
+    if (t == 1.0F) {
       result[0] = new RGroup(this);
       result[1] = new RGroup();
       result[0].setStyle(this);
@@ -611,300 +654,298 @@ public class RGroup extends RGeomElem
     result[1] = new RGroup();
 
     float[] indAndAdv = indAndAdvAt(t);
-    int indOfElement = (int)(indAndAdv[0]);
+    int indOfElement = (int) (indAndAdv[0]);
     float advOfElement = indAndAdv[1];
 
     // Add the elements before the cut point
-    for(int i=0; i<indOfElement; i++){
-      switch(elements[i].getType()){
-      case RGeomElem.MESH:
-        result[0].addElement(new RMesh((RMesh)elements[i]));
-        break;
-        
-      case RGeomElem.GROUP:
-        result[0].addElement(new RGroup((RGroup)elements[i]));
-        break;
-        
-      case RGeomElem.POLYGON:
-        result[0].addElement(new RPolygon((RPolygon)elements[i]));
-        break;
-        
-      case RGeomElem.SHAPE:
-        result[0].addElement(new RShape((RShape)elements[i]));
-        break;
+    for (int i = 0; i < indOfElement; i++) {
+      switch (elements[i].getType()) {
+        case RGeomElem.MESH:
+          result[0].addElement(new RMesh((RMesh) elements[i]));
+          break;
+
+        case RGeomElem.GROUP:
+          result[0].addElement(new RGroup((RGroup) elements[i]));
+          break;
+
+        case RGeomElem.POLYGON:
+          result[0].addElement(new RPolygon((RPolygon) elements[i]));
+          break;
+
+        case RGeomElem.SHAPE:
+          result[0].addElement(new RShape((RShape) elements[i]));
+          break;
       }
     }
 
     // Add the cut point element cutted
     RGeomElem element = this.elements[indOfElement];
-    switch(element.getType())
-      {
+    switch (element.getType()) {
       case RGeomElem.GROUP:
-        RGroup[] splittedGroups = ((RGroup)element).split(advOfElement);
-        if( splittedGroups != null ){
+        RGroup[] splittedGroups = ((RGroup) element).split(advOfElement);
+        if (splittedGroups != null) {
           result[0].addElement(new RGroup(splittedGroups[0]));
           result[1].addElement(new RGroup(splittedGroups[1]));
         }
         break;
-        
+
       case RGeomElem.SHAPE:
-        RShape[] splittedShapes = ((RShape)element).split(advOfElement);
-        if( splittedShapes != null ){
+        RShape[] splittedShapes = ((RShape) element).split(advOfElement);
+        if (splittedShapes != null) {
           result[0].addElement(new RShape(splittedShapes[0]));
           result[1].addElement(new RShape(splittedShapes[1]));
         }
         break;
-      }
+    }
 
     // Add the elements after the cut point    
-    for(int i=indOfElement+1; i<countElements(); i++){
-      switch(elements[i].getType()){
-      case RGeomElem.MESH:
-        result[1].addElement(new RMesh((RMesh)elements[i]));
-        break;
-        
-      case RGeomElem.GROUP:
-        result[1].addElement(new RGroup((RGroup)elements[i]));
-        break;
-        
-      case RGeomElem.POLYGON:
-        result[1].addElement(new RPolygon((RPolygon)elements[i]));
-        break;
-        
-      case RGeomElem.SHAPE:
-        result[1].addElement(new RShape((RShape)elements[i]));
-        break;
+    for (int i = indOfElement + 1; i < countElements(); i++) {
+      switch (elements[i].getType()) {
+        case RGeomElem.MESH:
+          result[1].addElement(new RMesh((RMesh) elements[i]));
+          break;
+
+        case RGeomElem.GROUP:
+          result[1].addElement(new RGroup((RGroup) elements[i]));
+          break;
+
+        case RGeomElem.POLYGON:
+          result[1].addElement(new RPolygon((RPolygon) elements[i]));
+          break;
+
+        case RGeomElem.SHAPE:
+          result[1].addElement(new RShape((RShape) elements[i]));
+          break;
       }
     }
-    
+
     result[0].setStyle(this);
     result[1].setStyle(this);
-    
+
     return result;
   }
 
-  public RGroup[] splitPaths(float t){
+  public RGroup[] splitPaths(float t) {
     RGroup[] result = new RGroup[2];
     result[0] = new RGroup();
     result[1] = new RGroup();
-    for(int i = 0; i<this.countElements(); i++){
+    for (int i = 0; i < this.countElements(); i++) {
       RGeomElem element = this.elements[i];
-      
-      switch(element.getType())
-        {
+
+      switch (element.getType()) {
         case RGeomElem.GROUP:
-          RGroup[] splittedGroups = ((RGroup)element).splitPaths(t);
-          if( splittedGroups != null ){
+          RGroup[] splittedGroups = ((RGroup) element).splitPaths(t);
+          if (splittedGroups != null) {
             result[0].addElement(splittedGroups[0]);
             result[1].addElement(splittedGroups[1]);
           }
           break;
-          
+
         case RGeomElem.SHAPE:
-          RShape[] splittedShapes = ((RShape)element).splitPaths(t);
-          if( splittedShapes != null ){
+          RShape[] splittedShapes = ((RShape) element).splitPaths(t);
+          if (splittedShapes != null) {
             result[0].addElement(splittedShapes[0]);
             result[1].addElement(splittedShapes[1]);
           }
           break;
-        }
+      }
     }
     result[0].setStyle(this);
     result[1].setStyle(this);
 
     return result;
   }
-  
+
   /**
    * Use this to insert a split point into each command of the group.
-   * @eexample insertHandleInPaths
-   * @param t float, the parameter of advancement on the curve. t must have values between 0 and 1.
-   * */
-  public void insertHandleInPaths(float t){
-    if((t == 0F) || (t == 1F)){
+   *
+   insertHandleInPaths
+   * @param t float, the parameter of advancement on the curve. t must have
+   * values between 0 and 1.
+   *
+   */
+  public void insertHandleInPaths(float t) {
+    if ((t == 0F) || (t == 1F)) {
       return;
     }
-    
-    for(int i = 0; i<this.countElements(); i++){
+
+    for (int i = 0; i < this.countElements(); i++) {
       RGeomElem element = this.elements[i];
-      
-      switch(element.getType())
-        {
+
+      switch (element.getType()) {
         case RGeomElem.GROUP:
-          ((RGroup)element).insertHandleInPaths(t);
+          ((RGroup) element).insertHandleInPaths(t);
           break;
-          
+
         case RGeomElem.SHAPE:
-          ((RShape)element).insertHandleInPaths(t);
+          ((RShape) element).insertHandleInPaths(t);
           break;
-        }
-    }    
+      }
+    }
   }
-  
-  
+
   @Override
-  protected void calculateCurveLengths(){
+  protected void calculateCurveLengths() {
     lenCurves = new float[countElements()];
     lenCurve = 0F;
-    for(int i=0;i<countElements();i++){
-      lenCurves[i] = elements[i].getCurveLength();  
+    for (int i = 0; i < countElements(); i++) {
+      lenCurves[i] = elements[i].getCurveLength();
       lenCurve += lenCurves[i];
     }
   }
-  
-  
+
   /**
    * Use this method to adapt a group of of figures to a group.
-     * @param wght
-     * @param lngthOffset
-   * @eexample RGroup_adapt
-   * @param grp  the path to which to adapt
+   *
+   * @param wght
+   * @param lngthOffset
+   RGroup_adapt
+   * @param grp the path to which to adapt
    */
-  public void adapt(RGroup grp, float wght, float lngthOffset) throws RuntimeException{
+  public void adapt(RGroup grp, float wght, float lngthOffset) throws RuntimeException {
     RRectangle c = this.getBounds();
     float xmin = c.getMinX();
     float xmax = c.getMaxX();
     float ymax = c.getMaxY();
-    
+
     int numElements = this.countElements();
-    
-    switch(RG.adaptorType){
-    case RG.BYPOINT:
-      for(int i=0;i<numElements;i++){
-        RGeomElem elem = this.elements[i];
-        RPoint[] ps = elem.getHandles();
-        if(ps != null){
+
+    switch (RG.adaptorType) {
+      case RG.BYPOINT:
+        for (int i = 0; i < numElements; i++) {
+          RGeomElem elem = this.elements[i];
+          RPoint[] ps = elem.getHandles();
+          if (ps != null) {
             for (RPoint p1 : ps) {
-                float px = p1.x;
-                float py = p1.y;
-                float t = ((px-xmin)/(xmax-xmin) + lngthOffset ) % 1.001F;
-                float amp = (ymax-py);
-                RPoint tg = grp.getTangent(t);
-                RPoint p = grp.getPoint(t);
-                float angle = (float)Math.atan2(tg.y, tg.x) - (float)Math.PI/2F;
-                p1.x = p.x + wght*amp*(float)Math.cos(angle);
-                p1.y = p.y + wght*amp*(float)Math.sin(angle);
+              float px = p1.x;
+              float py = p1.y;
+              float t = ((px - xmin) / (xmax - xmin) + lngthOffset) % 1.001F;
+              float amp = (ymax - py);
+              RPoint tg = grp.getTangent(t);
+              RPoint p = grp.getPoint(t);
+              float angle = (float) Math.atan2(tg.y, tg.x) - (float) Math.PI / 2F;
+              p1.x = p.x + wght * amp * (float) Math.cos(angle);
+              p1.y = p.y + wght * amp * (float) Math.sin(angle);
             }
+          }
         }
-      }
-      break;
-    case RG.BYELEMENTPOSITION:
-      
-      for(int i=0;i<numElements;i++){
-        RGeomElem elem = this.elements[i];
-        RRectangle elemc = elem.getBounds();
-        
-        float px = (elemc.bottomRight.x + elemc.topLeft.x) / 2F;
-        float py = (elemc.bottomRight.y - elemc.topLeft.y) / 2F;
-        float t = ((px-xmin)/(xmax-xmin) + lngthOffset ) % 1F;
-        
-        RPoint tg = grp.getTangent(t);
-        RPoint p = grp.getPoint(t);
-        float angle = (float)Math.atan2(tg.y, tg.x);
-        
-        RPoint pletter = new RPoint(px,py);
-        p.sub(pletter);
-        
-        RMatrix mtx = new RMatrix();
-        mtx.translate(p);
-        mtx.rotate(angle,pletter);
-        mtx.scale(wght,pletter);
-        
-        elem.transform(mtx);
-      }
-      break;
-      
-    case RG.BYELEMENTINDEX:
-      
-      for(int i=0;i<numElements;i++){
-        RGeomElem elem = this.elements[i];
-        RRectangle elemc = elem.getBounds();
-        
-        float px = (elemc.bottomRight.x + elemc.topLeft.x) / 2F;
-        float py = (elemc.bottomRight.y - elemc.topLeft.y) / 2F;
-        float t = ((float)i/(float)numElements + lngthOffset ) % 1F;
-        
-        RPoint tg = grp.getTangent(t);
-        RPoint p = grp.getPoint(t);
-        float angle = (float)Math.atan2(tg.y, tg.x);
-        
-        RPoint pletter = new RPoint(px,py);
-        p.sub(pletter);
-        
-        RMatrix mtx = new RMatrix();
-        mtx.translate(p);
-        mtx.rotate(angle,pletter);
-        mtx.scale(wght,pletter);
-        
-        elem.transform(mtx);
-      }
-      break;
-      
-    default:
-      throw new RuntimeException("Unknown adaptor type : "+RG.adaptorType+". The method RG.setAdaptor() only accepts RG.BYPOINT or RG.BYELEMENT as parameter values.");
+        break;
+      case RG.BYELEMENTPOSITION:
+
+        for (int i = 0; i < numElements; i++) {
+          RGeomElem elem = this.elements[i];
+          RRectangle elemc = elem.getBounds();
+
+          float px = (elemc.bottomRight.x + elemc.topLeft.x) / 2F;
+          float py = (elemc.bottomRight.y - elemc.topLeft.y) / 2F;
+          float t = ((px - xmin) / (xmax - xmin) + lngthOffset) % 1F;
+
+          RPoint tg = grp.getTangent(t);
+          RPoint p = grp.getPoint(t);
+          float angle = (float) Math.atan2(tg.y, tg.x);
+
+          RPoint pletter = new RPoint(px, py);
+          p.sub(pletter);
+
+          RMatrix mtx = new RMatrix();
+          mtx.translate(p);
+          mtx.rotate(angle, pletter);
+          mtx.scale(wght, pletter);
+
+          elem.transform(mtx);
+        }
+        break;
+
+      case RG.BYELEMENTINDEX:
+
+        for (int i = 0; i < numElements; i++) {
+          RGeomElem elem = this.elements[i];
+          RRectangle elemc = elem.getBounds();
+
+          float px = (elemc.bottomRight.x + elemc.topLeft.x) / 2F;
+          float py = (elemc.bottomRight.y - elemc.topLeft.y) / 2F;
+          float t = ((float) i / (float) numElements + lngthOffset) % 1F;
+
+          RPoint tg = grp.getTangent(t);
+          RPoint p = grp.getPoint(t);
+          float angle = (float) Math.atan2(tg.y, tg.x);
+
+          RPoint pletter = new RPoint(px, py);
+          p.sub(pletter);
+
+          RMatrix mtx = new RMatrix();
+          mtx.translate(p);
+          mtx.rotate(angle, pletter);
+          mtx.scale(wght, pletter);
+
+          elem.transform(mtx);
+        }
+        break;
+
+      default:
+        throw new RuntimeException("Unknown adaptor type : " + RG.adaptorType + ". The method RG.setAdaptor() only accepts RG.BYPOINT or RG.BYELEMENT as parameter values.");
     }
   }
-  
-  public void adapt(RGroup grp) throws RuntimeException{
+
+  public void adapt(RGroup grp) throws RuntimeException {
     adapt(grp, RG.adaptorScale, RG.adaptorLengthOffset);
   }
 
-  public void adapt(RShape shp){
+  public void adapt(RShape shp) {
     RGroup grp = new RGroup();
     grp.addElement(shp);
     adapt(grp);
   }
 
-  public void adapt(RShape shp, float wght, float lngthOffset){
+  public void adapt(RShape shp, float wght, float lngthOffset) {
     RGroup grp = new RGroup();
     grp.addElement(shp);
     adapt(grp, wght, lngthOffset);
   }
-  
 
-  public void polygonize(){
+  public void polygonize() {
     RGroup grp = toPolygonGroup().toShapeGroup();
     this.elements = grp.elements;
   }
 
-  private void append(RGeomElem elem){
+  private void append(RGeomElem elem) {
     RGeomElem[] newelements;
-    if(elements==null){
+    if (elements == null) {
       newelements = new RGeomElem[1];
       newelements[0] = elem;
-    }else{
-      newelements = new RGeomElem[this.elements.length+1];
-      System.arraycopy(this.elements,0,newelements,0,this.elements.length);
-      newelements[this.elements.length]=elem;
+    } else {
+      newelements = new RGeomElem[this.elements.length + 1];
+      System.arraycopy(this.elements, 0, newelements, 0, this.elements.length);
+      newelements[this.elements.length] = elem;
     }
-    this.elements=newelements;
+    this.elements = newelements;
   }
-  
-  private void extract(int i) throws RuntimeException{
+
+  private void extract(int i) throws RuntimeException {
     RGeomElem[] newelements;
-    if(elements==null){
+    if (elements == null) {
       throw new RuntimeException("The group is empty. No elements to remove.");
-    }else{
-      if(i<0){
+    } else {
+      if (i < 0) {
         throw new RuntimeException("Negative values for indexes are not valid.");
       }
-      if(i>elements.length-1){
+      if (i > elements.length - 1) {
         throw new RuntimeException("Index out of the bounds of the group.  You are trying to erase an element with an index higher than the number of elements in the group.");
       }
-      if(elements.length==1){
+      if (elements.length == 1) {
         newelements = null;
-      }else if(i==0){
-        newelements = new RGeomElem[this.elements.length-1];
-        System.arraycopy(this.elements,1,newelements,0,this.elements.length-1);
-      }else if(i==elements.length-1){
-        newelements = new RGeomElem[this.elements.length-1];
-        System.arraycopy(this.elements,0,newelements,0,this.elements.length-1);
-      }else{
-        newelements = new RGeomElem[this.elements.length-1];
-        System.arraycopy(this.elements,0,newelements,0,i);
-        System.arraycopy(this.elements,i+1,newelements,i,this.elements.length-i-1);
+      } else if (i == 0) {
+        newelements = new RGeomElem[this.elements.length - 1];
+        System.arraycopy(this.elements, 1, newelements, 0, this.elements.length - 1);
+      } else if (i == elements.length - 1) {
+        newelements = new RGeomElem[this.elements.length - 1];
+        System.arraycopy(this.elements, 0, newelements, 0, this.elements.length - 1);
+      } else {
+        newelements = new RGeomElem[this.elements.length - 1];
+        System.arraycopy(this.elements, 0, newelements, 0, i);
+        System.arraycopy(this.elements, i + 1, newelements, i, this.elements.length - i - 1);
       }
     }
-    this.elements=newelements;
+    this.elements = newelements;
   }
 }