/ - Diff - Distorted Android

« Previous | Next »

Revision e0a16874

Added by Leszek Koltunski over 8 years ago

ID e0a168740a05d5d6eccae412808b34bebd887f90
Parent d333eb6b
Child 9351ad55

cleanup in DistortedObject's methods.

      */
     public abstract class DistortedObject
+    {
         private static float[] mViewMatrix = new float[16];
         private static final Float2D mZero2D = new Float2D(0,0);
         private static final Float3D mZero3D = new Float3D(0,0,0);
         private static float[] mViewMatrix   = new float[16];
         protected EffectQueueMatrix    mM;
         protected EffectQueueFragment  mF;
-...
     /**
      * Moves the Object by a vector that changes in time as interpolated by the Interpolator.
+     *
      * @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.
      * @param vector 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.
      */
       public long move(Interpolator3D di)
       public long move(Interpolator3D vector)
+        {
         return mM.add(EffectNames.MOVE,null,di);
         return mM.add(EffectNames.MOVE,vector);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Moves the Bitmap by a vector that smoothly changes from (0,0,0) to (x,y,z).
      * Moves the Object 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.
-...
         di.add(new Float3D(0.0f,0.0f,0.0f));
         di.add(new Float3D(x,y,z));
         return mM.add(EffectNames.MOVE,null,di);
         return mM.add(EffectNames.MOVE,di);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Moves the Bitmap by vector (x,y,z) immediately.
      * Moves the Object by vector (x,y,z) immediately.
+     *
      * @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.
-...
      */
       public long move(float x,float y,float z)
+        {
         return mM.add(EffectNames.MOVE,0.0f,0.0f,0.0f,x,y,z,0.0f);
         return mM.add(EffectNames.MOVE,mZero3D,x,y,z,0.0f);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     /**
      * Scales the Object by factors that change in time as returned by the Interpolator.
+     *
      * @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.
      * @param scale 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.
      */
       public long scale(Interpolator3D di)
       public long scale(Interpolator3D scale)
+        {
         return mM.add(EffectNames.SCALE,null,di);
         return mM.add(EffectNames.SCALE,scale);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
         di.add(new Float3D(1.0f,1.0f,1.0f));
         di.add(new Float3D(xscale,yscale,zscale));
         return mM.add(EffectNames.SCALE,null,di);
         return mM.add(EffectNames.SCALE,di);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      */
       public long scale(float xscale,float yscale,float zscale)
+        {
         return mM.add(EffectNames.SCALE,0.0f,0.0f,0.0f,xscale,yscale,zscale,0.0f);
         return mM.add(EffectNames.SCALE,mZero3D,xscale,yscale,zscale,0.0f);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      */
       public long scale(float scale)
+        {
         return mM.add(EffectNames.SCALE,0.0f,0.0f,0.0f,scale,scale,scale,0.0f);
         return mM.add(EffectNames.SCALE,mZero3D,scale,scale,scale,0.0f);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     /**
      * Rotates the Object around a (possibly moving) point, with angle and axis that change in time.
+     *
      * @param i 3-dimensional Interpolator which at any given time will return the current 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 center    3-dimensional Interpolator which at any given time will return the current center
      *                  of the rotation
      * @param angleAxis 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(Interpolator3D i, Interpolator4D v)
       public long rotate(Interpolator3D center, Interpolator4D angleAxis)
+        {
         return mM.add(EffectNames.ROTATE, i, v);
         return mM.add(EffectNames.ROTATE, center, angleAxis);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotates the Object around a static point, with angle and axis that change in time.
+     *
      * @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.
      * @param center    Center of the rotation
      * @param angleAxis 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)
       public long rotate(Float3D center, Interpolator4D angleAxis)
+        {
         return mM.add(EffectNames.ROTATE, point.x, point.y, point.z , v);
         return mM.add(EffectNames.ROTATE, center , angleAxis);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      * Rotates the Object around a static point, with angle that changes in time, around axis
      * (axisX, axisY, axisZ).
+     *
      * @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)
      * @param center Center of the rotation
      * @param angle  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 center, Interpolator1D angle, float axisX, float axisY, float axisZ)
+        {
         return mM.add(EffectNames.ROTATE, point.x, point.y, point.z , v, axisX, axisY, axisZ);
         return mM.add(EffectNames.ROTATE, center , angle, axisX, axisY, axisZ);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      * Rotates the Object around a (possibly moving) 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 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.
      * @param center 3-dimensional Interpolator which at any given time will return the current center
      *               of the rotation.
      * @param angle  1-dimensional Interpolator which returns the current rotation angle.
      * @return       ID of the effect added, or -1 if we failed to add one.
      */
       public long rotate(Interpolator3D i, Interpolator1D a)
       public long rotate(Interpolator3D center, Interpolator1D angle)
+        {
         return mM.add(EffectNames.ROTATE, i, a, 0.0f,0.0f,1.0f);
         return mM.add(EffectNames.ROTATE, center, angle, 0.0f,0.0f,1.0f);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      * 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 point    Coordinates of the Point we are rotating around.
      * @param center   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.
      */
       public long rotate(Float3D point, int angle, int duration)
       public long rotate(Float3D center, int angle, int duration)
+        {
         Interpolator1D di = new Interpolator1D();
         di.setCount(0.5f);
-...
         di.add(new Float1D(    0));
         di.add(new Float1D(angle));
         return mM.add(EffectNames.ROTATE,point.x,point.y,point.z, di, 0.0f,0.0f,1.0f);
         return mM.add(EffectNames.ROTATE, center, di, 0.0f,0.0f,1.0f);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      * Rotates the Object immediately by 'angle' degrees around point p.
      * Axis of rotation is given by the last 3 floats.
+     *
      * @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)
      * @param center 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 center, float angle, float axisX, float axisY, float axisZ)
+        {
         return mM.add(EffectNames.ROTATE, point.x, point.y, point.z, angle, axisX, axisY, axisZ);
         return mM.add(EffectNames.ROTATE, center, angle, axisX, axisY, axisZ);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotates the Object immediately by 'angle' degrees around point p.
+     *
      * @param point  Coordinates of the Point we are rotating around.
      * @param center 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)
       public long rotate(Float3D center, int angle)
+        {
         return mM.add(EffectNames.ROTATE,point.x,point.y,point.z,angle,0.0f,0.0f,1.0f);
         return mM.add(EffectNames.ROTATE, center, angle,0.0f,0.0f,1.0f);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
     /**
      * Rotates the Object immediately by quaternion (qX,qY,qZ,qW).
+     *
      * @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)
      * @param center 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 center, float qX, float qY, float qZ, float qW)
+        {
         return mM.add(EffectNames.QUATERNION,point.x,point.y,point.z,qX,qY,qZ,qW);
         return mM.add(EffectNames.QUATERNION,center,qX,qY,qZ,qW);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Rotates the Object by a quaternion that's at the moment returned by the InterpolatorQuat.
+     *
      * @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.
      * @param center Coordinates of the Point we are rotating around.
      * @param quat   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)
       public long quaternion(Float3D center, InterpolatorQuat quat)
+        {
         return mM.add(EffectNames.QUATERNION,point.x,point.y,point.z,iq);
         return mM.add(EffectNames.QUATERNION, center, quat);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * 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 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.
      * @param center Interpolator that returns the current center of rotation.
      * @param quat   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.
      */
       public long quaternion(Interpolator3D i, InterpolatorQuat iq)
       public long quaternion(Interpolator3D center, InterpolatorQuat quat)
+        {
         return mM.add(EffectNames.QUATERNION,i,iq);
         return mM.add(EffectNames.QUATERNION,center,quat);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      * 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 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.
      * @param center  Center of shearing, i.e. the point which stays unmoved.
      * @param shear   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)
       public long shear(Float3D center, Interpolator shear)
+        {
         return mM.add(EffectNames.SHEAR, point.x, point.y, point.z, di);
         return mM.add(EffectNames.SHEAR, center, shear);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Shears the Object in 3D. Order: first X shearing, then Y, then Z.
+     *
      * @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
      * @param center Center of shearing, i.e. the point which stays unmoved.
      * @param shear  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)
       public long shear(Float3D center, Float3D shear)
+        {
         Interpolator3D di = new Interpolator3D();
         di.setCount(0.5f);
         di.setDuration(0);
         di.add(new Float3D(0.0f,0.0f,0.0f));
         di.add(vector);
         di.add(shear);
         return mM.add(EffectNames.SHEAR, point.x, point.y, point.z, di );
         return mM.add(EffectNames.SHEAR, center, di );
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      * 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      1-dimensional Interpolator which, at any given time, returns the size of the macroblocks.
      * @param size   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
      * @param center 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)
       public long macroblock(Interpolator1D size, Float4D region, Interpolator2D center)
+        {
         return mF.add(EffectNames.MACROBLOCK, a, region, i);
         return mF.add(EffectNames.MACROBLOCK, size, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      * <p>
      * The difference between this and the previous method is that here the center of the Effect stays constant.
+     *
      * @param a      1-dimensional Interpolator which, at any given time, returns the size of the macroblocks.
      * @param size   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.
      * @param center 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)
       public long macroblock(Interpolator1D size, Float4D region, Float2D center)
+        {
         return mF.add(EffectNames.MACROBLOCK, a, region, point.x, point.y);
         return mF.add(EffectNames.MACROBLOCK, size, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      * @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
      * @param center   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 macroblock(int pixels, Float4D region, Interpolator2D i, int duration, float count)
       public long macroblock(int pixels, Float4D region, Interpolator2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         di.setCount(count);
-...
         di.add(new Float1D(1));
         di.add(new Float1D(pixels));
         return mF.add(EffectNames.MACROBLOCK, di, region, i);
         return mF.add(EffectNames.MACROBLOCK, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
      * @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 center   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 macroblock(int pixels, Float4D region, Float2D point, int duration, float count)
       public long macroblock(int pixels, Float4D region, Float2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         di.setCount(count);
-...
         di.add(new Float1D(1));
         di.add(new Float1D(pixels));
         return mF.add(EffectNames.MACROBLOCK, di, region, point.x, point.y);
         return mF.add(EffectNames.MACROBLOCK, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Creates macroblocks on the whole Bitmap.
      * Creates macroblocks on the whole Object.
      * <p>
      * The macroblocks change in size; at time 0 there are none, and after 'duration/2' milliseconds
      * they are of (pixels X pixels) size; after 'duration' milliseconds there are again none (i.e. their
-...
         di.add(new Float1D(1));
         di.add(new Float1D(pixels));
         return mF.add(EffectNames.MACROBLOCK, di, null, 0.0f, 0.0f);
         return mF.add(EffectNames.MACROBLOCK, di, null, mZero2D);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // CHROMA
     /**
      * Makes a certain sub-region of the Bitmap smoothly change all three of its RGB components.
      * Makes a certain sub-region of the Object smoothly change all three of its RGB components.
+     *
      * @param t      1-dimensional Interpolator that returns the level of blend a given pixel will be
      * @param blend  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. (1,0,0) is RED.
      * @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
      * @param center 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)
       public long chroma(Interpolator1D blend, Float3D color, Float4D region, Interpolator2D center)
+        {
         return mF.add(EffectNames.CHROMA, t, color, region, i);
         return mF.add(EffectNames.CHROMA, blend, color, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change all three of its RGB components.
      * Makes a certain sub-region of the Object smoothly change all three of its RGB components.
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param t      1-dimensional Interpolator that returns the level of blend a given pixel will be
      * @param blend  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. (1,0,0) is RED.
      * @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 center 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)
       public long chroma(Interpolator1D blend, Float3D color, Float4D region, Float2D center)
+        {
         return mF.add(EffectNames.CHROMA, t, color, region, point.x, point.y);
         return mF.add(EffectNames.CHROMA, blend, color, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change all three of its RGB components.
      * Makes a certain sub-region of the Object smoothly change all three of its RGB components.
+     *
      * @param t      Level of blend a given pixel will be mixed with the next parameter 'color':
      * @param blend  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. (1,0,0) is RED.
      * @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
      * @param center 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)
       public long chroma(float blend, Float3D color, Float4D region, Interpolator2D center)
+        {
         return mF.add(EffectNames.CHROMA, t, color, region, i);
         return mF.add(EffectNames.CHROMA, blend, color, region, center);
+        }
     ///// //////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change all three of its RGB components.
      * Makes a certain sub-region of the Object smoothly change all three of its RGB components.
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param t      Level of blend a given pixel will be mixed with the next parameter 'color':
      * @param blend  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. (1,0,0) is RED.
      * @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.
      * @param center 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)
       public long chroma(float blend, Float3D color, Float4D region, Float2D center)
+        {
         return mF.add(EffectNames.CHROMA, t, color, region, point.x, point.y);
         return mF.add(EffectNames.CHROMA, blend, color, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change all three of its RGB components.
      * Makes a certain sub-region of the Object smoothly change all three of its RGB components.
      * <p>
      * Here the Effect applies to the whole bitmap.
+     *
      * @param t     Level of blend a given pixel will be mixed with the next parameter 'color':
      * @param blend 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. (1,0,0) is RED.
      * @return      ID of the effect added, or -1 if we failed to add one.
      */
       public long chroma(float t, Float3D color)
       public long chroma(float blend, Float3D color)
+        {
         return mF.add(EffectNames.CHROMA, t, color, null, 0, 0);
         return mF.add(EffectNames.CHROMA, blend, color, null, mZero2D);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change all three of its RGB components.
      * Makes a certain sub-region of the Object smoothly change all three of its RGB components.
+     *
      * See {@link #chroma(Interpolator1D, Float3D, Float4D, Interpolator2D)}
      */
       public long smooth_chroma(Interpolator1D t, Float3D color, Float4D region, Interpolator2D i)
       public long smooth_chroma(Interpolator1D blend, Float3D color, Float4D region, Interpolator2D center)
+        {
         return mF.add(EffectNames.SMOOTH_CHROMA, t, color, region, i);
         return mF.add(EffectNames.SMOOTH_CHROMA, blend, color, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change all three of its RGB components.
      * Makes a certain sub-region of the Object smoothly change all three of its RGB components.
+     *
      * See {@link #chroma(Interpolator1D, Float3D, Float4D, Float2D)}
      */
       public long smooth_chroma(Interpolator1D t, Float3D color, Float4D region, Float2D point)
       public long smooth_chroma(Interpolator1D blend, Float3D color, Float4D region, Float2D center)
+        {
         return mF.add(EffectNames.SMOOTH_CHROMA, t, color, region, point.x, point.y);
         return mF.add(EffectNames.SMOOTH_CHROMA, blend, color, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change all three of its RGB components.
      * Makes a certain sub-region of the Object smoothly change all three of its RGB components.
+     *
      * See {@link #chroma(float, Float3D, Float4D, Interpolator2D)}
      */
       public long smooth_chroma(float t, Float3D color, Float4D region, Interpolator2D i)
       public long smooth_chroma(float blend, Float3D color, Float4D region, Interpolator2D center)
+        {
         return mF.add(EffectNames.SMOOTH_CHROMA, t, color, region, i);
         return mF.add(EffectNames.SMOOTH_CHROMA, blend, color, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change all three of its RGB components.
      * Makes a certain sub-region of the Object smoothly change all three of its RGB components.
+     *
      * See {@link #chroma(float, Float3D, Float4D, Float2D)}
      */
       public long smooth_chroma(float t, Float3D color, Float4D region, Float2D point)
       public long smooth_chroma(float blend, Float3D color, Float4D region, Float2D center)
+        {
         return mF.add(EffectNames.SMOOTH_CHROMA, t, color, region, point.x, point.y);
         return mF.add(EffectNames.SMOOTH_CHROMA, blend, color, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change all three of its RGB components.
      * Makes a certain sub-region of the Object smoothly change all three of its RGB components.
+     *
      * See {@link #chroma(float, Float3D)}
      */
       public long smooth_chroma(float t, Float3D color)
       public long smooth_chroma(float blend, Float3D color)
+        {
         return mF.add(EffectNames.SMOOTH_CHROMA, t, color, null, 0, 0);
         return mF.add(EffectNames.SMOOTH_CHROMA, blend, color, null, mZero2D);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // ALPHA
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its transparency level.
      * Makes a certain sub-region of the Object smoothly change its transparency level.
+     *
      * @param a      1-dimensional Interpolator that returns the level of transparency we want to have at any given
      * @param alpha  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
      *               Null here means 'apply the Effect to the whole Object'.
      * @param center 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)
       public long alpha(Interpolator1D alpha, Float4D region, Interpolator2D center)
+        {
         return mF.add(EffectNames.ALPHA, a, region, i);
         return mF.add(EffectNames.ALPHA, alpha, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its transparency level.
      * Makes a certain sub-region of the Object smoothly change its transparency level.
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @param a      1-dimensional Interpolator that returns the level of transparency we want to have at any given
      * @param alpha  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.
      *               Null here means 'apply the Effect to the whole Object'.
      * @param center 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)
       public long alpha(Interpolator1D alpha, Float4D region, Float2D center)
+        {
         return mF.add(EffectNames.ALPHA, a, region, point.x, point.y);
         return mF.add(EffectNames.ALPHA, alpha, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its transparency level.
      * Makes a certain sub-region of the Object smoothly change its transparency level.
+     *
      * @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
      *               Null here means 'apply the Effect to the whole Object'.
      * @param center 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 alpha(float alpha, Float4D region, Interpolator2D i, int duration, float count)
       public long alpha(float alpha, Float4D region, Interpolator2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         di.setCount(count);
-...
         di.add(new Float1D(1));
         di.add(new Float1D(alpha));
         return mF.add(EffectNames.ALPHA, di, region, i);
         return mF.add(EffectNames.ALPHA, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its transparency level.
      * Makes a certain sub-region of the Object smoothly change its transparency level.
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @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 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 Object'.
      * @param center   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)
       public long alpha(float alpha, Float4D region, Float2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         di.setCount(count);
-...
         di.add(new Float1D(1));
         di.add(new Float1D(alpha));
         return mF.add(EffectNames.ALPHA, di, region, point.x, point.y);
         return mF.add(EffectNames.ALPHA, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its transparency level.
      * Makes a certain sub-region of the Object smoothly change its transparency level.
      * <p>
      * Here the center of the Effect stays constant and the effect for now change in time.
+     *
      * @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.
      *               Null here means 'apply the Effect to the whole Object'.
      * @param center 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)
       public long alpha(float alpha, Float4D region, Float2D center)
+        {
         Interpolator1D di = new Interpolator1D();
         di.setCount(0.5f);
-...
         di.add(new Float1D(1));
         di.add(new Float1D(alpha));
         return mF.add(EffectNames.ALPHA, di, region, point.x, point.y);
         return mF.add(EffectNames.ALPHA, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes the whole Bitmap change its transparency level.
      * Makes the whole Object change its transparency level.
+     *
      * @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.
-...
         di.add(new Float1D(1));
         di.add(new Float1D(alpha));
         return mF.add(EffectNames.ALPHA, di,null, 0.0f, 0.0f);
         return mF.add(EffectNames.ALPHA, di,null, mZero2D);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its transparency level.
      * Makes a certain sub-region of the Object smoothly change its transparency level.
+     *
      * See {@link #alpha(Interpolator1D, Float4D, Interpolator2D)}
      */
       public long smooth_alpha(Interpolator1D a, Float4D region, Interpolator2D i)
       public long smooth_alpha(Interpolator1D alpha, Float4D region, Interpolator2D center)
+        {
         return mF.add(EffectNames.SMOOTH_ALPHA, a, region, i);
         return mF.add(EffectNames.SMOOTH_ALPHA, alpha, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its transparency level.
      * Makes a certain sub-region of the Object smoothly change its transparency level.
+     *
      * See {@link #alpha(Interpolator1D, Float4D, Float2D)}
      */
       public long smooth_alpha(Interpolator1D a, Float4D region, Float2D point)
       public long smooth_alpha(Interpolator1D alpha, Float4D region, Float2D center)
+        {
         return mF.add(EffectNames.SMOOTH_ALPHA, a, region, point.x, point.y);
         return mF.add(EffectNames.SMOOTH_ALPHA, alpha, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its transparency level.
      * Makes a certain sub-region of the Object smoothly change its transparency level.
+     *
      * See {@link #alpha(float, Float4D, Interpolator2D, int, float)}
      */
       public long smooth_alpha(float alpha, Float4D region, Interpolator2D i, int duration, float count)
       public long smooth_alpha(float alpha, Float4D region, Interpolator2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         di.setCount(count);
-...
         di.add(new Float1D(1));
         di.add(new Float1D(alpha));
         return mF.add(EffectNames.SMOOTH_ALPHA, di, region, i);
         return mF.add(EffectNames.SMOOTH_ALPHA, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its transparency level.
      * Makes a certain sub-region of the Object smoothly change its transparency level.
+     *
      * See {@link #alpha(float, Float4D, Float2D, int, float)}
      */
       public long smooth_alpha(float alpha, Float4D region, Float2D point, int duration, float count)
       public long smooth_alpha(float alpha, Float4D region, Float2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         di.setCount(count);
-...
         di.add(new Float1D(1));
         di.add(new Float1D(alpha));
         return mF.add(EffectNames.SMOOTH_ALPHA, di, region, point.x, point.y);
         return mF.add(EffectNames.SMOOTH_ALPHA, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its transparency level.
      * Makes a certain sub-region of the Object smoothly change its transparency level.
+     *
      * See {@link #alpha(float, Float4D, Float2D)}
      */
       public long smooth_alpha(float alpha, Float4D region, Float2D point)
       public long smooth_alpha(float alpha, Float4D region, Float2D center)
+        {
         Interpolator1D di = new Interpolator1D();
         di.setCount(0.5f);
-...
         di.add(new Float1D(1));
         di.add(new Float1D(alpha));
         return mF.add(EffectNames.SMOOTH_ALPHA, di, region, point.x, point.y);
         return mF.add(EffectNames.SMOOTH_ALPHA, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // BRIGHTNESS
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its brightness level.
      * Makes a certain sub-region of the Object smoothly change its brightness level.
+     *
      * @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.
      * @param brightness 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 Object'.
      * @param center     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)
       public long brightness(Interpolator1D brightness, Float4D region, Interpolator2D center)
+        {
         return mF.add(EffectNames.BRIGHTNESS, a, region, i);
         return mF.add(EffectNames.BRIGHTNESS, brightness, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its brightness level.
      * Makes a certain sub-region of the Object smoothly change its brightness level.
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @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.
      * @param brightness 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 Object'.
      * @param center     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)
       public long brightness(Interpolator1D brightness, Float4D region, Float2D center)
+        {
         return mF.add(EffectNames.BRIGHTNESS, a, region, point.x, point.y);
         return mF.add(EffectNames.BRIGHTNESS, brightness, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its brightness level.
      * Makes a certain sub-region of the Object smoothly change its brightness level.
+     *
      * @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
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     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)
       public long brightness(float brightness, Float4D region, Interpolator2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         di.setCount(count);
-...
         di.add(new Float1D(1));
         di.add(new Float1D(brightness));
         return mF.add(EffectNames.BRIGHTNESS, di, region, i);
         return mF.add(EffectNames.BRIGHTNESS, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its brightness level.
      * Makes a certain sub-region of the Object smoothly change its brightness level.
      * <p>
      * Here the center of the Effect stays constant.
+     *
-...
      *                   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.
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     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)
       public long brightness(float brightness, Float4D region, Float2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         di.setCount(count);
-...
         di.add(new Float1D(1));
         di.add(new Float1D(brightness));
         return mF.add(EffectNames.BRIGHTNESS, di, region, point.x, point.y);
         return mF.add(EffectNames.BRIGHTNESS, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its brightness level.
      * Makes a certain sub-region of the Object smoothly change its brightness level.
      * <p>
      * Here the center of the Effect stays constant and the effect for now change in time.
+     *
-...
      *                   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.
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     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)
       public long brightness(float brightness, Float4D region, Float2D center)
+        {
         Interpolator1D di = new Interpolator1D();
         di.setCount(0.5f);
-...
         di.add(new Float1D(1));
         di.add(new Float1D(brightness));
         return mF.add(EffectNames.BRIGHTNESS, di, region, point.x, point.y);
         return mF.add(EffectNames.BRIGHTNESS, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // SMOOTH BRIGHTNESS
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its brightness level.
      * Makes a certain sub-region of the Object smoothly change its brightness level.
+     *
      * @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.
      * @param brightness 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 Object'.
      * @param center     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)
       public long smooth_brightness(Interpolator1D brightness, Float4D region, Interpolator2D center)
+        {
         return mF.add(EffectNames.SMOOTH_BRIGHTNESS, a, region, i);
         return mF.add(EffectNames.SMOOTH_BRIGHTNESS, brightness, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its brightness level.
      * Makes a certain sub-region of the Object smoothly change its brightness level.
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @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.
      * @param brightness 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 Object'.
      * @param center     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)
       public long smooth_brightness(Interpolator1D brightness, Float4D region, Float2D center)
+        {
         return mF.add(EffectNames.SMOOTH_BRIGHTNESS, a, region, point.x, point.y);
         return mF.add(EffectNames.SMOOTH_BRIGHTNESS, brightness, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its brightness level.
      * Makes a certain sub-region of the Object smoothly change its brightness level.
+     *
      * @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
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     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)
       public long smooth_brightness(float brightness, Float4D region, Interpolator2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         di.setCount(count);
-...
         di.add(new Float1D(1));
         di.add(new Float1D(brightness));
         return mF.add(EffectNames.SMOOTH_BRIGHTNESS, di, region, i);
         return mF.add(EffectNames.SMOOTH_BRIGHTNESS, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its brightness level.
      * Makes a certain sub-region of the Object smoothly change its brightness level.
      * <p>
      * Here the center of the Effect stays constant.
+     *
-...
      *                   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.
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     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)
       public long smooth_brightness(float brightness, Float4D region, Float2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         di.setCount(count);
-...
         di.add(new Float1D(1));
         di.add(new Float1D(brightness));
         return mF.add(EffectNames.SMOOTH_BRIGHTNESS, di, region, point.x, point.y);
         return mF.add(EffectNames.SMOOTH_BRIGHTNESS, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its brightness level.
      * Makes a certain sub-region of the Object smoothly change its brightness level.
      * <p>
      * Here the center of the Effect stays constant and the effect for now change in time.
+     *
-...
      *                   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.
      *                   Null here means 'apply the Effect to the whole Object'.
      * @param center     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)
       public long smooth_brightness(float brightness, Float4D region, Float2D center)
+        {
         Interpolator1D di = new Interpolator1D();
         di.setCount(0.5f);
-...
         di.add(new Float1D(1));
         di.add(new Float1D(brightness));
         return mF.add(EffectNames.SMOOTH_BRIGHTNESS, di, region, point.x, point.y);
         return mF.add(EffectNames.SMOOTH_BRIGHTNESS, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes the whole Bitmap change its brightness level.
      * Makes the whole Object change its brightness level.
+     *
      * @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',
-...
         di.add(new Float1D(1));
         di.add(new Float1D(brightness));
         return mF.add(EffectNames.SMOOTH_BRIGHTNESS, di,null, 0.0f, 0.0f);
         return mF.add(EffectNames.SMOOTH_BRIGHTNESS, di,null, mZero2D);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // CONTRAST
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its contrast level.
      * Makes a certain sub-region of the Object smoothly change its contrast level.
+     *
      * @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.
      * @param contrast 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 Object'.
      * @param center   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)
       public long contrast(Interpolator1D contrast, Float4D region, Interpolator2D center)
+        {
         return mF.add(EffectNames.CONTRAST, a, region, i);
         return mF.add(EffectNames.CONTRAST, contrast, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its contrast level.
      * Makes a certain sub-region of the Object smoothly change its contrast level.
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @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.
      * @param contrast 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 Object'.
      * @param center  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)
       public long contrast(Interpolator1D contrast, Float4D region, Float2D center)
+        {
         return mF.add(EffectNames.CONTRAST, a, region, point.x, point.y);
         return mF.add(EffectNames.CONTRAST, contrast, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its contrast level.
      * Makes a certain sub-region of the Object smoothly change its contrast level.
+     *
      * @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
      *                 Null here means 'apply the Effect to the whole Object'.
      * @param center   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 contrast(float contrast, Float4D region, Interpolator2D i, int duration, float count)
       public long contrast(float contrast, Float4D region, Interpolator2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         di.setCount(count);
-...
         di.add(new Float1D(1));
         di.add(new Float1D(contrast));
         return mF.add(EffectNames.CONTRAST, di, region, i);
         return mF.add(EffectNames.CONTRAST, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its contrast level.
      * Makes a certain sub-region of the Object smoothly change its contrast level.
      * <p>
      * Here the center of the Effect stays constant.
+     *
-...
      *                 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.
      *                 Null here means 'apply the Effect to the whole Object'.
      * @param center   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 contrast(float contrast, Float4D region, Float2D point, int duration, float count)
       public long contrast(float contrast, Float4D region, Float2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         di.setCount(count);
-...
         di.add(new Float1D(1));
         di.add(new Float1D(contrast));
         return mF.add(EffectNames.CONTRAST, di, region, point.x, point.y);
         return mF.add(EffectNames.CONTRAST, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its contrast level.
      * Makes a certain sub-region of the Object smoothly change its contrast level.
      * <p>
      * Here the center of the Effect stays constant and the effect for now change in time.
+     *
-...
      *                 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.
      *                 Null here means 'apply the Effect to the whole Object'.
      * @param center   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)
       public long contrast(float contrast, Float4D region, Float2D center)
+        {
         Interpolator1D di = new Interpolator1D();
         di.setCount(0.5f);
-...
         di.add(new Float1D(1));
         di.add(new Float1D(contrast));
         return mF.add(EffectNames.CONTRAST, di, region, point.x, point.y);
         return mF.add(EffectNames.CONTRAST, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // SMOOTH CONTRAST
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its contrast level.
      * Makes a certain sub-region of the Object smoothly change its contrast level.
+     *
      * @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.
      * @param contrast 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 Object'.
      * @param center   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)
       public long smooth_contrast(Interpolator1D contrast, Float4D region, Interpolator2D center)
+        {
         return mF.add(EffectNames.SMOOTH_CONTRAST, a, region, i);
         return mF.add(EffectNames.SMOOTH_CONTRAST, contrast, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its contrast level.
      * Makes a certain sub-region of the Object smoothly change its contrast level.
      * <p>
      * Here the center of the Effect stays constant.
+     *
      * @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.
      * @param contrast 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 Object'.
      * @param center   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)
       public long smooth_contrast(Interpolator1D contrast, Float4D region, Float2D center)
+        {
         return mF.add(EffectNames.SMOOTH_CONTRAST, a, region, point.x, point.y);
         return mF.add(EffectNames.SMOOTH_CONTRAST, contrast, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its contrast level.
      * Makes a certain sub-region of the Object smoothly change its contrast level.
+     *
      * @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
      *                 Null here means 'apply the Effect to the whole Object'.
      * @param center   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_contrast(float contrast, Float4D region, Interpolator2D i, int duration, float count)
       public long smooth_contrast(float contrast, Float4D region, Interpolator2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         di.setCount(count);
-...
         di.add(new Float1D(1));
         di.add(new Float1D(contrast));
         return mF.add(EffectNames.SMOOTH_CONTRAST, di, region, i);
         return mF.add(EffectNames.SMOOTH_CONTRAST, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its contrast level.
      * Makes a certain sub-region of the Object smoothly change its contrast level.
      * <p>
      * Here the center of the Effect stays constant.
+     *
-...
      *                 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.
      *                 Null here means 'apply the Effect to the whole Object'.
      * @param center   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_contrast(float contrast, Float4D region, Float2D point, int duration, float count)
       public long smooth_contrast(float contrast, Float4D region, Float2D center, int duration, float count)
+        {
         Interpolator1D di = new Interpolator1D();
         di.setCount(count);
-...
         di.add(new Float1D(1));
         di.add(new Float1D(contrast));
         return mF.add(EffectNames.SMOOTH_CONTRAST, di, region, point.x, point.y);
         return mF.add(EffectNames.SMOOTH_CONTRAST, di, region, center);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Makes a certain sub-region of the Bitmap smoothly change its contrast level.

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff

Project

General

Profile

Distorted Android

Revision e0a16874

Added by Leszek Koltunski over 8 years ago