class Stepper {                          // stepper for the rings
  boolean [] B = new boolean [10];       // Boolean flags and number of recursions  
  int d=0;
  Stepper (int pd) {d=pd; this.reset();};
  void reset() {for(int i=0; i<d; i++) B[i]=true; d=rec;}
  int next() {int c=0; while(B[c]&&(c<d)) {B[c]=false; c++;}; B[c]=true; return(c); } // returns ID of ring that should do a b3 step
  }
int n(int c) {return((c+1)%5);}  int p(int c) {return((c+4)%5);}                                      // next and previous in ring
pt l(pt A, float s, pt B) {return(new pt(A.x+s*(B.x-A.x),A.y+s*(B.y-A.y),A.z+s*(B.z-A.z))); };        // linear interpolation
pt b(pt A, pt B, pt C, float s) {return( l(l(B,s/4.,A),0.5,l(B,s/4.,C))); };                          // tucks in a vertex towards its neighbors
pt f(pt A, pt B, pt C, pt D, float s) {return( l(l(A,1.+(1.-s)/8.,B) ,0.5,l(D,1.+(1.-s)/8.,C))); };    // bulges out a mid-edge point 

class ring {                                 // ring for traversing refined curves
    pt[] P = new pt[5];                      // a FIFO of 5 points {A,B,C,D,E}
    int c=2;                                 // index of middle point C  (it is rotated at each step to avoid copying points)
    ring () {for (int i=0; i<5; i++) P[i]=new pt(0,0);};
  void push (pt F) {c=n(c); P[n(n(c))]=F.make();}            // loads new point and advances index
  void reset() {c=2;};
  pt pt() {return(P[c].make());}
  pt b1(float s)  {pt bb = b( P[p(p(c))],P[p(c)],P[c],                 s); return(bb); }      // b for second vertex
  pt f12(float s) {pt bb = f(P[p(p(c))], P[p(c)],P[c],      P[n(c)],   s); return(bb); }      // f for second mid-edge
  pt b2(float s)  {pt bb = b(P[p(c)],    P[c],   P[n(c)],              s); return(bb); }      // b for third vertex
  pt f23(float s) {pt bb = f(P[p(c)],    P[c],   P[n(c)],   P[n(n(c))],s); return(bb); }      // f for fourth mid-edge
  pt b3(float s)  {pt bb = b(P[c],       P[n(c)],P[n(n(c))],           s); return(bb); }      // b for fifth vertex
  void derive(ring Q, float a, float b) {c=2; P[0]=Q.b1(a); P[1]=Q.f12(b); P[2]=Q.b2(a); P[3]=Q.f23(b); P[4]=Q.b3(a);} // makes ring from parent ring
  void show() {beginShape(); int b=p(p(c)); for(int i=0; i<5; i++) {P[b].vert(); b=n(b);}; endShape(); for(int i=0; i<5; i++) P[i].show(6);} // show ring
  }

class Polyloop {             // class of polyloops (closed loop polygon)
  int vn = 5, cap=5000;      // number of control vertices and the cap on vn
  pt[] P = new pt [cap];     // control points
  ring [] R = new ring[7];   // 7 rings
  int rc;                     // counter showing the next control point to load in the top rig
  Stepper stepper = new Stepper(rec);    // stepper for knowing which ring to advance
  int bi=0;
  Polyloop () {                     // creates empty poly
    vn=0; for (int i=0; i<cap; i++) P[i]=new pt(0,0); for(int i=0; i<7; i++) R[i] = new ring(); } 
    
  void pushRing() {R[0].push(P[rc]); rc=this.in(rc);}                                                                  // pushes the next control point to the top ring
  void loadRing() {stepper.reset(); R[0].reset(); rc=0; for(int i=0; i<5; i++) {R[0].push(P[rc]); rc=this.in(rc); }; }     // pushes first 5 points to top ring
  void deriveRings() {R[0].reset(); for (int r=1; r<=rec; r++) {float a=gs, b=gs;  if (r==1) {a=ga; b=gb;}; R[r].derive(R[r-1],a,b);}; }  // derive all other rings
  void showRing(int r) {R[r].show();}                                                          // shows 5 points of ring (for demonstration only)
  void f(int r) {float a=gs, b=gs;  if (r==1) {a=ga; b=gb;}; R[r].push(R[r-1].f23(b));}        // pushes ring r with the f23 of parent ring
  void b(int r) {float a=gs, b=gs;  if (r==1) {a=ga; b=gb;}; R[r].push(R[r-1].b3(a));}          // pushes ring r with the b3 of parent ring
  pt next() {int level=rec-stepper.next(); if(level==0) this.pushRing(); else this.b(level); for (int r=level+1; r<=rec; r++) this.f(r); return(R[rec].pt());} // advances last ring by one point along curve 
 
  void showRefined() {this.loadRing(); this.deriveRings(); beginShape(); for (int j=0; j<vn*int(pow(2,rec)); j++) this.next().vert(); endShape(CLOSE); }  // displays curve 
 
  float area () {float A=0; for (int i=0; i<vn-1; i++) A+=(P[i+1].x-P[i].x)*(P[i+1].y+P[i].y)/2. ; A+=(P[0].x-P[vn-1].x)*(P[0].y+P[vn-1].y)/2.; return(A); }

  void reset (int pvn) {            // resets poly tp pvn samples along a circle 
    vn=pvn; for (int i=0; i<vn; i++) {P[i].setFromValues(-sin((i+0.5)*TWO_PI/vn)*(width*0.40)+width/2.0,cos((i+0.5)*TWO_PI/vn)*(height*0.40)+height/2.0);}; }

  void from(int pvn, pt [] Q)  {    // copy pvn points from array Q
     vn=pvn; for (int i=0; i<vn; i++) P[i].setFromPt(Q[i]);  };

  void empty()  {                // empties points
     vn=0; };

  void add(pt Q)  {    // adds point Q
     P[vn++].setTo(Q);  };

  void from(Polyloop Q)  {        // copy points from polyloop Q
     vn=Q.vn; for (int i=0; i<vn; i++) P[i].setFromPt(Q.P[i]);  };

  void blendTowards(Polyloop Q, float s)  {        // blend towards Q by ratio s
     if (Q.vn>=vn) for (int i=0; i<vn; i++) P[i].moveTowards(Q.P[i],s);  };

  void drawCurve(boolean closed) {              // draws polyloop curve
    beginShape();  for (int i=0; i<vn; i++) P[i].vert();  if(closed) endShape(CLOSE); else endShape(); };  

  void drawVertices() {             // draws vertices
    for (int i=0; i<vn; i++) P[i].show(6);   }; 

  void shitfIDs() {             // draws vertices
    pt P0=P[vn-1].make(); for (int i=vn-1; i>0; i--) P[i].setTo(P[i-1]);  P[0].setTo(P0); }; 

  void drawVertexIDs() {             // draws vertices
    for (int i=0; i<vn; i++) {vec V=P[i].vecToMid(P[this.ip(i)],P[this.in(i)]); V.unit(); V.mul(-10); V.add(-3,5); P[i].label(str(i),V); };}; 

  void drawMidEdgePoints() {        // draw mid-edge points
    for (int i=0; i<vn; i++) average(P[i],P[in(i)]).show(3);  };    
  
  boolean grabInsert(pt Mouse) {               // if mouse close to vertex: grab it. If close to mid-edge: insert it
    float bd=900;                                                     // init square of smallest distance to selected point
    for (int i=0; i<vn; i++) { if (Mouse.disTo(P[i])<bd) {bd=Mouse.disTo(P[i]); bi=i;  };};       // select closeest vertex
    if (bd>10) {                                                         // if closest vertex is too far
      bd=600;                                                       // reinitilize distance squared
      for (int i=0; i<vn; i++) {if (Mouse.disTo(average(P[i],P[this.in(i)]))<bd) {bd=Mouse.disTo(average(P[i],P[this.in(i)])); bi=i;};};   // closest mid-edge point
      if (bd<20) {  
          for (int i=vn-1; i>bi; i--) {P[i+1].setFromPt(P[i]); };                // shift down the rest 
          bi++;  P[bi].setFrom(Mouse); vn++;                                  // insert new vertex at mouse position
          }
        else {bi=-1;};                                                 // nothing selected
      };
    return(bi!=-1);
    }
    
 void delete() {                   // deletes selected point if it is out
     if ( (bi!=-1) &&  P[bi].isOut() ) {for (int i=bi; i<vn; i++) {P[i].setFromPt(P[this.in(i)]);}; vn--; };  bi=-1; }
  
  int in(int j) {  if (j==vn-1) {return (0);}  else {return(j+1);}  };  // next vertex in loop
  int ip(int j) {  if (j==0) {return (vn-1);}  else {return(j-1);}  };  // previous vertex in loop

  void refine() {
    for (int i=vn-1; 0<=i; i--) P[2*i].setFromPt(P[i]);  vn*=2;     
    for (int i=1; i<vn-1; i+=2) P[i].setFromPt(average(P[i-1],P[i+1]));  
    P[vn-1].setFromPt(average(P[vn-2],P[0])); } 

  void coarsen() {vn/=2; for (int i=0; i<vn; i++) P[i].setFromPt(P[2*i+1]); } 

  void dual() {this.refine(); this.coarsen();}

  void frame() {
     float sx=width; float sy=height; float bx=0.0; float by=0.0; 
     for (int i=0; i<vn; i++) {if (P[i].x>bx) {bx=P[i].x;}; if (P[i].x<sx) {sx=P[i].x;}; if (P[i].y>by) {by=P[i].y;}; if (P[i].y<sy) {sy=P[i].y;}; };
     float m=max(bx-sx,by-sy);  float dx=(m-(bx-sx))/2; float dy=(m-(by-sy))/2; 
     for (int i=0; i<vn; i++) {P[i].x=(P[i].x-sx+dx)*4*width/5/m+width/10;  P[i].y=(P[i].y-sy+dy)*4*height/5/m+height/10;};    }   

  void zoom(float s) {for (int i=0; i<vn; i++) P[i].moveTowards(new pt(mouseX,mouseY),s);};   
 
  void mul(float s) {for (int i=0; i<vn; i++) P[i].moveTowards(new pt(width/2,height/2),s);};   

  void moveBy(vec V) {for (int i=0; i<vn; i++) P[i].moveBy(V);};   

  void bspline(int deg, int rec) { // stroke(color(int(121*deg/7),120,100));
    for(int r=0; r<rec; r++) {this.refine(); for(int d=0; d<deg-1; d++) this.dual(); for(int d=0; d<int(deg/2); d++) this.shitfIDs(); }; }

  void align() {for (int i=0; i<vn; i++) {
    if ( abs(P[in(i)].x-P[i].x)>abs(P[in(i)].y-P[i].y)) {float dy=(P[in(i)].y-P[i].y)/2; P[in(i)].y-=dy; P[i].y+=dy;}
    else {float dx=(P[in(i)].x-P[i].x)/2; P[in(i)].x-=dx; P[i].x+=dx;};   }; }                                                           

  void savePts() {
    String [] inppts = new String [vn+1];
    int s=0;
    inppts[s++]=str(vn);
    for (int i=0; i<vn; i++) {inppts[s++]=str(P[i].x)+","+str(P[i].y);};
    saveStrings("points.pts",inppts);
    };

  void loadPts() {
    String [] ss = loadStrings("points.pts");
    String subpts;
    int s=0;
    int comma;
    vn = int(ss[s]);
    for(int i=0;i<vn; i++) {
      comma=ss[++s].indexOf(',');
      P[i]=new pt (float(ss[s].substring(0, comma)), float(ss[s].substring(comma+1, ss[s].length())));
    };
   };

 }