Distorted Android

///////////////////////////////////////////////////////////////////////////////////////////////////

// Copyright 2016 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// Distorted is free software: you can redistribute it and/or modify                             //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Distorted is distributed in the hope that it will be useful,                                  //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.examples.dynamic;

import android.app.ActivityManager;

import android.content.Context;

import android.content.pm.ConfigurationInfo;

import android.graphics.Rect;

import android.opengl.GLSurfaceView;

import android.view.MotionEvent;

import android.util.AttributeSet;

import android.graphics.Canvas;

import android.graphics.Paint.Style;

import android.graphics.Paint;

import org.distorted.library.type.Dynamic;

import org.distorted.library.type.Dynamic1D;

import org.distorted.library.type.Dynamic2D;

import org.distorted.library.type.Dynamic3D;

import org.distorted.library.type.Dynamic4D;

import org.distorted.library.type.DynamicQuat;

import org.distorted.library.type.Static1D;

import org.distorted.library.type.Static2D;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import java.lang.ref.WeakReference;

///////////////////////////////////////////////////////////////////////////////////////////////////

public class DynamicSurfaceView extends GLSurfaceView

    {

    public static final int DIM_1D   = 0; 

    public static final int DIM_2D   = 1; 

    public static final int DIM_3DXY = 2; 

    public static final int DIM_3DXZ = 3; 

    public static final int DIM_4DXY = 4;

    public static final int DIM_4DZW = 5;

    public static final int DIM_Q_XY = 6;

    public static final int DIM_Q_ZW = 7;

    private static final int MAX_DIM = 4;

    private static final float QUAT_QUOT = 0.9f;

    static final int NUM_POINTS = 250;

    private static final Object lock = new Object();

    private final WeakReference<DynamicActivity> mAct;

    private static int halfScreenHeight=0;

    private static int halfScreenWidth =0;

    private final Dynamic1D   di1D;

    private final Dynamic2D   di2D;

    private final Dynamic3D   di3D;

    private final Dynamic4D   di4D;

    private final DynamicQuat diQu;

    private final Paint mPaint;

    private int mMoving;

    private int mDuration;

    private int mPosition;

    private long mDiffTime, mLastTime, mStartTime;

    private final float[] mNoise = new float[MAX_DIM];

    private float mCount;

    private int mSize1, mSize2, mSizeT, mAvg;

    private float mFontHeight;

    private int currentDim= DIM_2D;

    private Static1D p1D;

    private Static2D p2D;

    private Static3D p3D;

    private Static4D p4D;

    private Static4D pQD;

    private final Static1D p1N;

    private final Static2D p2N;

    private final Static3D p3N;

    private final Static4D p4N;

    private final Static4D pQN;

    private final float[] mPoints = new float[MAX_DIM*NUM_POINTS];

    private boolean mRunning;

///////////////////////////////////////////////////////////////////////////////////////////////////

    public DynamicSurfaceView(Context context, AttributeSet attrs)

      {

      super(context, attrs);

      DynamicActivity act = (DynamicActivity)context;

      mAct = new WeakReference<>(act);

      mPaint = new Paint();

      mPaint.setStyle(Style.FILL);

      mPaint.setAntiAlias(true);

      mDuration = 10000;

      mCount    = 0.0f;

      mPosition = 0;

      mDiffTime = -1;

      mLastTime = -1;

      mStartTime= -1;

      mMoving   = -1;

      mRunning  = false;

      for(int i=0; i<MAX_DIM; i++) mNoise[i] = 0.0f;

      clearPoints();

      di1D = new Dynamic1D(mDuration,mCount);

      p1N  = new Static1D(mNoise[0]);

      di2D = new Dynamic2D(mDuration,mCount);

      p2N  = new Static2D(mNoise[0],mNoise[1]);

      di3D = new Dynamic3D(mDuration,mCount);

      p3N  = new Static3D(mNoise[0],mNoise[1],mNoise[2]);

      di4D = new Dynamic4D(mDuration,mCount);

      p4N  = new Static4D(mNoise[0],mNoise[1],mNoise[2],mNoise[3]);

      diQu = new DynamicQuat(mDuration,mCount);

      pQN  = new Static4D(mNoise[0],mNoise[1],mNoise[2],mNoise[3]);

      di1D.setAccessType(Dynamic.ACCESS_TYPE_SEQUENTIAL);

      di2D.setAccessType(Dynamic.ACCESS_TYPE_SEQUENTIAL);

      di3D.setAccessType(Dynamic.ACCESS_TYPE_SEQUENTIAL);

      di4D.setAccessType(Dynamic.ACCESS_TYPE_SEQUENTIAL);

      diQu.setAccessType(Dynamic.ACCESS_TYPE_SEQUENTIAL);

      if(!isInEditMode())

        {

        setFocusable(true);

        setFocusableInTouchMode(true);

        DynamicRenderer mRenderer = new DynamicRenderer(this);

        final ActivityManager activityManager     = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);

        final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();

        setEGLContextClientVersion( (configurationInfo.reqGlEsVersion>>16) >= 3 ? 3:2 );

        setRenderer(mRenderer);

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void onSurfaceChanged(int width,int height)

      {

      mAvg = (width+height)/2;

      mSize1 = mAvg/150;

      mSize2 = mAvg/50;

      mSizeT = mAvg/30;

      mPaint.setTextSize(mSizeT);

      mPaint.setTextAlign(Paint.Align.CENTER);

      final Rect textBounds = new Rect();

      String text = "1";

      mPaint.getTextBounds(text, 0, text.length(), textBounds);

      mFontHeight = textBounds.exactCenterY();

      clearPoints();

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public static void surfaceChanged(int w, int h)

      {

      halfScreenWidth = w/2;

      halfScreenHeight= h/2;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void setMode(int mode)

      {

      di1D.setMode(mode);  

      di2D.setMode(mode);

      di3D.setMode(mode);

      di4D.setMode(mode);

      diQu.setMode(mode);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void setSpeedMode(int mode)

      {

      di1D.setSpeedMode(mode);

      di2D.setSpeedMode(mode);

      di3D.setSpeedMode(mode);

      di4D.setSpeedMode(mode);

      diQu.setSpeedMode(mode); // not implemented yet!

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void setDuration(int duration)

      {

      mDuration = duration;

      di1D.setDuration(duration);

      di2D.setDuration(duration);

      di3D.setDuration(duration);

      di4D.setDuration(duration);

      diQu.setDuration(duration);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void setCount(float count)

      {

      mCount = count;

      di1D.setCount(count);

      di2D.setCount(count);

      di3D.setCount(count);

      di4D.setCount(count);

      diQu.setCount(count);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void setConvexity(float convexity)

      {

      di1D.setConvexity(convexity);

      di2D.setConvexity(convexity);

      di3D.setConvexity(convexity);

      di4D.setConvexity(convexity);

      diQu.setConvexity(convexity);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

// DynamicQuat does not support noise

    public void setNoise(float noise0, float noise1, float noise2, float noise3)

      {

      mNoise[0] = noise0;

      mNoise[1] = noise1;

      mNoise[2] = noise2;

      mNoise[3] = noise3;

      p1N.set(mNoise[0]);

      p2N.set(mNoise[0],mNoise[1]);

      p3N.set(mNoise[0],mNoise[1],mNoise[2]);

      p4N.set(mNoise[0],mNoise[1],mNoise[2], mNoise[3]);

      di1D.setNoise(p1N);

      di2D.setNoise(p2N);

      di3D.setNoise(p3N);

      di4D.setNoise(p4N);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void setDimension(int dim)

      {

      if( currentDim != dim )

        {

        if( !(currentDim==DIM_3DXY && dim==DIM_3DXZ) && !(currentDim==DIM_3DXZ && dim==DIM_3DXY) &&

            !(currentDim==DIM_4DXY && dim==DIM_4DZW) && !(currentDim==DIM_4DZW && dim==DIM_4DXY) &&

            !(currentDim==DIM_Q_XY && dim==DIM_Q_ZW) && !(currentDim==DIM_Q_ZW && dim==DIM_Q_XY)  )

          {

          resetPoints();

          }

        currentDim = dim;

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void drawCurve(Canvas c, long time)

      {

      if( mLastTime<0 )

        {

        mLastTime = time;

        }

      else

        {

        mDiffTime = time - mLastTime;

        }

      synchronized(lock)

        {

        switch(currentDim)

          {

          case DIM_1D  : drawHorizontalAxis(c,"x");

                         drawPath(c,di1D,0,1,time);

                         drawRedPoints1D(c);

                         break;

          case DIM_2D  : drawHorizontalAxis(c,"x");

                         drawVerticalAxis  (c,"y");

                         drawPath(c,di2D,0,1,time);

                         drawRedPoints2D(c);

                         break;

          case DIM_3DXY: drawHorizontalAxis(c,"x");

                         drawVerticalAxis  (c,"y");

                         drawPath(c,di3D,0,1,time);

                         drawRedPoints3D(c);

                         break;

          case DIM_3DXZ: drawHorizontalAxis(c,"x");

                         drawVerticalAxis  (c,"z");

                         drawPath(c,di3D,0,2,time);

                         drawRedPoints3D(c);

                         break;

          case DIM_4DXY: drawHorizontalAxis(c,"x");

                         drawVerticalAxis  (c,"y");

                         drawPath(c,di4D,0,1,time);

                         drawRedPoints4D(c);

                         break;

          case DIM_4DZW: drawHorizontalAxis(c,"z");

                         drawVerticalAxis  (c,"w");

                         drawPath(c,di4D,2,3,time);

                         drawRedPoints4D(c);

                         break;

          case DIM_Q_XY: drawHorizontalAxis(c,"x");

                         drawVerticalAxis  (c,"y");

                         drawPath(c,diQu,0,1,time);

                         drawRedPointsQu(c);

                         break;

          case DIM_Q_ZW: drawHorizontalAxis(c,"z");

                         drawVerticalAxis  (c,"w");

                         drawPath(c,diQu,2,3,time);

                         drawRedPointsQu(c);

                         break;

          }

        }

      mLastTime = time;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void clearPoints()

      {

      for(int i=0; i<MAX_DIM*NUM_POINTS; i++)

         {

         mPoints[i] = -100000.0f;

         }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void resetPoints()

      {

      synchronized(lock)

        {

        clearPoints();

        switch(currentDim)

          {

          case DIM_1D  : di1D.removeAll(); break;

          case DIM_2D  : di2D.removeAll(); break;

          case DIM_3DXY:

          case DIM_3DXZ: di3D.removeAll(); break;

          case DIM_4DXY:

          case DIM_4DZW: di4D.removeAll(); break;

          case DIM_Q_XY:

          case DIM_Q_ZW: diQu.removeAll(); break;

          }

        DynamicActivity act = mAct.get();

        act.setNumRedPoints(0);

        act.clearPoints();

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void startDynamic()

      {

      mRunning = true;

      mLastTime= -1;

      mStartTime = System.currentTimeMillis();

      clearPoints();

      di1D.resetToBeginning();

      di2D.resetToBeginning();

      di3D.resetToBeginning();

      di4D.resetToBeginning();

      diQu.resetToBeginning();

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    public void stopDynamic()

      {

      mRunning = false;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void drawHorizontalAxis(Canvas c, String label)

      {

      mPaint.setColor(0xff000000);

      c.drawLine(0, halfScreenHeight, halfScreenWidth*2, halfScreenHeight, mPaint);

      c.drawText( label, 0.95f*halfScreenWidth*2, halfScreenHeight + mSizeT , mPaint);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void drawVerticalAxis(Canvas c, String label)

      {

      mPaint.setColor(0xff000000);

      c.drawLine(halfScreenWidth, 0, halfScreenWidth, halfScreenHeight*2, mPaint);

      c.drawText(label, halfScreenWidth + mSizeT,                mSizeT , mPaint);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void drawPath(Canvas c, Dynamic dyn, int indexH, int indexW, long time)

      {

      int len = dyn.getNumPoints();

      if( len>=2 )

        {

        if( mRunning )

          {

          if ( ++mPosition >= NUM_POINTS ) mPosition=0;

          if( dyn.getDimension()==1 )

            {

            mPoints[MAX_DIM*mPosition+indexW] = halfScreenHeight;

            }

          if( dyn.get(mPoints,MAX_DIM*mPosition, time, mDiffTime) )

            {

            stopDynamic();

            }

          addNewSpeedPoint(time);

          }

        if( currentDim!=DIM_Q_XY && currentDim!=DIM_Q_ZW )

          {

          for(int i=0; i<NUM_POINTS; i++)

            {

            int color = i<=mPosition ? 0xff - (mPosition           -i)*0xff/(NUM_POINTS-1)

                                     : 0xff - (mPosition+NUM_POINTS-i)*0xff/(NUM_POINTS-1);

            mPaint.setColor( 0xffffff + ((color&0xff)<<24) );

            c.drawCircle(mPoints[MAX_DIM*i+indexH], mPoints[MAX_DIM*i+indexW] , mSize1, mPaint );

            }

          }

        else

          {

          float x,y,min = QUAT_QUOT* (Math.min(halfScreenWidth, halfScreenHeight));

          for(int i=0; i<NUM_POINTS; i++)

            {

            int color = i<=mPosition ? 0xff - (mPosition           -i)*0xff/(NUM_POINTS-1)

                                     : 0xff - (mPosition+NUM_POINTS-i)*0xff/(NUM_POINTS-1);

            mPaint.setColor( 0xffffff + ((color&0xff)<<24) );

            x = mPoints[MAX_DIM*i+indexH]*min + halfScreenWidth;

            y = mPoints[MAX_DIM*i+indexW]*min + halfScreenHeight;

            c.drawCircle( x, y, mSize1, mPaint );

            }

          }

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void drawRedPoints1D(Canvas c)

      {

      int len = di1D.getNumPoints();

      for(int curr=0; curr<len; curr++)

        {

        p1D = di1D.getPoint(curr);

        drawRedPoint(c,curr+"", p1D.get0(), halfScreenHeight);

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void drawRedPoints2D(Canvas c)

      {

      int len = di2D.getNumPoints();

      for(int curr=0; curr<len; curr++)

        {

        p2D = di2D.getPoint(curr);

        drawRedPoint(c,curr+"", p2D.get0(), p2D.get1());

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void drawRedPoints3D(Canvas c)

      {

      int len = di3D.getNumPoints();

      for(int curr=0; curr<len; curr++)

        {

        p3D = di3D.getPoint(curr);

        drawRedPoint(c,curr+"", p3D.get0(), currentDim==DIM_3DXY ? p3D.get1():p3D.get2());

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void drawRedPoints4D(Canvas c)

      {

      int len = di4D.getNumPoints();

      for(int curr=0; curr<len; curr++)

        {

        p4D = di4D.getPoint(curr);

        if( currentDim==DIM_4DXY ) drawRedPoint(c,curr+"", p4D.get0(), p4D.get1());

        else                       drawRedPoint(c,curr+"", p4D.get2(), p4D.get3());

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void drawRedPointsQu(Canvas c)

      {

      int len = diQu.getNumPoints();

      float x,y, min = QUAT_QUOT* (halfScreenWidth<halfScreenHeight ? halfScreenWidth:halfScreenHeight );

      for(int curr=0; curr<len; curr++)

        {

        pQD = diQu.getPoint(curr);

        if( currentDim==DIM_Q_XY )

          {

          x = pQD.get0()*min + halfScreenWidth;

          y = pQD.get1()*min + halfScreenHeight;

          }

        else

          {

          x = pQD.get2()*min + halfScreenWidth;

          y = pQD.get3()*min + halfScreenHeight;

          }

        drawRedPoint(c,curr+"", x,y);

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void drawRedPoint(Canvas c, String label, float width, float height)

      {

      mPaint.setColor(0xffff0000);

      c.drawCircle( width, height, mSize2, mPaint);

      mPaint.setColor(0xffffffff);

      c.drawText(label, width,height-mFontHeight, mPaint);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void addNewPoint(float x, float y)

      {

      float gx,gy,gz,gw;

      int len;

      int minDist = (mAvg*mAvg)/100;

      switch(currentDim)

        {

        case DIM_1D : len = di1D.getNumPoints();

                      for(int g=0; g<len; g++)

                        {

                        p1D = di1D.getPoint(g);

                        gx = p1D.get0();

                        if( (x-gx)*(x-gx) < minDist )

                          {

                          mMoving = g;

                          break;

                          }

                        }

                      if( mMoving <0 )

                        {

                        synchronized(lock)

                          {

                          di1D.add(new Static1D(x));

                          mAct.get().setNumRedPoints(len+1);

                          }

                        }

                      break;

        case DIM_2D : len = di2D.getNumPoints();

                      for(int g=0; g<len; g++)

                        {

                        p2D = di2D.getPoint(g);

                        gx = p2D.get0();

                        gy = p2D.get1();

                        if( (x-gx)*(x-gx) + (y-gy)*(y-gy) < minDist )

                          {

                          mMoving = g;

                          break;

                          }

                        }

                      if( mMoving <0 )

                        {

                        synchronized(lock)

                          {

                          di2D.add(new Static2D(x,y));

                          mAct.get().setNumRedPoints(len+1);

                          }

                        }

                      break;

        case DIM_3DXY:

        case DIM_3DXZ:len = di3D.getNumPoints();

                      for(int g=0; g<len; g++)

                        {

                        p3D = di3D.getPoint(g);

                        gx = p3D.get0();

                        gy = p3D.get1();

                        gz = p3D.get2();

                        if( currentDim==DIM_3DXY )

                          {

                          if( (x-gx)*(x-gx) + (y-gy)*(y-gy) < minDist )

                            {

                            mMoving = g;

                            break;

                            }

                          }

                        if( currentDim==DIM_3DXZ )

                          {

                          if( (x-gx)*(x-gx) + (y-gz)*(y-gz) < minDist )

                            {

                            mMoving = g;

                            break;

                            }

                          }

                        }

                      if( mMoving <0 )

                        {

                        synchronized(lock)

                          {

                          if( currentDim==DIM_3DXY ) di3D.add(new Static3D(x,y, halfScreenHeight));

                          if( currentDim==DIM_3DXZ ) di3D.add(new Static3D(x, halfScreenHeight,y));

                          mAct.get().setNumRedPoints(len+1);

                          }

                        }

                      break;

        case DIM_4DXY:

        case DIM_4DZW:len = di4D.getNumPoints();

                      for(int g=0; g<len; g++)

                        {

                        p4D = di4D.getPoint(g);

                        gx = p4D.get0();

                        gy = p4D.get1();

                        gz = p4D.get2();

                        gw = p4D.get3();

                        if( currentDim==DIM_4DXY )

                          {

                          if( (x-gx)*(x-gx) + (y-gy)*(y-gy) < minDist )

                            {

                            mMoving = g;

                            break;

                            }

                          }

                        if( currentDim==DIM_4DZW )

                          {

                          if( (x-gz)*(x-gz) + (y-gw)*(y-gw) < minDist )

                            {

                            mMoving = g;

                            break;

                            }

                          }

                        }

                      if( mMoving <0 )

                        {

                        synchronized(lock)

                          {

                          if( currentDim==DIM_4DXY ) di4D.add(new Static4D(x,y, halfScreenWidth, halfScreenHeight));

                          if( currentDim==DIM_4DZW ) di4D.add(new Static4D( halfScreenWidth, halfScreenHeight,x,y));

                          mAct.get().setNumRedPoints(len+1);

                          }

                        }

                      break;

        case DIM_Q_XY:

        case DIM_Q_ZW:len = diQu.getNumPoints();

                      float min = QUAT_QUOT* (halfScreenWidth<halfScreenHeight ? halfScreenWidth:halfScreenHeight );

                      for(int g=0; g<len; g++)

                        {

                        pQD = diQu.getPoint(g);

                        if( currentDim==DIM_Q_XY )

                          {

                          gx = pQD.get0()*min + halfScreenWidth;

                          gy = pQD.get1()*min + halfScreenHeight;

                          if( (x-gx)*(x-gx) + (y-gy)*(y-gy) < minDist )

                            {

                            mMoving = g;

                            break;

                            }

                          }

                        if( currentDim==DIM_Q_ZW )

                          {

                          gz = pQD.get2()*min + halfScreenWidth;

                          gw = pQD.get3()*min + halfScreenHeight;

                          if( (x-gz)*(x-gz) + (y-gw)*(y-gw) < minDist )

                            {

                            mMoving = g;

                            break;

                            }

                          }

                        }

                      if( mMoving <0 )

                        {

                        float z,w;

                        x = (x - halfScreenWidth ) / min;

                        y = (y - halfScreenHeight) / min;

                        float len1 = x*x + y*y;

                        if( len1>= 1.0f )

                          {

                          float A = (float)Math.sqrt(len1);

                          x = x/A;

                          y = y/A;

                          z = 0.0f;

                          w = 0.0f;

                          }

                        else

                          {

                          z = (float)Math.sqrt(1-len1);

                          w = 0.0f;

                          }

                        synchronized(lock)

                          {

                          if( currentDim==DIM_Q_XY ) diQu.add(new Static4D(x,y,z,w));

                          if( currentDim==DIM_Q_ZW ) diQu.add(new Static4D(z,w,x,y));

                          mAct.get().setNumRedPoints(len+1);

                          }

                        }

                      break;

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private void addNewSpeedPoint(long time)

      {

      int prev = mPosition-1;

      if( prev<0 ) prev = NUM_POINTS-1;

      float xdiff = mPoints[MAX_DIM*prev  ]-mPoints[MAX_DIM*mPosition  ];

      float ydiff = mPoints[MAX_DIM*prev+1]-mPoints[MAX_DIM*mPosition+1];

      float zdiff = mPoints[MAX_DIM*prev+2]-mPoints[MAX_DIM*mPosition+2];

      float wdiff = mPoints[MAX_DIM*prev+3]-mPoints[MAX_DIM*mPosition+3];

      float dist = (float)Math.sqrt( xdiff*xdiff + ydiff*ydiff + zdiff*zdiff + wdiff*wdiff);

      float speed= mDiffTime<=0 ? 0: dist / mDiffTime;

      float timepoint = ((float)(time-mStartTime))/mDuration;

      if( dist<1000.0f )   // otherwise this is a very first call; do not send it!

        {

        mAct.get().addPoint( timepoint - (int)timepoint, speed );

        }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    @Override

    public boolean onTouchEvent(MotionEvent event)

      {

      int action = event.getAction();

      float xDown, yDown;

      switch(action)

        {

        case MotionEvent.ACTION_DOWN: xDown = event.getX();

                                      yDown = event.getY();

                                      addNewPoint(xDown,yDown);

                                      break;

        case MotionEvent.ACTION_MOVE: if( mMoving >=0 )

                                        {

                                        xDown = event.getX();

                                        yDown = event.getY();

                                        switch(currentDim)

                                          {

                                          case DIM_1D  : di1D.setPoint(mMoving, xDown);

                                                         break;