//*****************************************************************************
// CURVE TWEENING, Jarek Rossignac, 2008
//*****************************************************************************
int _deg=3;
float [] _w = new float[5];          // weights for retrofitting
boolean symmetryEnds=true;
POLY C  = new POLY(); // control, retrofit, and subdivided polyloops

boolean [] used = new boolean [10];
float Carea=0, Clength=0, Sarea=0, Slength=0;
//float nrv=30; // number of vertices on resampled curve U
pt closest = new pt(0,0);  // tracks closest point on control polyloop
float taper (float v, int i, int n) {  // returns v scaled down smothly when i approaches 0 or n
    if (i<n/4) return (1-sq(cos(PI*i/n*2)))*v; else if (i>3*n/4) return (1-sq(cos(PI*(i-n/2)/n*2)))*v; else return v; }
boolean ccl;
//************************************************************************************************************************
POLY P(POLY Q) {POLY P = new POLY(); P.setTo(Q); return P;}
// ****************************************    POLY CLASS   ************************************* START !!!!!!!!
class POLY {                    // class of polyloops (open loop polygon)
  int vn = 6, cap=20000;         // number of control vertices and the cap on vn
  pt[] P = new pt [cap];        // control points
  int[] m = new int[3];         // marks: vertex indices splitting poly in 4 for morphing and dollies
  int p = 0;                    // id of currently point selected (with mouse for dragging, etc.)
  POLY () {for (int i=0; i<cap; i++) P[i]=new pt(0,0); vn=2; P[1].setTo(1,0); }  // makes them all the (0,0) except P1
  POLY(POLY Q)  {for (int i=0; i<cap; i++) P[i]=new pt(0,0); vn=Q.vn; for (int i=0; i<vn; i++) P[i]=P(Q.P[i]); copyMarks(Q); }; // makes a copy
  void reset (int pvn) {        // puts pvn points on a circle 
        vn=pvn; for (int i=0; i<vn; i++) {P[i].setTo(-sin((i+0.5)*TWO_PI/vn)*(height*0.40)+height/2.0,cos((i+0.5)*TWO_PI/vn)*(height*0.40)+height/2.0);}; }
  void from(int pvn, pt [] Q)  { vn=pvn; for (int i=0; i<vn; i++) P[i].setTo(Q[i]); };  // makes P be the pvn first points of Q
  void empty()  { vn=0; };      // resets the vertex count to zero
  void appendPt(pt Q)  { P[vn++].setTo(Q);  }; // add point at end 
// RINGS ********************************************
  int rv=0; // index to the next vertex to be inserted in R[0]
  void rollRingAlternateColor() { rv=0; ops=0; drawing=false; for (int i=0; i<5; i++) moveRing(); // initialize rings before drawing
       ccl=true; drawing=true;  beginShape(); for (int i=5; i<vn; i++) {ccl=!ccl; if(ccl) stroke(red); else stroke(green); moveRing();} lP.v(); endShape();}
  void rollRing() { rv=0; drawing=false; for (int i=0; i<5; i++) moveRing(); // initialize rings before drawing
       drawing=true;  beginShape(); for (int i=5; i<vn; i++) moveRing(); lP.v(); endShape();}
  void moveRing() {loadRing(0,P[rv]); rv++; pushRing(0); pushRing(0);} // advance top ring by 1
  void ringRollX() {rv=0; drawing=false; for (int i=0; i<5; i++) {ringLoad(); ringAdvance();}; // initialize rings before drawing
       drawing=true;  beginShape(); for (int i=5; i<vn; i++) {ringLoad(); ringAdvance();} lP.v(); endShape(); }
  void ringRoll() {rv=0; drawing=false; swapRings(); ringStart(); // initialize rings before drawing
       drawing=true;  beginShape(); for (int i=5; i<vn; i++) {ringLoad(); ringAdvance(0);} lP.v(); endShape(); }
  void ringLoad() {load(P[rv++]);}
 void ringStart() {
    ringLoad();  //  0   
    ringLoad();  //  1        
    ringLoad();  //  2
    push(0);     //  3
    ringLoad();  //  4 
    push(0);     //  5
    push(0);     //  6 
    push(1);     //  7
    ringLoad();  //  8
    push(0);     //  9                 
    push(1);     // 10                 
    push(1);     // 11                 
    push(2);     // 12
    push(0);     // 13    
    push(1);     // 14    
    push(2);     // 15
    push(2);     // 16
     push(3);    //  a
    push(1);     // 17  
     push(2);     // 18
      push(3);    //  b
      push(3);    //  c
       push(4);    //    
     push(2);     // 19
      push(3);    //  d
       push(4);    //    
       push(4);    //    
        push(5);    //    
      push(3);    //  e                                                         
       push(4);    //    
        push(5);    //    
        push(5);    //    
         push(6);    //    
       push(4);    //    
        push(5);    //    
         push(6);    //    
         push(6);    //    
          push(7);    //    
        push(5);    //    
         push(6);    //    
          push(7);    //    
          push(7);    //    
           push(8);    //    
         push(6);    //    
          push(7);    //    
           push(8);    //    
           push(8);    //    
            push(9);    //    
          push(7);    //    
           push(8);    //    
            push(9);    //    
            push(9);    //    
           push(8);    //    
            push(9);    //    
            push(9);    //    
    }
  void ringAdvance(int k) {if(k>_rec) return; push(k); ringAdvance(k+1); push(k); ringAdvance(k+1); }
 
  void ringAdvance() {
   push(0); 
    push(1); 
     push(2); 
      push(3); 
       push(4); 
        push(5); 
        push(5); 
       push(4); 
        push(5); 
        push(5); 
      push(3); 
       push(4); 
        push(5); 
        push(5); 
       push(4); 
        push(5); 
        push(5); 
     push(2); 
      push(3); 
       push(4); 
        push(5); 
        push(5); 
       push(4); 
        push(5); 
        push(5); 
      push(3); 
       push(4); 
        push(5); 
        push(5); 
       push(4); 
        push(5); 
        push(5); 
    push(1); 
     push(2); 
      push(3); 
       push(4); 
        push(5); 
        push(5); 
       push(4); 
        push(5); 
        push(5); 
      push(3); 
       push(4); 
        push(5); 
        push(5); 
       push(4); 
        push(5); 
        push(5); 
     push(2); 
      push(3); 
       push(4); 
        push(5); 
        push(5); 
       push(4); 
        push(5); 
        push(5); 
      push(3); 
       push(4); 
        push(5); 
        push(5); 
       push(4); 
        push(5); 
        push(5); 
   push(0); 
    push(1); 
     push(2); 
      push(3); 
       push(4); 
        push(5); 
        push(5); 
       push(4); 
        push(5); 
        push(5); 
      push(3); 
       push(4); 
        push(5); 
        push(5); 
       push(4); 
        push(5); 
        push(5); 
     push(2); 
      push(3); 
       push(4); 
        push(5); 
        push(5); 
       push(4); 
        push(5); 
        push(5); 
      push(3); 
       push(4); 
        push(5); 
        push(5); 
       push(4); 
        push(5); 
        push(5); 
    push(1); 
     push(2); 
      push(3); 
       push(4); 
        push(5); 
        push(5); 
       push(4); 
        push(5); 
        push(5); 
      push(3); 
       push(4); 
        push(5); 
        push(5); 
       push(4); 
        push(5); 
        push(5); 
     push(2); 
      push(3); 
       push(4); 
        push(5); 
        push(5); 
       push(4); 
        push(5); 
        push(5); 
      push(3); 
       push(4); 
        push(5); 
        push(5); 
       push(4); 
        push(5); 
        push(5); 
     
   }
  
    void ringAdvanceX() {
   push(0); 
    push(1); 
     push(2); 
      push(3); 
       push(4); 
       push(4); 
      push(3); 
       push(4); 
       push(4); 
     push(2); 
      push(3); 
       push(4); 
       push(4); 
      push(3); 
       push(4); 
       push(4); 
    push(1); 
     push(2); 
      push(3); 
       push(4); 
       push(4); 
      push(3); 
       push(4); 
       push(4); 
     push(2); 
      push(3); 
       push(4); 
       push(4); 
      push(3); 
       push(4); 
       push(4); 
     
   push(0); 
    push(1); 
     push(2); 
      push(3); 
       push(4); 
       push(4); 
      push(3); 
       push(4); 
       push(4); 
     push(2); 
      push(3); 
       push(4); 
       push(4); 
      push(3); 
       push(4); 
       push(4); 
    push(1); 
     push(2); 
      push(3); 
       push(4); 
       push(4); 
      push(3); 
       push(4); 
       push(4); 
     push(2); 
      push(3); 
       push(4); 
       push(4); 
      push(3); 
       push(4); 
       push(4); }
     
  void subdivideGlobal() { pt[] Q = new pt [vn]; for (int i=0; i<vn; i++) Q[i]=P[i]; sub(Q,_rec,0);}   
  void subdivideSpans() { pt[] Q = new pt [6]; for (int j=0; j<vn-5; j++) {for (int i=0; i<6; i++) Q[i]=P[j+i]; sub(Q,_rec,0);} ;} 
 

// DOLLY ********************** m[] selects 5 vertices of the POLY (used for morphing) ***********************
  void resetMarks() {for(int i=0; i<3; i++) m[i]=max(min(int(float(vn)*(i+1)/4.),vn-2),1);} // Uniform spacing of the IDs, regardless of distance
  void resetEndMarks() {m[0]=0; m[1]=int(vn/2); m[2]=vn-1;} // Uniform spacing of the IDs, regardless of distance
  void scaleMarks(float s) {for(int i=0; i<3; i++) m[i]*=s;}                                // used to track m[] when refining, subvividing, and coarsening
  void addMarks(int s) {for(int i=0; i<3; i++) m[i]+=s;}                                    // used to update m[] when inserting / deleting vertices
  void copyMarks(POLY Q) {for(int i=0; i<3; i++) m[i]=Q.m[i];}                              // used to transfer m[] when making a copy of a POLY
  void writeMarks() {for(int i=0; i<3; i++) print(",  m["+i+"]="+m[i]); println();}         // used for debugging
  void checkMarks() {for(int i=1; i<3; i++) m[i]=max(m[i],m[i-1]+1);}                         // makes increasing marks
  
// DISPLAY ************************************************************************************
  pt p(int i) {return P(P[i]);}  // returns point i
  pt first() {return P(P[0]);}  // returns point i
  pt last() {return P(P[vn-1]);}  // returns point i
  pt p() {return P(P[p]);}       // returns point p
  void drawVertices() {for (int i=0; i<vn; i++) P[i].show(3); }  // draws vertices as small circles
  void drawPoints() {beginShape(POINTS); for (int i=0; i<vn; i++) P[i].v();  endShape(); };  // draws vertices as points
  void drawVertexIDs() {for (int i=0; i<vn; i++) {vec V=S(-10,U(proVec(P[prev(i)],P[i],P[next(i)]))); V.add(-3,5); P[i].showLabel(str(i),V); };}; 
  void show() {drawControl();} 
  void drawCurve() {drawControl(); } 
  void drawControl() { beginShape();  for (int i=0; i<vn; i++) P[i].v(); endShape();}
  void drawBeziers() {addEnds(); for (int i=2; i<vn-3; i++) drawBezier(i); chopEnds();}
  void drawBezier(int i) {drawCubicBezier(P[i], T(P[i],1./6,V(P[prev(i)],P[next(i)])), T(P[next(i)],-1./6,V(P[i],P[next(next(i))])), P[next(i)]); }
  void drawEnds() {addEnds(); P[0].to(P[1]); P[1].to(P[2]);  P[vn-1].to(P[vn-2]); P[vn-2].to(P[vn-3]); P[0].show(2); P[1].show(2); P[vn-1].show(2); P[vn-2].show(2); chopEnds(); }
 
// LENGTH, PROJECTION, DISTANCE ************************************************************************************
  float length () {float L=0; for (int i=0; i<vn-1; i++) L+=d(P[i],P[i+1]); return(L); }  
  float length (int s, int e) {float L=0; for (int i=s; i<e; i++) L+=d(P[i],P[i+1]); return(L); }  
  float distance(pt M) {return(M.disTo(project(M)));}
  int closestVertex(pt M) {int p=0; for (int i=1; i<vn; i++) if (M.disTo(P[i])<M.disTo(P[p])) p=i; return p; }
  pt project(pt M) {
     int v=closestVertex(M);                                                                            
     int e=-1; float d = M.disTo(P[v]);
     for (int i=0; i<vn-1; i++) if ( M.projectsBetween(P[i],P[next(i)])  && (M.disToLine(P[i],P[next(i)])<d)) {e=i; d=M.disToLine(P[e],P[next(e)]);};
     if (e!=-1) return(M.makeProjectionOnLine(P[e],P[next(e)])); else return P(P[v]);
     }

// EDIT ************************************************************************************
  void pickClosestVertex(pt M) {p=0; for (int i=1; i<vn; i++) if (M.disTo(P[i])<M.disTo(P[p])) p=i;  }
  void dragVertex(vec V) {P[p].translateBy(V); }
  void moveVertexTo(pt M) {P[p].setTo(M); }
  void pullVertex(pt M) {P[p].translateTowards(0.1,M); }
  void pullVertex(float s, pt M) {P[p].translateTowards(s,M); }
  void delete(int p) { for (int i=p; i<vn-1; i++) {P[i].setTo(P[next(i)]); s[i]=s[next(i)]; g[i]=g[next(i)];} vn--;}
  void delete() { for (int i=p; i<vn-1; i++) P[i].setTo(P[next(i)]); vn--; p=prev(p);}
  void grabInsert(pt M ) {                // grabs closeest vertex or adds vertex at closest edge. It will be dragged by te mouse
      p=0; for (int i=1; i<vn; i++) if (M.disTo(P[i])<M.disTo(P[p])) p=i; 
     int e=-1;
     float d = M.disTo(P[p]);
     for (int i=0; i<vn; i++) 
        if ( (0.25<M.ratioOfProjectionBetween(P[i],P[next(i)])) && (M.ratioOfProjectionBetween(P[i],P[next(i)])<0.75) && (M.disToLine(P[i],P[next(i)])<d))
          {e=i; d=M.disToLine(P[e],P[next(e)]);};
      if (e!=-1) { for (int i=vn-1; i>e; i--) P[i+1].setTo(P[i]); vn++; p=next(e); P[p].setTo(mouseX,mouseY);  };
      }
   void frame() {
     float sx=height; 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*height/5/m+height/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].translateTowards(s, new pt(mouseX,mouseY));};   
  void scaleBy(float s) {for (int i=0; i<vn; i++) P[i].setTo(L(P[i],s,P[p]));};   
  void scaleByC(float s) {for (int i=0; i<vn; i++) P[i].setTo(L(P[i],s,screenCenter()));};   
  void translateBy(vec V) {for (int i=0; i<vn; i++) P[i].translateBy(V); };   
  void rotateBy(float aa) {for (int i=0; i<vn; i++) P[i].rotateBy(aa,P[p]);}; 
  void rotateBy(float aa, pt Q) {for (int i=0; i<vn; i++) P[i].rotateBy(aa,Q);}; 
  void move(pt A, vec V) {
     vec U = V(screenCenter(),A); float d = U.norm(); 
     if (d<5) translateBy(V);
     else {
        U.normalize(); 
        vec W = U.makeScaledBy(dot(U,V));  translateBy(W); 
        pt C = screenCenter().makeTranslatedBy(-sq(height/8)/d,U); stroke(cyan); C.show(3);
        float aa = angle(C.makeVecTo(A).makeOffsetVec(V),C.makeVecTo(A)); rotateBy(aa,C);
       };
     }
  void align() {for (int i=0; i<vn; i++) {
    if ( abs(P[next(i)].x-P[i].x)>abs(P[next(i)].y-P[i].y)) {float dy=(P[next(i)].y-P[i].y)/2; P[next(i)].y-=dy; P[i].y+=dy;}
    else {float dx=(P[next(i)].x-P[i].x)/2; P[next(i)].x-=dx; P[i].x+=dx;};   }; } 
  void localSmooth() {vroi+=1; for(int i=0;i<10;i++) {pickClosestVertex(Mouse()); smoothenHere();}; }
  void localPullOld() {vroi+=1;
      for(int i=0;i<10;i++) {pickClosestVertex(Mouse()); smoothenHere2();}; 
      for(int i=0;i<20;i++) {smoothenHere2(); pickClosestVertex(Mouse()); pullVertex(0.5,Mouse()); };  
//      for(int i=0;i<10;i++) {pickClosestVertex(Mouse()); smoothenHere2();}; 
      }                  
  void localPull() {pickClosestVertex(Mouse()); dragVertex(MouseDrag()); }                  
   
// INDICES ************************************************************************************
  int next(int j) {  if (j==vn-1) {return (0);}  else {return(j+1);}  };  // next vertex in loop
  int prev(int j) {  if (j==0) {return (vn-1);}  else {return(j-1);}  };  // previous vertex in loop                                                     

// ARCHIVAL ON FILE ************************************************************************************
 void savePts(String fn) { 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(fn,inppts);  
    };
 void loadPts(String fn) { String [] ss = loadStrings(fn);
    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()))); }; 
    };

 void saveMarks(String fn) { String [] inppts = new String [3]; for (int i=0; i<3; i++) inppts[i]=str(m[i]);  saveStrings(fn,inppts);  };
 void loadMarks(String fn) { String [] ss = loadStrings(fn); for (int i=0; i<3; i++) m[i]=int(ss[i]); };

// BLEND WITH OTHER POLYLOOPS ****************************************************************************************************************** #############
  void setTo(POLY Q) {vn=Q.vn; for (int i=0; i<vn; i++) P[i].setTo(Q.P[i]); for (int i=0; i<3; i++) m[i]=Q.m[i]; };
  void blendTowards(POLY Q, float s)  {for (int i=0; i<min(vn,Q.vn); i++) P[i].translateTowards(s,Q.P[i]);  };
  void blendByDifference(POLY Q, POLY R, float s)  {for (int i=0; i<min(vn,Q.vn); i++) P[i].translateBy(s,V(Q.P[i],R.P[i]));  };
  void nudgeTowards(POLY Q, float s)  {  // moves by fraction s towards Q with a ramp up and down close to the ends of Q 
     int b = closestVertex(Q.first());
     int e = closestVertex(Q.last());
     if (b>e) {int t=b; b=e; e=t; Q.resample(e-b+1); int j=e-b; for (int i=b; i<=e; i++) P[i].translateTowards(taper(s,i-b,e-b),Q.P[j--]);  }       
     else {Q.resample(e-b+1); int j=0; for (int i=b; i<=e; i++) P[i].translateTowards(taper(s,i-b,e-b),Q.P[j++]); };
     for (int i=1; i<100; i++) smoothen(b,e); 
     };

// COMPATIBLE *****************************************************************************************************************************  
 POLY compatibleO(POLY Q) {  if(vn==0) return this; 
    POLY R= P(this);
    //    print("C: vn="+vn); writeMarks();  print("R: vn="+R.vn); R.writeMarks();
    if(Q.m[0]>R.m[0]) R.resample(Q.m[0]+1,0,R.m[0]); 
    if(Q.m[1]-Q.m[0]>R.m[1]-R.m[0]) R.resample(Q.m[1]-Q.m[0]+1,R.m[0],R.m[1]); 
    if(Q.m[2]-Q.m[1]>R.m[2]-R.m[1]) R.resample(Q.m[2]-Q.m[1]+1,R.m[1],R.m[2]); 
    if(Q.vn-Q.m[2]>R.vn-R.m[2]) R.resample(Q.vn-Q.m[2]+1,R.m[2],R.vn-1); 
    return R; } 
    
 POLY compatible(POLY Q) {  if(vn==0) return this; 
    POLY R= P(this);
    //    print("C: vn="+vn); writeMarks();  print("R: vn="+R.vn); R.writeMarks();
    R.resample(max(Q.m[0],R.m[0])+1,0,R.m[0]); 
    R.resample(max(Q.m[1]-Q.m[0],R.m[1]-R.m[0])+1,R.m[0],R.m[1]); 
    R.resample(max(Q.m[2]-Q.m[1],R.m[2]-R.m[1])+1,R.m[1],R.m[2]); 
    R.resample(max(Q.vn-Q.m[2],R.vn-R.m[2])+1,R.m[2],R.vn-1); 
    return R; } 
    
// REGULARIZE *********************************************************************************  
   POLY regularized() {  if(vn==0) return this;
     POLY Q= P(this); 
     for (int i=0; i<_filters; i++) Q.smoothen(); 
     for (int i=0; i<_subdivisions; i++)  Q.refine(_gs);  
     Q.resample(_samples);  
     if (threeSegments) Q.resetMarks(); else Q.resetEndMarks();
     return Q; } 
   void prep() {  
     for (int i=0; i<_filters; i++) smoothen(); 
     for (int i=0; i<_subdivisions; i++) refine(_gs); 
     resample(_samples); 
     if (threeSegments) resetMarks(); else resetEndMarks();
     } 

// RESAMPLE ************************************************************************************
  void resample(int nrv) { if(vn==0) println("resample vn="+vn+", nrv="+nrv);  if(vn==0) return;
    float L = length();                            
    pt R[] = new pt[nrv+1];  // temporary array for new samples
    pt Q = new pt(0,0);
    float d = L / (nrv-1);  // desired distance between new samples
    float rd=d;  // remaining distance to next sample
    float cl=0;  // length of remaining portion of current edge
    int nk=1;    // index of the next vertex on the original curve
    int n=0;     // number of already added points
     Q.setTo(P[0]);     // Set Q as first vertex         
     R[n++]=P(Q);       // add Q as first sample and increment counter n
     while (n<nrv-1)  { // keep adding samples to R
       cl=Q.disTo(P[nk]);                                                 
       if (rd<=cl) {Q.translateTowardsBy(rd,P[nk]); R[n++]=P(Q); cl-=rd; rd=d; }  // next sample is along the current edge (or at its end)
              else {rd-=cl; Q.setTo(P[nk++]); };                                 // move past the end-vertex of the current edge
        };
     R[n++]=P(P[vn-1]);                       // last sample is last vertex
   for (int i=0; i<n; i++) P[i].setTo(R[i]); // copy new samples to P
   vn=n;      // reset vertex count                                
   }
   
  void resample4(int nrv) {resample(nrv, m[0], m[2], m[4]); m[0]=nrv-1; m[1]=2*(nrv-1); m[2]=3*(nrv-1); }
  void resample(int nrv, int s, int m, int e) { if(vn==0) println("resample vn="+vn+", nrv="+nrv);  if(vn==0) return;
    pt R[] = new pt[nrv*4];  // temporary array for new samples
    pt Q = new pt(0,0);
    float L;                            
    float d;  // desired distance between new samples
    float rd;  // remaining distance to next sample
    float cl;  // length of remaining portion of current edge
    int nk;    // index of the next vertex on the original curve
    int n=0;     // number of already added points
 
    L=length(0,s); d=L/float(nrv-1); rd=d; cl=0; Q.setTo(P[0]); R[n++]=P(Q); nk=1;      
    while (n<nrv-1) {cl=Q.disTo(P[nk]); if (rd<=cl) {Q.translateTowardsBy(rd,P[nk]); R[n++]=P(Q); cl-=rd; rd=d;} else {rd-=cl; Q.setTo(P[nk++]);};};

    L=length(s,m); d=L/float(nrv-1); rd=d; cl=0; Q.setTo(P[s]); R[n++]=P(Q); nk=s+1;       
    while (n<2*(nrv-1)) {cl=Q.disTo(P[nk]); if (rd<=cl) {Q.translateTowardsBy(rd,P[nk]); R[n++]=P(Q); cl-=rd; rd=d;} else {rd-=cl; Q.setTo(P[nk++]);};};

    L=length(m,e); d=L/float(nrv-1); rd=d; cl=0; Q.setTo(P[m]); R[n++]=P(Q); nk=m+1;      
    while (n<3*(nrv-1)) {cl=Q.disTo(P[nk]); if (rd<=cl) {Q.translateTowardsBy(rd,P[nk]); R[n++]=P(Q); cl-=rd; rd=d;} else {rd-=cl; Q.setTo(P[nk++]);};};

    L=length(e,vn-1); d=L/float(nrv-1); rd=d; cl=0; Q.setTo(P[e]); R[n++]=P(Q); nk=e+1;     
    while (n<4*(nrv-1)) {cl=Q.disTo(P[nk]); if (rd<=cl) {Q.translateTowardsBy(rd,P[nk]); R[n++]=P(Q); cl-=rd; rd=d;} else {rd-=cl; Q.setTo(P[nk++]);};};

    R[n++]=P(P[vn-1]);       
    for (int i=0; i<n; i++) P[i].setTo(R[i]); // copy new samples to P
    vn=n;      // reset vertex count                                
    }
   
 void resample(int ns, int s, int e) { if(vn==0) return;
  //  println("resample ns="+ns+", s="+s+", e="+e);
    pt R[] = new pt[ns+vn];  // temporary array for new samples
    pt Q = P((P[s]));
    float L=length(s,e); // length of section to be resampled                            
    float d=L/float(ns-1);  // desired distance between new samples
    float rd=d;  // remaining distance to next sample
    float cl=0;  // length of remaining portion of current edge
    int nk=s+1;    // index of the next vertex on the original curve
    int n=0;     // number of already added points
    for (int i=0; i<=s; i++) R[n++]=P((P[i])); // copy first part of old samples from P
     while (n<s+ns-1) {cl=Q.disTo(P[nk]); if (rd<=cl) {Q.translateTowardsBy(rd,P[nk]); R[n++]=P(Q); cl-=rd; rd=d;} else {rd-=cl; Q.setTo(P[nk++]);};};
    for (int i=e; i<vn; i++) R[n++]=P(P[i]);  // copy third part of old samples from P
    for (int i=0; i<n; i++) P[i].setTo(R[i]); // copy new samples to P
    vn=n;      // reset vertex count  
    for (int i=0; i<3; i++) {if(m[i]>=e) m[i]+=ns-e+s-1; else if(m[i]>=s) m[i]=s+int(float(ns)*float(m[i]-s)/float(e-s)); };    
    }
    
//  COARSEN REFINE ************************************************************************************
  void refine() {
      for (int i=vn-1; 0<=i; i--) P[2*i].setTo(P[i]);  
      vn=2*vn-1; 
      for (int i=1; i<vn-1; i+=2) P[i].setTo(A(P[i-1],P[i+1])); 
      scaleMarks(2);
      } 
      
  void coarsen() {
      vn=(vn+1)/2; 
      for (int i=0; i<vn; i++) P[i].setTo(P[2*i]); 
      scaleMarks(0.5);
      } 
   
 // SUBDIVISION ************************************************************************************
 void refine(float s) { 
     addEnds();
     pt[] Q = new pt [2*vn];     
     int j=0; for (int i=1; i<vn-2; i++) { Q[j++]= B(P[prev(i)],P[i],P[next(i)],s); Q[j++]=F(P[prev(i)],P[i],P[next(i)],P[next(next(i))],s); };
      int k=vn-2; Q[j++]=B(P[prev(k)],P[k],P[next(k)],s);
      vn=j; 
      for (int i=0; i<vn; i++) P[i].setTo(Q[i]);
      chopEnds();
     }

 void refineProportional() { 
   addEnds();
   pt[] Q = new pt [2*vn];     // new control points
   int j=0;
   for (int i=1; i<vn-2; i++) {Q[j++]=P(P[i]); Q[j++]=prop(P[prev(i)],P[i],P[next(i)],P[next(next(i))]); }
   Q[j++]=P(P[vn-2]);
   vn=j; 
   for (int i=0; i<vn; i++) P[i].setTo(Q[i]);
   chopEnds();
   scaleMarks(2);
  }
                                             
 // RETROFITTING ************************************************************************************
 void setAsLimitOf (POLY R, float s) {vn=R.vn; for (int i=0; i<vn; i++) P[i].setTo(limit(R.p(prev(prev(i))),R.p(prev(i)),R.p(i),R.p(next(i)),R.p(next(next(i))),s,_rec));}
 void retrofit(POLY C, POLY S) { for (int i=0; i<vn; i++) P[i].translateBy(S.p(i).makeVecTo(C.p(i))); };

// SMOOTHING ************************************************************************************
 vec[] L = new vec [cap];     // adjustment vectors for smoothing
 void computeL2x() {for (int i=2; i<vn-2; i++) L[i]=P[i].makeVecTo(A(P[prev(i)],P[next(i)]).makeTranslatedBy( bulgeVec(P[prev(prev(i))],P[prev(i)],P[next(i)],P[next(next(i))]) ) );};
 void computeL2() {for (int i=0; i<vn; i++) L[i]=vecToCubic(P[prev(prev(i))],P[prev(i)],P[i],P[next(i)],P[next(next(i))]);};
 void computeL() {for (int i=0; i<vn; i++) L[i]=P[i].makeVecTo(A(P[prev(i)],P[next(i)]) ).makeScaledBy(0.5);};
 void applyL() {for (int i=0; i<vn; i++) P[i].translateBy(0.1,L[i]);};
 void applyLhere(float roi) {for (int i=0; i<vn; i++) if (P[i].disToMouse()<roi) P[i].translateBy(0.5,L[i]);};
 void applyLaround(float roi) {for (int i=0; i<vn; i++) if ((i!=p)&&(P[i].disToMouse()<roi)) P[i].translateBy(0.5,L[i]);};
 void applyLaround(float roi, pt M) {for (int i=0; i<vn; i++) if ((i!=p)&&(d(P[i],M)<roi)) P[i].translateBy(max(0,(roi-d(P[i],M))/roi),L[i]);};
 void showL() {for (int i=0; i<vn; i++) L[i].showAt(P[i]); }; 
 void perturb(float e) {for (int i=0; i<vn; i++) { P[i].x+=random(e); P[i].y+=random(e); } ; }
 void smoothen() {addEnds(); computeL2(); applyL(); chopEnds();}
 void smoothenHere() {addEnds(); computeL(); applyLaround(vroi); chopEnds();}
 void smoothenHere2() {addEnds(); computeL2(); applyLaround(vroi); chopEnds();}

 void smoothen(int b, int e) {addEnds(); computeL2(b,e); applyL(b,e); chopEnds();}
 void computeL2(int b, int e) {for (int i=b; i<e; i++) L[i]=vecToCubic(P[prev(prev(i))],P[prev(i)],P[i],P[next(i)],P[next(next(i))]);};
 void applyL(int b, int e) {for (int i=b; i<e; i++) P[i].translateBy(0.5,L[i]);};

// SELF TRIM ************************************************************************************
  boolean[] g = new boolean [cap];     // good edge follows this vertex
  boolean[] w = new boolean [cap];     //  edge was visited
  int[] s = new int [cap];            // same vertex as 

 void clean () {allGood(); insertCrossings(); setGood(); markBadVertices(); removeBadVertices(); extendSilhouettes(); } 
 void allGood()  {for (int i=0; i<vn; i++) {g[i]=true; s[i]=-1;}; }
 void insertCrossings() {for (int i=0; i<vn-4; i++) {for (int j=i+2; j<vn-1; j++) 
     if ((i!=next(j))&&(s[i]!=j)&&(s[next(i)]!=j)&&(s[i]!=next(j))&&(s[next(i)]!=next(j))&&edgesIntersect(P[i],P[next(i)],P[j],P[next(j)],0.01)) {
        pt X=linesIntersection(P[i],P[next(i)],P[j],P[next(j)]);  insert(X,j); insert(X,i);  s[i+1]=j+2;   s[j+2]=i+1;      }; };  }
 void insert(pt M, int e) {for (int i=vn-1; i>e; i--) {P[i+1].setTo(P[i]); g[i+1]=g[i]; s[i+1]=s[i]; }; 
   vn++; p=next(e); P[p].setTo(M); g[p]=g[e]; s[p]=-1;  for (int i=0; i<vn; i++) if(s[i]>e) s[i]++;  }
 void setGood() { boolean p=true; for (int i=0; i<vn-1; i++) { if(s[i]!=-1) p=!p; g[i]=p; }; }
 void drawGoodCurve() { for (int i=0; i<vn-1; i++) if(g[i]) P[i].showSegmentTo(P[next(i)]); }
 void markBadVertices() {for (int i=0; i<vn; i++) s[i]=0; for (int i=2; i<vn-2; i++) if(g[i]) s[i]=1; s[vn-3]=1;} 
 void removeBadVertices() { for (int i=0; i<vn-1; i++) if(s[i]==0) {delete(i); i--;}; } 
 void drawLoops() { for (int i=0; i<vn; i++) w[i]=false;  for (int i=0; i<vn; i++) if(g[i]&&!w[i]) {drawLoop(i); } ;}
 void drawLoop(int i) {int j=i;  P[j].showSegmentTo(P[next(j)]); w[j]=true;
    for(int t=0; t<1000; t++) { j=next(j); if(!g[j]) j=s[j]; P[j].showSegmentTo(P[next(j)]); w[j]=true; if(j==i) return; }; }

//******************* SILHOUETTES ***********************************************************************************
 void extendSilhouettes() {}  // ?????????????????????????????
    
// MORPH ************************************************************************************
 void reverse() {for (int i=0; i<int(vn/2); i++) {pt T; T=P[i]; P[i]=P[vn-1-i]; P[vn-1-i]=T;};}
 POLY makeRelative(EDGE E) {POLY Q=new POLY(); for (int i=0; i<vn; i++) Q.P[i]=E.grab(P[i]); Q.vn=vn; Q.copyMarks(this); return Q;}
 POLY makeAbsolute(EDGE E) {POLY Q=new POLY(); for (int i=0; i<vn; i++) Q.P[i]=E.put(P[i]); Q.vn=vn; Q.copyMarks(this); return Q;}
 EDGE edgeWithEnds() {return E(P[0],P[vn-1]); }
 EDGE edge() {return E(P[m[0]],P[m[2]]); }

// ENDS    ************************************************************************************ 
  void chopEnds() {vn-=4;  for (int i=0; i<vn; i++) { P[i].setTo(P[i+2]);};  } 
  void addEnds() {for (int i=vn-1; 0<=i; i--) P[i+2].setTo(P[i]); vn+=4;  adjustEnds(); }   
  void adjustEnds() {
    pt P0= End0(P[2],P[next(2)],P[next(next(2))]);
    pt P1= End1(P[2],P[next(2)],P[next(next(2))]);
    pt Pn= End1(P[vn-3],P[prev(vn-3)],P[prev(prev(vn-3))]);
    pt Pnn=End0(P[vn-3],P[prev(vn-3)],P[prev(prev(vn-3))]);
    P[0].setTo(P0); P[1].setTo(P1);   P[vn-2].setTo(Pn); P[vn-1].setTo(Pnn); 
     }

 } // end polyloop class ************************************************************************************ !!!!!!!!!!!!! END

pt   End1(pt P0, pt P1, pt P2) { return L(P1,2,P0); }
pt   End0(pt P0, pt P1, pt P2) { return T(L(P1,2,P0),V(P2,P1)); }