geomerative 0.1.0-java

data/src/geomerative/RPoint.java

@@ -0,0 +1,419 @@
+/**
+    Copyright 2004-2008 Ricard Marxer  <email@ricardmarxer.com>
+
+    This file is part of Geomerative.
+
+    Geomerative is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Geomerative is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Geomerative.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package geomerative;
+
+/**
+ * RPoint is a very simple interface for creating, holding and drawing 2D points.
+ * @eexample RPoint
+ * @usage Geometry
+ * @related x
+ * @related y
+ */
+public class RPoint
+{
+  /**
+   * The x coordinate of the point.
+   * @eexample RPoint_x
+   * @usage Geometry
+   * @related y
+   */
+  public float x;
+
+  /**
+   * The y coordinate of the point.
+   * @eexample RPoint_y
+   * @usage Geometry
+   * @related x
+   */
+  public float y;
+
+  /**
+   * Create a new point, given the coordinates.
+   * @eexample RPoint_constructor
+   * @usage Geometry
+   * @param x  the x coordinate of the new point
+   * @param y  the y coordinate of the new point
+   * @related x
+   * @related y
+   */
+  public RPoint(float x,float y)
+  {
+    this.x = x;
+    this.y = y;
+  }
+
+  public RPoint(double x, double y)
+  {
+    this.x = (float)x;
+    this.y = (float)y;
+  }
+
+  /**
+   * Create a new point at (0, 0).
+   * @eexample RPoint_constructor
+   * @usage Geometry
+   * @related x
+   * @related y
+   */
+  public RPoint()
+  {
+    x = 0;
+    y = 0;
+  }
+
+  /**
+   * Copy a point.
+   * @eexample RPoint_constructor
+   * @usage Geometry
+   * @param p  the point we wish to make a copy of
+   * @related x
+   * @related y
+   */
+  public RPoint(RPoint p)
+  {
+    this.x = p.x;
+    this.y = p.y;
+  }
+
+  /**
+   * @invisible
+   */
+  float getX()
+  {
+    return this.x;
+  }
+
+  /**
+   * @invisible
+   */
+  float getY()
+  {
+    return this.y;
+  }
+
+
+  /**
+   * @invisible
+   */
+  void setLocation(float nx, float ny)
+  {
+    this.x = nx;
+    this.y = ny;
+  }
+
+  /**
+   * Use this to apply a transformation to the point.
+   * @eexample RPoint_transform
+   * @usage Geometry
+   * @param m  the transformation matrix to be applied
+   * @related translate ( )
+   * @related rotate ( )
+   * @related scale ( )
+   */
+  public void transform(RMatrix m)
+  {
+    float tempx = m.m00*x + m.m01*y + m.m02;
+    float tempy = m.m10*x + m.m11*y + m.m12;
+
+    x = tempx;
+    y = tempy;
+  }
+
+  /**
+   * Apply a translation to the point.
+   * @eexample RPoint_translate
+   * @usage Geometry
+   * @param tx  the coefficient of x translation
+   * @param ty  the coefficient of y translation
+   * @related transform ( )
+   * @related rotate ( )
+   * @related scale ( )
+   */
+  public void translate(float tx, float ty)
+  {
+    x += tx;
+    y += ty;
+  }
+
+  /**
+   * Apply a translation to the point.
+   * @eexample RPoint_translate
+   * @usage Geometry
+   * @param t  the translation vector to be applied
+   * @related transform ( )
+   * @related rotate ( )
+   * @related scale ( )
+   */
+  public void translate(RPoint t)
+  {
+    x += t.x;
+    y += t.y;
+  }
+
+  /**
+   * Apply a rotation to the point, given the angle and optionally the coordinates of the center of rotation.
+   * @eexample RPoint_rotate
+   * @usage Geometry
+   * @param angle  the angle of rotation to be applied
+   * @param vx  the x coordinate of the center of rotation
+   * @param vy  the y coordinate of the center of rotation
+   * @related transform ( )
+   * @related translate ( )
+   * @related scale ( )
+   */
+  public void rotate(float angle, float vx, float vy)
+  {
+    float c = (float)Math.cos(angle);
+    float s = (float)Math.sin(angle);
+
+    x -= vx;
+    y -= vy;
+
+    float tempx = x;
+    float tempy = y;
+
+    x = tempx*c - tempy*s;
+    y = tempx*s + tempy*c;
+
+    x += vx;
+    y += vy;
+  }
+
+  public void rotate(float angle)
+  {
+    float c = (float)Math.cos(angle);
+    float s = (float)Math.sin(angle);
+
+    float tempx = x;
+    float tempy = y;
+
+    x = tempx*c - tempy*s;
+    y = tempx*s + tempy*c;
+  }
+
+  /**
+   * Apply a rotation to the point, given the angle and optionally the point of the center of rotation.
+   * @eexample RPoint_rotate
+   * @usage Geometry
+   * @param angle  the angle of rotation to be applied
+   * @param v  the position vector of the center of rotation
+   * @related transform ( )
+   * @related translate ( )
+   * @related scale ( )
+   */
+  public void rotate(float angle, RPoint v)
+  {
+    float c = (float)Math.cos(angle);
+    float s = (float)Math.sin(angle);
+
+    x -= v.x;
+    y -= v.y;
+
+    float tempx = x;
+    float tempy = y;
+
+    x = tempx*c - tempy*s;
+    y = tempx*s + tempy*c;
+
+    x += v.x;
+    y += v.y;
+  }
+
+  /**
+   * Apply a scaling to the point, given the scaling factors.
+   * @eexample RPoint_scale
+   * @usage Geometry
+   * @param sx  the scaling coefficient over the x axis
+   * @param sy  the scaling coefficient over the y axis
+   * @related transform ( )
+   * @related translate ( )
+   * @related rotate ( )
+   */
+  public void scale (float sx, float sy)
+  {
+    x *= sx;
+    y *= sy;
+  }
+
+  /**
+   * Apply a scaling to the point, given a scaling factor.
+   * @eexample RPoint_scale
+   * @usage Geometry
+   * @param s  the scaling coefficient for a uniform scaling
+   * @related transform ( )
+   * @related translate ( )
+   * @related rotate ( )
+   */
+  public void scale (float s)
+  {
+    x *= s;
+    y *= s;
+  }
+
+  /**
+   * Apply a scaling to the point, given a scaling vector.
+   * @eexample RPoint_scale
+   * @usage Geometry
+   * @param s  the scaling vector
+   * @related transform ( )
+   * @related translate ( )
+   * @related rotate ( )
+   */
+  public void scale (RPoint s)
+  {
+    x *= s.x;
+    y *= s.y;
+  }
+
+
+  /**
+   * Use this to normalize the point. This means that after applying, it's norm will be equal to 1.
+   * @eexample RPoint_normalize
+   * @usage Geometry
+   * @related transform ( )
+   * @related translate ( )
+   * @related rotate ( )
+   * @related scale ( )
+   */
+  public void normalize ()
+  {
+    float norma = norm();
+    if(norma!=0) scale(1/norma);
+  }
+
+  /**
+   * Use this to subtract a vector from this point.
+   * @eexample RPoint_sub
+   * @usage Geometry
+   * @param p  the vector to substract
+   * @related add ( )
+   * @related mult ( )
+   * @related cross ( )
+   */
+  public void sub (RPoint p)
+  {
+    x -= p.x;
+    y -= p.y;
+  }
+
+  /**
+   * Use this to add a vector to this point.
+   * @eexample RPoint_add
+   * @usage Geometry
+   * @param p  the vector to add
+   * @related sub ( )
+   * @related mult ( )
+   * @related cross ( )
+   */
+  public void add (RPoint p)
+  {
+    x += p.x;
+    y += p.y;
+  }
+
+  /**
+   * Use this to multiply a vector to this point. This returns a float corresponding to the scalar product of both vectors.
+   * @eexample RPoint_mult
+   * @usage Geometry
+   * @param p  the vector to multiply
+   * @return float, the result of the scalar product
+   * @related add ( )
+   * @related sub ( )
+   * @related cross ( )
+   */
+  public float mult (RPoint p)
+  {
+    return (x * p.x + y * p.y);
+  }
+
+  /**
+   * Use this to perform a cross product of the point with another point.  This returns a RPoint corresponding to the cross product of both vectors.
+   * @eexample RPoint_cross
+   * @usage Geometry
+   * @param p  the vector to perform the cross product with
+   * @return RPoint, the resulting vector of the cross product
+   * @related add ( )
+   * @related sub ( )
+   * @related mult ( )
+   */
+  public RPoint cross (RPoint p)
+  {
+    return new RPoint(x * p.y - p.x * y, y * p.x - p.y * x);
+  }
+
+  /**
+   * Use this to obtain the norm of the point.
+   * @eexample RPoint_norm
+   * @usage Geometry
+   * @return float, the norm of the point
+   * @related angle ( )
+   */
+  public float norm ()
+  {
+    return (float)Math.sqrt(mult(this));
+  }
+
+  /**
+   * Use this to obtain the square norm of the point.
+   * @eexample RPoint_norm
+   * @usage Geometry
+   * @return float, the norm of the point
+   * @related angle ( )
+   */
+  public float sqrnorm ()
+  {
+    return (float)mult(this);
+  }
+
+  /**
+   * Use this to obtain the angle between the vector and another vector
+   * @eexample RPoint_angle
+   * @usage Geometry
+   * @param p  the vector relative to which we want to evaluate the angle
+   * @return float, the angle between the two vectors
+   * @related norm ( )
+   */
+  public float angle (RPoint p)
+  {
+    float normp = p.norm();
+    float normthis = norm();
+    return (float)Math.acos(mult(p)/(normp*normthis));
+  }
+
+  /**
+   * Use this to obtain the distance between the vector and another vector
+   * @eexample RPoint_dist
+   * @usage Geometry
+   * @param p  the vector relative to which we want to evaluate the distance
+   * @return float, the distance between the two vectors
+   * @related norm ( )
+   */
+  public float dist (RPoint p)
+  {
+    float dx = (p.x-this.x);
+    float dy = (p.y-this.y);
+    return (float)Math.sqrt(dx*dx + dy*dy);
+  }
+
+
+  public void print(){
+    System.out.print("("+x+","+y+")\n");
+  }
+}

data/src/geomerative/RPolygon.java

@@ -0,0 +1,1110 @@
+/**
+ * Copyright 2004-2008 Ricard Marxer  <email@ricardmarxer.com>
+ *
+    This file is part of Geomerative.
+ *
+ * Geomerative is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later
+ * version.
+ *
+ * Geomerative is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * Geomerative. If not, see <http://www.gnu.org/licenses/>.
+ */
+package geomerative;
+
+import processing.core.*;
+
+/**
+ * RPolygon is a reduced interface for creating, holding and drawing complex
+ * polygons. Polygons are groups of one or more contours (RContour). This
+ * 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
+ */
+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);
+    }
+
+    static public RPolygon createCircle(float radius) {
+        return createCircle(0, 0, radius, defaultDetail);
+    }
+
+    /**
+     * 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;
+    }
+
+    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
+     * @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
+            );
+        }
+        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
+     * @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;
+    }
+
+    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.
+     *
+     * @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;
+    }
+
+    /**
+     * 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;
+        }
+
+        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());
+        }
+        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));
+    }
+
+    /**
+     * 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);
+    }
+
+    /**
+     * 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());
+        }
+        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.
+     *
+     * @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;
+        }
+
+        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
+     * @invisible
+     */
+    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 @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]);
+
+                for (int j = 1; j < newpoints.length; j++) {
+                    result.addLineTo(newpoints[j]);
+                }
+
+                if (contours[i].closed) {
+                    result.addClose();
+                }
+
+                result.paths[i].setStyle(contours[i]);
+            }
+        }
+
+        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;
+        }
+
+        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;
+                }
+            }
+        }
+        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;
+                }
+            }
+        }
+        return result;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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
+                    // boolean smoothing = g.smooth;
+                    try {
+
+                        g.noSmooth();
+
+                    } catch (Exception e) {
+                    }
+
+                    RMesh tempMesh = this.toMesh();
+                    tempMesh.draw(g);
+
+                    // Restore the old stroke color
+                    if (stroking) {
+                        g.stroke(g.strokeColor);
+                    }
+
+                }
+
+                // 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);
+                }
+            }
+        }
+    }
+
+    /**
+     *
+     * @param g
+     */
+    @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();
+
+                    RMesh tempMesh = this.toMesh();
+                    if (tempMesh != null) {
+                        tempMesh.draw(g);
+                    }
+
+                    // Restore the old stroke color
+                    if (stroking) {
+                        g.stroke(g.g.strokeColor);
+                    }
+
+                }
+
+                // 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);
+                }
+            }
+        }
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     *
+     * @param t
+     * @return
+     */
+    @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;
+    }
+
+    /**
+     *
+     * @return
+     */
+    @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.
+     *
+     * @eexample 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){
+     for(int i=0;i<numContours;i++){
+     contours[i].transform(m);
+     }
+     }
+     }
+     */
+  // ----------------------
+    // --- 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);
+    }
+
+    /**
+     * 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);
+    }
+
+    /**
+     * 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();
+            }
+
+            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 new RRectangle(xmin, ymin, (xmax - xmin), (ymax - ymin));
+        } else {
+            throw new UnsupportedOperationException("getBounds not supported on complex poly.");
+        }
+    }
+
+    /**
+     * 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 the number points of the first inner polygon
+     *
+     * @return
+     */
+    protected int getNumPoints() {
+        if (this.contours == null) {
+            return 0;
+        }
+        if (this.contours[0].points == null) {
+            return 0;
+        }
+        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 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;
+    }
+}