commit d7bbef2fef8eabd42e65701f16ce17faf2961927
Author: Leszek Koltunski <admin@distorted.org>
Date:   Mon May 30 23:05:45 2016 +0000

    Fix javadoc errors

diff --git a/src/main/java/org/distorted/library/DistortedObject.java b/src/main/java/org/distorted/library/DistortedObject.java
index 8aecd6e..6f5f892 100644
--- a/src/main/java/org/distorted/library/DistortedObject.java
+++ b/src/main/java/org/distorted/library/DistortedObject.java
@@ -374,9 +374,9 @@ public abstract class DistortedObject
 /**
  * Moves the Object by a vector that changes in time as interpolated by the Interpolator.
  * 
- * @param di a 3-dimensional Interpolator which at any given time will return a Float3D
+ * @param di 3-dimensional Interpolator which at any given time will return a Float3D
  *           representing the current coordinates of the vector we want to move the Object with.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @return   ID of the effect added, or -1 if we failed to add one. 
  */
   public long move(Interpolator3D di)
     {   
@@ -387,11 +387,11 @@ public abstract class DistortedObject
 /**
  * Moves the Bitmap by a vector that smoothly changes from (0,0,0) to (x,y,z).
  *  
- * @param x The x-coordinate of the vector we want to move the Object with. 
- * @param y The y-coordinate of the vector we want to move the Object with.
- * @param z The z-coordinate of the vector we want to move the Object with.
+ * @param x        The x-coordinate of the vector we want to move the Object with. 
+ * @param y        The y-coordinate of the vector we want to move the Object with.
+ * @param z        The z-coordinate of the vector we want to move the Object with.
  * @param duration The time, in milliseconds, it takes to complete the movement.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long move(float x,float y,float z, int duration)
     {   
@@ -411,7 +411,7 @@ public abstract class DistortedObject
  * @param x The x-coordinate of the vector we want to move the Object with. 
  * @param y The y-coordinate of the vector we want to move the Object with.
  * @param z The z-coordinate of the vector we want to move the Object with.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @return  ID of the effect added, or -1 if we failed to add one. 
  */
   public long move(float x,float y,float z)
     {   
@@ -423,9 +423,9 @@ public abstract class DistortedObject
 /**
  * Scales the Object by factors that change in time as returned by the Interpolator.
  * 
- * @param di a 3-dimensional Interpolator which at any given time returns a Float3D
+ * @param di 3-dimensional Interpolator which at any given time returns a Float3D
  *           representing the current x- , y- and z- scale factors.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @return   ID of the effect added, or -1 if we failed to add one. 
  */
   public long scale(Interpolator3D di)
     {   
@@ -437,12 +437,12 @@ public abstract class DistortedObject
  * Scales the Object by a factor that smoothly changes from (1,1,1) at time 0 to (xscale,yscale,zscale)
  * after 'duration' milliseconds. 
  *    
- * @param xscale After time 'duration' passes, Bitmap's width will get multiplied by xscale; e.g. if 
- *               xscale=2, after 'duration' milliseconds the Object will become twice broader.
- * @param yscale factor to scale Object's height with.
- * @param zscale factor to scale Object's depth with.
+ * @param xscale   After time 'duration' passes, Bitmap's width will get multiplied by xscale; e.g. if 
+ *                 xscale=2, after 'duration' milliseconds the Object will become twice broader.
+ * @param yscale   Factor to scale Object's height with.
+ * @param zscale   Factor to scale Object's depth with.
  * @param duration Time, in milliseconds, it takes to interpolate to the full (xscale,yscale,zscale) scaling factors.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long scale(float xscale,float yscale,float zscale, int duration)
     {   
@@ -463,7 +463,7 @@ public abstract class DistortedObject
  *               xscale=2, the Object immediately becomes twice broader.
  * @param yscale factor to scale Object's height with.
  * @param zscale factor to scale Object's depth with. 
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long scale(float xscale,float yscale,float zscale)
     {   
@@ -474,9 +474,9 @@ public abstract class DistortedObject
 /**
  * Convenience function - scale the Object by the same factor in all 3 dimensions.   
  *   
- * @param scale all 3 Object's dimensions gets multiplied by this factor; e.g. if 
+ * @param scale all 3 Object's dimensions get multiplied by this factor; e.g. if 
  *              scale=2, the Object immediately becomes twice larger.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @return      ID of the effect added, or -1 if we failed to add one. 
  */
   public long scale(float scale)
     {   
@@ -492,7 +492,7 @@ public abstract class DistortedObject
  *          the rotation
  * @param v 4-dimensional Interpolator which at any given time will return a Float4D
  *          representing the current rotation in the (angle,axisX,axisY,axisY) form. 
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @return  ID of the effect added, or -1 if we failed to add one. 
  */
   public long rotate(Interpolator3D i, Interpolator4D v)
     {   
@@ -503,10 +503,10 @@ public abstract class DistortedObject
 /**
  * Rotates the Object around a static point, with angle and axis that change in time.
  * 
- * @param p the center of the rotation
- * @param v 4-dimensional Interpolator which at any given time will return a Float4D
- *          representing the current rotation in the (angle,axisX,axisY,axisY) form. 
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param point Center of the rotation
+ * @param v     4-dimensional Interpolator which at any given time will return a Float4D
+ *              representing the current rotation in the (angle,axisX,axisY,axisY) form. 
+ * @return      ID of the effect added, or -1 if we failed to add one. 
  */
   public long rotate(Float3D point, Interpolator4D v)
     {   
@@ -515,13 +515,16 @@ public abstract class DistortedObject
   
 ///////////////////////////////////////////////////////////////////////////////////////////////////  
 /**
- * Rotates the Object around a static point, with angle that changes in time.
+ * Rotates the Object around a static point, with angle that changes in time, around axis 
+ * (axisX, axisY, axisZ). 
  * 
- * @param p the center of the rotation
- * @param v 1-dimensional Interpolator which at any given time will return the current rotation 
- *          angle.
- * @param (axisX, axisY, axisZ) the rotation vector          
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param point Center of the rotation
+ * @param v     1-dimensional Interpolator which at any given time will return the current rotation 
+ *              angle.
+ * @param axisX Rotation vector: x-coordinate
+ * @param axisY Rotation vector: y-coordinate         
+ * @param axisZ Rotation vector: z-coordinate         
+ * @return      ID of the effect added, or -1 if we failed to add one. 
  */
   public long rotate(Float3D point, Interpolator1D v, float axisX, float axisY, float axisZ)
     {   
@@ -536,7 +539,7 @@ public abstract class DistortedObject
  * @param i 3-dimensional Interpolator which at any given time will return the current center
  *          of the rotation.
  * @param a 1-dimensional Interpolator which returns the current rotation angle.         
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @return  ID of the effect added, or -1 if we failed to add one. 
  */
   public long rotate(Interpolator3D i, Interpolator1D a)
     {   
@@ -548,10 +551,10 @@ public abstract class DistortedObject
  * Rotates the Object around a constant point, with angle that changes in time.  
  * Axis of rotation is the vector (0,0,1), i.e. a vector normal to the screen surface.
  *   
- * @param p Coordinates of the Point we are rotating around.
- * @param angle The angle, in degrees, that we want to rotate the Bitmap to.
+ * @param point    Coordinates of the Point we are rotating around.
+ * @param angle    Angle that we want to rotate the Bitmap to. Unit: degrees
  * @param duration Time, in milliseconds, it takes to complete one rotation from 0 to 'angle' degrees.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long rotate(Float3D point, int angle, int duration)
     {   
@@ -569,10 +572,12 @@ public abstract class DistortedObject
  * Rotates the Object immediately by 'angle' degrees around point p.   
  * Axis of rotation is given by the last 3 floats.
  *   
- * @param p Coordinates of the Point we are rotating around.
- * @param angle The angle, in degrees, that we want to rotate the Bitmap to.
- * @param (axisX,axisY,axisZ) - axis of rotation.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param point Coordinates of the Point we are rotating around.
+ * @param angle Angle that we want to rotate the Bitmap to. Unit: degrees
+ * @param axisX Axis of rotation: x-coordinate
+ * @param axisY Axis of rotation: y-coordinate
+ * @param axisZ Axis of rotation: z-coordinate
+ * @return      ID of the effect added, or -1 if we failed to add one. 
  */
   public long rotate(Float3D point, float angle, float axisX, float axisY, float axisZ)
     {   
@@ -583,8 +588,8 @@ public abstract class DistortedObject
 /**
  * Rotates the Object immediately by 'angle' degrees around point p.   
  *   
- * @param p      Coordinates of the Point we are rotating around.
- * @param angle  The angle, in degrees, that we want to rotate the Bitmap to.
+ * @param point  Coordinates of the Point we are rotating around.
+ * @param angle  The angle that we want to rotate the Bitmap to. Unit: degrees
  * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long rotate(Float3D point, int angle)
@@ -597,9 +602,12 @@ public abstract class DistortedObject
 /**
  * Rotates the Object immediately by quaternion (qX,qY,qZ,qW).
  *   
- * @param p Coordinates of the Point we are rotating around.
- * @param (qX,qY,qZ,qW) - the quaternion.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param point Coordinates of the Point we are rotating around.
+ * @param qX    Quaternion: x-coordinate
+ * @param qY    Quaternion: y-coordinate
+ * @param qZ    Quaternion: z-coordinate
+ * @param qW    Quaternion: w-coordinate
+ * @return      ID of the effect added, or -1 if we failed to add one. 
  */
   public long quaternion(Float3D point, float qX, float qY, float qZ, float qW)
     {   
@@ -610,9 +618,9 @@ public abstract class DistortedObject
 /**
  * Rotates the Object by a quaternion that's at the moment returned by the InterpolatorQuat.
  *   
- * @param p Coordinates of the Point we are rotating around.
- * @param iq - Interpolator that's going to, at any given moment, return a quaternion.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param point Coordinates of the Point we are rotating around.
+ * @param iq    Interpolator that's going to, at any given moment, return a quaternion.
+ * @return      ID of the effect added, or -1 if we failed to add one. 
  */
   public long quaternion(Float3D point, InterpolatorQuat iq)
     {   
@@ -623,9 +631,9 @@ public abstract class DistortedObject
 /**
  * Rotates the Object around a moving point by a quaternion that's at the moment returned by the InterpolatorQuat.
  *   
- * @param i Interpolator that returns the current center of rotation.
+ * @param i  Interpolator that returns the current center of rotation.
  * @param iq Interpolator that's going to, at any given moment, return a quaternion representing the current rotation.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @return   ID of the effect added, or -1 if we failed to add one. 
  */
   public long quaternion(Interpolator3D i, InterpolatorQuat iq)
     {   
@@ -638,10 +646,10 @@ public abstract class DistortedObject
  * Shears the Object. If the Interpolator is 1D, it will shear along the X-axis. 2D Interpolator adds
  * shearing along the Y-axis, 3D one along Z axis.
  *
- * @param p  Center of shearing, i.e. the point which stays unmoved. 
- * @param di 1- 2- or 3D Interpolator which, at any given point, returns the ordered 1-, 2- or 3-tuple 
- *           of shear factors.
- * @return   ID of the effect added, or -1 if we failed to add one. 
+ * @param point  Center of shearing, i.e. the point which stays unmoved. 
+ * @param di     1- 2- or 3D Interpolator which, at any given point, returns the ordered 1-, 2- 
+ *               or 3-tuple of shear factors.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long shear(Float3D point, Interpolator di)
     {
@@ -652,10 +660,10 @@ public abstract class DistortedObject
 /**
  * Shears the Object in 3D. Order: first X shearing, then Y, then Z.
  * 
- * @param p  Center of shearing, i.e. the point which stays unmoved. 
- * @param v  ordered 3-tuple (x-degree, y-degree, z-degree) of shearing (tangent of the angle with 
- *           which the X,Y and Z axis get slanted) 
- * @return   ID of the effect added, or -1 if we failed to add one. 
+ * @param point  Center of shearing, i.e. the point which stays unmoved. 
+ * @param vector ordered 3-tuple (x-degree, y-degree, z-degree) of shearing (tangent of the angle with 
+ *               which the X,Y and Z axis get slanted) 
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long shear(Float3D point, Float3D vector)
     {
@@ -676,12 +684,12 @@ public abstract class DistortedObject
  * Creates macroblocks at and around point defined by the Interpolator2D and the Region. 
  * Size of the macroblocks at any given time is returned by the Interpolator1D.
  * 
- * @param a a 1-dimensional Interpolator which, at any given time, returns the size of the macroblocks.
- * @param r The Region this Effect is limited to.
- *          Null here means 'apply the effect to the whole Bitmap'.
- * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing the
- *          current center of the effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param a      1-dimensional Interpolator which, at any given time, returns the size of the macroblocks.
+ * @param region Region this Effect is limited to.
+ *               Null here means 'apply the effect to the whole Bitmap'.
+ * @param i      2-dimensional Interpolator which, at any given time, returns a Float2D representing the
+ *               current center of the effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long macroblock(Interpolator1D a, Float4D region, Interpolator2D i)
     {
@@ -695,11 +703,11 @@ public abstract class DistortedObject
  * <p>
  * The difference between this and the previous method is that here the center of the Effect stays constant.
  *    
- * @param a a 1-dimensional Interpolator which, at any given time, returns the size of the macroblocks.
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the effect to the whole Bitmap'.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param a      1-dimensional Interpolator which, at any given time, returns the size of the macroblocks.
+ * @param region Region this Effect is limited to. 
+ *               Null here means 'apply the effect to the whole Bitmap'.
+ * @param point  Center of the Effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long macroblock(Interpolator1D a, Float4D region, Float2D point)
     {
@@ -714,14 +722,14 @@ public abstract class DistortedObject
  * they are of (pixels X pixels) size; after 'duration' milliseconds there are again none (i.e. their
  * size is 1X1, i.e. 1 pixel).   
  * 
- * @param pixels The maximum size, in pixels, of the Macroblocks we want to see.
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the effect to the whole Bitmap'.
- * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing the
- *          current center of the effect.
+ * @param pixels   Maximum size, in pixels, of the Macroblocks we want to see.
+ * @param region   Region this Effect is limited to. 
+ *                 Null here means 'apply the effect to the whole Bitmap'.
+ * @param i        2-dimensional Interpolator which, at any given time, returns a Float2D representing the
+ *                 current center of the effect.
  * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param count    Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long macroblock(int pixels, Float4D region, Interpolator2D i, int duration, float count)
     {
@@ -744,13 +752,13 @@ public abstract class DistortedObject
  * <p>
  * The difference between this and the previous method is that here the center of the Effect stays constant.
  *    
- * @param pixels The maximum size, in pixels, of the Macroblocks we want to see.
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the effect to the whole Bitmap'.
- * @param p Center of the Effect.
+ * @param pixels   Maximum size, in pixels, of the Macroblocks we want to see.
+ * @param region   Region this Effect is limited to. 
+ *                 Null here means 'apply the effect to the whole Bitmap'.
+ * @param point    Center of the Effect.
  * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param count    Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long macroblock(int pixels, Float4D region, Float2D point, int duration, float count)
     {
@@ -774,10 +782,10 @@ public abstract class DistortedObject
  * The difference between this and the previous method is that here there is no masking Region; thus
  * there is also no center of the Effect. 
  *    
- * @param pixels The maximum size, in pixels, of the Macroblocks we want to see.
+ * @param pixels   Maximum size, in pixels, of the Macroblocks we want to see.
  * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param count    Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long macroblock(int pixels, int duration, float count) 
     {
@@ -796,14 +804,14 @@ public abstract class DistortedObject
 /**
  * Makes a certain sub-region of the Bitmap smoothly change all three of its RGB components.
  *        
- * @param a a 1-dimensional Interpolator that returns the level of blend a given pixel will be mixed with 
- *          the next parameter 'color': pixel = (1-level)*pixel + level*color
- * @param color The color to mix.         
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing the
- *          current center of the effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param t      1-dimensional Interpolator that returns the level of blend a given pixel will be
+ *               mixed with the next parameter 'color': pixel = (1-level)*pixel + level*color
+ * @param color  Color to mix.         
+ * @param region Region this Effect is limited to. 
+ *               Null here means 'apply the Effect to the whole Bitmap'.
+ * @param i      2-dimensional Interpolator which, at any given time, returns a Float2D representing 
+ *               the current center of the effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long chroma(Interpolator1D t, Float3D color, Float4D region, Interpolator2D i)
     {
@@ -816,13 +824,13 @@ public abstract class DistortedObject
  * <p>
  * Here the center of the Effect stays constant.
  *         
- * @param a a 1-dimensional Interpolator that returns the level of blend a given pixel will be mixed with 
- *          the next parameter 'color': pixel = (1-level)*pixel + level*color
- * @param color The color to mix.         
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param t      1-dimensional Interpolator that returns the level of blend a given pixel will be 
+ *               mixed with the next parameter 'color': pixel = (1-level)*pixel + level*color
+ * @param color  Color to mix.         
+ * @param region Region this Effect is limited to. 
+ *               Null here means 'apply the Effect to the whole Bitmap'.
+ * @param point  Center of the Effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long chroma(Interpolator1D t, Float3D color, Float4D region, Float2D point)
     {
@@ -833,33 +841,33 @@ public abstract class DistortedObject
 /**
  * Makes a certain sub-region of the Bitmap smoothly change all three of its RGB components.
  *        
- * @param t the level of blend a given pixel will be mixed with the next parameter 'color': 
- *          pixel = (1-t)*pixel + t*color
- * @param color The color to mix.       
- * @param reg The Region this Effect is limited to.
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing the
- *          current center of the effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param t      Level of blend a given pixel will be mixed with the next parameter 'color': 
+ *               pixel = (1-t)*pixel + t*color
+ * @param color  Color to mix.       
+ * @param region Region this Effect is limited to.
+ *               Null here means 'apply the Effect to the whole Bitmap'.
+ * @param i      2-dimensional Interpolator which, at any given time, returns a Float2D representing the
+ *               current center of the effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long chroma(float t, Float3D color, Float4D region, Interpolator2D i)
     {
     return mF.add(EffectNames.CHROMA, t, color, region, i);
     }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
+///// //////////////////////////////////////////////////////////////////////////////////////////////
 /**
  * Makes a certain sub-region of the Bitmap smoothly change all three of its RGB components.
  * <p>
  * Here the center of the Effect stays constant.
  *         
- * @param t the level of blend a given pixel will be mixed with the next parameter 'color': 
- *          pixel = (1-t)*pixel + t*color
- * @param color The color to mix.       
- * @param reg The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param t      Level of blend a given pixel will be mixed with the next parameter 'color': 
+ *               pixel = (1-t)*pixel + t*color
+ * @param color  Color to mix.       
+ * @param region The Region this Effect is limited to. 
+ *               Null here means 'apply the Effect to the whole Bitmap'.
+ * @param point  Center of the Effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long chroma(float t, Float3D color, Float4D region, Float2D point)
     {
@@ -872,10 +880,10 @@ public abstract class DistortedObject
  * <p>
  * Here the Effect applies to the whole bitmap.
  *         
- * @param t the level of blend a given pixel will be mixed with the next parameter 'color': 
- *          pixel = (1-t)*pixel + t*color
- * @param color The color to mix.       
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param t     Level of blend a given pixel will be mixed with the next parameter 'color': 
+ *              pixel = (1-t)*pixel + t*color
+ * @param color Color to mix.       
+ * @return      ID of the effect added, or -1 if we failed to add one. 
  */
   public long chroma(float t, Float3D color)
     {
@@ -943,13 +951,13 @@ public abstract class DistortedObject
 /**
  * Makes a certain sub-region of the Bitmap smoothly change its transparency level.
  *        
- * @param a a 1-dimensional Interpolator that returns the level of transparency we want to have at any given 
- *          moment.
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing the
- *          current center of the effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param a      1-dimensional Interpolator that returns the level of transparency we want to have at any given 
+ *               moment.
+ * @param region Region this Effect is limited to. 
+ *               Null here means 'apply the Effect to the whole Bitmap'.
+ * @param i      2-dimensional Interpolator which, at any given time, returns a Float2D representing the
+ *               current center of the effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long alpha(Interpolator1D a, Float4D region, Interpolator2D i)
     {
@@ -962,12 +970,12 @@ public abstract class DistortedObject
  * <p>
  * Here the center of the Effect stays constant.
  *         
- * @param a a 1-dimensional Interpolator that returns the level of transparency we want to have at any given 
- *          moment.
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param a      1-dimensional Interpolator that returns the level of transparency we want to have at any given 
+ *               moment.
+ * @param region Region this Effect is limited to. 
+ *               Null here means 'apply the Effect to the whole Bitmap'.
+ * @param point  Center of the Effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long alpha(Interpolator1D a, Float4D region, Float2D point)
     {
@@ -978,14 +986,14 @@ public abstract class DistortedObject
 /**
  * Makes a certain sub-region of the Bitmap smoothly change its transparency level.
  *        
- * @param alpha Level of Alpha (0<=Alpha<=1) we want to interpolate to.
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing the
- *          current center of the effect.
+ * @param alpha  Level of Alpha (between 0 and 1) we want to interpolate to.
+ * @param region Region this Effect is limited to. 
+ *               Null here means 'apply the Effect to the whole Bitmap'.
+ * @param i      2-dimensional Interpolator which, at any given time, returns a Float2D representing the
+ *               current center of the effect.
  * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param count  Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long alpha(float alpha, Float4D region, Interpolator2D i, int duration, float count)
     {
@@ -1004,13 +1012,13 @@ public abstract class DistortedObject
  * <p>
  * Here the center of the Effect stays constant.
  *         
- * @param alpha Level of Alpha (0<=Alpha<=1) we want to interpolate to.
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param p Center of the Effect.
+ * @param alpha  Level of Alpha (between 0 and 1) we want to interpolate to.
+ * @param region Region this Effect is limited to. 
+ *               Null here means 'apply the Effect to the whole Bitmap'.
+ * @param point  Center of the Effect.
  * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param count  Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long alpha(float alpha, Float4D region, Float2D point, int duration, float count)
     {
@@ -1029,11 +1037,11 @@ public abstract class DistortedObject
  * <p>
  * Here the center of the Effect stays constant and the effect for now change in time.
  *         
- * @param alpha Level of Alpha (0<=Alpha<=1) we want to interpolate to.
- * @param r The Region this Effect is limited to.
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param alpha  Level of Alpha (between 0 and 1) we want to interpolate to.
+ * @param region Region this Effect is limited to.
+ *               Null here means 'apply the Effect to the whole Bitmap'.
+ * @param point  Center of the Effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long alpha(float alpha, Float4D region, Float2D point)
     {
@@ -1050,10 +1058,10 @@ public abstract class DistortedObject
 /**
  * Makes the whole Bitmap change its transparency level.
  * 
- * @param alpha Level of Alpha (0<=Alpha<=1) we want to interpolate to.
+ * @param alpha    Level of Alpha (between 0 and 1) we want to interpolate to.
  * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param count    Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long alpha(float alpha, int duration, float count) 
     {
@@ -1145,13 +1153,13 @@ public abstract class DistortedObject
 /**
  * Makes a certain sub-region of the Bitmap smoothly change its brightness level.
  *        
- * @param a a 1-dimensional Interpolator that returns the level of brightness we want to have at any given 
- *          moment.
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing the
- *          current center of the effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param a      1-dimensional Interpolator that returns the level of brightness we want to have at any given 
+ *               moment.
+ * @param region Region this Effect is limited to. 
+ *               Null here means 'apply the Effect to the whole Bitmap'.
+ * @param i      2-dimensional Interpolator which, at any given time, returns a Float2D representing the
+ *               current center of the effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long brightness(Interpolator1D a, Float4D region, Interpolator2D i)
     {
@@ -1164,12 +1172,12 @@ public abstract class DistortedObject
  * <p>
  * Here the center of the Effect stays constant.
  *         
- * @param a a 1-dimensional Interpolator that returns the level of brightness we want to have at any given 
- *          moment.
- * @param r The Region this Effect is limited to.
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param a      1-dimensional Interpolator that returns the level of brightness we want to have at any given 
+ *               moment.
+ * @param region Region this Effect is limited to.
+ *               Null here means 'apply the Effect to the whole Bitmap'.
+ * @param point  Center of the Effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long brightness(Interpolator1D a, Float4D region, Float2D point)
     {
@@ -1180,16 +1188,16 @@ public abstract class DistortedObject
 /**
  * Makes a certain sub-region of the Bitmap smoothly change its brightness level.
  *        
- * @param brightness Level of Brightness (0<=brightness<=infinity) we want to interpolate to.
- *        1 - level of brightness unchanged, anything less than 1 - 'darken the image', anything more than 1-
- *        lighten it up. 
- * @param r The Region this Effect is limited to.
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing the
- *          current center of the effect.
- * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param brightness Level of Brightness (between 0 and infinity) we want to interpolate to.
+ *                   1 - level of brightness unchanged, anything less than 1 - 'darken the image',
+ *                   anything more than 1- lighten it up. 
+ * @param region     Region this Effect is limited to.
+ *                   Null here means 'apply the Effect to the whole Bitmap'.
+ * @param i          2-dimensional Interpolator which, at any given time, returns a Float2D
+ *                   representing the current center of the effect.
+ * @param duration   Time, in milliseconds, it takes to do one full interpolation.
+ * @param count      Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return           ID of the effect added, or -1 if we failed to add one. 
  */
   public long brightness(float brightness, Float4D region, Interpolator2D i, int duration, float count)
     {
@@ -1208,15 +1216,15 @@ public abstract class DistortedObject
  * <p>
  * Here the center of the Effect stays constant.
  *         
- * @param brightness Level of Brightness (0<=brightness<=infinity) we want to interpolate to.
- *        1 - level of brightness unchanged, anything less than 1 - 'darken the image', anything more than 1-
- *        lighten it up.
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param p Center of the Effect.
- * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param brightness Level of Brightness (between 0 and infinity) we want to interpolate to.
+ *                   1 - level of brightness unchanged, anything less than 1 - 'darken the image',
+ *                   anything more than 1 - lighten it up.
+ * @param region     Region this Effect is limited to. 
+ *                   Null here means 'apply the Effect to the whole Bitmap'.
+ * @param point      Center of the Effect.
+ * @param duration   Time, in milliseconds, it takes to do one full interpolation.
+ * @param count      Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return           ID of the effect added, or -1 if we failed to add one. 
  */
   public long brightness(float brightness, Float4D region, Float2D point, int duration, float count)
     {
@@ -1235,13 +1243,13 @@ public abstract class DistortedObject
  * <p>
  * Here the center of the Effect stays constant and the effect for now change in time.
  *         
- * @param brightness Level of Brightness (0<=brightness<=infinity) we want to interpolate to.
- *        1 - level of brightness unchanged, anything less than 1 - 'darken the image', anything more than 1-
- *        lighten it up.
- * @param r The Region this Effect is limited to.
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param brightness Level of Brightness (between 0 and infinity) we want to interpolate to.
+ *                   1 - level of brightness unchanged, anything less than 1 - 'darken the image',
+ *                   anything more than 1 - lighten it up.
+ * @param region     Region this Effect is limited to.
+ *                   Null here means 'apply the Effect to the whole Bitmap'.
+ * @param point      Center of the Effect.
+ * @return           ID of the effect added, or -1 if we failed to add one. 
  */
   public long brightness(float brightness, Float4D region, Float2D point)
     {
@@ -1260,13 +1268,13 @@ public abstract class DistortedObject
 /**
  * Makes a certain sub-region of the Bitmap smoothly change its brightness level.
  *        
- * @param a a 1-dimensional Interpolator that returns the level of brightness we want to have at any given 
- *          moment.
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing the
- *          current center of the effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param a      1-dimensional Interpolator that returns the level of brightness we want to have at
+ *               any given moment.
+ * @param region Region this Effect is limited to. 
+ *               Null here means 'apply the Effect to the whole Bitmap'.
+ * @param i      2-dimensional Interpolator which, at any given time, returns a Float2D
+ *               representing the current center of the effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long smooth_brightness(Interpolator1D a, Float4D region, Interpolator2D i)
     {
@@ -1279,12 +1287,12 @@ public abstract class DistortedObject
  * <p>
  * Here the center of the Effect stays constant.
  *         
- * @param a a 1-dimensional Interpolator that returns the level of brightness we want to have at any given 
- *          moment.
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param a      1-dimensional Interpolator that returns the level of brightness we want to have at
+ *               any given moment.
+ * @param region Region this Effect is limited to. 
+ *               Null here means 'apply the Effect to the whole Bitmap'.
+ * @param point  Center of the Effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long smooth_brightness(Interpolator1D a, Float4D region, Float2D point)
     {
@@ -1295,16 +1303,16 @@ public abstract class DistortedObject
 /**
  * Makes a certain sub-region of the Bitmap smoothly change its brightness level.
  *        
- * @param brightness Level of Brightness (0<=brightness<=infinity) we want to interpolate to.
- *        1 - level of brightness unchanged, anything less than 1 - 'darken the image', anything more than 1-
- *        lighten it up. 
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing the
- *          current center of the effect.
- * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param brightness Level of Brightness (between 0 and infinity) we want to interpolate to.
+ *                   1 - level of brightness unchanged, anything less than 1 - 'darken the image',
+ *                   anything more than 1 - lighten it up. 
+ * @param region     Region this Effect is limited to. 
+ *                   Null here means 'apply the Effect to the whole Bitmap'.
+ * @param i          2-dimensional Interpolator which, at any given time, returns a Float2D
+ *                   represention the current center of the effect.
+ * @param duration   Time, in milliseconds, it takes to do one full interpolation.
+ * @param count      Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return           ID of the effect added, or -1 if we failed to add one. 
  */
   public long smooth_brightness(float brightness, Float4D region, Interpolator2D i, int duration, float count)
     {
@@ -1323,15 +1331,15 @@ public abstract class DistortedObject
  * <p>
  * Here the center of the Effect stays constant.
  *         
- * @param brightness Level of Brightness (0<=brightness<=infinity) we want to interpolate to.
- *        1 - level of brightness unchanged, anything less than 1 - 'darken the image', anything more than 1-
- *        lighten it up.
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param p Center of the Effect.
- * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param brightness Level of Brightness (between 0 and infinity) we want to interpolate to.
+ *                   1 - level of brightness unchanged, anything less than 1 - 'darken the image',
+ *                   anything more than 1 - lighten it up.
+ * @param region     Region this Effect is limited to. 
+ *                   Null here means 'apply the Effect to the whole Bitmap'.
+ * @param point      Center of the Effect.
+ * @param duration   Time, in milliseconds, it takes to do one full interpolation.
+ * @param count      Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return           ID of the effect added, or -1 if we failed to add one. 
  */
   public long smooth_brightness(float brightness, Float4D region, Float2D point, int duration, float count)
     {
@@ -1350,13 +1358,13 @@ public abstract class DistortedObject
  * <p>
  * Here the center of the Effect stays constant and the effect for now change in time.
  *         
- * @param brightness Level of Brightness (0<=brightness<=infinity) we want to interpolate to.
- *        1 - level of brightness unchanged, anything less than 1 - 'darken the image', anything more than 1-
- *        lighten it up.
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param brightness Level of Brightness (between 0 and infinity) we want to interpolate to.
+ *                   1 - level of brightness unchanged, anything less than 1 - 'darken the image',
+ *                   anything more than 1 - lighten it up.
+ * @param region     Region this Effect is limited to. 
+ *                   Null here means 'apply the Effect to the whole Bitmap'.
+ * @param point      Center of the Effect.
+ * @return           ID of the effect added, or -1 if we failed to add one. 
  */
   public long smooth_brightness(float brightness, Float4D region, Float2D point)
     {
@@ -1373,12 +1381,12 @@ public abstract class DistortedObject
 /**
  * Makes the whole Bitmap change its brightness level.
  * 
- * @param brightness Level of Brightness (0<=brightness<=infinity) we want to interpolate to.
- *        1 - level of brightness unchanged, anything less than 1 - 'darken the image', anything more than 1-
- *        lighten it up.
- * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param brightness Level of Brightness (between 0 and infinity) we want to interpolate to.
+ *                   1 - level of brightness unchanged, anything less than 1 - 'darken the image',
+ *                   anything more than 1- lighten it up.
+ * @param duration   Time, in milliseconds, it takes to do one full interpolation.
+ * @param count      Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return           ID of the effect added, or -1 if we failed to add one. 
  */
   public long smooth_brightness(float brightness, int duration, float count) 
     {
@@ -1397,13 +1405,13 @@ public abstract class DistortedObject
 /**
  * Makes a certain sub-region of the Bitmap smoothly change its contrast level.
  *        
- * @param a a 1-dimensional Interpolator that returns the level of contrast we want to have at any given 
- *          moment.
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing the
- *          current center of the effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param a      1-dimensional Interpolator that returns the level of contrast we want to have
+ *               at any given moment.
+ * @param region Region this Effect is limited to. 
+ *               Null here means 'apply the Effect to the whole Bitmap'.
+ * @param i      2-dimensional Interpolator which, at any given time, returns a Float2D
+ *               representing the current center of the effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long contrast(Interpolator1D a, Float4D region, Interpolator2D i)
     {
@@ -1416,12 +1424,12 @@ public abstract class DistortedObject
  * <p>
  * Here the center of the Effect stays constant.
  *         
- * @param a a 1-dimensional Interpolator that returns the level of contrast we want to have at any given 
- *          moment.
- * @param r The Region this Effect is limited to.
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param a      1-dimensional Interpolator that returns the level of contrast we want to have
+ *               at any given moment.
+ * @param region Region this Effect is limited to.
+ *               Null here means 'apply the Effect to the whole Bitmap'.
+ * @param point  Center of the Effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long contrast(Interpolator1D a, Float4D region, Float2D point)
     {
@@ -1432,16 +1440,16 @@ public abstract class DistortedObject
 /**
  * Makes a certain sub-region of the Bitmap smoothly change its contrast level.
  *        
- * @param contrast Level of contrast (0<=contrast<=infinity) we want to interpolate to.
- *        1 - level of contrast unchanged, anything less than 1 - reduce contrast, anything more than 1-
- *        increase the contrast. 
- * @param r The Region this Effect is limited to.
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing the
- *          current center of the effect.
+ * @param contrast Level of contrast (between 0 and infinity) we want to interpolate to.
+ *                 1 - level of contrast unchanged, anything less than 1 - reduce contrast,
+ *                 anything more than 1 - increase the contrast. 
+ * @param region   Region this Effect is limited to.
+ *                 Null here means 'apply the Effect to the whole Bitmap'.
+ * @param i        2-dimensional Interpolator which, at any given time, returns a Float2D
+ *                 represention the current center of the effect.
  * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param count    Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long contrast(float contrast, Float4D region, Interpolator2D i, int duration, float count)
     {
@@ -1460,15 +1468,15 @@ public abstract class DistortedObject
  * <p>
  * Here the center of the Effect stays constant.
  *         
- * @param contrast Level of contrast (0<=contrast<=infinity) we want to interpolate to.
- *        1 - level of contrast unchanged, anything less than 1 - reduce contrast, anything more than 1-
- *        increase the contrast. 
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param p Center of the Effect.
+ * @param contrast Level of contrast (between 0 and infinity) we want to interpolate to.
+ *                 1 - level of contrast unchanged, anything less than 1 - reduce contrast,
+ *                 anything more than 1 -increase the contrast. 
+ * @param region   Region this Effect is limited to. 
+ *                 Null here means 'apply the Effect to the whole Bitmap'.
+ * @param point    Center of the Effect.
  * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param count    Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long contrast(float contrast, Float4D region, Float2D point, int duration, float count)
     {
@@ -1487,13 +1495,13 @@ public abstract class DistortedObject
  * <p>
  * Here the center of the Effect stays constant and the effect for now change in time.
  *         
- * @param contrast Level of contrast (0<=contrast<=infinity) we want to interpolate to.
- *        1 - level of contrast unchanged, anything less than 1 - reduce contrast, anything more than 1-
- *        increase the contrast. 
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param contrast Level of contrast (between 0 and infinity) we want to interpolate to.
+ *                 1 - level of contrast unchanged, anything less than 1 - reduce contrast,
+ *                 anything more than 1 - increase the contrast. 
+ * @param region   Region this Effect is limited to. 
+ *                 Null here means 'apply the Effect to the whole Bitmap'.
+ * @param point    Center of the Effect.
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long contrast(float contrast, Float4D region, Float2D point)
     {
@@ -1512,13 +1520,13 @@ public abstract class DistortedObject
 /**
  * Makes a certain sub-region of the Bitmap smoothly change its contrast level.
  *        
- * @param a a 1-dimensional Interpolator that returns the level of contrast we want to have at any given 
- *          moment.
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing the
- *          current center of the effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param a      1-dimensional Interpolator that returns the level of contrast we want to have
+ *               at any given moment.
+ * @param region Region this Effect is limited to. 
+ *               Null here means 'apply the Effect to the whole Bitmap'.
+ * @param i      2-dimensional Interpolator which, at any given time, returns a Float2D
+ *               representing the current center of the effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long smooth_contrast(Interpolator1D a, Float4D region, Interpolator2D i)
     {
@@ -1531,12 +1539,12 @@ public abstract class DistortedObject
  * <p>
  * Here the center of the Effect stays constant.
  *         
- * @param a a 1-dimensional Interpolator that returns the level of contrast we want to have at any given 
- *          moment.
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param a      1-dimensional Interpolator that returns the level of contrast we want to have
+ *               at any given moment.
+ * @param region Region this Effect is limited to. 
+ *               Null here means 'apply the Effect to the whole Bitmap'.
+ * @param point  Center of the Effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long smooth_contrast(Interpolator1D a, Float4D region, Float2D point)
     {
@@ -1547,16 +1555,16 @@ public abstract class DistortedObject
 /**
  * Makes a certain sub-region of the Bitmap smoothly change its contrast level.
  *        
- * @param contrast Level of contrast (0<=contrast<=infinity) we want to interpolate to.
- *        1 - level of contrast unchanged, anything less than 1 - reduce contrast, anything more than 1-
- *        increase the contrast. 
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing the
- *          current center of the effect.
+ * @param contrast Level of contrast (between 0 and infinity) we want to interpolate to.
+ *                 1 - level of contrast unchanged, anything less than 1 - reduce contrast,
+ *                 anything more than 1 - increase the contrast. 
+ * @param region   Region this Effect is limited to. 
+ *                 Null here means 'apply the Effect to the whole Bitmap'.
+ * @param i        2-dimensional Interpolator which, at any given time, returns a Float2D
+ *                 representing the current center of the effect.
  * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param count    Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long smooth_contrast(float contrast, Float4D region, Interpolator2D i, int duration, float count)
     {
@@ -1575,15 +1583,15 @@ public abstract class DistortedObject
  * <p>
  * Here the center of the Effect stays constant.
  *         
- * @param contrast Level of contrast (0<=contrast<=infinity) we want to interpolate to.
- *        1 - level of contrast unchanged, anything less than 1 - reduce contrast, anything more than 1-
- *        increase the contrast. 
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param p Center of the Effect.
+ * @param contrast Level of contrast (between 0 and infinity) we want to interpolate to.
+ *                 1 - level of contrast unchanged, anything less than 1 - reduce contrast,
+ *                 anything more than 1 - increase the contrast. 
+ * @param region   Region this Effect is limited to. 
+ *                 Null here means 'apply the Effect to the whole Bitmap'.
+ * @param point    Center of the Effect.
  * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param count    Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long smooth_contrast(float contrast, Float4D region, Float2D point, int duration, float count)
     {
@@ -1602,13 +1610,13 @@ public abstract class DistortedObject
  * <p>
  * Here the center of the Effect stays constant and the effect for now change in time.
  *         
- * @param contrast Level of contrast (0<=contrast<=infinity) we want to interpolate to.
- *        1 - level of contrast unchanged, anything less than 1 - reduce contrast, anything more than 1-
- *        increase the contrast. 
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param contrast Level of contrast (between 0 and infinity) we want to interpolate to.
+ *                 1 - level of contrast unchanged, anything less than 1 - reduce contrast,
+ *                 anything more than 1 - increase the contrast. 
+ * @param region   Region this Effect is limited to. 
+ *                 Null here means 'apply the Effect to the whole Bitmap'.
+ * @param point    Center of the Effect.
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long smooth_contrast(float contrast, Float4D region, Float2D point)
     {
@@ -1625,12 +1633,12 @@ public abstract class DistortedObject
 /**
  * Makes the whole Bitmap change its contrast level.
  * 
- * @param contrast Level of contrast (0<=contrast<=infinity) we want to interpolate to.
- *        1 - level of contrast unchanged, anything less than 1 - reduce contrast, anything more than 1-
- *        increase the contrast. 
+ * @param contrast Level of contrast (between 0 and infinity) we want to interpolate to.
+ *                 1 - level of contrast unchanged, anything less than 1 - reduce contrast,
+ *                 anything omre than 1 - increase the contrast. 
  * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param count    Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long smooth_contrast(float contrast, int duration, float count) 
     {
@@ -1650,13 +1658,13 @@ public abstract class DistortedObject
 /**
  * Makes a certain sub-region of the Bitmap smoothly change its saturation level.
  *        
- * @param a a 1-dimensional Interpolator that returns the level of saturation we want to have at any given 
- *          moment.
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing the
- *          current center of the effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param a      1-dimensional Interpolator that returns the level of saturation we want to have
+ *               at any given moment.
+ * @param region Region this Effect is limited to. 
+ *               Null here means 'apply the Effect to the whole Bitmap'.
+ * @param i      2-dimensional Interpolator which, at any given time, returns a Float2D
+ *               representing the current center of the effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long saturation(Interpolator1D a, Float4D region, Interpolator2D i)
     {
@@ -1669,12 +1677,12 @@ public abstract class DistortedObject
  * <p>
  * Here the center of the Effect stays constant.
  *         
- * @param a a 1-dimensional Interpolator that returns the level of saturation we want to have at any given 
- *          moment.
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param a      1-dimensional Interpolator that returns the level of saturation we want to have
+ *               at any given moment.
+ * @param region Region this Effect is limited to. 
+ *               Null here means 'apply the Effect to the whole Bitmap'.
+ * @param point  Center of the Effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long saturation(Interpolator1D a, Float4D region, Float2D point)
     {
@@ -1685,16 +1693,16 @@ public abstract class DistortedObject
 /**
  * Makes a certain sub-region of the Bitmap smoothly change its saturation level.
  *        
- * @param saturation Level of saturation (0<=saturation<=infinity) we want to interpolate to.
- *        1 - level of saturation unchanged, anything less than 1 - reduce saturation, anything more than 1-
- *        increase the saturation. 
- * @param r The Region this Effect is limited to.
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing the
- *          current center of the effect.
- * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param saturation Level of saturation (between 0 and infinity) we want to interpolate to.
+ *                   1 - level of saturation unchanged, anything less than 1 - reduce saturation,
+ *                   anything more than 1 - increase the saturation. 
+ * @param region     Region this Effect is limited to.
+ *                   Null here means 'apply the Effect to the whole Bitmap'.
+ * @param i          2-dimensional Interpolator which, at any given time, returns a Float2D
+ *                   representing the current center of the effect.
+ * @param duration   Time, in milliseconds, it takes to do one full interpolation.
+ * @param count      Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return           ID of the effect added, or -1 if we failed to add one. 
  */
   public long saturation(float saturation, Float4D region, Interpolator2D i, int duration, float count)
     {
@@ -1713,15 +1721,15 @@ public abstract class DistortedObject
  * <p>
  * Here the center of the Effect stays constant.
  *         
- * @param saturation Level of saturation (0<=saturation<=infinity) we want to interpolate to.
- *        1 - level of saturation unchanged, anything less than 1 - reduce saturation, anything more than 1-
- *        increase the saturation. 
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param p Center of the Effect.
- * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param saturation Level of saturation (between 0 and infinity) we want to interpolate to.
+ *                   1 - level of saturation unchanged, anything less than 1 - reduce saturation,
+ *                   anything more than 1 - increase the saturation. 
+ * @param region     Region this Effect is limited to. 
+ *                   Null here means 'apply the Effect to the whole Bitmap'.
+ * @param point      Center of the Effect.
+ * @param duration   Time, in milliseconds, it takes to do one full interpolation.
+ * @param count      Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return           ID of the effect added, or -1 if we failed to add one. 
  */
   public long saturation(float saturation, Float4D region, Float2D point, int duration, float count)
     {
@@ -1740,13 +1748,13 @@ public abstract class DistortedObject
  * <p>
  * Here the center of the Effect stays constant and the effect for now change in time.
  *         
- * @param saturation Level of saturation (0<=saturation<=infinity) we want to interpolate to.
- *        1 - level of saturation unchanged, anything less than 1 - reduce saturation, anything more than 1-
- *        increase the saturation. 
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param saturation Level of saturation (between 0 and infinity) we want to interpolate to.
+ *                   1 - level of saturation unchanged, anything less than 1 - reduce saturation,
+ *                   anything more than 1- increase the saturation. 
+ * @param region     Region this Effect is limited to. 
+ *                   Null here means 'apply the Effect to the whole Bitmap'.
+ * @param point      Center of the Effect.
+ * @return           ID of the effect added, or -1 if we failed to add one. 
  */
   public long saturation(float saturation, Float4D region, Float2D point)
     {
@@ -1765,13 +1773,13 @@ public abstract class DistortedObject
 /**
  * Makes a certain sub-region of the Bitmap smoothly change its saturation level.
  *        
- * @param a a 1-dimensional Interpolator that returns the level of saturation we want to have at any given 
- *          moment.
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing the
- *          current center of the effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param a      1-dimensional Interpolator that returns the level of saturation we want to have
+ *               at any given moment.
+ * @param region Region this Effect is limited to. 
+ *               Null here means 'apply the Effect to the whole Bitmap'.
+ * @param i      2-dimensional Interpolator which, at any given time, returns a Float2D 
+ *               representing the current center of the effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long smooth_saturation(Interpolator1D a, Float4D region, Interpolator2D i)
     {
@@ -1784,12 +1792,12 @@ public abstract class DistortedObject
  * <p>
  * Here the center of the Effect stays constant.
  *         
- * @param a a 1-dimensional Interpolator that returns the level of saturation we want to have at any given 
- *          moment.
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param a      1-dimensional Interpolator that returns the level of saturation we want to have
+ *               at any given moment.
+ * @param region Region this Effect is limited to. 
+ *               Null here means 'apply the Effect to the whole Bitmap'.
+ * @param point  Center of the Effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long smooth_saturation(Interpolator1D a, Float4D region, Float2D point)
     {
@@ -1800,16 +1808,16 @@ public abstract class DistortedObject
 /**
  * Makes a certain sub-region of the Bitmap smoothly change its saturation level.
  *        
- * @param saturation Level of saturation (0<=saturation<=infinity) we want to interpolate to.
- *        1 - level of saturation unchanged, anything less than 1 - reduce saturation, anything more than 1-
- *        increase the saturation. 
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param i 2-dimensional Interpolator which, at any given time, returns a Float2D representing the
- *          current center of the effect.
- * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param saturation Level of saturation (between 0 and infinity) we want to interpolate to.
+ *                   1 - level of saturation unchanged, anything less than 1 - reduce saturation,
+ *                   anything more than 1 -increase the saturation. 
+ * @param region     Region this Effect is limited to. 
+ *                   Null here means 'apply the Effect to the whole Bitmap'.
+ * @param i          2-dimensional Interpolator which, at any given time, returns a Float2D
+ *                   representing the current center of the effect.
+ * @param duration   Time, in milliseconds, it takes to do one full interpolation.
+ * @param count      Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return           ID of the effect added, or -1 if we failed to add one. 
  */
   public long smooth_saturation(float saturation, Float4D region, Interpolator2D i, int duration, float count)
     {
@@ -1828,15 +1836,15 @@ public abstract class DistortedObject
  * <p>
  * Here the center of the Effect stays constant.
  *         
- * @param saturation Level of saturation (0<=saturation<=infinity) we want to interpolate to.
- *        1 - level of saturation unchanged, anything less than 1 - reduce saturation, anything more than 1-
- *        increase the saturation. 
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param p Center of the Effect.
- * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param saturation Level of saturation (between 0 and infinity) we want to interpolate to.
+ *                   1 - level of saturation unchanged, anything less than 1 - reduce saturation,
+ *                   anything more than 1 - increase the saturation. 
+ * @param region     Region this Effect is limited to. 
+ *                   Null here means 'apply the Effect to the whole Bitmap'.
+ * @param point      Center of the Effect.
+ * @param duration   Time, in milliseconds, it takes to do one full interpolation.
+ * @param count      Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return           ID of the effect added, or -1 if we failed to add one. 
  */
   public long smooth_saturation(float saturation, Float4D region, Float2D point, int duration, float count)
     {
@@ -1855,13 +1863,13 @@ public abstract class DistortedObject
  * <p>
  * Here the center of the Effect stays constant and the effect for now change in time.
  *         
- * @param saturation Level of saturation (0<=saturation<=infinity) we want to interpolate to.
- *        1 - level of saturation unchanged, anything less than 1 - reduce saturation, anything more than 1-
- *        increase the saturation. 
- * @param r The Region this Effect is limited to. 
- *          Null here means 'apply the Effect to the whole Bitmap'.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param saturation Level of saturation (between 0 and infinity) we want to interpolate to.
+ *                   1 - level of saturation unchanged, anything less than 1 - reduce saturation,
+ *                   anything more than 1 - increase the saturation. 
+ * @param region     Region this Effect is limited to. 
+ *                   Null here means 'apply the Effect to the whole Bitmap'.
+ * @param point      Center of the Effect.
+ * @return           ID of the effect added, or -1 if we failed to add one. 
  */
   public long smooth_saturation(float saturation, Float4D region, Float2D point)
     {
@@ -1878,12 +1886,12 @@ public abstract class DistortedObject
 /**
  * Makes the whole Bitmap change its saturation level.
  * 
- * @param saturation Level of saturation (0<=saturation<=infinity) we want to interpolate to.
- *        1 - level of saturation unchanged, anything less than 1 - reduce saturation, anything more than 1-
- *        increase the saturation. 
- * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param saturation Level of saturation (between 0 and infinity) we want to interpolate to.
+ *                   1 - level of saturation unchanged, anything less than 1 - reduce saturation,
+ *                   anything more than 1 - increase the saturation. 
+ * @param duration   Time, in milliseconds, it takes to do one full interpolation.
+ * @param count      Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return           ID of the effect added, or -1 if we failed to add one. 
  */
   public long smooth_saturation(float saturation, int duration, float count) 
     {
@@ -1903,12 +1911,12 @@ public abstract class DistortedObject
 /**
  * Distort a (possibly changing in time) part of the Bitmap by a (possibly changing in time) vector of force.
  * 
- * @param i A 2- or 3-dimensional Interpolator that returns a 2- or 3-dimensional Point which represents
- *          the vector the Center of the Effect is currently being dragged with.
- * @param r Region that masks the effect of the Distortion.
- * @param p A 2-dimensional Interpolator that, at any given time, returns a Point2D representing 
- *          the Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param i      2- or 3-dimensional Interpolator that returns a 2- or 3-dimensional Point which
+ *               represents the vector the Center of the Effect is currently being dragged with.
+ * @param region Region that masks the effect of the Distortion.
+ * @param p      2-dimensional Interpolator that, at any given time, returns a Point2D representing 
+ *               the Center of the Effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long distort(Interpolator i, Float4D region, Interpolator2D p)
     {  
@@ -1921,11 +1929,11 @@ public abstract class DistortedObject
  * <p>
  * Difference between this and the previous method is that here the center of the Effect stays constant.
  *   
- * @param i A 2- or 3-dimensional Interpolator that returns a 2- or 3-dimensional Point which represents
- *          the vector the Center of the Effect is currently being dragged with.
- * @param r Region that masks the effect of the Distortion.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param i      2- or 3-dimensional Interpolator that returns a 2- or 3-dimensional Point which
+ *               represents the vector the Center of the Effect is currently being dragged with.
+ * @param region Region that masks the effect of the Distortion.
+ * @param point  Center of the Effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long distort(Interpolator i, Float4D region, Float2D point)
     {  
@@ -1936,10 +1944,10 @@ public abstract class DistortedObject
 /**
  * Distort the whole Bitmap by a (possibly changing in time) vector of force.
  * 
- * @param i A 2- or 3-dimensional Interpolator that returns a 2- or 3-dimensional Point which represents
- *          the vector the Center of the Effect is currently being dragged with.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param i     2- or 3-dimensional Interpolator that returns a 2- or 3-dimensional Point which
+ *              represents the vector the Center of the Effect is currently being dragged with.
+ * @param point Center of the Effect.
+ * @return      ID of the effect added, or -1 if we failed to add one. 
  */
   public long distort(Interpolator i, Float2D point)
     {
@@ -1950,12 +1958,12 @@ public abstract class DistortedObject
 /**
  * Distort part of the Bitmap by a vector of force that changes from (0,0,0) to v.
  * 
- * @param v The maximum vector of force. 
- * @param r Region that masks the effect of the Distortion.
- * @param p Center of the Effect.
+ * @param vector   Maximum vector of force. 
+ * @param region   Region that masks the effect of the Distortion.
+ * @param point    Center of the Effect.
  * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param count    Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long distort(Float3D vector, Float4D region, Float2D point, int duration, float count)
     {  
@@ -1972,11 +1980,11 @@ public abstract class DistortedObject
 /**
  * Distort the whole Bitmap by a vector of force that changes from (0,0,0) to v.
  * 
- * @param v The maximum vector of force.
- * @param p Center of the Effect.
+ * @param vector   Maximum vector of force.
+ * @param point    Center of the Effect.
  * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param count    Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long distort(Float3D vector, Float2D point, int duration, float count)
     {
@@ -1996,10 +2004,10 @@ public abstract class DistortedObject
  * Difference between this and the previous method is that here the vector of force will get interpolated
  * to the maximum v and the effect will end. We are thus limited to count=0.5.
  * 
- * @param v The maximum, final vector of force.
- * @param p Center of the Effect.
+ * @param vector   Maximum, final vector of force.
+ * @param point    Center of the Effect.
  * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long distort(Float3D vector, Float2D point, int duration)
     {
@@ -2018,9 +2026,9 @@ public abstract class DistortedObject
  * <p>
  * Here we apply a constant vector of force.
  * 
- * @param v The vector of force.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param vector Vector of force.
+ * @param point  Center of the Effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long distort(Float3D vector, Float2D point )
     {
@@ -2040,11 +2048,11 @@ public abstract class DistortedObject
  * Deform the shape of the whole Bitmap with a (possibly changing in time) vector of force applied to 
  * a (possibly changing in time) point on the Bitmap.
  *     
- * @param i A 2-dimensional Interpolator that, at any given time, returns a Point2D representing 
- *          vector of force that deforms the shapre of the whole Bitmap.
- * @param p A 2-dimensional Interpolator that, at any given time, returns a Point2D representing 
- *          the Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param i     Interpolator that, at any given time, returns a Point2D representing vector of 
+ *              force that deforms the shapre of the whole Bitmap.
+ * @param point 2-dimensional Interpolator that, at any given time, returns a Point2D representing 
+ *              the Center of the Effect.
+ * @return      ID of the effect added, or -1 if we failed to add one. 
  */
   public long deform(Interpolator i, Interpolator2D point)
     {  
@@ -2056,10 +2064,10 @@ public abstract class DistortedObject
  * Deform the shape of the whole Bitmap with a (possibly changing in time) vector of force applied to 
  * a constant point on the Bitmap.
  * 
- * @param i A 2-dimensional Interpolator that, at any given time, returns a Point2D representing 
- *          vector of force that deforms the shapre of the whole Bitmap.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param i     Interpolator that, at any given time, returns a Point2D representing 
+ *              vector of force that deforms the shapre of the whole Bitmap.
+ * @param point Center of the Effect.
+ * @return      ID of the effect added, or -1 if we failed to add one. 
  */
   public long deform(Interpolator i, Float2D point)
     {
@@ -2071,11 +2079,11 @@ public abstract class DistortedObject
  * Deform the shape of the whole Bitmap with a vector of force smoothly changing from (0,0,0) to v 
  * applied to a constant point on the Bitmap. 
  * 
- * @param v Vector of force.
- * @param p Center of the Effect.
+ * @param vector   Vector of force.
+ * @param point    Center of the Effect.
  * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param count    Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long deform(Float3D vector, Float2D point, int duration, float count)
     {
@@ -2095,10 +2103,10 @@ public abstract class DistortedObject
  * <p>
  * Identical to calling the previous method with count=0.5.
  * 
- * @param v Final vector of force.
- * @param p Center of the Effect.
+ * @param vector   Final vector of force.
+ * @param point    Center of the Effect.
  * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long deform(Float3D vector, Float2D point, int duration)
     {
@@ -2116,9 +2124,9 @@ public abstract class DistortedObject
  * Deform the shape of the whole Bitmap with a constant vector of force applied to a constant 
  * point on the Bitmap. 
  * 
- * @param v Vector of force.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param vector Vector of force.
+ * @param point  Center of the Effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long deform(Float3D vector, Float2D point )
     {
@@ -2138,12 +2146,12 @@ public abstract class DistortedObject
  * Pull all points around the center of the effect towards the center (if degree>=1) or push them 
  * away from the center (degree<=1)
  *    
- * @param di A 1-dimensional Interpolator which, at any given time, returns a Point1D representing
- *          the current degree of the effect.
- * @param r Region that masks the effect of the Sink.
- * @param p A 2-dimensional Interpolator that, at any given time, returns a Point2D representing 
- *          the Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param di     1-dimensional Interpolator which, at any given time, returns a Point1D representing
+ *               the current degree of the effect.
+ * @param region Region that masks the effect of the Sink.
+ * @param point  2-dimensional Interpolator that, at any given time, returns a Point2D representing 
+ *               the Center of the Effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long sink(Interpolator1D di, Float4D region, Interpolator2D point)
     {
@@ -2157,11 +2165,11 @@ public abstract class DistortedObject
  * <p>
  * Here the Center stays constant.
  *      
- * @param di A 1-dimensional Interpolator which, at any given time, returns a Point1D representing
- *          the current degree of the effect.
- * @param r Region that masks the effect of the Sink.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param di     1-dimensional Interpolator which, at any given time, returns a Point1D
+ *               representing the current degree of the effect.
+ * @param region Region that masks the effect of the Sink.
+ * @param point  Center of the Effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long sink(Interpolator1D di, Float4D region, Float2D point)
     {
@@ -2175,13 +2183,13 @@ public abstract class DistortedObject
  * <p>
  * Here we can only interpolate between 1 and degree.
  * 
- * @param degree How much to push or pull. 0<=degree<=infinity.
- * @param r Region that masks the effect of the Sink.
- * @param p A 2-dimensional Interpolator that, at any given time, returns a Point2D representing 
- *          the Center of the Effect.
+ * @param degree   How much to push or pull. Between 0 and infinity.
+ * @param region   Region that masks the effect of the Sink.
+ * @param p        2-dimensional Interpolator that, at any given time, returns a Point2D representing 
+ *                 the Center of the Effect.
  * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param count    Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long sink(float degree, Float4D region, Interpolator2D p, int duration, float count)
     {
@@ -2199,12 +2207,12 @@ public abstract class DistortedObject
  * Pull all points around the center of the effect towards the center (if degree>=1) or push them 
  * away from the center (degree<=1).
  *   
- * @param degree How much to push or pull. 0<=degree<=infinity.
- * @param r Region that masks the effect of the Sink.
- * @param p Center of the Effect.
+ * @param degree   How much to push or pull. Between 0 and infinity.
+ * @param region   Region that masks the effect of the Sink.
+ * @param point    Center of the Effect.
  * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param count    Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long sink(float degree, Float4D region, Float2D point, int duration, float count)
     {
@@ -2222,11 +2230,11 @@ public abstract class DistortedObject
  * Pull all points of the Bitmap towards the center of the Effect (if degree>=1) or push them 
  * away from the center (degree<=1).
  * 
- * @param degree How much to push or pull. 0<=degree<=infinity.
- * @param p Center of the Effect.
+ * @param degree   How much to push or pull. Between 0 and infinity.
+ * @param point    Center of the Effect.
  * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param count    Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long sink(float degree, Float2D point, int duration, float count) 
     {
@@ -2246,10 +2254,10 @@ public abstract class DistortedObject
  * <p>
  * Equivalent to calling the previous method with count=0.5.
  * 
- * @param degree How much to push or pull. 0<=degree<=infinity.
- * @param p Center of the Effect.
+ * @param degree   How much to push or pull. Between 0 and infinity.
+ * @param point    Center of the Effect.
  * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long sink(float degree, Float2D point, int duration) 
     {
@@ -2269,9 +2277,9 @@ public abstract class DistortedObject
  * <p>
  * Equivalent of calling the previous method with duration=0; i.e. we pull immediately.
  * 
- * @param degree How much to push or pull. 0<=degree<=infinity.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param degree How much to push or pull. Between 0 and infinity.
+ * @param point  Center of the Effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long sink(float degree, Float2D point) 
     {
@@ -2291,12 +2299,12 @@ public abstract class DistortedObject
  * Rotate part of the Bitmap around the Center of the Effect by a certain angle (as returned by the
  * Interpolator). 
  *   
- * @param di A 1-dimensional Interpolator which, at any given time, returns a Point1D representing 
- *           the degree of Swirl.
- * @param r Region that masks the effect of the Swirl.
- * @param p A 2-dimensional Interpolator that, at any given time, returns a Point2D representing 
- *          the Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param di     1-dimensional Interpolator which, at any given time, returns a Point1D representing 
+ *               the degree of Swirl.
+ * @param region Region that masks the effect of the Swirl.
+ * @param point  2-dimensional Interpolator that, at any given time, returns a Point2D representing 
+ *               the Center of the Effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long swirl(Interpolator1D di, Float4D region, Interpolator2D point)
     {    
@@ -2310,11 +2318,11 @@ public abstract class DistortedObject
  * <p>
  * Here the Center stays constant.
  *      
- * @param di A 1-dimensional Interpolator which, at any given time, returns a Point1D representing 
- *           the degree of Swirl.
- * @param r Region that masks the effect of the Swirl.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param di     1-dimensional Interpolator which, at any given time, returns a Point1D representing 
+ *               the degree of Swirl.
+ * @param region Region that masks the effect of the Swirl.
+ * @param point  Center of the Effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long swirl(Interpolator1D di, Float4D region, Float2D point)
     {    
@@ -2325,13 +2333,13 @@ public abstract class DistortedObject
 /**
  * Rotate part of the Bitmap around the Center of the Effect by 'degree' angle.
  *   
- * @param degree Angle, in degrees, of rotation.
- * @param r Region that masks the effect of the Swirl.
- * @param p A 2-dimensional Interpolator that, at any given time, returns a Point2D representing 
- *          the Center of the Effect.
+ * @param degree   Angle of rotation. Unit: degrees.
+ * @param region   Region that masks the effect of the Swirl.
+ * @param point    2-dimensional Interpolator that, at any given time, returns a Point2D representing 
+ *                 the Center of the Effect.
  * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param count    Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long swirl(int degree, Float4D region, Interpolator2D point, int duration, float count)
     {
@@ -2350,12 +2358,12 @@ public abstract class DistortedObject
  * <p>
  * Here the Center stays constant.
  *    
- * @param degree Angle, in degrees, of rotation.
- * @param r Region that masks the effect of the Swirl.
- * @param p Center of the Effect.
+ * @param degree   Angle of rotation. Unit: degrees.
+ * @param region   Region that masks the effect of the Swirl.
+ * @param point    Center of the Effect.
  * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param count    Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long swirl(int degree, Float4D region, Float2D point, int duration, float count)
     {
@@ -2372,11 +2380,11 @@ public abstract class DistortedObject
 /**
  * Rotate the whole Bitmap around the Center of the Effect by 'degree' angle.
  * 
- * @param degree Angle, in degrees, of rotation.
- * @param p Center of the Effect.
+ * @param degree   Angle of rotation. Unit: degrees.
+ * @param point    Center of the Effect.
  * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @param count Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param count    Controls how many interpolations we want to do. See {@link Interpolator#setCount(float)}
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long swirl(int degree, Float2D point, int duration, float count) 
     {
@@ -2395,10 +2403,10 @@ public abstract class DistortedObject
  * <p>
  * Equivalent to calling the previous method with count=0.5.
  * 
- * @param degree Angle, in degrees, of rotation.
- * @param p Center of the Effect.
+ * @param degree   Angle of rotation. Unit: degrees.
+ * @param point    Center of the Effect.
  * @param duration Time, in milliseconds, it takes to do one full interpolation.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @return         ID of the effect added, or -1 if we failed to add one. 
  */
   public long swirl(int degree, Float2D point, int duration) 
     {
@@ -2417,9 +2425,9 @@ public abstract class DistortedObject
  * <p>
  * Equivalent to calling the previous method with duration=0.
  * 
- * @param degree Angle, in degrees, of rotation.
- * @param p Center of the Effect.
- * @return ID of the effect added, or -1 if we failed to add one. 
+ * @param degree Angle of rotation. Unit: degrees.
+ * @param point  Center of the Effect.
+ * @return       ID of the effect added, or -1 if we failed to add one. 
  */
   public long swirl(int degree, Float2D point) 
     {
diff --git a/src/main/java/org/distorted/library/EffectMessage.java b/src/main/java/org/distorted/library/EffectMessage.java
index 0f5111c..20eb493 100644
--- a/src/main/java/org/distorted/library/EffectMessage.java
+++ b/src/main/java/org/distorted/library/EffectMessage.java
@@ -20,10 +20,10 @@ public enum EffectMessage
  * Interpolation of the effect has finished. 
  * <p>
  * If you set up an interpolated effect and set its Interpolator to do 3.5 interpolations of 1000 ms each
- * with calls to {@link DistortedInterpolator#setCount(3.5f)} and {@link DistortedInterpolator#setDuration(1000)},
+ * with calls to {@link Interpolator#setCount(float)} and {@link Interpolator#setDuration(long)},
  * then you are going to get this message exactly once after 3.5*1000 = 3500 milliseconds when the interpolation 
  * finishes. You will never get this message if you set the effect to go on indefinitely with a call to 
- * {@link DistortedInterpolator#setCount(0.0)}.
+ * {@link Interpolator#setCount(float)}.
  * <p>  
  * If then the end effect is equal to the effect's zero point, then immediately after this message you 
  * will also get a EFFECT_REMOVED message.
diff --git a/src/main/java/org/distorted/library/Float4D.java b/src/main/java/org/distorted/library/Float4D.java
index 7c2f0f4..748d9ac 100644
--- a/src/main/java/org/distorted/library/Float4D.java
+++ b/src/main/java/org/distorted/library/Float4D.java
@@ -48,7 +48,7 @@ public class Float4D extends Float3D
  * @param vx new value of the first float
  * @param vy new value of the second float
  * @param vz new value of the third float
- * @param vz new value of the fourth float
+ * @param vw new value of the fourth float
  */
   public void set(int vx, int vy, int vz, int vw)
     {
@@ -65,7 +65,7 @@ public class Float4D extends Float3D
  * @param vx new value of the first float
  * @param vy new value of the second float
  * @param vz new value of the third float
- * @param vz new value of the fourth float
+ * @param vw new value of the fourth float
  */
   public void set(float vx, float vy, float vz, float vw)
     {
diff --git a/src/main/java/org/distorted/library/Interpolator.java b/src/main/java/org/distorted/library/Interpolator.java
index c5e6ff6..e55aff1 100644
--- a/src/main/java/org/distorted/library/Interpolator.java
+++ b/src/main/java/org/distorted/library/Interpolator.java
@@ -135,7 +135,7 @@ public abstract class Interpolator
  * <li>Jump is when we go from first to last and then jump back to the first.
  * </ul>
  * 
- * @param mode {@link Interpolator.MODE_LOOP}, {@link Interpolator.MODE_PATH} or {@link Interpolator.MODE_JUMP}.
+ * @param mode {@link Interpolator#MODE_LOOP}, {@link Interpolator#MODE_PATH} or {@link Interpolator#MODE_JUMP}.
  */
 
   public void setMode(int mode)