geomerative 0.4.3-java → 2.1.0-java

data/src/geomerative/RPath.java

@@ -28,495 +28,494 @@ import processing.core.PGraphics;
  * Paths are ordered lists of commands (RCommand) which define the outlines of
  * shapes. Paths can be self-intersecting.
  *
- * @eexample RPath
- * @usage Geometry
- * @related RCommand
- * @related RPolygon
- * @extended
+ RPath
+ * Geometry
+ * RCommand
+ * RPolygon
+
  *
  */
 public class RPath extends RGeomElem {
 
-    /**
-     * @invisible
-     */
-    public int type = RGeomElem.SUBSHAPE;
-
-    /**
-     * Array of RCommand objects holding the commands of the path.
-     *
-     * @eexample commands
-     * @related RCommand
-     * @related countCommands ( )
-     */
-    public RCommand[] commands;
-
-    /**
-     * Last point from where to add the next command. Initialized to (0, 0).
-     *
-     * @eexample lastPoint
-     * @related RPoint
-     * @invisible
-     */
-    public RPoint lastPoint;
-
-    boolean closed = false;
-
-    /**
-     * Create a new empty path.
-     *
-     * @eexample RPath
-     */
-    public RPath() {
-        this.lastPoint = new RPoint();
-    }
-
-    /**
-     * Create a new path, given an array of points.
-     *
-     * @eexample RPath
-     * @param points the points of the new path
-     */
-    public RPath(RPoint[] points) {
-        if (points == null) {
-            return;
-        }
-        this.lastPoint = points[0];
-
-        for (int i = 1; i < points.length; i++) {
-            this.addLineTo(points[i]);
-        }
-
+  /**
+   *
+   */
+  public int type = RGeomElem.SUBSHAPE;
+
+  /**
+   * Array of RCommand objects holding the commands of the path.
+   *
+   commands
+   * RCommand
+   * countCommands ( )
+   */
+  public RCommand[] commands;
+
+  /**
+   * Last point from where to add the next command. Initialized to (0, 0).
+   *
+   lastPoint
+   * RPoint
+   *
+   */
+  public RPoint lastPoint;
+
+  boolean closed = false;
+
+  /**
+   * Create a new empty path.
+   *
+   RPath
+   */
+  public RPath() {
+    this.lastPoint = new RPoint();
+  }
+
+  /**
+   * Create a new path, given an array of points.
+   *
+   RPath
+   * @param points the points of the new path
+   */
+  public RPath(RPoint[] points) {
+    if (points == null) {
+      return;
     }
+    this.lastPoint = points[0];
 
-    /**
-     * Create a new path, given the coordinates of the first point.
-     *
-     * @eexample RPath
-     * @param x x coordinate of the first point of the new path
-     * @param y y coordinate of the first point of the new path
-     */
-    public RPath(float x, float y) {
-        this.lastPoint = new RPoint(x, y);
+    for (int i = 1; i < points.length; i++) {
+      this.addLineTo(points[i]);
     }
 
-    /**
-     * Create a new path, given the first point.
-     *
-     * @eexample RPath
-     * @param p first point of the new path
-     */
-    public RPath(RPoint p) {
-        this.lastPoint = p;
+  }
+
+  /**
+   * Create a new path, given the coordinates of the first point.
+   *
+   RPath
+   * @param x x coordinate of the first point of the new path
+   * @param y y coordinate of the first point of the new path
+   */
+  public RPath(float x, float y) {
+    this.lastPoint = new RPoint(x, y);
+  }
+
+  /**
+   * Create a new path, given the first point.
+   *
+   RPath
+   * @param p first point of the new path
+   */
+  public RPath(RPoint p) {
+    this.lastPoint = p;
+  }
+
+  /**
+   * Copy a path.
+   *
+   RPath
+   * @param s path to be copied
+   */
+  public RPath(RPath s) {
+    int numCommands = s.countCommands();
+    if (numCommands != 0) {
+      lastPoint = new RPoint(s.commands[0].startPoint);
+      for (int i = 0; i < numCommands; i++) {
+        this.append(new RCommand(s.commands[i], lastPoint));
+        lastPoint = commands[i].endPoint;
+      }
     }
-
-    /**
-     * Copy a path.
-     *
-     * @eexample RPath
-     * @param s path to be copied
-     */
-    public RPath(RPath s) {
-        int numCommands = s.countCommands();
-        if (numCommands != 0) {
-            lastPoint = new RPoint(s.commands[0].startPoint);
-            for (int i = 0; i < numCommands; i++) {
-                this.append(new RCommand(s.commands[i], lastPoint));
-                lastPoint = commands[i].endPoint;
-            }
-        }
-
-        closed = s.closed;
-        setStyle(s);
-    }
-
-    public RPath(RCommand c) {
-        this();
-        this.addCommand(c);
+    closed = s.closed;
+    setStyle(s);
+  }
+
+  public RPath(RCommand c) {
+    this();
+    this.addCommand(c);
+  }
+
+  /**
+   * Use this method to count the number of commands in the contour.
+   *
+   countCommands
+   * @return int, the number commands in the contour
+   */
+  public int countCommands() {
+    if (this.commands == null) {
+      return 0;
     }
 
-    /**
-     * Use this method to count the number of commands in the contour.
-     *
-     * @eexample countCommands
-     * @return int, the number commands in the contour
-     */
-    public int countCommands() {
-        if (this.commands == null) {
-            return 0;
+    return this.commands.length;
+  }
+
+  /**
+   * Use this to return the start, control and end points of the path. It
+   * returns the points in the way of an array of RPoint.
+   *
+   getHandles
+   * @return RPoint[], the start, control and end points returned in an array.
+   *
+   */
+  @Override
+  public RPoint[] getHandles() {
+    int numCommands = countCommands();
+
+    RPoint[] result = null;
+    RPoint[] newresult;
+    for (int i = 0; i < numCommands; i++) {
+      RPoint[] newPoints = commands[i].getHandles();
+      if (newPoints != null) {
+        if (result == null) {
+          result = new RPoint[newPoints.length];
+          System.arraycopy(newPoints, 0, result, 0, newPoints.length);
+        } else {
+          int overlap = 0;
+          if (newPoints[0] == result[result.length - 1]) {
+            overlap = 1;
+          }
+          newresult = new RPoint[result.length + newPoints.length - overlap];
+          System.arraycopy(result, 0, newresult, 0, result.length);
+          System.arraycopy(newPoints, overlap, newresult, result.length, newPoints.length - overlap);
+          result = newresult;
         }
-
-        return this.commands.length;
+      }
     }
-
-    /**
-     * Use this to return the start, control and end points of the path. It
-     * returns the points in the way of an array of RPoint.
-     *
-     * @eexample getHandles
-     * @return RPoint[], the start, control and end points returned in an array.
-     *
-     */
-    @Override
-    public RPoint[] getHandles() {
-        int numCommands = countCommands();
-
-        RPoint[] result = null;
-        RPoint[] newresult;
-        for (int i = 0; i < numCommands; i++) {
-            RPoint[] newPoints = commands[i].getHandles();
-            if (newPoints != null) {
-                if (result == null) {
-                    result = new RPoint[newPoints.length];
-                    System.arraycopy(newPoints, 0, result, 0, newPoints.length);
-                } else {
-                    int overlap = 0;
-                    if (newPoints[0] == result[result.length - 1]) {
-                        overlap = 1;
-                    }
-                    newresult = new RPoint[result.length + newPoints.length - overlap];
-                    System.arraycopy(result, 0, newresult, 0, result.length);
-                    System.arraycopy(newPoints, overlap, newresult, result.length, newPoints.length - overlap);
-                    result = newresult;
-                }
-            }
-        }
-        return result;
+    return result;
+  }
+
+  /**
+   * Use this to return the points on the curve. It returns the points in the
+   * way of an array of RPoint.
+   *
+   getPoints
+   * @return RPoint[], the vertices returned in an array.
+   *
+   */
+  @Override
+  public RPoint[] getPoints() {
+    int numCommands = countCommands();
+    if (numCommands == 0) {
+      return null;
     }
 
-    /**
-     * Use this to return the points on the curve. It returns the points in the
-     * way of an array of RPoint.
-     *
-     * @eexample getPoints
-     * @return RPoint[], the vertices returned in an array.
-     *
-     */
-    @Override
-    public RPoint[] getPoints() {
-        int numCommands = countCommands();
-        if (numCommands == 0) {
-            return null;
-        }
-
-        // Add the curve points of each command
-        // First set the accumulated offset to the value of the inital offset
-        RCommand.segmentAccOffset = RCommand.segmentOffset;
-        RPoint[] result = null;
-        RPoint[] newresult;
-        for (int i = 0; i < numCommands; i++) {
-            RPoint[] newPoints = commands[i].getPoints(false);
-            if (newPoints != null) {
-                if (result == null) {
-                    result = new RPoint[newPoints.length];
-                    System.arraycopy(newPoints, 0, result, 0, newPoints.length);
-                } else {
-                    // Check for overlapping
-                    // Overlapping happens when the last point of the last command 
-                    // is the same as the first point of the current command
-                    RPoint lastp = result[result.length - 1];
-                    RPoint firstp = newPoints[0];
-                    int overlap = 0;
-                    if ((lastp.x == firstp.x) && (lastp.y == firstp.y)) {
-                        overlap = 1;
-                    }
-                    newresult = new RPoint[result.length + newPoints.length - overlap];
-                    System.arraycopy(result, 0, newresult, 0, result.length);
-                    System.arraycopy(newPoints, overlap, newresult, result.length, newPoints.length - overlap);
-                    result = newresult;
-                }
-            }
-        }
-        // Always add last point
+    // Add the curve points of each command
+    // First set the accumulated offset to the value of the inital offset
+    RCommand.segmentAccOffset = RCommand.segmentOffset;
+    RPoint[] result = null;
+    RPoint[] newresult;
+    for (int i = 0; i < numCommands; i++) {
+      RPoint[] newPoints = commands[i].getPoints(false);
+      if (newPoints != null) {
         if (result == null) {
-            return result;
+          result = new RPoint[newPoints.length];
+          System.arraycopy(newPoints, 0, result, 0, newPoints.length);
+        } else {
+          // Check for overlapping
+          // Overlapping happens when the last point of the last command 
+          // is the same as the first point of the current command
+          RPoint lastp = result[result.length - 1];
+          RPoint firstp = newPoints[0];
+          int overlap = 0;
+          if ((lastp.x == firstp.x) && (lastp.y == firstp.y)) {
+            overlap = 1;
+          }
+          newresult = new RPoint[result.length + newPoints.length - overlap];
+          System.arraycopy(result, 0, newresult, 0, result.length);
+          System.arraycopy(newPoints, overlap, newresult, result.length, newPoints.length - overlap);
+          result = newresult;
         }
-        newresult = new RPoint[result.length + 1];
-        System.arraycopy(result, 0, newresult, 0, result.length);
-        newresult[newresult.length - 1] = new RPoint(commands[numCommands - 1].endPoint);
-        return newresult;
+      }
     }
-
-    /**
-     * Use this to return the points of each path of the path. It returns the
-     * points in the way of an array of array of RPoint.
-     *
-     * @eexample RGroup_getPoints
-     * @return RPoint[], the points returned in an array.
-     *
-     */
-    @Override
-    public RPoint[][] getPointsInPaths() {
-        RPoint[][] result = {this.getPoints()};
-        return result;
+    // Always add last point
+    if (result == null) {
+      return result;
     }
-
-    /**
-     * Use this to return the handles of each path of the path. It returns the
-     * handles in the way of an array of array of RPoint.
-     *
-     * @eexample RGroup_getHandles
-     * @return RPoint[], the handles returned in an array.
-     *
-     */
-    @Override
-    public RPoint[][] getHandlesInPaths() {
-        RPoint[][] result = {this.getHandles()};
-        return result;
+    newresult = new RPoint[result.length + 1];
+    System.arraycopy(result, 0, newresult, 0, result.length);
+    newresult[newresult.length - 1] = new RPoint(commands[numCommands - 1].endPoint);
+    return newresult;
+  }
+
+  /**
+   * Use this to return the points of each path of the path. It returns the
+   * points in the way of an array of array of RPoint.
+   *
+   RGroup_getPoints
+   * @return RPoint[], the points returned in an array.
+   *
+   */
+  @Override
+  public RPoint[][] getPointsInPaths() {
+    RPoint[][] result = {this.getPoints()};
+    return result;
+  }
+
+  /**
+   * Use this to return the handles of each path of the path. It returns the
+   * handles in the way of an array of array of RPoint.
+   *
+   RGroup_getHandles
+   * @return RPoint[], the handles returned in an array.
+   *
+   */
+  @Override
+  public RPoint[][] getHandlesInPaths() {
+    RPoint[][] result = {this.getHandles()};
+    return result;
+  }
+
+  /**
+   * Use this to return the tangents of each path of the path. It returns the
+   * tangents in the way of an array of array of RPoint.
+   *
+   RGroup_getTangents
+   * @return RPoint[], the tangents returned in an array.
+   *
+   */
+  @Override
+  public RPoint[][] getTangentsInPaths() {
+    RPoint[][] result = {this.getTangents()};
+    return result;
+  }
+
+  @Override
+  protected void calculateCurveLengths() {
+    lenCurves = new float[countCommands()];
+    lenCurve = 0F;
+    for (int i = 0; i < countCommands(); i++) {
+      lenCurves[i] = commands[i].getCurveLength();
+      lenCurve += lenCurves[i];
     }
-
-    /**
-     * Use this to return the tangents of each path of the path. It returns the
-     * tangents in the way of an array of array of RPoint.
-     *
-     * @eexample RGroup_getTangents
-     * @return RPoint[], the tangents returned in an array.
-     *
-     */
-    @Override
-    public RPoint[][] getTangentsInPaths() {
-        RPoint[][] result = {this.getTangents()};
-        return result;
+  }
+
+  /**
+   * Use this to return the tangents on the curve. It returns the vectors in the
+   * way of an array of RPoint.
+   *
+   getTangents
+   * @return RPoint[], the tangent vectors returned in an array.
+   *
+   */
+  @Override
+  public RPoint[] getTangents() {
+    int numCommands = countCommands();
+    if (numCommands == 0) {
+      return null;
     }
 
-    @Override
-    protected void calculateCurveLengths() {
-        lenCurves = new float[countCommands()];
-        lenCurve = 0F;
-        for (int i = 0; i < countCommands(); i++) {
-            lenCurves[i] = commands[i].getCurveLength();
-            lenCurve += lenCurves[i];
+    RPoint[] result = null;
+    RPoint[] newresult;
+    for (int i = 0; i < numCommands; i++) {
+      RPoint[] newTangents = commands[i].getTangents();
+      if (newTangents != null) {
+        if (newTangents.length != 1) {
+          int overlap = 1;
+          if (result == null) {
+            result = new RPoint[newTangents.length];
+            System.arraycopy(newTangents, 0, result, 0, newTangents.length);
+          } else {
+            newresult = new RPoint[result.length + newTangents.length - overlap];
+            System.arraycopy(result, 0, newresult, 0, result.length);
+            System.arraycopy(newTangents, overlap, newresult, result.length, newTangents.length - overlap);
+            result = newresult;
+          }
         }
+      }
     }
-
-    /**
-     * Use this to return the tangents on the curve. It returns the vectors in
-     * the way of an array of RPoint.
-     *
-     * @eexample getTangents
-     * @return RPoint[], the tangent vectors returned in an array.
-     *
-     */
-    @Override
-    public RPoint[] getTangents() {
-        int numCommands = countCommands();
-        if (numCommands == 0) {
-            return null;
-        }
-
-        RPoint[] result = null;
-        RPoint[] newresult;
-        for (int i = 0; i < numCommands; i++) {
-            RPoint[] newTangents = commands[i].getTangents();
-            if (newTangents != null) {
-                if (newTangents.length != 1) {
-                    int overlap = 1;
-                    if (result == null) {
-                        result = new RPoint[newTangents.length];
-                        System.arraycopy(newTangents, 0, result, 0, newTangents.length);
-                    } else {
-                        newresult = new RPoint[result.length + newTangents.length - overlap];
-                        System.arraycopy(result, 0, newresult, 0, result.length);
-                        System.arraycopy(newTangents, overlap, newresult, result.length, newTangents.length - overlap);
-                        result = newresult;
-                    }
-                }
-            }
-        }
-        return result;
+    return result;
+  }
+
+  /**
+   * Use this to return the intersection points between this path and a command.
+   * Returns null if no intersection exists.
+   *
+   * @param other
+   * @return RPoint[], the intersection points returned in an array.
+   *
+   */
+  public RPoint[] intersectionPoints(RCommand other) {
+    int numCommands = countCommands();
+    if (numCommands == 0) {
+      return null;
     }
 
-    /**
-     * Use this to return the intersection points between this path and a
-     * command. Returns null if no intersection exists.
-     *
-     * @param other
-     * @return RPoint[], the intersection points returned in an array.
-     *
-     */
-    public RPoint[] intersectionPoints(RCommand other) {
-        int numCommands = countCommands();
-        if (numCommands == 0) {
-            return null;
-        }
-
-        RPoint[] result = null;
-        RPoint[] newresult;
-        for (int i = 0; i < numCommands; i++) {
-            RPoint[] newPoints = commands[i].intersectionPoints(other);
-            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;
-                }
-            }
+    RPoint[] result = null;
+    RPoint[] newresult;
+    for (int i = 0; i < numCommands; i++) {
+      RPoint[] newPoints = commands[i].intersectionPoints(other);
+      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 return the intersection points between two paths. Returns
-     * null if no intersection exists.
-     *
-     * @param other
-     * @return RPoint[], the intersection points returned in an array.
-     *
-     */
-    public RPoint[] intersectionPoints(RPath other) {
-        int numCommands = countCommands();
-        int numOtherCommands = other.countCommands();
-
-        if (numCommands == 0) {
-            return null;
-        }
-
-        RPoint[] result = null;
-        RPoint[] newresult;
-
-        for (int j = 0; j < numOtherCommands; j++) {
-            for (int i = 0; i < numCommands; i++) {
-                RPoint[] newPoints = commands[i].intersectionPoints(other.commands[j]);
-                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;
+    return result;
+  }
+
+  /**
+   * Use this to return the intersection points between two paths. Returns null
+   * if no intersection exists.
+   *
+   * @param other
+   * @return RPoint[], the intersection points returned in an array.
+   *
+   */
+  public RPoint[] intersectionPoints(RPath other) {
+    int numCommands = countCommands();
+    int numOtherCommands = other.countCommands();
+
+    if (numCommands == 0) {
+      return null;
     }
 
-    /**
-     * Use this to find the closest or intersection points between this path and
-     * a command.
-     *
-     * @param other
-     * @return RPoint[], the intersection points returned in an array.
-     *
-     */
-    public RClosest closestPoints(RCommand other) {
-        int numCommands = countCommands();
-        if (numCommands == 0) {
-            return null;
+    RPoint[] result = null;
+    RPoint[] newresult;
+
+    for (int j = 0; j < numOtherCommands; j++) {
+      for (int i = 0; i < numCommands; i++) {
+        RPoint[] newPoints = commands[i].intersectionPoints(other.commands[j]);
+        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;
+          }
         }
+      }
+    }
 
-        // TODO: get here the max value of an integer
-        float minDist = 100000;
+    return result;
+  }
+
+  /**
+   * Use this to find the closest or intersection points between this path and a
+   * command.
+   *
+   * @param other
+   * @return RPoint[], the intersection points returned in an array.
+   *
+   */
+  public RClosest closestPoints(RCommand other) {
+    int numCommands = countCommands();
+    if (numCommands == 0) {
+      return null;
+    }
 
-        RClosest result = new RClosest();
+    // TODO: get here the max value of an integer
+    float minDist = 100000;
 
-        for (int i = 0; i < numCommands; i++) {
-            RClosest currResult = commands[i].closestPoints(other);
+    RClosest result = new RClosest();
 
-            result.update(currResult);
-        }
+    for (int i = 0; i < numCommands; i++) {
+      RClosest currResult = commands[i].closestPoints(other);
 
-        return result;
+      result.update(currResult);
     }
 
-    /**
-     * Use this to return the intersection points between two paths. Returns
-     * null if no intersection exists.
-     *
-     * @param other
-     * @return RPoint[], the intersection points returned in an array.
-     *
-     */
-    public RClosest closestPoints(RPath other) {
-        int numCommands = countCommands();
-        int numOtherCommands = other.countCommands();
-
-        if (numCommands == 0) {
-            return null;
-        }
-
-        // TODO: get here the max value of an integer
-        float minDist = 100000;
+    return result;
+  }
+
+  /**
+   * Use this to return the intersection points between two paths. Returns null
+   * if no intersection exists.
+   *
+   * @param other
+   * @return RPoint[], the intersection points returned in an array.
+   *
+   */
+  public RClosest closestPoints(RPath other) {
+    int numCommands = countCommands();
+    int numOtherCommands = other.countCommands();
+
+    if (numCommands == 0) {
+      return null;
+    }
 
-        RClosest result = new RClosest();
+    // TODO: get here the max value of an integer
+    float minDist = 100000;
 
-        for (int j = 0; j < numOtherCommands; j++) {
-            for (int i = 0; i < numCommands; i++) {
-                RClosest currResult = commands[i].closestPoints(other.commands[j]);
-                result.update(currResult);
-            }
-        }
+    RClosest result = new RClosest();
 
-        return result;
+    for (int j = 0; j < numOtherCommands; j++) {
+      for (int i = 0; i < numCommands; i++) {
+        RClosest currResult = commands[i].closestPoints(other.commands[j]);
+        result.update(currResult);
+      }
     }
 
-    /**
-     * Return a specific point on the curve. It returns the RPoint for a given
-     * advancement parameter t on the curve.
-     *
-     * @eexample getPoint
-     * @param t the parameter of advancement on the curve. t must have values
-     * between 0 and 1.
-     * @return RPoint, the vertice returned.
-     *
-     */
-    @Override
-    public RPoint getPoint(float t) {
-        int numCommands = countCommands();
-        if (numCommands == 0) {
-            return new RPoint();
-        }
-
-        if (t == 0.0F) {
-            return commands[0].getPoint(0F);
-        }
-        if (t == 1.0F) {
-            return commands[numCommands - 1].getPoint(1F);
-        }
-
-        float[] indAndAdv = indAndAdvAt(t);
-        int indOfElement = (int) (indAndAdv[0]);
-        float advOfElement = indAndAdv[1];
+    return result;
+  }
+
+  /**
+   * Return a specific point on the curve. It returns the RPoint for a given
+   * advancement parameter t on the curve.
+   *
+   getPoint
+   * @param t the parameter of advancement on the curve. t must have values
+   * between 0 and 1.
+   * @return RPoint, the vertice returned.
+   *
+   */
+  @Override
+  public RPoint getPoint(float t) {
+    int numCommands = countCommands();
+    if (numCommands == 0) {
+      return new RPoint();
+    }
 
-        return commands[indOfElement].getPoint(advOfElement);
+    if (t == 0.0F) {
+      return commands[0].getPoint(0F);
+    }
+    if (t == 1.0F) {
+      return commands[numCommands - 1].getPoint(1F);
     }
 
-    /**
-     * Use this to return a specific tangent on the curve. It returns the RPoint
-     * tangent for a given advancement parameter t on the curve.
-     *
-     * @eexample getPoint
-     * @param t float, the parameter of advancement on the curve. t must have
-     * values between 0 and 1.
-     * @return RPoint, the vertice returned.
-     *
-     */
-    @Override
-    public RPoint getTangent(float t) {
-        int numCommands = countCommands();
-        if (numCommands == 0) {
-            return new RPoint();
-        }
+    float[] indAndAdv = indAndAdvAt(t);
+    int indOfElement = (int) (indAndAdv[0]);
+    float advOfElement = indAndAdv[1];
+
+    return commands[indOfElement].getPoint(advOfElement);
+  }
+
+  /**
+   * Use this to return a specific tangent on the curve. It returns the RPoint
+   * tangent for a given advancement parameter t on the curve.
+   *
+   getPoint
+   * @param t float, the parameter of advancement on the curve. t must have
+   * values between 0 and 1.
+   * @return RPoint, the vertice returned.
+   *
+   */
+  @Override
+  public RPoint getTangent(float t) {
+    int numCommands = countCommands();
+    if (numCommands == 0) {
+      return new RPoint();
+    }
 
-        if (t == 0.0F) {
-            return commands[0].getTangent(0F);
-        }
-        if (t == 1.0F) {
-            return commands[numCommands - 1].getTangent(1F);
-        }
+    if (t == 0.0F) {
+      return commands[0].getTangent(0F);
+    }
+    if (t == 1.0F) {
+      return commands[numCommands - 1].getTangent(1F);
+    }
 
-        float[] indAndAdv = indAndAdvAt(t);
-        int indOfElement = (int) (indAndAdv[0]);
-        float advOfElement = indAndAdv[1];
+    float[] indAndAdv = indAndAdvAt(t);
+    int indOfElement = (int) (indAndAdv[0]);
+    float advOfElement = indAndAdv[1];
 
-        /* This takes the medium between two intersecting commands, sometimes this is not wanted
+    /* This takes the medium between two intersecting commands, sometimes this is not wanted
          if(advOfElement==1.0F){
          int indNextCommand = (indOfElement + 1) % numCommands;
          result = commands[indOfElement].getTangent(advOfElement);
@@ -532,453 +531,452 @@ public class RPath extends RGeomElem {
          }else{
          result = commands[indOfElement].getTangent(advOfElement);
          }
-         */
-        return commands[indOfElement].getTangent(advOfElement);
-    }
-
-    /**
-     * Use this to return a specific tangent on the curve. It returns true if
-     * the point passed as a parameter is inside the path. Implementation taken
-     * from:
-     * http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html
-     *
-     * @param p the point for which to test containement..
-     * @return boolean, true if the point is in the path.
-     *
      */
-    @Override
-    public boolean contains(RPoint p) {
-        float testx = p.x;
-        float testy = p.y;
-
-        // Test for containment in bounding box
-        RRectangle bbox = getBounds();
-        float xmin = bbox.getMinX();
-        float xmax = bbox.getMaxX();
-
-        float ymin = bbox.getMinY();
-        float ymax = bbox.getMaxY();
-
-        if ((testx < xmin) || (testx > xmax) || (testy < ymin) || (testy > ymax)) {
-            return false;
-        }
-
-        // Test for containment in path
-        RPoint[] verts = getPoints();
-
-        if (verts == null) {
-            return false;
-        }
-
-        int nvert = verts.length;
-        int i;
-        int j;
-        boolean c = false;
-        for (i = 0, j = nvert - 1; i < nvert; j = i++) {
-            if (((verts[i].y > testy) != (verts[j].y > testy))
-                && (testx < (verts[j].x - verts[i].x) * (testy - verts[i].y) / (verts[j].y - verts[i].y) + verts[i].x)) {
-                c = !c;
-            }
-        }
-        return c;
+    return commands[indOfElement].getTangent(advOfElement);
+  }
+
+  /**
+   * Use this to return a specific tangent on the curve. It returns true if the
+   * point passed as a parameter is inside the path. Implementation taken from:
+   * http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html
+   *
+   * @param p the point for which to test containement..
+   * @return boolean, true if the point is in the path.
+   *
+   */
+  @Override
+  public boolean contains(RPoint p) {
+    float testx = p.x;
+    float testy = p.y;
+
+    // Test for containment in bounding box
+    RRectangle bbox = getBounds();
+    float xmin = bbox.getMinX();
+    float xmax = bbox.getMaxX();
+
+    float ymin = bbox.getMinY();
+    float ymax = bbox.getMaxY();
+
+    if ((testx < xmin) || (testx > xmax) || (testy < ymin) || (testy > ymax)) {
+      return false;
     }
 
-    /**
-     * Use this to insert a split point into the path.
-     *
-     * @eexample insertHandle
-     * @param t float, the parameter of advancement on the curve. t must have
-     * values between 0 and 1.
-     *
-     */
-    public void insertHandle(float t) {
-        if ((t == 0F) || (t == 1F)) {
-            return;
-        }
-
-        float[] indAndAdv = indAndAdvAt(t);
-        int indOfElement = (int) (indAndAdv[0]);
-        float advOfElement = indAndAdv[1];
-
-        // Split the affected command and reconstruct each of the shapes
-        RCommand[] splittedCommands = commands[indOfElement].split(advOfElement);
-
-        if (splittedCommands[0] == null || splittedCommands[1] == null) {
-            return;
-        }
-
-        // Extract the splitted command
-        extract(indOfElement);
-
-        // Insert the splittedCommands
-        insert(splittedCommands[1], indOfElement);
-        insert(splittedCommands[0], indOfElement);
+    // Test for containment in path
+    RPoint[] verts = getPoints();
 
-        // Clear the cache
-        lenCurves = null;
-        lenCurve = -1F;
+    if (verts == null) {
+      return false;
     }
 
-    /**
-     * Use this to insert a split point into each command of the path.
-     *
-     * @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)) {
-            return;
-        }
-
-        int numCommands = countCommands();
-
-        for (int i = 0; i < numCommands * 2; i += 2) {
-            // Split the affected command and reconstruct each of the shapes
-            RCommand[] splittedCommands = commands[i].split(t);
-
-            if (splittedCommands[0] == null || splittedCommands[1] == null) {
-                return;
-            }
-
-            // Extract the splitted command
-            extract(i);
-
-            // Insert the splittedCommands
-            insert(splittedCommands[1], i);
-            insert(splittedCommands[0], i);
-        }
-
-        // Clear the cache
-        lenCurves = null;
-        lenCurve = -1F;
+    int nvert = verts.length;
+    int i;
+    int j;
+    boolean c = false;
+    for (i = 0, j = nvert - 1; i < nvert; j = i++) {
+      if (((verts[i].y > testy) != (verts[j].y > testy))
+        && (testx < (verts[j].x - verts[i].x) * (testy - verts[i].y) / (verts[j].y - verts[i].y) + verts[i].x)) {
+        c = !c;
+      }
+    }
+    return c;
+  }
+
+  /**
+   * Use this to insert a split point into the path.
+   *
+   insertHandle
+   * @param t float, the parameter of advancement on the curve. t must have
+   * values between 0 and 1.
+   *
+   */
+  public void insertHandle(float t) {
+    if ((t == 0F) || (t == 1F)) {
+      return;
     }
 
-    /**
-     * Use this to split a path into two separate new paths.
-     *
-     * @eexample split
-     * @param t float, the parameter of advancement on the curve. t must have
-     * values between 0 and 1.
-     * @return RPath[], an array of two RPath.
-     *
-     */
-    public RPath[] split(float t) {
-        RPath[] result = new RPath[2];
-
-        int numCommands = countCommands();
-        if (numCommands == 0) {
-            return null;
-        }
-
-        if (t == 0.0F) {
-            result[0] = new RPath();
-            result[1] = new RPath(this);
-            result[0].setStyle(this);
-            result[1].setStyle(this);
-
-            return result;
-        }
-
-        if (t == 1.0F) {
-            result[0] = new RPath(this);
-            result[1] = new RPath();
-            result[0].setStyle(this);
-            result[1].setStyle(this);
-
-            return result;
-        }
-
-        float[] indAndAdv = indAndAdvAt(t);
-        int indOfElement = (int) (indAndAdv[0]);
-        float advOfElement = indAndAdv[1];
-
-        // Split the affected command and reconstruct each of the shapes
-        RCommand[] splittedCommands = commands[indOfElement].split(advOfElement);
-
-        result[0] = new RPath();
-        for (int i = 0; i < indOfElement; i++) {
-            result[0].addCommand(new RCommand(commands[i]));
-        }
-        result[0].addCommand(new RCommand(splittedCommands[0]));
-        result[0].setStyle(this);
+    float[] indAndAdv = indAndAdvAt(t);
+    int indOfElement = (int) (indAndAdv[0]);
+    float advOfElement = indAndAdv[1];
 
-        result[1] = new RPath();
-        for (int i = indOfElement + 1; i < countCommands(); i++) {
-            result[1].addCommand(new RCommand(commands[i]));
-        }
-        result[1].addCommand(new RCommand(splittedCommands[1]));
-        result[1].setStyle(this);
+    // Split the affected command and reconstruct each of the shapes
+    RCommand[] splittedCommands = commands[indOfElement].split(advOfElement);
 
-        return result;
+    if (splittedCommands[0] == null || splittedCommands[1] == null) {
+      return;
     }
 
-    public void polygonize() {
-        RPoint[] points = getPoints();
-
-        if (points == null) {
-            this.commands = null;
-        } else {
-            RPath result = new RPath(points[0]);
-            for (int i = 1; i < points.length; i++) {
-                result.addLineTo(points[i]);
-            }
-            this.commands = result.commands;
-        }
+    // Extract the splitted command
+    extract(indOfElement);
+
+    // Insert the splittedCommands
+    insert(splittedCommands[1], indOfElement);
+    insert(splittedCommands[0], indOfElement);
+
+    // Clear the cache
+    lenCurves = null;
+    lenCurve = -1F;
+  }
+
+  /**
+   * Use this to insert a split point into each command of the path.
+   *
+   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;
     }
 
-    /**
-     * Use this method to draw the path.
-     *
-     * @eexample drawPath
-     * @param g PGraphics, the graphics object on which to draw the path
-     */
-    @Override
-    public void draw(PGraphics g) {
-        countCommands();
+    int numCommands = countCommands();
 
-        // By default always draw with an adaptative segmentator
-        int lastSegmentator = RCommand.segmentType;
-        RCommand.setSegmentator(RCommand.ADAPTATIVE);
+    for (int i = 0; i < numCommands * 2; i += 2) {
+      // Split the affected command and reconstruct each of the shapes
+      RCommand[] splittedCommands = commands[i].split(t);
 
-        RPoint[] points = getPoints();
+      if (splittedCommands[0] == null || splittedCommands[1] == null) {
+        return;
+      }
 
-        if (points == null) {
-            return;
-        }
-
-        g.beginShape();
-        for (RPoint point : points) {
-            g.vertex(point.x, point.y);
-        }
-        g.endShape(closed ? PConstants.CLOSE : PConstants.OPEN);
+      // Extract the splitted command
+      extract(i);
 
-        // Restore the user set segmentator
-        RCommand.setSegmentator(lastSegmentator);
+      // Insert the splittedCommands
+      insert(splittedCommands[1], i);
+      insert(splittedCommands[0], i);
     }
 
-    /**
-     *
-     * @param g
-     */
-    @Override
-    public void draw(PApplet g) {
-        countCommands();
-
-        // By default always draw with an adaptative segmentator
-        int lastSegmentator = RCommand.segmentType;
-        RCommand.setSegmentator(RCommand.ADAPTATIVE);
-
-        RPoint[] points = getPoints();
-        RCommand.setSegmentator(lastSegmentator);
-        if (points == null) {
-            return;
-        }
-        g.beginShape();
-        for (RPoint point : points) {
-            g.vertex(point.x, point.y);
-        }
-        g.endShape(closed ? PConstants.CLOSE : PConstants.OPEN);
-
-        // Restore the user set segmentator
-        RCommand.setSegmentator(lastSegmentator);
+    // Clear the cache
+    lenCurves = null;
+    lenCurve = -1F;
+  }
+
+  /**
+   * Use this to split a path into two separate new paths.
+   *
+   split
+   * @param t float, the parameter of advancement on the curve. t must have
+   * values between 0 and 1.
+   * @return RPath[], an array of two RPath.
+   *
+   */
+  public RPath[] split(float t) {
+    RPath[] result = new RPath[2];
+
+    int numCommands = countCommands();
+    if (numCommands == 0) {
+      return null;
     }
 
-    /**
-     * Use this method to add new commands to the contour.
-     *
-     * @param p
-     * @eexample addCommand
-     * @invisible
-     */
-    public final void addCommand(RCommand p) {
-        this.append(p);
+    if (t == 0.0F) {
+      result[0] = new RPath();
+      result[1] = new RPath(this);
+      result[0].setStyle(this);
+      result[1].setStyle(this);
 
-        lastPoint = commands[commands.length - 1].endPoint;
+      return result;
     }
 
-    /**
-     * Add a new cubic bezier to the path. The first point of the bezier will be
-     * the last point added to the path.
-     *
-     * @eexample addBezierTo
-     * @param cp1 first control point
-     * @param cp2 second control point
-     * @param end end point
-     */
-    public void addBezierTo(RPoint cp1, RPoint cp2, RPoint end) {
-        this.addCommand(RCommand.createBezier4(lastPoint, cp1, cp2, end));
-    }
-
-    /**
-     * Add a new cubic bezier to the path. The first point of the bezier will be
-     * the last point added to the path.
-     *
-     * @eexample addBezierTo
-     * @param cp1x the x coordinate of the first control point
-     * @param cp1y the y coordinate of the first control point
-     * @param cp2x the x coordinate of the second control point
-     * @param cp2y the y coordinate of the second control point
-     * @param endx the x coordinate of the end point
-     * @param endy the y coordinate of the end point
-     */
-    public void addBezierTo(float cp1x, float cp1y, float cp2x, float cp2y, float endx, float endy) {
-        RPoint cp1 = new RPoint(cp1x, cp1y);
-        RPoint cp2 = new RPoint(cp2x, cp2y);
-        RPoint end = new RPoint(endx, endy);
+    if (t == 1.0F) {
+      result[0] = new RPath(this);
+      result[1] = new RPath();
+      result[0].setStyle(this);
+      result[1].setStyle(this);
 
-        addBezierTo(cp1, cp2, end);
+      return result;
     }
 
-    /**
-     * Add a new quadratic bezier to the path. The first point of the bezier
-     * will be the last point added to the path.
-     *
-     * @eexample addQuadTo
-     * @param cp1 first control point
-     * @param end end point
-     */
-    public void addQuadTo(RPoint cp1, RPoint end) {
-        this.addCommand(RCommand.createBezier3(lastPoint, cp1, end));
-    }
+    float[] indAndAdv = indAndAdvAt(t);
+    int indOfElement = (int) (indAndAdv[0]);
+    float advOfElement = indAndAdv[1];
 
-    /**
-     * Add a new quadratic bezier to the path. The first point of the bezier
-     * will be the last point added to the path.
-     *
-     * @eexample addQuadTo
-     * @param cp1x the x coordinate of the first control point
-     * @param cp1y the y coordinate of the first control point
-     * @param endx the x coordinate of the end point
-     * @param endy the y coordinate of the end point
-     */
-    public void addQuadTo(float cp1x, float cp1y, float endx, float endy) {
-        RPoint cp1 = new RPoint(cp1x, cp1y);
-        RPoint end = new RPoint(endx, endy);
+    // Split the affected command and reconstruct each of the shapes
+    RCommand[] splittedCommands = commands[indOfElement].split(advOfElement);
 
-        addQuadTo(cp1, end);
+    result[0] = new RPath();
+    for (int i = 0; i < indOfElement; i++) {
+      result[0].addCommand(new RCommand(commands[i]));
     }
+    result[0].addCommand(new RCommand(splittedCommands[0]));
+    result[0].setStyle(this);
 
-    /**
-     * Add a new line to the path. The first point of the line will be the last
-     * point added to the path.
-     *
-     * @eexample addLineTo
-     * @param end end point
-     */
-    public final void addLineTo(RPoint end) {
-        this.addCommand(RCommand.createLine(lastPoint, end));
+    result[1] = new RPath();
+    for (int i = indOfElement + 1; i < countCommands(); i++) {
+      result[1].addCommand(new RCommand(commands[i]));
     }
-
-    /**
-     * Add a new line to the path. The first point of the line will be the last
-     * point added to the path.
-     *
-     * @eexample addLineTo
-     * @param endx the x coordinate of the end point
-     * @param endy the y coordinate of the end point
-     */
-    public void addLineTo(float endx, float endy) {
-        RPoint end = new RPoint(endx, endy);
-        addLineTo(end);
+    result[1].addCommand(new RCommand(splittedCommands[1]));
+    result[1].setStyle(this);
+
+    return result;
+  }
+
+  public void polygonize() {
+    RPoint[] points = getPoints();
+
+    if (points == null) {
+      this.commands = null;
+    } else {
+      RPath result = new RPath(points[0]);
+      for (int i = 1; i < points.length; i++) {
+        result.addLineTo(points[i]);
+      }
+      this.commands = result.commands;
     }
-
-    public void addClose() {
-        if (commands == null) {
-            return;
-        }
-
-        if ((commands[commands.length - 1].endPoint.x == commands[0].startPoint.x) && (commands[commands.length - 1].endPoint.y == commands[0].startPoint.y)) {
-            commands[commands.length - 1].endPoint = new RPoint(commands[0].startPoint.x, commands[0].startPoint.y);
-            lastPoint = commands[commands.length - 1].endPoint;
-        } else {
-            addLineTo(new RPoint(commands[0].startPoint.x, commands[0].startPoint.y));
-        }
-
-        closed = true;
+  }
+
+  /**
+   * Use this method to draw the path.
+   *
+   drawPath
+   * @param g PGraphics, the graphics object on which to draw the path
+   */
+  @Override
+  public void draw(PGraphics g) {
+    countCommands();
+
+    // By default always draw with an adaptative segmentator
+    int lastSegmentator = RCommand.segmentType;
+    RCommand.setSegmentator(RCommand.ADAPTATIVE);
+
+    RPoint[] points = getPoints();
+
+    if (points == null) {
+      return;
     }
 
-    /**
-     * @return @invisible
-     */
-    @Override
-    public RPolygon toPolygon() {
-        return this.toShape().toPolygon();
+    g.beginShape();
+    for (RPoint point : points) {
+      g.vertex(point.x, point.y);
     }
-
-    /**
-     * @return @invisible
-     */
-    @Override
-    public RShape toShape() {
-        return new RShape(this);
+    g.endShape(closed ? PConstants.CLOSE : PConstants.OPEN);
+
+    // Restore the user set segmentator
+    RCommand.setSegmentator(lastSegmentator);
+  }
+
+  /**
+   *
+   * @param g
+   */
+  @Override
+  public void draw(PApplet g) {
+    countCommands();
+
+    // By default always draw with an adaptative segmentator
+    int lastSegmentator = RCommand.segmentType;
+    RCommand.setSegmentator(RCommand.ADAPTATIVE);
+
+    RPoint[] points = getPoints();
+    RCommand.setSegmentator(lastSegmentator);
+    if (points == null) {
+      return;
     }
-
-    /**
-     * @return @invisible
-     */
-    @Override
-    public RMesh toMesh() {
-        return this.toPolygon().toMesh();
+    g.beginShape();
+    for (RPoint point : points) {
+      g.vertex(point.x, point.y);
+    }
+    g.endShape(closed ? PConstants.CLOSE : PConstants.OPEN);
+
+    // Restore the user set segmentator
+    RCommand.setSegmentator(lastSegmentator);
+  }
+
+  /**
+   * Use this method to add new commands to the contour.
+   *
+   * @param p
+   addCommand
+   *
+   */
+  public final void addCommand(RCommand p) {
+    this.append(p);
+
+    lastPoint = commands[commands.length - 1].endPoint;
+  }
+
+  /**
+   * Add a new cubic bezier to the path. The first point of the bezier will be
+   * the last point added to the path.
+   *
+   addBezierTo
+   * @param cp1 first control point
+   * @param cp2 second control point
+   * @param end end point
+   */
+  public void addBezierTo(RPoint cp1, RPoint cp2, RPoint end) {
+    this.addCommand(RCommand.createBezier4(lastPoint, cp1, cp2, end));
+  }
+
+  /**
+   * Add a new cubic bezier to the path. The first point of the bezier will be
+   * the last point added to the path.
+   *
+   addBezierTo
+   * @param cp1x the x coordinate of the first control point
+   * @param cp1y the y coordinate of the first control point
+   * @param cp2x the x coordinate of the second control point
+   * @param cp2y the y coordinate of the second control point
+   * @param endx the x coordinate of the end point
+   * @param endy the y coordinate of the end point
+   */
+  public void addBezierTo(float cp1x, float cp1y, float cp2x, float cp2y, float endx, float endy) {
+    RPoint cp1 = new RPoint(cp1x, cp1y);
+    RPoint cp2 = new RPoint(cp2x, cp2y);
+    RPoint end = new RPoint(endx, endy);
+
+    addBezierTo(cp1, cp2, end);
+  }
+
+  /**
+   * Add a new quadratic bezier to the path. The first point of the bezier will
+   * be the last point added to the path.
+   *
+   addQuadTo
+   * @param cp1 first control point
+   * @param end end point
+   */
+  public void addQuadTo(RPoint cp1, RPoint end) {
+    this.addCommand(RCommand.createBezier3(lastPoint, cp1, end));
+  }
+
+  /**
+   * Add a new quadratic bezier to the path. The first point of the bezier will
+   * be the last point added to the path.
+   *
+   addQuadTo
+   * @param cp1x the x coordinate of the first control point
+   * @param cp1y the y coordinate of the first control point
+   * @param endx the x coordinate of the end point
+   * @param endy the y coordinate of the end point
+   */
+  public void addQuadTo(float cp1x, float cp1y, float endx, float endy) {
+    RPoint cp1 = new RPoint(cp1x, cp1y);
+    RPoint end = new RPoint(endx, endy);
+
+    addQuadTo(cp1, end);
+  }
+
+  /**
+   * Add a new line to the path. The first point of the line will be the last
+   * point added to the path.
+   *
+   addLineTo
+   * @param end end point
+   */
+  public final void addLineTo(RPoint end) {
+    this.addCommand(RCommand.createLine(lastPoint, end));
+  }
+
+  /**
+   * Add a new line to the path. The first point of the line will be the last
+   * point added to the path.
+   *
+   addLineTo
+   * @param endx the x coordinate of the end point
+   * @param endy the y coordinate of the end point
+   */
+  public void addLineTo(float endx, float endy) {
+    RPoint end = new RPoint(endx, endy);
+    addLineTo(end);
+  }
+
+  public void addClose() {
+    if (commands == null) {
+      return;
     }
 
-    /**
-     * Use this method to get the type of element this is.
-     *
-     * @eexample RPolygon_getType
-     * @return int, will allways return RGeomElem.POLYGON
-     */
-    @Override
-    public int getType() {
-        return type;
+    if ((commands[commands.length - 1].endPoint.x == commands[0].startPoint.x) && (commands[commands.length - 1].endPoint.y == commands[0].startPoint.y)) {
+      commands[commands.length - 1].endPoint = new RPoint(commands[0].startPoint.x, commands[0].startPoint.y);
+      lastPoint = commands[commands.length - 1].endPoint;
+    } else {
+      addLineTo(new RPoint(commands[0].startPoint.x, commands[0].startPoint.y));
     }
 
-    @Override
-    public void print() {
-        for (int i = 0; i < countCommands(); i++) {
-            String commandType = "";
-            switch (commands[i].commandType) {
-                case RCommand.LINETO:
-                    commandType = "LINETO";
-                    break;
-
-                case RCommand.CUBICBEZIERTO:
-                    commandType = "BEZIERTO";
-                    break;
-
-                case RCommand.QUADBEZIERTO:
-                    commandType = "QUADBEZIERTO";
-                    break;
-            }
-
-            System.out.println("cmd type: " + commandType);
-            System.out.print("start point: ");
-            commands[i].startPoint.print();
-            System.out.print("\n");
-            System.out.print("end point: ");
-            commands[i].endPoint.print();
-            System.out.print("\n");
-            if (commands[i].controlPoints != null) {
-                System.out.println("control points: ");
-                for (RPoint controlPoint : commands[i].controlPoints) {
-                    controlPoint.print();
-                    System.out.print(" ");
-                    System.out.print("\n");
-                }
-            }
-            System.out.print("\n");
+    closed = true;
+  }
+
+  /**
+   * @return
+   */
+  @Override
+  public RPolygon toPolygon() {
+    return this.toShape().toPolygon();
+  }
+
+  /**
+   * @return
+   */
+  @Override
+  public RShape toShape() {
+    return new RShape(this);
+  }
+
+  /**
+   * @return
+   */
+  @Override
+  public RMesh toMesh() {
+    return this.toPolygon().toMesh();
+  }
+
+  /**
+   * Use this method to get the type of element this is.
+   *
+   RPolygon_getType
+   * @return int, will allways return RGeomElem.POLYGON
+   */
+  @Override
+  public int getType() {
+    return type;
+  }
+
+  @Override
+  public void print() {
+    for (int i = 0; i < countCommands(); i++) {
+      String commandType = "";
+      switch (commands[i].commandType) {
+        case RCommand.LINETO:
+          commandType = "LINETO";
+          break;
+
+        case RCommand.CUBICBEZIERTO:
+          commandType = "BEZIERTO";
+          break;
+
+        case RCommand.QUADBEZIERTO:
+          commandType = "QUADBEZIERTO";
+          break;
+      }
+
+      System.out.println("cmd type: " + commandType);
+      System.out.print("start point: ");
+      commands[i].startPoint.print();
+      System.out.print("\n");
+      System.out.print("end point: ");
+      commands[i].endPoint.print();
+      System.out.print("\n");
+      if (commands[i].controlPoints != null) {
+        System.out.println("control points: ");
+        for (RPoint controlPoint : commands[i].controlPoints) {
+          controlPoint.print();
+          System.out.print(" ");
+          System.out.print("\n");
         }
+      }
+      System.out.print("\n");
     }
-
-    /**
-     * Use this method to transform the shape.
-     *
-     * @eexample RPath_transform
-     * @param m RMatrix, the matrix defining the affine transformation
-     * @related draw ( )
-     */
-    // OPT: not transform the EndPoint since it's equal to the next StartPoint
+  }
+
+  /**
+   * Use this method to transform the shape.
+   *
+   RPath_transform
+   * @param m RMatrix, the matrix defining the affine transformation
+   * draw ( )
+   */
+  // OPT: not transform the EndPoint since it's equal to the next StartPoint
   /*
      public void transform(RMatrix m){
      RPoint[] ps = getHandles();
@@ -1000,101 +998,101 @@ public class RPath extends RGeomElem {
      }
     
      }
-     */
-    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 */
-        /* Old method with uniform advancement per command
+   */
+  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 */
+ /* Old method with uniform advancement per command
          float advPerCommand;
          advPerCommand = 1F / numPaths;
          indOfElement = (int)(Math.floor(t / advPerCommand)) % numPaths;
          advOfElement = (t*numPaths - indOfElement);
-         */
-        float accumulatedAdvancement = lengthsCurves[indOfElement] / lengthCurve;
-        float prevAccumulatedAdvancement = 0F;
-
-        /* Find in what command the advancement point is  */
-        while (t > accumulatedAdvancement) {
-            indOfElement++;
-            prevAccumulatedAdvancement = accumulatedAdvancement;
-            accumulatedAdvancement += (lengthsCurves[indOfElement] / lengthCurve);
-        }
+     */
+    float accumulatedAdvancement = lengthsCurves[indOfElement] / lengthCurve;
+    float prevAccumulatedAdvancement = 0F;
+
+    /* Find in what command the advancement point is  */
+    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];
+    float[] indAndAdv = new float[2];
 
-        indAndAdv[0] = indOfElement;
-        indAndAdv[1] = advOfElement;
+    indAndAdv[0] = indOfElement;
+    indAndAdv[1] = advOfElement;
 
-        return indAndAdv;
-    }
+    return indAndAdv;
+  }
 
-    private void append(RCommand nextcommand) {
-        RCommand[] newcommands;
-        if (commands == null) {
-            newcommands = new RCommand[1];
-            newcommands[0] = nextcommand;
-        } else {
-            newcommands = new RCommand[this.commands.length + 1];
-            System.arraycopy(this.commands, 0, newcommands, 0, this.commands.length);
-            newcommands[this.commands.length] = nextcommand;
-        }
-        this.commands = newcommands;
+  private void append(RCommand nextcommand) {
+    RCommand[] newcommands;
+    if (commands == null) {
+      newcommands = new RCommand[1];
+      newcommands[0] = nextcommand;
+    } else {
+      newcommands = new RCommand[this.commands.length + 1];
+      System.arraycopy(this.commands, 0, newcommands, 0, this.commands.length);
+      newcommands[this.commands.length] = nextcommand;
     }
+    this.commands = newcommands;
+  }
 
-    private void insert(RCommand newcommand, int i) throws RuntimeException {
-        if (i < 0) {
-            throw new RuntimeException("Negative values for indexes are not valid.");
-        }
-
-        RCommand[] newcommands;
-        if (commands == null) {
-            newcommands = new RCommand[1];
-            newcommands[0] = newcommand;
-        } else {
-            if (i > commands.length) {
-                throw new RuntimeException("Index out of the bounds.  You are trying to insert an element with an index higher than the number of commands in the group.");
-            }
-
-            newcommands = new RCommand[this.commands.length + 1];
-            System.arraycopy(this.commands, 0, newcommands, 0, i);
-            newcommands[i] = newcommand;
-            System.arraycopy(this.commands, i, newcommands, i + 1, this.commands.length - i);
-        }
-        this.commands = newcommands;
+  private void insert(RCommand newcommand, int i) throws RuntimeException {
+    if (i < 0) {
+      throw new RuntimeException("Negative values for indexes are not valid.");
     }
 
-    private void extract(int i) throws RuntimeException {
-        RCommand[] newcommands;
-        if (commands == null) {
-            throw new RuntimeException("The group is empty. No commands to remove.");
-        } else {
-            if (i < 0) {
-                throw new RuntimeException("Negative values for indexes are not valid.");
-            }
-            if (i > commands.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 commands in the group.");
-            }
-            if (commands.length == 1) {
-                newcommands = null;
-            } else if (i == 0) {
-                newcommands = new RCommand[this.commands.length - 1];
-                System.arraycopy(this.commands, 1, newcommands, 0, this.commands.length - 1);
-            } else if (i == commands.length - 1) {
-                newcommands = new RCommand[this.commands.length - 1];
-                System.arraycopy(this.commands, 0, newcommands, 0, this.commands.length - 1);
-            } else {
-                newcommands = new RCommand[this.commands.length - 1];
-                System.arraycopy(this.commands, 0, newcommands, 0, i);
-                System.arraycopy(this.commands, i + 1, newcommands, i, this.commands.length - i - 1);
-            }
-        }
-        this.commands = newcommands;
+    RCommand[] newcommands;
+    if (commands == null) {
+      newcommands = new RCommand[1];
+      newcommands[0] = newcommand;
+    } else {
+      if (i > commands.length) {
+        throw new RuntimeException("Index out of the bounds.  You are trying to insert an element with an index higher than the number of commands in the group.");
+      }
+
+      newcommands = new RCommand[this.commands.length + 1];
+      System.arraycopy(this.commands, 0, newcommands, 0, i);
+      newcommands[i] = newcommand;
+      System.arraycopy(this.commands, i, newcommands, i + 1, this.commands.length - i);
+    }
+    this.commands = newcommands;
+  }
+
+  private void extract(int i) throws RuntimeException {
+    RCommand[] newcommands;
+    if (commands == null) {
+      throw new RuntimeException("The group is empty. No commands to remove.");
+    } else {
+      if (i < 0) {
+        throw new RuntimeException("Negative values for indexes are not valid.");
+      }
+      if (i > commands.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 commands in the group.");
+      }
+      if (commands.length == 1) {
+        newcommands = null;
+      } else if (i == 0) {
+        newcommands = new RCommand[this.commands.length - 1];
+        System.arraycopy(this.commands, 1, newcommands, 0, this.commands.length - 1);
+      } else if (i == commands.length - 1) {
+        newcommands = new RCommand[this.commands.length - 1];
+        System.arraycopy(this.commands, 0, newcommands, 0, this.commands.length - 1);
+      } else {
+        newcommands = new RCommand[this.commands.length - 1];
+        System.arraycopy(this.commands, 0, newcommands, 0, i);
+        System.arraycopy(this.commands, i + 1, newcommands, i, this.commands.length - i - 1);
+      }
     }
+    this.commands = newcommands;
+  }
 }