geomerative 1.1.0-java → 2.0.0-java

data/src/geomerative/RPolygon.java

@@ -1,7 +1,7 @@
 /**
  * Copyright 2004-2008 Ricard Marxer  <email@ricardmarxer.com>
  *
-    This file is part of Geomerative.
+ * This file is part of Geomerative.
  *
  * Geomerative is free software: you can redistribute it and/or modify it under
  * the terms of the GNU General Public License as published by the Free Software
@@ -26,839 +26,836 @@ import processing.core.*;
  * interface allows us to perform binary operations (difference, xor, union and
  * intersection) on polygons.
  *
- * @eexample RPolygon
- * @usage Geometry
- * @related RContour
- * @related createCircle ( )
- * @related createRing ( )
- * @related createStar ( )
- * @related diff ( )
- * @related xor ( )
- * @related union ( )
- * @related intersection ( )
- * @extended
+ RPolygon
+ * Geometry
+ * RContour
+ * createCircle ( )
+ * createRing ( )
+ * createStar ( )
+ * diff ( )
+ * xor ( )
+ * union ( )
+ * intersection ( )
+
  */
 public class RPolygon extends RGeomElem {
 
-    /**
-     * @invisible
-     */
-    public int type = RGeomElem.POLYGON;
-    public static int defaultDetail = 50;
-
-    /**
-     * Array of RContour objects holding the contours of the polygon.
-     *
-     * @eexample contours
-     * @related RContour
-     * @related countContours ( )
-     * @related addContour ( )
-     */
-    public RContour[] contours;
-    int currentContour = 0;
-
-    // ----------------------
-    // --- Public Methods ---
-    // ----------------------
-    /**
-     * Make a copy of the given polygon.
-     *
-     * @eexample createPolygon
-     * @param p the object of which to make a copy
-     */
-    public RPolygon(RPolygon p) {
-        if (p == null) {
-            return;
-        }
-
-        for (int i = 0; i < p.countContours(); i++) {
-            this.append(new RContour(p.contours[i]));
-        }
-        type = RGeomElem.POLYGON;
-
-        setStyle(p);
-    }
-
-    /**
-     * Create a new polygon given an array of points.
-     *
-     * @eexample createPolygon
-     * @param points the points for the new polygon.
-     */
-    public RPolygon(RPoint[] points) {
-        this(new RContour(points));
-    }
-
-    /**
-     * Create a new polygon given a contour.
-     *
-     * @param newcontour the contour for the new polygon.
-     */
-    public RPolygon(RContour newcontour) {
-        this.append(newcontour);
-        type = RGeomElem.POLYGON;
-    }
-
-    /**
-     * Create an empty polygon.
-     */
-    public RPolygon() {
-        contours = null;
-        type = RGeomElem.POLYGON;
-    }
-
-    /**
-     * Use this method to create a new circle polygon.
-     *
-     * @param x
-     * @param y
-     * @eexample createCircle
-     * @param radius the radius of the circle
-     * @param detail the number of vertices of the polygon
-     * @return RPolygon, the circular polygon newly created
-     */
-    static public RPolygon createCircle(float x, float y, float radius, int detail) {
-        RPoint[] points = new RPoint[detail];
-        double radiansPerStep = 2 * Math.PI / detail;
-        for (int i = 0; i < detail; i++) {
-            points[i] = new RPoint(
-                    radius * Math.cos(i * radiansPerStep) + x,
-                    radius * Math.sin(i * radiansPerStep) + y
-            );
-        }
-        return new RPolygon(points);
-    }
-
-    static public RPolygon createCircle(float radius, int detail) {
-        return createCircle(0, 0, radius, detail);
-    }
-
-    static public RPolygon createCircle(float x, float y, float radius) {
-        return createCircle(x, y, radius, defaultDetail);
-    }
+  /**
+   *
+   */
+  public int type = RGeomElem.POLYGON;
+  public static int defaultDetail = 50;
 
-    static public RPolygon createCircle(float radius) {
-        return createCircle(0, 0, radius, defaultDetail);
+  /**
+   * Array of RContour objects holding the contours of the polygon.
+   *
+   contours
+   * RContour
+   * countContours ( )
+   * addContour ( )
+   */
+  public RContour[] contours;
+  int currentContour = 0;
+
+  // ----------------------
+  // --- Public Methods ---
+  // ----------------------
+  /**
+   * Make a copy of the given polygon.
+   *
+   createPolygon
+   * @param p the object of which to make a copy
+   */
+  public RPolygon(RPolygon p) {
+    if (p == null) {
+      return;
     }
 
-    /**
-     * Use this method to create a new rectangle polygon.
-     *
-     * @eexample createRectangle
-     * @param x the upper-left corner x coordinate
-     * @param y the upper-left corner y coordinate
-     * @param w the width
-     * @param h the height
-     * @return RPolygon, the circular polygon newly created
-     */
-    static public RPolygon createRectangle(float x, float y, float w, float h) {
-        RPolygon rectangle = new RPolygon();
-        rectangle.addPoint(x, y);
-        rectangle.addPoint(x + w, y);
-        rectangle.addPoint(x + w, y + h);
-        rectangle.addPoint(x, y + h);
-        rectangle.addPoint(x, y);
-        return rectangle;
+    for (int i = 0; i < p.countContours(); i++) {
+      this.append(new RContour(p.contours[i]));
     }
+    type = RGeomElem.POLYGON;
 
-    static public RPolygon createRectangle(float w, float h) {
-        return createRectangle(0, 0, w, h);
-    }
+    setStyle(p);
+  }
 
-    /**
-     * Use this method to create a new starform polygon.
-     *
-     * @param x
-     * @param y
-     * @eexample createStar
-     * @param radiusBig the outter radius of the star polygon
-     * @param radiusSmall the inner radius of the star polygon
-     * @param spikes the amount of spikes on the star polygon
-     * @return RPolygon, the starform polygon newly created
-     */
-    static public RPolygon createStar(float x, float y, float radiusBig, float radiusSmall, int spikes) {
-        int numPoints = spikes * 2;
-        RPoint[] points = new RPoint[numPoints];
-        double radiansPerStep = Math.PI / spikes;
-        for (int i = 0; i < numPoints; i += 2) {
-            points[i] = new RPoint(
-                    radiusBig * Math.cos(i * radiansPerStep) + x,
-                    radiusBig * Math.sin(i * radiansPerStep) + y
-            );
-            points[i + 1] = new RPoint(
-                    radiusSmall * Math.cos(i * radiansPerStep) + x,
-                    radiusSmall * Math.sin(i * radiansPerStep) + y
-            );
+  /**
+   * Create a new polygon given an array of points.
+   *
+   createPolygon
+   * @param points the points for the new polygon.
+   */
+  public RPolygon(RPoint[] points) {
+    this(new RContour(points));
+  }
+
+  /**
+   * Create a new polygon given a contour.
+   *
+   * @param newcontour the contour for the new polygon.
+   */
+  public RPolygon(RContour newcontour) {
+    this.append(newcontour);
+    type = RGeomElem.POLYGON;
+  }
+
+  /**
+   * Create an empty polygon.
+   */
+  public RPolygon() {
+    contours = null;
+    type = RGeomElem.POLYGON;
+  }
+
+  /**
+   * Use this method to create a new circle polygon.
+   *
+   * @param x
+   * @param y
+   createCircle
+   * @param radius the radius of the circle
+   * @param detail the number of vertices of the polygon
+   * @return RPolygon, the circular polygon newly created
+   */
+  static public RPolygon createCircle(float x, float y, float radius, int detail) {
+    RPoint[] points = new RPoint[detail];
+    double radiansPerStep = 2 * Math.PI / detail;
+    for (int i = 0; i < detail; i++) {
+      points[i] = new RPoint(
+        radius * Math.cos(i * radiansPerStep) + x,
+        radius * Math.sin(i * radiansPerStep) + y
+      );
+    }
+    return new RPolygon(points);
+  }
+
+  static public RPolygon createCircle(float radius, int detail) {
+    return createCircle(0, 0, radius, detail);
+  }
+
+  static public RPolygon createCircle(float x, float y, float radius) {
+    return createCircle(x, y, radius, defaultDetail);
+  }
+
+  static public RPolygon createCircle(float radius) {
+    return createCircle(0, 0, radius, defaultDetail);
+  }
+
+  /**
+   * Use this method to create a new rectangle polygon.
+   *
+   createRectangle
+   * @param x the upper-left corner x coordinate
+   * @param y the upper-left corner y coordinate
+   * @param w the width
+   * @param h the height
+   * @return RPolygon, the circular polygon newly created
+   */
+  static public RPolygon createRectangle(float x, float y, float w, float h) {
+    RPolygon rectangle = new RPolygon();
+    rectangle.addPoint(x, y);
+    rectangle.addPoint(x + w, y);
+    rectangle.addPoint(x + w, y + h);
+    rectangle.addPoint(x, y + h);
+    rectangle.addPoint(x, y);
+    return rectangle;
+  }
+
+  static public RPolygon createRectangle(float w, float h) {
+    return createRectangle(0, 0, w, h);
+  }
+
+  /**
+   * Use this method to create a new starform polygon.
+   *
+   * @param x
+   * @param y
+   createStar
+   * @param radiusBig the outter radius of the star polygon
+   * @param radiusSmall the inner radius of the star polygon
+   * @param spikes the amount of spikes on the star polygon
+   * @return RPolygon, the starform polygon newly created
+   */
+  static public RPolygon createStar(float x, float y, float radiusBig, float radiusSmall, int spikes) {
+    int numPoints = spikes * 2;
+    RPoint[] points = new RPoint[numPoints];
+    double radiansPerStep = Math.PI / spikes;
+    for (int i = 0; i < numPoints; i += 2) {
+      points[i] = new RPoint(
+        radiusBig * Math.cos(i * radiansPerStep) + x,
+        radiusBig * Math.sin(i * radiansPerStep) + y
+      );
+      points[i + 1] = new RPoint(
+        radiusSmall * Math.cos(i * radiansPerStep) + x,
+        radiusSmall * Math.sin(i * radiansPerStep) + y
+      );
+    }
+    return new RPolygon(points);
+  }
+
+  static public RPolygon createStar(float radiusBig, float radiusSmall, int spikes) {
+    return createStar(0, 0, radiusBig, radiusSmall, spikes);
+  }
+
+  /**
+   * Use this method to create a new ring polygon.
+   *
+   * @param x
+   * @param y
+   createRing
+   * @param radiusBig the outter radius of the ring polygon
+   * @param radiusSmall the inner radius of the ring polygon
+   * @param detail the number of vertices on each contour of the ring
+   * @return RPolygon, the ring polygon newly created
+   */
+  static public RPolygon createRing(float x, float y, float radiusBig, float radiusSmall, int detail) {
+    RPoint[] inner = new RPoint[detail];
+    RPoint[] outer = new RPoint[detail];
+    double radiansPerStep = 2 * Math.PI / detail;
+    for (int i = 0; i < detail; i++) {
+      inner[i] = new RPoint(
+        radiusSmall * Math.cos(i * radiansPerStep) + x,
+        radiusSmall * Math.sin(i * radiansPerStep) + y
+      );
+      outer[i] = new RPoint(
+        radiusBig * Math.cos(i * radiansPerStep) + x,
+        radiusBig * Math.sin(i * radiansPerStep) + y
+      );
+    }
+    RPolygon ring = new RPolygon();
+    ring.addContour(outer);
+    ring.addContour(inner);
+    return ring;
+  }
+
+  static public RPolygon createRing(float radiusBig, float radiusSmall, int detail) {
+    return createRing(0, 0, radiusBig, radiusSmall, detail);
+  }
+
+  static public RPolygon createRing(float x, float y, float radiusBig, float radiusSmall) {
+    return createRing(x, y, radiusBig, radiusSmall, defaultDetail);
+  }
+
+  static public RPolygon createRing(float radiusBig, float radiusSmall) {
+    return createRing(0, 0, radiusBig, radiusSmall, defaultDetail);
+  }
+
+  /**
+   * Use this method to get the centroid of the element.
+   *
+   RGroup_getCentroid
+   * @return RPo the centroid point of the element
+   * getBounds ( )
+   * getCenter ( )
+   */
+  @Override
+  public RPoint getCentroid() {
+    RPoint bestCentroid = new RPoint();
+    float bestArea = Float.NEGATIVE_INFINITY;
+    if (contours != null) {
+      for (RContour contour : contours) {
+        float area = Math.abs(contour.getArea());
+        if (area > bestArea) {
+          bestArea = area;
+          bestCentroid = contour.getCentroid();
         }
-        return new RPolygon(points);
-    }
-
-    static public RPolygon createStar(float radiusBig, float radiusSmall, int spikes) {
-        return createStar(0, 0, radiusBig, radiusSmall, spikes);
+      }
+      return bestCentroid;
     }
+    return null;
+  }
 
-    /**
-     * Use this method to create a new ring polygon.
-     *
-     * @param x
-     * @param y
-     * @eexample createRing
-     * @param radiusBig the outter radius of the ring polygon
-     * @param radiusSmall the inner radius of the ring polygon
-     * @param detail the number of vertices on each contour of the ring
-     * @return RPolygon, the ring polygon newly created
-     */
-    static public RPolygon createRing(float x, float y, float radiusBig, float radiusSmall, int detail) {
-        RPoint[] inner = new RPoint[detail];
-        RPoint[] outer = new RPoint[detail];
-        double radiansPerStep = 2 * Math.PI / detail;
-        for (int i = 0; i < detail; i++) {
-            inner[i] = new RPoint(
-                    radiusSmall * Math.cos(i * radiansPerStep) + x,
-                    radiusSmall * Math.sin(i * radiansPerStep) + y
-            );
-            outer[i] = new RPoint(
-                    radiusBig * Math.cos(i * radiansPerStep) + x,
-                    radiusBig * Math.sin(i * radiansPerStep) + y
-            );
-        }
-        RPolygon ring = new RPolygon();
-        ring.addContour(outer);
-        ring.addContour(inner);
-        return ring;
+  /**
+   * Use this method to count the number of contours in the polygon.
+   *
+   countContours
+   * @return int the number contours in the polygon
+   * addContour ( )
+   */
+  public int countContours() {
+    if (this.contours == null) {
+      return 0;
     }
 
-    static public RPolygon createRing(float radiusBig, float radiusSmall, int detail) {
-        return createRing(0, 0, radiusBig, radiusSmall, detail);
-    }
+    return this.contours.length;
+  }
 
-    static public RPolygon createRing(float x, float y, float radiusBig, float radiusSmall) {
-        return createRing(x, y, radiusBig, radiusSmall, defaultDetail);
+  /**
+   * Add a new contour to the polygon.
+   *
+   addContour
+   * @param c the contour to be added
+   * addPoint ( )
+   */
+  public void addContour(RContour c) {
+    this.append(c);
+  }
+
+  /**
+   * Add an empty contour to the polygon.
+   *
+   addContour
+   * addPoint ( )
+   */
+  public void addContour() {
+    this.append(new RContour());
+  }
+
+  /**
+   * Add a new contour to the polygon given an array of points.
+   *
+   addContour
+   * @param points the points of the new contour to be added
+   * addPoint ( )
+   */
+  public void addContour(RPoint[] points) {
+    this.append(new RContour(points));
+  }
+
+  /**
+   * Use this method to set the current contour to which append points.
+   *
+   * @param indContour
+   addContour
+   * addPoint ( )
+   */
+  public void setContour(int indContour) {
+    this.currentContour = indContour;
+  }
+
+  /**
+   * Add a new point to the current contour.
+   *
+   addPoint
+   * @param p the point to be added
+   * addContour ( )
+   * setCurrent ( )
+   */
+  public void addPoint(RPoint p) {
+    if (contours == null) {
+      this.append(new RContour());
+    }
+    this.contours[currentContour].append(p);
+  }
+
+  /**
+   * Add a new point to the current contour.
+   *
+   addPoint
+   * @param x the x coordinate of the point to be added
+   * @param y the y coordinate of the point to be added
+   * addContour ( )
+   * setCurrent ( )
+   */
+  public void addPoint(float x, float y) {
+    if (contours == null) {
+      this.append(new RContour());
+    }
+    this.contours[currentContour].append(new RPoint(x, y));
+  }
+
+  /**
+   * Add a new point to the selected contour.
+   *
+   addPoint
+   * @param indContour the index of the contour to which the point will be added
+   * @param p the point to be added
+   * addContour ( )
+   * setCurrent ( )
+   */
+  public void addPoint(int indContour, RPoint p) {
+    if (contours == null) {
+      this.append(new RContour());
+    }
+    this.contours[indContour].append(p);
+  }
+
+  /**
+   * Add a new point to the selected contour.
+   *
+   addPoint
+   * @param indContour the index of the contour to which the point will be added
+   * @param x the x coordinate of the point to be added
+   * @param y the y coordinate of the point to be added
+   * addContour ( )
+   * setCurrent ( )
+   */
+  public void addPoint(int indContour, float x, float y) {
+    if (contours == null) {
+      this.append(new RContour());
+    }
+    this.contours[indContour].append(new RPoint(x, y));
+  }
+
+  public void addClose() {
+    if (contours == null) {
+      return;
+    }
+
+    contours[contours.length - 1].addClose();
+  }
+
+  /**
+   * Use this method to create a new mesh from a given polygon.
+   *
+   toMesh
+   * @return RMesh, the mesh made of tristrips resulting of a tesselation of the
+   * polygon
+   * draw ( )
+   */
+  @Override
+  public RMesh toMesh() {
+    if (contours == null) {
+      return new RMesh();
+    }
+
+    RMesh mesh = RClip.polygonToMesh(this);
+    if (mesh == null) {
+      return null;
+    }
+
+    mesh.setStyle(this);
+    return mesh;
+  }
+
+  @Override
+  public void print() {
+    System.out.println("polygon: ");
+    for (int i = 0; i < countContours(); i++) {
+      System.out.println("---  contour " + i + " ---");
+      contours[i].print();
+      System.out.println("---------------");
+    }
+  }
+
+  /**
+   * Removes contours with less than 3 points. These are contours that are open.
+   * Since close polygons have points[0] == points[-1] and two more points to
+   * form a triangle at least. This is useful to avoid the clipping algorithm
+   * from breaking.
+   *
+   * @return
+   *
+   */
+  protected RPolygon removeOpenContours() {
+    RPolygon clean = new RPolygon();
+    for (int i = 0; i < countContours(); i++) {
+      if (contours[i].countPoints() > 3) {
+        clean.addContour(contours[i]);
+      }
     }
+    clean.setStyle(this);
+    return clean;
+  }
+
+  /**
+   * @return
+   */
+  @Override
+  public RPolygon toPolygon() {
+    return new RPolygon(this);
+  }
+
+  /**
+   * @return
+   */
+  @Override
+  public RShape toShape() {
+    int numContours = countContours();
 
-    static public RPolygon createRing(float radiusBig, float radiusSmall) {
-        return createRing(0, 0, radiusBig, radiusSmall, defaultDetail);
-    }
+    RShape result = new RShape();
+    for (int i = 0; i < numContours; i++) {
+      RPoint[] newpoints = this.contours[i].getHandles();
 
-    /**
-     * Use this method to get the centroid of the element.
-     *
-     * @eexample RGroup_getCentroid
-     * @return RPo the centroid point of the element
-     * @related getBounds ( )
-     * @related getCenter ( )
-     */
-    @Override
-    public RPoint getCentroid() {
-        RPoint bestCentroid = new RPoint();
-        float bestArea = Float.NEGATIVE_INFINITY;
-        if (contours != null) {
-            for (RContour contour : contours) {
-                float area = Math.abs(contour.getArea());
-                if (area > bestArea) {
-                    bestArea = area;
-                    bestCentroid = contour.getCentroid();
-                }
-            }
-            return bestCentroid;
-        }
-        return null;
-    }
+      if (newpoints != null) {
+        result.addMoveTo(newpoints[0]);
 
-    /**
-     * Use this method to count the number of contours in the polygon.
-     *
-     * @eexample countContours
-     * @return int the number contours in the polygon
-     * @related addContour ( )
-     */
-    public int countContours() {
-        if (this.contours == null) {
-            return 0;
+        for (int j = 1; j < newpoints.length; j++) {
+          result.addLineTo(newpoints[j]);
         }
 
-        return this.contours.length;
-    }
-
-    /**
-     * Add a new contour to the polygon.
-     *
-     * @eexample addContour
-     * @param c the contour to be added
-     * @related addPoint ( )
-     */
-    public void addContour(RContour c) {
-        this.append(c);
-    }
-
-    /**
-     * Add an empty contour to the polygon.
-     *
-     * @eexample addContour
-     * @related addPoint ( )
-     */
-    public void addContour() {
-        this.append(new RContour());
-    }
-
-    /**
-     * Add a new contour to the polygon given an array of points.
-     *
-     * @eexample addContour
-     * @param points the points of the new contour to be added
-     * @related addPoint ( )
-     */
-    public void addContour(RPoint[] points) {
-        this.append(new RContour(points));
-    }
-
-    /**
-     * Use this method to set the current contour to which append points.
-     *
-     * @param indContour
-     * @eexample addContour
-     * @related addPoint ( )
-     */
-    public void setContour(int indContour) {
-        this.currentContour = indContour;
-    }
-
-    /**
-     * Add a new point to the current contour.
-     *
-     * @eexample addPoint
-     * @param p the point to be added
-     * @related addContour ( )
-     * @related setCurrent ( )
-     */
-    public void addPoint(RPoint p) {
-        if (contours == null) {
-            this.append(new RContour());
+        if (contours[i].closed) {
+          result.addClose();
         }
-        this.contours[currentContour].append(p);
-    }
 
-    /**
-     * Add a new point to the current contour.
-     *
-     * @eexample addPoint
-     * @param x the x coordinate of the point to be added
-     * @param y the y coordinate of the point to be added
-     * @related addContour ( )
-     * @related setCurrent ( )
-     */
-    public void addPoint(float x, float y) {
-        if (contours == null) {
-            this.append(new RContour());
-        }
-        this.contours[currentContour].append(new RPoint(x, y));
+        result.paths[i].setStyle(contours[i]);
+      }
     }
 
-    /**
-     * Add a new point to the selected contour.
-     *
-     * @eexample addPoint
-     * @param indContour the index of the contour to which the point will be
-     * added
-     * @param p the point to be added
-     * @related addContour ( )
-     * @related setCurrent ( )
-     */
-    public void addPoint(int indContour, RPoint p) {
-        if (contours == null) {
-            this.append(new RContour());
-        }
-        this.contours[indContour].append(p);
-    }
+    result.setStyle(this);
+    return result;
+  }
 
-    /**
-     * Add a new point to the selected contour.
-     *
-     * @eexample addPoint
-     * @param indContour the index of the contour to which the point will be
-     * added
-     * @param x the x coordinate of the point to be added
-     * @param y the y coordinate of the point to be added
-     * @related addContour ( )
-     * @related setCurrent ( )
-     */
-    public void addPoint(int indContour, float x, float y) {
-        if (contours == null) {
-            this.append(new RContour());
+  /**
+   * Use this to return the points of the polygon. It returns the points in the
+   * way of an array of RPoint.
+   *
+   RPolygon_getHandles
+   * @return RPoint[], the points returned in an array.
+   *
+   */
+  @Override
+  public RPoint[] getHandles() {
+    int numContours = countContours();
+    if (numContours == 0) {
+      return null;
+    }
+
+    RPoint[] result = null;
+    RPoint[] newresult = null;
+    for (int i = 0; i < numContours; i++) {
+      RPoint[] newPoints = contours[i].getHandles();
+      if (newPoints != null) {
+        if (result == null) {
+          result = new RPoint[newPoints.length];
+          System.arraycopy(newPoints, 0, result, 0, newPoints.length);
+        } else {
+          newresult = new RPoint[result.length + newPoints.length];
+          System.arraycopy(result, 0, newresult, 0, result.length);
+          System.arraycopy(newPoints, 0, newresult, result.length, newPoints.length);
+          result = newresult;
         }
-        this.contours[indContour].append(new RPoint(x, y));
+      }
     }
+    return result;
+  }
 
-    public void addClose() {
-        if (contours == null) {
-            return;
+  /**
+   * Use this to return the points of the polygon. It returns the points in the
+   * way of an array of RPoint.
+   *
+   RPolygon_getPoints
+   * @return RPoint[], the points returned in an array.
+   *
+   */
+  @Override
+  public RPoint[] getPoints() {
+    int numContours = countContours();
+    if (numContours == 0) {
+      return null;
+    }
+
+    RPoint[] result = null;
+    RPoint[] newresult = null;
+    for (int i = 0; i < numContours; i++) {
+      RPoint[] newPoints = contours[i].getPoints();
+      if (newPoints != null) {
+        if (result == null) {
+          result = new RPoint[newPoints.length];
+          System.arraycopy(newPoints, 0, result, 0, newPoints.length);
+        } else {
+          newresult = new RPoint[result.length + newPoints.length];
+          System.arraycopy(result, 0, newresult, 0, result.length);
+          System.arraycopy(newPoints, 0, newresult, result.length, newPoints.length);
+          result = newresult;
         }
-
-        contours[contours.length - 1].addClose();
+      }
     }
+    return result;
+  }
 
-    /**
-     * Use this method to create a new mesh from a given polygon.
-     *
-     * @eexample toMesh
-     * @return RMesh, the mesh made of tristrips resulting of a tesselation of
-     * the polygon
-     * @related draw ( )
-     */
-    @Override
-    public RMesh toMesh() {
-        if (contours == null) {
-            return new RMesh();
-        }
-
-        RMesh mesh = RClip.polygonToMesh(this);
-        if (mesh == null) {
-            return null;
+  /**
+   * 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;
+  }
+
+  /**
+   * Use this method to get the area covered by the polygon.
+   *
+   getArea
+   * @return float, the area covered by the polygon
+   * draw ( )
+   */
+  @Override
+  public float getArea() {
+    if (getNumPoints() < 3) {
+      return 0.0F;
+    }
+    float ax = getX(0);
+    float ay = getY(0);
+    float area = 0.0F;
+    for (int i = 1; i < (getNumPoints() - 1); i++) {
+      float bx = getX(i);
+      float by = getY(i);
+      float cx = getX(i + 1);
+      float cy = getY(i + 1);
+      float tarea = ((cx - bx) * (ay - by)) - ((ax - bx) * (cy - by));
+      area += tarea;
+    }
+    area = 0.5F * Math.abs(area);
+    return area;
+  }
+
+  /**
+   * Use this method to draw the polygon.
+   *
+   drawPolygon
+   * @param g PGraphics, the graphics object on which to draw the polygon
+   * draw ( )
+   */
+  @Override
+  public void draw(PGraphics g) {
+    int numContours = countContours();
+    if (numContours != 0) {
+      if (isIn(g)) {
+        if (!RG.ignoreStyles) {
+          saveContext(g);
+          setContext(g);
         }
 
-        mesh.setStyle(this);
-        return mesh;
-    }
+        // Check whether to draw the fill or not
+        if (g.fill) {
+          // Since we are drawing the different tristrips we must turn off the stroke or make it the same color as the fill
+          // NOTE: there's currently no way of drawing the outline of a mesh, since no information is kept about what vertices are at the edge
 
-    @Override
-    public void print() {
-        System.out.println("polygon: ");
-        for (int i = 0; i < countContours(); i++) {
-            System.out.println("---  contour " + i + " ---");
-            contours[i].print();
-            System.out.println("---------------");
-        }
-    }
+          // Save the information about the current stroke color and turn off
+          boolean stroking = g.stroke;
+          g.noStroke();
 
-    /**
-     * Removes contours with less than 3 points. These are contours that are
-     * open. Since close polygons have points[0] == points[-1] and two more
-     * points to form a triangle at least. This is useful to avoid the clipping
-     * algorithm from breaking.
-     *
-     * @return 
-     * @invisible
-     */
-    protected RPolygon removeOpenContours() {
-        RPolygon clean = new RPolygon();
-        for (int i = 0; i < countContours(); i++) {
-            if (contours[i].countPoints() > 3) {
-                clean.addContour(contours[i]);
+          // Save smoothing state and turn off
+          int smoothing = g.smooth;
+          try {
+            if (smoothing > 0) {
+              g.noSmooth();
             }
-        }
-        clean.setStyle(this);
-        return clean;
-    }
-
-    /**
-     * @return 
-     * @invisible
-     */
-    @Override
-    public RPolygon toPolygon() {
-        return new RPolygon(this);
-    }
-
-    /**
-     * @return 
-     * @invisible
-     */
-    @Override
-    public RShape toShape() {
-        int numContours = countContours();
-
-        RShape result = new RShape();
-        for (int i = 0; i < numContours; i++) {
-            RPoint[] newpoints = this.contours[i].getHandles();
-
-            if (newpoints != null) {
-                result.addMoveTo(newpoints[0]);
+          } catch (Exception e) {
+          }
 
-                for (int j = 1; j < newpoints.length; j++) {
-                    result.addLineTo(newpoints[j]);
-                }
+          RMesh tempMesh = this.toMesh();
+          tempMesh.draw(g);
 
-                if (contours[i].closed) {
-                    result.addClose();
-                }
+          // Restore the old stroke color
+          if (stroking) {
+            g.stroke(g.strokeColor);
+          }
 
-                result.paths[i].setStyle(contours[i]);
+          // Restore the old smoothing state
+          try {
+            if (smoothing > 0) {
+              g.smooth();
             }
+          } catch (Exception e) {
+          }
         }
 
-        result.setStyle(this);
-        return result;
-    }
-
-    /**
-     * Use this to return the points of the polygon. It returns the points in
-     * the way of an array of RPoint.
-     *
-     * @eexample RPolygon_getHandles
-     * @return RPoint[], the points returned in an array.
-   *
-     */
-    @Override
-    public RPoint[] getHandles() {
-        int numContours = countContours();
-        if (numContours == 0) {
-            return null;
+        // Check whether to draw the stroke or not
+        if (g.stroke) {
+          for (int i = 0; i < numContours; i++) {
+            contours[i].draw(g);
+          }
         }
 
-        RPoint[] result = null;
-        RPoint[] newresult = null;
-        for (int i = 0; i < numContours; i++) {
-            RPoint[] newPoints = contours[i].getHandles();
-            if (newPoints != null) {
-                if (result == null) {
-                    result = new RPoint[newPoints.length];
-                    System.arraycopy(newPoints, 0, result, 0, newPoints.length);
-                } else {
-                    newresult = new RPoint[result.length + newPoints.length];
-                    System.arraycopy(result, 0, newresult, 0, result.length);
-                    System.arraycopy(newPoints, 0, newresult, result.length, newPoints.length);
-                    result = newresult;
-                }
-            }
+        if (!RG.ignoreStyles) {
+          restoreContext(g);
         }
-        return result;
+      }
     }
+  }
 
-    /**
-     * Use this to return the points of the polygon. It returns the points in
-     * the way of an array of RPoint.
-     *
-     * @eexample RPolygon_getPoints
-     * @return RPoint[], the points returned in an array.
-   *
-     */
-    @Override
-    public RPoint[] getPoints() {
-        int numContours = countContours();
-        if (numContours == 0) {
-            return null;
-        }
-
-        RPoint[] result = null;
-        RPoint[] newresult = null;
-        for (int i = 0; i < numContours; i++) {
-            RPoint[] newPoints = contours[i].getPoints();
-            if (newPoints != null) {
-                if (result == null) {
-                    result = new RPoint[newPoints.length];
-                    System.arraycopy(newPoints, 0, result, 0, newPoints.length);
-                } else {
-                    newresult = new RPoint[result.length + newPoints.length];
-                    System.arraycopy(result, 0, newresult, 0, result.length);
-                    System.arraycopy(newPoints, 0, newresult, result.length, newPoints.length);
-                    result = newresult;
-                }
-            }
+  @Override
+  public void draw(PApplet g) {
+    int numContours = countContours();
+    if (numContours != 0) {
+      if (isIn(g)) {
+        if (!RG.ignoreStyles) {
+          saveContext(g);
+          setContext(g);
         }
-        return result;
-    }
 
-    /**
-     * Use this method to get the type of element this is.
-     *
-     * @eexample RPolygon_getType
-     * @return int, will allways return RGeomElem.POLYGON
-     */
-    public int getType() {
-        return type;
-    }
+        // Check whether to draw the fill or not
+        if (g.g.fill) {
+          // Since we are drawing the different tristrips we must turn off the stroke or make it the same color as the fill
+          // NOTE: there's currently no way of drawing the outline of a mesh, since no information is kept about what vertices are at the edge
 
-    /**
-     * Use this method to get the area covered by the polygon.
-     *
-     * @eexample getArea
-     * @return float, the area covered by the polygon
-     * @related draw ( )
-     */
-    @Override
-    public float getArea() {
-        if (getNumPoints() < 3) {
-            return 0.0F;
-        }
-        float ax = getX(0);
-        float ay = getY(0);
-        float area = 0.0F;
-        for (int i = 1; i < (getNumPoints() - 1); i++) {
-            float bx = getX(i);
-            float by = getY(i);
-            float cx = getX(i + 1);
-            float cy = getY(i + 1);
-            float tarea = ((cx - bx) * (ay - by)) - ((ax - bx) * (cy - by));
-            area += tarea;
-        }
-        area = 0.5F * Math.abs(area);
-        return area;
-    }
+          // Save the information about the current stroke color and turn off
+          boolean stroking = g.g.stroke;
+          g.noStroke();
 
-    /**
-     * Use this method to draw the polygon.
-     *
-     * @eexample drawPolygon
-     * @param g PGraphics, the graphics object on which to draw the polygon
-     * @related draw ( )
-     */
-    @Override
-    public void draw(PGraphics g) {
-        int numContours = countContours();
-        if (numContours != 0) {
-            if (isIn(g)) {
-                if (!RG.ignoreStyles) {
-                    saveContext(g);
-                    setContext(g);
-                }
-
-                // Check whether to draw the fill or not
-                if (g.fill) {
-                    // Since we are drawing the different tristrips we must turn off the stroke or make it the same color as the fill
-                    // NOTE: there's currently no way of drawing the outline of a mesh, since no information is kept about what vertices are at the edge
-
-                    // Save the information about the current stroke color and turn off
-                    boolean stroking = g.stroke;
-                    g.noStroke();
-
-                    // Save smoothing state and turn off
-                    int smoothing = g.smooth;
-                    try {
-                        if (smoothing > 0) {
-                            g.noSmooth();
-                        }
-                    } catch (Exception e) {
-                    }
-
-                    RMesh tempMesh = this.toMesh();
-                    tempMesh.draw(g);
-
-                    // Restore the old stroke color
-                    if (stroking) {
-                        g.stroke(g.strokeColor);
-                    }
-
-                    // Restore the old smoothing state
-                    try {
-                        if (smoothing > 0) {
-                            g.smooth();
-                        }
-                    } catch (Exception e) {
-                    }
-                }
-
-                // Check whether to draw the stroke or not
-                if (g.stroke) {
-                    for (int i = 0; i < numContours; i++) {
-                        contours[i].draw(g);
-                    }
-                }
-
-                if (!RG.ignoreStyles) {
-                    restoreContext(g);
-                }
+          // Save smoothing state and turn off
+          int smoothing = g.g.smooth;
+          try {
+            if (smoothing > 0) {
+              g.noSmooth();
             }
-        }
-    }
-
-    @Override
-    public void draw(PApplet g) {
-        int numContours = countContours();
-        if (numContours != 0) {
-            if (isIn(g)) {
-                if (!RG.ignoreStyles) {
-                    saveContext(g);
-                    setContext(g);
-                }
-
-                // Check whether to draw the fill or not
-                if (g.g.fill) {
-                    // Since we are drawing the different tristrips we must turn off the stroke or make it the same color as the fill
-                    // NOTE: there's currently no way of drawing the outline of a mesh, since no information is kept about what vertices are at the edge
-
-                    // Save the information about the current stroke color and turn off
-                    boolean stroking = g.g.stroke;
-                    g.noStroke();
-
-                    // Save smoothing state and turn off
-                    int smoothing = g.g.smooth;
-                    try {
-                        if (smoothing > 0) {
-                            g.noSmooth();
-                        }
-                    } catch (Exception e) {
-                    }
-
-                    RMesh tempMesh = this.toMesh();
-                    if (tempMesh != null) {
-                        tempMesh.draw(g);
-                    }
-
-                    // Restore the old stroke color
-                    if (stroking) {
-                        g.stroke(g.g.strokeColor);
-                    }
-
-                    // Restore the old smoothing state
-                    try {
-                        if (smoothing > 0) {
-                            g.smooth();
-                        }
-                    } catch (Exception e) {
-                    }
-                }
-
-                // Check whether to draws the stroke or not
-                if (g.g.stroke) {
-                    for (int i = 0; i < numContours; i++) {
-                        contours[i].draw(g);
-                    }
-                }
-
-                if (!RG.ignoreStyles) {
-                    restoreContext(g);
-                }
+          } catch (Exception e) {
+          }
+
+          RMesh tempMesh = this.toMesh();
+          if (tempMesh != null) {
+            tempMesh.draw(g);
+          }
+
+          // Restore the old stroke color
+          if (stroking) {
+            g.stroke(g.g.strokeColor);
+          }
+
+          // Restore the old smoothing state
+          try {
+            if (smoothing > 0) {
+              g.smooth();
             }
+          } catch (Exception e) {
+          }
         }
-    }
-
-    /**
-     * Use this method to get the intersection of this polygon with the polygon
-     * passed in as a parameter.
-     *
-     * @eexample intersection
-     * @param p RPolygon, the polygon with which to perform the intersection
-     * @return RPolygon, the intersection of the two polygons
-     * @related union ( )
-     * @related xor ( )
-     * @related diff ( )
-     */
-    public RPolygon intersection(RPolygon p) {
-        RPolygon res = RClip.intersection(p, this);
-        res.setStyle(this.getStyle());
-        return res;
-    }
-
-    /**
-     * Use this method to get the union of this polygon with the polygon passed
-     * in as a parameter.
-     *
-     * @eexample union
-     * @param p RPolygon, the polygon with which to perform the union
-     * @return RPolygon, the union of the two polygons
-     * @related intersection ( )
-     * @related xor ( )
-     * @related diff ( )
-     */
-    public RPolygon union(RPolygon p) {
-        RPolygon res = RClip.union(p, this);
-        res.setStyle(this.getStyle());
-        return res;
-    }
-
-    /**
-     * Use this method to get the xor of this polygon with the polygon passed in
-     * as a parameter.
-     *
-     * @eexample xor
-     * @param p RPolygon, the polygon with which to perform the xor
-     * @return RPolygon, the xor of the two polygons
-     * @related union ( )
-     * @related intersection ( )
-     * @related diff ( )
-     */
-    public RPolygon xor(RPolygon p) {
-        RPolygon res = RClip.xor(p, this);
-        res.setStyle(this.getStyle());
-        return res;
-    }
-
-    /**
-     * Use this method to get the difference between this polygon and the
-     * polygon passed in as a parameter.
-     *
-     * @eexample diff
-     * @param p RPolygon, the polygon with which to perform the difference
-     * @return RPolygon, the difference of the two polygons
-     * @related union ( )
-     * @related xor ( )
-     * @related intersection ( )
-     */
-    public RPolygon diff(RPolygon p) {
-        RPolygon res = RClip.diff(this, p);
-        res.setStyle(this.getStyle());
-        return res;
-    }
-
-    /**
-     * Use this method to get a rebuilt version of a given polygon by removing
-     * extra points and solving intersecting contours or holes.
-     *
-     * @eexample RPolygon_update
-     * @return RPolygon, the updated polygon
-     * @related diff ( )
-     * @related union ( )
-     * @related xor ( )
-     * @related intersection ( )
-     */
-    public RPolygon update() {
-        return RClip.update(this);
-    }
 
-    @Override
-    public RPoint getPoint(float t) {
-        PApplet.println("Feature not yet implemented for this class.");
-        return null;
-    }
-
-    @Override
-    public RPoint getTangent(float t) {
-        PApplet.println("Feature not yet implemented for this class.");
-        return null;
-    }
-
-    /**
-     *
-     * @return
-     */
-    @Override
-    public RPoint[] getTangents() {
-        PApplet.println("Feature not yet implemented for this class.");
-        return null;
-    }
-
-    @Override
-    public RPoint[][] getPointsInPaths() {
-        PApplet.println("Feature not yet implemented for this class.");
-        return null;
-    }
-
-    @Override
-    public RPoint[][] getHandlesInPaths() {
-        PApplet.println("Feature not yet implemented for this class.");
-        return null;
-    }
-
-    @Override
-    public RPoint[][] getTangentsInPaths() {
-        PApplet.println("Feature not yet implemented for this class.");
-        return null;
-    }
+        // Check whether to draws the stroke or not
+        if (g.g.stroke) {
+          for (int i = 0; i < numContours; i++) {
+            contours[i].draw(g);
+          }
+        }
 
-    @Override
-    public boolean contains(RPoint p) {
-        PApplet.println("Feature not yet implemented for this class.");
-        return false;
+        if (!RG.ignoreStyles) {
+          restoreContext(g);
+        }
+      }
     }
+  }
 
-    /**
-     * Use this method to transform the polygon.
-     *
-     * @eexample RPolygon_transform
-     * @param m RMatrix, the matrix of the affine transformation to apply to the
-     * polygon
-     */
-    /*
+  /**
+   * Use this method to get the intersection of this polygon with the polygon
+   * passed in as a parameter.
+   *
+   intersection
+   * @param p RPolygon, the polygon with which to perform the intersection
+   * @return RPolygon, the intersection of the two polygons
+   * union ( )
+   * xor ( )
+   * diff ( )
+   */
+  public RPolygon intersection(RPolygon p) {
+    RPolygon res = RClip.intersection(p, this);
+    res.setStyle(this.getStyle());
+    return res;
+  }
+
+  /**
+   * Use this method to get the union of this polygon with the polygon passed in
+   * as a parameter.
+   *
+   union
+   * @param p RPolygon, the polygon with which to perform the union
+   * @return RPolygon, the union of the two polygons
+   * intersection ( )
+   * xor ( )
+   * diff ( )
+   */
+  public RPolygon union(RPolygon p) {
+    RPolygon res = RClip.union(p, this);
+    res.setStyle(this.getStyle());
+    return res;
+  }
+
+  /**
+   * Use this method to get the xor of this polygon with the polygon passed in
+   * as a parameter.
+   *
+   xor
+   * @param p RPolygon, the polygon with which to perform the xor
+   * @return RPolygon, the xor of the two polygons
+   * union ( )
+   * intersection ( )
+   * diff ( )
+   */
+  public RPolygon xor(RPolygon p) {
+    RPolygon res = RClip.xor(p, this);
+    res.setStyle(this.getStyle());
+    return res;
+  }
+
+  /**
+   * Use this method to get the difference between this polygon and the polygon
+   * passed in as a parameter.
+   *
+   diff
+   * @param p RPolygon, the polygon with which to perform the difference
+   * @return RPolygon, the difference of the two polygons
+   * union ( )
+   * xor ( )
+   * intersection ( )
+   */
+  public RPolygon diff(RPolygon p) {
+    RPolygon res = RClip.diff(this, p);
+    res.setStyle(this.getStyle());
+    return res;
+  }
+
+  /**
+   * Use this method to get a rebuilt version of a given polygon by removing
+   * extra points and solving intersecting contours or holes.
+   *
+   RPolygon_update
+   * @return RPolygon, the updated polygon
+   * diff ( )
+   * union ( )
+   * xor ( )
+   * intersection ( )
+   */
+  public RPolygon update() {
+    return RClip.update(this);
+  }
+
+  @Override
+  public RPoint getPoint(float t) {
+    PApplet.println("Feature not yet implemented for this class.");
+    return null;
+  }
+
+  @Override
+  public RPoint getTangent(float t) {
+    PApplet.println("Feature not yet implemented for this class.");
+    return null;
+  }
+
+  /**
+   *
+   * @return
+   */
+  @Override
+  public RPoint[] getTangents() {
+    PApplet.println("Feature not yet implemented for this class.");
+    return null;
+  }
+
+  @Override
+  public RPoint[][] getPointsInPaths() {
+    PApplet.println("Feature not yet implemented for this class.");
+    return null;
+  }
+
+  @Override
+  public RPoint[][] getHandlesInPaths() {
+    PApplet.println("Feature not yet implemented for this class.");
+    return null;
+  }
+
+  @Override
+  public RPoint[][] getTangentsInPaths() {
+    PApplet.println("Feature not yet implemented for this class.");
+    return null;
+  }
+
+  @Override
+  public boolean contains(RPoint p) {
+    PApplet.println("Feature not yet implemented for this class.");
+    return false;
+  }
+
+  /**
+   * Use this method to transform the polygon.
+   *
+   RPolygon_transform
+   * @param m RMatrix, the matrix of the affine transformation to apply to the
+   * polygon
+   */
+  /*
     public void transform(RMatrix m){
     int numContours = countContours();
     if(numContours!=0){
@@ -867,242 +864,255 @@ public class RPolygon extends RGeomElem {
     }
     }
     }
-     */
-    // ----------------------
-    // --- Private Methods ---
-    // ----------------------
-    /**
-     * Remove all of the points. Creates an empty polygon.
-     */
-    protected void clear() {
-        this.contours = null;
-    }
-
-    /**
-     * Add a point to the first inner polygon.
-     * @param x
-     * @param y
-     */
-    protected void add(float x, float y) {
-        if (contours == null) {
-            this.append(new RContour());
-        }
-        this.contours[0].append(new RPoint(x, y));
-    }
-
-    /**
-     * Add a point to the first inner polygon.
-     * @param p
-     */
-    protected void add(RPoint p) {
-        if (contours == null) {
-            this.append(new RContour());
-        }
-        this.contours[0].append(p);
-    }
+   */
+  // ----------------------
+  // --- Private Methods ---
+  // ----------------------
+  /**
+   * Remove all of the points. Creates an empty polygon.
+   */
+  protected void clear() {
+    this.contours = null;
+  }
 
-    /**
-     * Add an inner polygon to this polygon - assumes that adding polygon does
-     * not have any inner polygons.
-     * @param p
-     */
-    protected void add(RPolygon p) {
-        /*if (this.contours.length > 0 && this.isHole){
+  /**
+   * Add a point to the first inner polygon.
+   *
+   * @param x
+   * @param y
+   */
+  protected void add(float x, float y) {
+    if (contours == null) {
+      this.append(new RContour());
+    }
+    this.contours[0].append(new RPoint(x, y));
+  }
+
+  /**
+   * Add a point to the first inner polygon.
+   *
+   * @param p
+   */
+  protected void add(RPoint p) {
+    if (contours == null) {
+      this.append(new RContour());
+    }
+    this.contours[0].append(p);
+  }
+
+  /**
+   * Add an inner polygon to this polygon - assumes that adding polygon does not
+   * have any inner polygons.
+   *
+   * @param p
+   */
+  protected void add(RPolygon p) {
+    /*if (this.contours.length > 0 && this.isHole){
       throw new IllegalStateException("Cannot add polys to something designated as a hole.");
       }*/
-        RContour c = new RContour();
-        for (int i = 0; i < p.getNumPoints(); i++) {
-            c.addPoint(p.getX(i), p.getY(i));
-        }
-        this.append(c);
+    RContour c = new RContour();
+    for (int i = 0; i < p.getNumPoints(); i++) {
+      c.addPoint(p.getX(i), p.getY(i));
     }
+    this.append(c);
+  }
 
-    /**
-     * Add an inner polygon to this polygon - assumes that adding polygon does
-     * not have any inner polygons.
-     * @param c
-     */
-    protected void add(RContour c) {
-        /*if (this.contours.length > 0 && this.isHole){
+  /**
+   * Add an inner polygon to this polygon - assumes that adding polygon does not
+   * have any inner polygons.
+   *
+   * @param c
+   */
+  protected void add(RContour c) {
+    /*if (this.contours.length > 0 && this.isHole){
       throw new IllegalStateException("Cannot add polys to something designated as a hole.");
       }*/
-        this.append(c);
-    }
-
-    /**
-     * Return true if the polygon is empty
-     * @return 
-     */
-    protected boolean isEmpty() {
-        return (this.contours == null);
-    }
-
-    /**
-     * Returns the bounding box of the polygon.
-     * @return 
-     */
-    protected RRectangle getBBox() {
-        if (this.contours == null) {
-            return new RRectangle();
-        } else if (this.contours.length == 1) {
-
-            float xmin = Float.MAX_VALUE;
-            float ymin = Float.MAX_VALUE;
-            float xmax = -Float.MAX_VALUE;
-            float ymax = -Float.MAX_VALUE;
-
-            if (this.contours[0].points == null) {
-                return new RRectangle();
-            }
+    this.append(c);
+  }
 
-            for (RPoint point : this.contours[0].points) {
-                float x = point.getX();
-                float y = point.getY();
-                if (x < xmin) {
-                    xmin = x;
-                }
-                if (x > xmax) {
-                    xmax = x;
-                }
-                if (y < ymin) {
-                    ymin = y;
-                }
-                if (y > ymax) {
-                    ymax = y;
-                }
-            }
+  /**
+   * Return true if the polygon is empty
+   *
+   * @return
+   */
+  protected boolean isEmpty() {
+    return (this.contours == null);
+  }
+
+  /**
+   * Returns the bounding box of the polygon.
+   *
+   * @return
+   */
+  protected RRectangle getBBox() {
+    if (this.contours == null) {
+      return new RRectangle();
+    } else if (this.contours.length == 1) {
+
+      float xmin = Float.MAX_VALUE;
+      float ymin = Float.MAX_VALUE;
+      float xmax = -Float.MAX_VALUE;
+      float ymax = -Float.MAX_VALUE;
+
+      if (this.contours[0].points == null) {
+        return new RRectangle();
+      }
 
-            return new RRectangle(xmin, ymin, (xmax - xmin), (ymax - ymin));
-        } else {
-            throw new UnsupportedOperationException("getBounds not supported on complex poly.");
+      for (RPoint point : this.contours[0].points) {
+        float x = point.getX();
+        float y = point.getY();
+        if (x < xmin) {
+          xmin = x;
         }
-    }
-
-    /**
-     * Returns the polygon at this index.
-     * @param polyIndex
-     * @return 
-     */
-    protected RPolygon getInnerPoly(int polyIndex) {
-        return new RPolygon(this.contours[polyIndex]);
-    }
-
-    /**
-     * Returns the number of inner polygons - inner polygons are assumed to
-     * return one here.
-     * @return 
-     */
-    protected int getNumInnerPoly() {
-        if (this.contours == null) {
-            return 0;
+        if (x > xmax) {
+          xmax = x;
         }
-        return this.contours.length;
-    }
-
-    /**
-     * Return the number points of the first inner polygon
-     * @return 
-     */
-    protected int getNumPoints() {
-        if (this.contours == null) {
-            return 0;
+        if (y < ymin) {
+          ymin = y;
         }
-        if (this.contours[0].points == null) {
-            return 0;
+        if (y > ymax) {
+          ymax = y;
         }
-        return this.contours[0].points.length;
-    }
+      }
 
-    /**
-     * Return the X value of the point at the index in the first inner polygon
-     * @param index
-     * @return 
-     */
-    protected float getX(int index) {
-        if (this.contours == null) {
-            return 0;
-        }
-        return this.contours[0].points[index].x;
+      return new RRectangle(xmin, ymin, (xmax - xmin), (ymax - ymin));
+    } else {
+      throw new UnsupportedOperationException("getBounds not supported on complex poly.");
     }
+  }
 
-    /**
-     * Return the Y value of the point at the index in the first inner polygon
-     * @param index
-     * @return 
-     */
-    protected float getY(int index) {
-        if (this.contours == null) {
-            return 0;
-        }
-        return this.contours[0].points[index].y;
+  /**
+   * Returns the polygon at this index.
+   *
+   * @param polyIndex
+   * @return
+   */
+  protected RPolygon getInnerPoly(int polyIndex) {
+    return new RPolygon(this.contours[polyIndex]);
+  }
+
+  /**
+   * Returns the number of inner polygons - inner polygons are assumed to return
+   * one here.
+   *
+   * @return
+   */
+  protected int getNumInnerPoly() {
+    if (this.contours == null) {
+      return 0;
     }
+    return this.contours.length;
+  }
 
-    /**
-     * Return true if this polygon is a hole. Holes are assumed to be inner
-     * polygons of a more complex polygon.
-     *
-     * @return 
-     * @throws IllegalStateException if called on a complex polygon.
-     */
-    public boolean isHole() {
-        if (this.contours == null || this.contours.length > 1) {
-            throw new IllegalStateException("Cannot call on a poly made up of more than one poly.");
-        }
-        return this.contours[0].isHole;
+  /**
+   * Return the number points of the first inner polygon
+   *
+   * @return
+   */
+  protected int getNumPoints() {
+    if (this.contours == null) {
+      return 0;
     }
-
-    /**
-     * Set whether or not this polygon is a hole. Cannot be called on a complex
-     * polygon.
-     *
-     * @param isHole
-     * @throws IllegalStateException if called on a complex polygon.
-     */
-    protected void setIsHole(boolean isHole) {
-        if (this.contours == null || this.contours.length > 1) {
-            throw new IllegalStateException("Cannot call on a poly made up of more than one poly.");
-        }
-        this.contours[0].isHole = isHole;
+    if (this.contours[0].points == null) {
+      return 0;
     }
+    return this.contours[0].points.length;
+  }
 
-    /**
-     * Return true if the given inner polygon is contributing to the set
-     * operation. This method should NOT be used outside the Clip algorithm.
-     * @param polyIndex
-     * @return 
-     */
-    protected boolean isContributing(int polyIndex) {
-        return this.contours[polyIndex].isContributing;
-    }
-
-    /**
-     * Set whether or not this inner polygon is constributing to the set
-     * operation. This method should NOT be used outside the Clip algorithm.
-     * @param polyIndex
-     * @param contributes
-     */
-    protected void setContributing(int polyIndex, boolean contributes) {
-        /*
+  /**
+   * Return the X value of the point at the index in the first inner polygon
+   *
+   * @param index
+   * @return
+   */
+  protected float getX(int index) {
+    if (this.contours == null) {
+      return 0;
+    }
+    return this.contours[0].points[index].x;
+  }
+
+  /**
+   * Return the Y value of the point at the index in the first inner polygon
+   *
+   * @param index
+   * @return
+   */
+  protected float getY(int index) {
+    if (this.contours == null) {
+      return 0;
+    }
+    return this.contours[0].points[index].y;
+  }
+
+  /**
+   * Return true if this polygon is a hole. Holes are assumed to be inner
+   * polygons of a more complex polygon.
+   *
+   * @return
+   * @throws IllegalStateException if called on a complex polygon.
+   */
+  public boolean isHole() {
+    if (this.contours == null || this.contours.length > 1) {
+      throw new IllegalStateException("Cannot call on a poly made up of more than one poly.");
+    }
+    return this.contours[0].isHole;
+  }
+
+  /**
+   * Set whether or not this polygon is a hole. Cannot be called on a complex
+   * polygon.
+   *
+   * @param isHole
+   * @throws IllegalStateException if called on a complex polygon.
+   */
+  protected void setIsHole(boolean isHole) {
+    if (this.contours == null || this.contours.length > 1) {
+      throw new IllegalStateException("Cannot call on a poly made up of more than one poly.");
+    }
+    this.contours[0].isHole = isHole;
+  }
+
+  /**
+   * Return true if the given inner polygon is contributing to the set
+   * operation. This method should NOT be used outside the Clip algorithm.
+   *
+   * @param polyIndex
+   * @return
+   */
+  protected boolean isContributing(int polyIndex) {
+    return this.contours[polyIndex].isContributing;
+  }
+
+  /**
+   * Set whether or not this inner polygon is constributing to the set
+   * operation. This method should NOT be used outside the Clip algorithm.
+   *
+   * @param polyIndex
+   * @param contributes
+   */
+  protected void setContributing(int polyIndex, boolean contributes) {
+    /*
     if( this.contours.length != 1 )
       {
         throw new IllegalStateException( "Only applies to polys of size 1" );
       }
-         */
-        this.contours[polyIndex].isContributing = contributes;
-    }
-
-    private void append(RContour nextcontour) {
-        RContour[] newcontours;
-        if (contours == null) {
-            newcontours = new RContour[1];
-            newcontours[0] = nextcontour;
-            currentContour = 0;
-        } else {
-            newcontours = new RContour[this.contours.length + 1];
-            System.arraycopy(this.contours, 0, newcontours, 0, this.contours.length);
-            newcontours[this.contours.length] = nextcontour;
-            currentContour++;
-        }
-        this.contours = newcontours;
-    }
+     */
+    this.contours[polyIndex].isContributing = contributes;
+  }
+
+  private void append(RContour nextcontour) {
+    RContour[] newcontours;
+    if (contours == null) {
+      newcontours = new RContour[1];
+      newcontours[0] = nextcontour;
+      currentContour = 0;
+    } else {
+      newcontours = new RContour[this.contours.length + 1];
+      System.arraycopy(this.contours, 0, newcontours, 0, this.contours.length);
+      newcontours[this.contours.length] = nextcontour;
+      currentContour++;
+    }
+    this.contours = newcontours;
+  }
 }