geomerative 0.2.0-java → 0.3.2-java

data/src/geomerative/RMesh.java

@@ -18,7 +18,12 @@
 */
 
 package geomerative ;
-import processing.core.*;
+
+
+import processing.core.PApplet;
+import processing.core.PConstants;
+import processing.core.PGraphics;
+
 
 /**
  * RMesh is a reduced interface for creating, holding and drawing meshes. A mesh is a group of triangular strips (RStrip).
@@ -239,7 +244,7 @@ public class RMesh extends RGeomElem
     }
     
     RPoint[] result=null;
-    RPoint[] newresult=null;
+    RPoint[] newresult;
     for(int i=0;i<numStrips;i++){
       RPoint[] newPoints = strips[i].getHandles();
       if(newPoints!=null){
@@ -270,7 +275,7 @@ public class RMesh extends RGeomElem
     }
     
     RPoint[] result=null;
-    RPoint[] newresult=null;
+    RPoint[] newresult;
     for(int i=0;i<numStrips;i++){
       RPoint[] newPoints = strips[i].getPoints();
       if(newPoints!=null){

data/src/geomerative/RPath.java

@@ -1,7 +1,7 @@
 /**
  * Copyright 2004-2008 Ricard Marxer  <email@ricardmarxer.com>
  *
-    This file is part of Geomerative.
+ * This file is part of Geomerative.
  *
  * Geomerative is free software: you can redistribute it and/or modify it under
  * the terms of the GNU General Public License as published by the Free Software
@@ -18,7 +18,10 @@
  */
 package geomerative;
 
-import processing.core.*;
+//import processing.core.*;
+import processing.core.PApplet;
+import processing.core.PConstants;
+import processing.core.PGraphics;
 
 /**
  * RPath is a reduced interface for creating, holding and drawing contours.
@@ -152,14 +155,14 @@ public class RPath extends RGeomElem {
      *
      * @eexample getHandles
      * @return RPoint[], the start, control and end points returned in an array.
-   *
+     *
      */
     @Override
     public RPoint[] getHandles() {
         int numCommands = countCommands();
 
         RPoint[] result = null;
-        RPoint[] newresult = null;
+        RPoint[] newresult;
         for (int i = 0; i < numCommands; i++) {
             RPoint[] newPoints = commands[i].getHandles();
             if (newPoints != null) {
@@ -187,7 +190,7 @@ public class RPath extends RGeomElem {
      *
      * @eexample getPoints
      * @return RPoint[], the vertices returned in an array.
-   *
+     *
      */
     @Override
     public RPoint[] getPoints() {
@@ -196,11 +199,11 @@ public class RPath extends RGeomElem {
             return null;
         }
 
-    // Add the curve points of each command
+        // Add the curve points of each command
         // First set the accumulated offset to the value of the inital offset
         RCommand.segmentAccOffset = RCommand.segmentOffset;
         RPoint[] result = null;
-        RPoint[] newresult = null;
+        RPoint[] newresult;
         for (int i = 0; i < numCommands; i++) {
             RPoint[] newPoints = commands[i].getPoints(false);
             if (newPoints != null) {
@@ -208,7 +211,7 @@ public class RPath extends RGeomElem {
                     result = new RPoint[newPoints.length];
                     System.arraycopy(newPoints, 0, result, 0, newPoints.length);
                 } else {
-          // Check for overlapping
+                    // Check for overlapping
                     // Overlapping happens when the last point of the last command 
                     // is the same as the first point of the current command
                     RPoint lastp = result[result.length - 1];
@@ -224,12 +227,13 @@ public class RPath extends RGeomElem {
                 }
             }
         }
-
         // Always add last point
+        if (result == null) {
+            return result;
+        }
         newresult = new RPoint[result.length + 1];
         System.arraycopy(result, 0, newresult, 0, result.length);
         newresult[newresult.length - 1] = new RPoint(commands[numCommands - 1].endPoint);
-
         return newresult;
     }
 
@@ -239,7 +243,7 @@ public class RPath extends RGeomElem {
      *
      * @eexample RGroup_getPoints
      * @return RPoint[], the points returned in an array.
-   *
+     *
      */
     @Override
     public RPoint[][] getPointsInPaths() {
@@ -253,7 +257,7 @@ public class RPath extends RGeomElem {
      *
      * @eexample RGroup_getHandles
      * @return RPoint[], the handles returned in an array.
-   *
+     *
      */
     @Override
     public RPoint[][] getHandlesInPaths() {
@@ -267,7 +271,7 @@ public class RPath extends RGeomElem {
      *
      * @eexample RGroup_getTangents
      * @return RPoint[], the tangents returned in an array.
-   *
+     *
      */
     @Override
     public RPoint[][] getTangentsInPaths() {
@@ -291,7 +295,7 @@ public class RPath extends RGeomElem {
      *
      * @eexample getTangents
      * @return RPoint[], the tangent vectors returned in an array.
-   *
+     *
      */
     @Override
     public RPoint[] getTangents() {
@@ -301,7 +305,7 @@ public class RPath extends RGeomElem {
         }
 
         RPoint[] result = null;
-        RPoint[] newresult = null;
+        RPoint[] newresult;
         for (int i = 0; i < numCommands; i++) {
             RPoint[] newTangents = commands[i].getTangents();
             if (newTangents != null) {
@@ -328,7 +332,7 @@ public class RPath extends RGeomElem {
      *
      * @param other
      * @return RPoint[], the intersection points returned in an array.
-   *
+     *
      */
     public RPoint[] intersectionPoints(RCommand other) {
         int numCommands = countCommands();
@@ -337,7 +341,7 @@ public class RPath extends RGeomElem {
         }
 
         RPoint[] result = null;
-        RPoint[] newresult = null;
+        RPoint[] newresult;
         for (int i = 0; i < numCommands; i++) {
             RPoint[] newPoints = commands[i].intersectionPoints(other);
             if (newPoints != null) {
@@ -361,7 +365,7 @@ public class RPath extends RGeomElem {
      *
      * @param other
      * @return RPoint[], the intersection points returned in an array.
-   *
+     *
      */
     public RPoint[] intersectionPoints(RPath other) {
         int numCommands = countCommands();
@@ -372,7 +376,7 @@ public class RPath extends RGeomElem {
         }
 
         RPoint[] result = null;
-        RPoint[] newresult = null;
+        RPoint[] newresult;
 
         for (int j = 0; j < numOtherCommands; j++) {
             for (int i = 0; i < numCommands; i++) {
@@ -400,7 +404,7 @@ public class RPath extends RGeomElem {
      *
      * @param other
      * @return RPoint[], the intersection points returned in an array.
-   *
+     *
      */
     public RClosest closestPoints(RCommand other) {
         int numCommands = countCommands();
@@ -428,7 +432,7 @@ public class RPath extends RGeomElem {
      *
      * @param other
      * @return RPoint[], the intersection points returned in an array.
-   *
+     *
      */
     public RClosest closestPoints(RPath other) {
         int numCommands = countCommands();
@@ -461,7 +465,7 @@ public class RPath extends RGeomElem {
      * @param t the parameter of advancement on the curve. t must have values
      * between 0 and 1.
      * @return RPoint, the vertice returned.
-   *
+     *
      */
     @Override
     public RPoint getPoint(float t) {
@@ -492,7 +496,7 @@ public class RPath extends RGeomElem {
      * @param t float, the parameter of advancement on the curve. t must have
      * values between 0 and 1.
      * @return RPoint, the vertice returned.
-   *
+     *
      */
     @Override
     public RPoint getTangent(float t) {
@@ -540,7 +544,7 @@ public class RPath extends RGeomElem {
      *
      * @param p the point for which to test containement..
      * @return boolean, true if the point is in the path.
-   *
+     *
      */
     @Override
     public boolean contains(RPoint p) {
@@ -567,7 +571,8 @@ public class RPath extends RGeomElem {
         }
 
         int nvert = verts.length;
-        int i, j = 0;
+        int i;
+        int j;
         boolean c = false;
         for (i = 0, j = nvert - 1; i < nvert; j = i++) {
             if (((verts[i].y > testy) != (verts[j].y > testy))
@@ -584,7 +589,7 @@ public class RPath extends RGeomElem {
      * @eexample insertHandle
      * @param t float, the parameter of advancement on the curve. t must have
      * values between 0 and 1.
-   *
+     *
      */
     public void insertHandle(float t) {
         if ((t == 0F) || (t == 1F)) {
@@ -620,7 +625,7 @@ public class RPath extends RGeomElem {
      * @eexample insertHandleInPaths
      * @param t float, the parameter of advancement on the curve. t must have
      * values between 0 and 1.
-   *
+     *
      */
     public void insertHandleInPaths(float t) {
         if ((t == 0F) || (t == 1F)) {
@@ -657,7 +662,7 @@ public class RPath extends RGeomElem {
      * @param t float, the parameter of advancement on the curve. t must have
      * values between 0 and 1.
      * @return RPath[], an array of two RPath.
-   *
+     *
      */
     public RPath[] split(float t) {
         RPath[] result = new RPath[2];
@@ -973,7 +978,7 @@ public class RPath extends RGeomElem {
      * @param m RMatrix, the matrix defining the affine transformation
      * @related draw ( )
      */
-  // OPT: not transform the EndPoint since it's equal to the next StartPoint
+    // OPT: not transform the EndPoint since it's equal to the next StartPoint
   /*
      public void transform(RMatrix m){
      RPoint[] ps = getHandles();

data/src/geomerative/RPoint.java

@@ -1,419 +1,419 @@
 /**
-    Copyright 2004-2008 Ricard Marxer  <email@ricardmarxer.com>
-
+ * 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/>.
-*/
-
+ *
+ * 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.
+ * 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");
-  }
+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) {
+        return (float) Math.hypot(p.x - this.x, p.y - this.y);
+    }
+
+    public void print() {
+        System.out.print("(" + x + "," + y + ")\n");
+    }
 }