int[] S = new int [scap];        // indices to resampled vertices on the computed polyloop
int sn =0;                       // number of samples
// STUDENT ADDED CLASS ////////////////////////////////

// this class stores curve information, and will parameterize lengths
class ParamSeg
{
  pt Start, End;  // start, end point of span
  vec pVec;      // vector representing span length
  float Length;  // unparameterized length of span
  float ParamLength;  // span length/total length of curve
  
  // create a span with start/end points
  public ParamSeg(pt s, pt e)
  {
    Start = s;
    End = e;
  
    // create vector
    pVec = new vec(e.x - s.x, e.y - s.y);
    // store length
    Length = s.disTo(e);  
  }
  
  // called to parameterize span
  public void createParamLength(float tlen){ParamLength = Length/tlen;}

  // called to interpolate the point on the line
  // ct = (t - previous parameterized spans)
  public pt getPos(float ct){ct /= ParamLength;return new pt(Start.x + pVec.x * ct, Start.y + pVec.y * ct);}
}

// STUDENT ADDED VARIABLES ////////////////////////////////
float totalLength = 0;  // saves the toal length of the curve
boolean compFlag = true;  // flag to set if lengths need to be recomputed
ParamSeg [] pointLenghtArray = new ParamSeg[scap];  // used to store parameterized curve

void drawSamples() {stroke(blue);  for (int i=0; i<sn; i++) C[S[i]].show(5); }; 
 
void selectSamples() {sn=svn/16; for (int i=0; i<sn; i++) S[i]=16*i; ;}

void pushSamples() {for (int i=0; i<sn; i++) 
    if ( C[S[i]].disTo(C[S[xn(i)]]) > C[S[i]].disTo(C[S[xp(i)]]) ) S[i]=sn(S[i]); else S[i]=sp(S[i]) ; }
    
void copySamples() {
  int m=svn+1; int mi=0; for (int i=0; i<sn; i++) if (S[i]<m) {mi=i; m=S[i];}; // finds mi = index of smallest S
  int j=0;  for (int i=0; i<sn; i++) {C[j++].setFromPt(C[S[mi]]); mi=xn(mi);}; // copies without writing over itself
  svn=sn;};
    
int xn(int j) { if (j==sn-1) {return (0);}  else {return(j+1);}  };  // next sample
int xp(int j) { if (j==0) {return (sn-1);}  else {return(j-1);}  };  // previous sample

// STUDENT FUNCTIONS //////////////////////////////////////////

// function to do one time per curve computations
void computeLength()
{
  if(compFlag == false) return;   // see if we need to recompute
  compFlag = false;  // flag that the computations have been done

  totalLength = 0;  // reset total length
  
  // compute length of each line segement
  for(int i=0;i<sn;i++)
  {
      pointLenghtArray[i] = new ParamSeg(C[i], C[xn(i)]);  // compute length
      totalLength += pointLenghtArray[i].Length;    // add to total length
  }

  // parameterize lengths
  for(int i=0;i<sn;i++)
  {
      pointLenghtArray[i].createParamLength(totalLength);
  }
}

// required function sampleAt(t).  Given t = [0, 1 ], it will
// interpolate a point on the polyline
pt sampleAt(float t)  
{
  float partalLength = 0; 
  sn = svn;    // save svn in sn (needed for xn, xp, computeLength)
  computeLength();
    
  // loop thru each span, and see if we are on it
  for(int i=0;i<sn;i++)
  {
    // if t > (sum_prev_spans + this_span) go to next span
    if(partalLength + pointLenghtArray[i].ParamLength < t)partalLength += pointLenghtArray[i].ParamLength;

    // else return interpolated point on this span
    else
    {
      return pointLenghtArray[i].getPos(t - partalLength);
    }    
  }
  
  return new pt(0, 0);
}
  
// hook function, called from P1b
void myUniformSampling() 
{
  int  numSteps  = svn * 5;
  float  resampleStep  = 1.0f/(float)(numSteps);
  
  compFlag = true;  // reset computation flag (we need to recompute polyline info)
  float step = 1.0f/numSteps;  // decide how many 
  pt tempC[] = new pt[numSteps];  // create a temporary array for info
  
  int i=0;  // reset i

  // generate points
  for(float t=0;t<1.0f;t+=resampleStep)
  {
    tempC[i++] = sampleAt(t);
  }
  
  // copy points into polyline array
  for(i=0;i<numSteps;i++)
  {
    C[i].setFromPt(tempC[i]);
  }
  
  svn = sn = numSteps;    // update point count
}