/*
  Gesture Types
 -1 = unkown?
  0 = Nothing!
  1 = speck
  2 = curvy line
  3 = closed shape
  
*/
int lastGesture=0;
int curGesture=0;
int minClosedSize=6;
float minClosedDist=0.001;
int interpretStroke(penStroke ps)
{
  if(ps==null||ps.points.length<1)
    return 0;
  int gt=0;
  float totalDistance=0;
  for(int i=0;i<ps.points.length-1;i++)
  {    
    totalDistance+=dist(ps.points[i].p,ps.points[i+1].p);
  }
  if(totalDistance<15)
    return 1;
  float collatedAng=0;  
  float ang=0;
  boolean closed=false;
  for(int i=0;i<ps.points.length-1;i++)
  {
    vec tp=new vec(ps.points[i].p);
    vec tpn=new vec(ps.points[i+1].p);
    seg curLine=new seg(tp,tpn);
    if(curLine.mag()>minClosedDist)
    {
      for(int s=i+minClosedSize;s<ps.points.length-1;s++)
      {
        seg nextLine=new seg(new vec(ps.points[s].p),new vec(ps.points[s+1].p));     
        if(nextLine.mag()>minClosedDist)
        {
          if(intersect(curLine,nextLine))
          {
//            println("total points "+ps.points.length);          
//            println(curLine.a.x+","+curLine.a.y+" "+curLine.b.x+","+curLine.b.y+" to "+nextLine.a.x+","+nextLine.a.y+" "+nextLine.b.x+","+nextLine.b.y);
//            println("intersected at: "+i);
//            ps.intersectAt=i;
            closed=true;
            return 3;                   
          }
        }
      }
    }
  }  
  
  return 2;
}

int findIntersectionFirst(penStroke ps)
{
  for(int i=0;i<ps.points.length-1;i++)
  {
    vec tp=new vec(ps.points[i].p);
    vec tpn=new vec(ps.points[i+1].p);
    seg curLine=new seg(tp,tpn);
    for(int s=i+2;s<ps.points.length-1;s++)
    {
      seg nextLine=new seg(new vec(ps.points[s].p),new vec(ps.points[s+1].p));     
      if(nextLine.mag()>minClosedDist)
      {
        if(intersect(curLine,nextLine))
        {
//          println(i);
//          println(s);
          return i;                   
        }
      }
    }
  }
  return -1;
}

int findIntersectionSecond(penStroke ps)
{
  for(int i=0;i<ps.points.length-1;i++)
  {
    vec tp=new vec(ps.points[i].p);
    vec tpn=new vec(ps.points[i+1].p);
    seg curLine=new seg(tp,tpn);
    for(int s=i+2;s<ps.points.length-1;s++)
    {
      seg nextLine=new seg(new vec(ps.points[s].p),new vec(ps.points[s+1].p));     
      if(nextLine.mag()>minClosedDist)
      {
        if(intersect(curLine,nextLine))
        {
//          println(i);
//          println(s);
          return s;                   
        }
      }
    }
  }
  return -1;
}

vec findIntersectionPoint(penStroke ps)
{
  vec n=new vec();
  for(int i=0;i<ps.points.length-1;i++)
  {
    vec tp=new vec(ps.points[i].p);
    vec tpn=new vec(ps.points[i+1].p);
    seg curLine=new seg(tp,tpn);
    for(int s=i+2;s<ps.points.length-1;s++)
    {
      seg nextLine=new seg(new vec(ps.points[s+1].p),new vec(ps.points[s].p));     
      if(nextLine.mag()>minClosedDist)
      {
        if(intersect(curLine,nextLine))
        {
//          seg curLine2=new seg(new vec(ps.points[i+1].p),new vec(ps.points[i+2].p));          
          n=intersectPoint(curLine,nextLine);
//          return n;
        }
      }
    }
  }
  return n;
}


class drawPoint
{
  vec p;
  float press;
  vec tilt;
  drawPoint()
  {
    p=new vec(mouseX,mouseY);
    press=512;;
    tilt=new vec();
  }
  drawPoint(drawPoint dp)
  {
    p=new vec(dp.p);
    press=dp.press;
    tilt=new vec(dp.tilt);
  }
  drawPoint(vec p,float pr)
  {
    this.p=new vec(p);
    press=pr;
  }
}

drawPoint avg(drawPoint dp[])
{
  drawPoint avgPoint=new drawPoint();
  if(dp==null)
    return avgPoint;
  if(dp.length<=1)
    return dp[0];
  vec totalP=new vec();
  float totalPress=0;
  for(int i=0;i<dp.length;i++)
  {
    totalP.add(dp[i].p);
    totalPress+=dp[i].press;
  }
  totalP.div(float(dp.length));
  totalPress/=float(dp.length);
  avgPoint.p=totalP;
  avgPoint.press=totalPress;
  return avgPoint;
}

class penStroke
{
  drawPoint points[];
  float averageLength=0;
  float totalLength=0;
  float totalPress=0;
  int intersectAt=-1;
  penStroke()
  {
    points=new drawPoint[0];
  }
  penStroke(penStroke ps)
  {
    points=new drawPoint[ps.points.length];
    System.arraycopy(ps.points,0,points,0,points.length);
    averageLength=ps.averageLength;
    totalLength=ps.totalLength;
  }
  penStroke(drawPoint p[])
  {
    points=new drawPoint[p.length];
    System.arraycopy(p,0,points,0,points.length);
    statistics();
  }
  vec getCenter()
  {
    vec total=new vec();
    for(int i=0;i<points.length;i++)
    {
      total.add(points[i].p);
    }
    total.div(points.length);
    return total;
  }
  void statistics()
  {
    float avgdist=0;
    float total=0;
    float tp=0;
    if(points.length<1)
      return;
    for(int i=0;i<points.length;i++)
    {
      if(i>0)
        total+=dist(points[i-1].p,points[i].p);
      tp+=points[i].press;
    }
    totalLength=total;
    averageLength=total/points.length;
    totalPress=tp;
//    println(totalPress);
  }
  void addPoint()
  {
    points=append(points,new drawPoint());
    if(points.length>1)
    {
      float d=dist(points[points.length-2].p,points[points.length-1].p);
      totalLength+=d;
    }
    averageLength=totalLength/points.length;
  }
}

drawPoint[] append(drawPoint dp[],drawPoint np)
{
  drawPoint temp[]=new drawPoint[dp.length+1];
  System.arraycopy(dp,0,temp,0,dp.length);
  temp[dp.length]=new drawPoint(np);
  return temp;
}

vec findVecPoint(penStroke ps,float k)
{
  drawPoint dp=findDrawPoint(ps,k);
  return dp.p;
}

drawPoint findDrawPoint(penStroke ps,float k)
{
  if(ps==null||ps.points.length<1)
    return new drawPoint();
  if(ps.points.length<2)
    return ps.points[0];
  float searchDistance=ps.totalLength*k;
  float curDistance=0;
  drawPoint v[]=ps.points;
  drawPoint nv=new drawPoint();
  for(int i=0;i<v.length-1;i++)
  {
    float nd=dist(v[i].p,v[i+1].p);
    if(curDistance+nd>searchDistance)
    {
      float distanceLeft=searchDistance-curDistance;
      float k2=distanceLeft/nd;      
      vec newPos=lerp(v[i].p,v[i+1].p,k2);
      float newPress=lerp(v[i].press,v[i+1].press,k2);
      nv=new drawPoint(newPos,newPress);
      break;
    }
    else
      curDistance+=nd;
  }
  return nv;  
}


penStroke simplify(penStroke ps)
{
  penStroke np=new penStroke();
  if(ps==null)
    return np;
  if(ps.points.length<2)
    return np;
//Simplification formula:    
  float maxDistance=ps.averageLength*4+constrain(100/ps.points.length,0,200);    
  maxDistance=constrain(maxDistance,5,30);
  drawPoint v[]=ps.points;
  drawPoint nv[]=new drawPoint[0];
//include first point?  
  nv=append(nv,v[0]);
  float curLength=0;
  int lastIndex=0;
  for(int i=1;i<v.length;i++)
  {
    curLength+=dist(v[i-1].p,v[i].p);
    if(curLength>maxDistance)
    {
      curLength=0;
      drawPoint temp[]=new drawPoint[0];
      for(int s=lastIndex;s<=i;s++)
      {
        temp=append(temp,v[s]);
      }
      drawPoint avgPoint=avg(temp);
      nv=append(nv,avgPoint);
      lastIndex=i+1;
    }
  }
//include last point?  
  nv=append(nv,v[v.length-1]);
  np=new penStroke(nv);
  return np;
}