/src/main/java/org/distorted/library/DistortedObject.java - Diff - Distorted Android

« Previous | Next »

Revision d7bbef2f

Added by Distorted Admin almost 8 years ago

ID d7bbef2fef8eabd42e65701f16ce17faf2961927
Parent da7ce0d8
Child b329f352

Fix javadoc errors

     /**
      * 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)
+        {
-...
     /**
      * 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)
+        {
-...
      * @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)
+        {
-...
     /**
      * 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)
+        {
-...
      * 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)
+        {
-...
      *               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)
+        {
-...
     /**
      * 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)
+        {
-...
      *          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)
+        {
-...
     /**
      * 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)
+        {
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * 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)
+        {
-...
      * @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)
+        {
-...
      * 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)
+        {
-...
      * 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)
+        {
-...
     /**
      * 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)
-...
     /**
      * 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)
+        {
-...
     /**
      * 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)
+        {
-...
     /**
      * 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)
+        {
-...
      * 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)
+        {
-...
     /**
      * 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)
+        {
-...
      * 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)
+        {
-...
      * <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)
+        {
-...
      * 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)
+        {
-...
      * <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)
+        {
-...
      * 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)
+        {
-...
     /**
      * 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)
+        {
-...
      * <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)
+        {
-...
     /**
      * 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)
+        {
-...
      * <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)
+        {
-...
     /**
      * 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)
+        {
-...
      * <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)
+        {
-...
     /**
      * 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)
+        {
-...
      * <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)
+        {
-...
      * <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)
+        {
-...
     /**
      * 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)
+        {
-...
     /**
      * 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)
+        {
-...
      * <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)
+        {
-...
     /**
      * 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)
+        {
-...
      * <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)
+        {
-...
      * <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)
+        {
-...
     /**
      * 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)
+        {
-...
      * <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)
+        {
-...
     /**
      * 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)
+        {
-...
      * <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)
+        {
-...
      * <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)
+        {
-...
     /**
      * 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)
+        {
-...
     /**
      * 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)
+        {
-...
      * <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)
+        {
-...
     /**
      * 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)
+        {
-...
      * <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)
+        {
-...
      * <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)
+        {
-...
     /**
      * 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)
+        {
-...
      * <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)
+        {
-...
     /**
      * 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)
+        {
-...
      * <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)
+        {
-...
      * <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)
+        {
-...
     /**
      * 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)
+        {
-...
     /**
      * 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)
+        {
-...
      * <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)
+        {
-...
     /**
      * 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)
+        {
-...
      * <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)
+        {
-...
      * <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)
+        {
-...
     /**
      * 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)
+        {
-...
      * <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)
+        {
-...
     /**
      * 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)
+        {
-...
      * <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)
+        {
-...
      * <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)
+        {
-...
     /**
      * 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)
+        {
-...
     /**
      * 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)
+        {
-...
      * <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)
+        {
-...
     /**
      * 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)
+        {
-...
     /**
      * 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)
+        {
-...
     /**
      * 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)
+        {
-...
      * 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)
+        {
-...
      * <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 )
+        {
-...
      * 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)
+        {
-...
      * 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)
+        {
-...
      * 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)
+        {
-...
      * <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)
+        {
-...
      * 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 )
+        {
-...
      * Pull all points around the center of the effect towards the center (if degree>=1) or push them
      * away from the center (degree<=1)

... 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 d7bbef2f

Added by Distorted Admin almost 8 years ago