//*****************************************************************************
// Polyloop editor + smoothing + subdivision + uniform sampling, Jarek Rossignac, August 2006
//*****************************************************************************
int vn =6;                     // number of control vertices
int xvn, svn=vn;              // number of new vertices
int cap=256;                   // size of control vetices arrays
int scap=cap*2*2*2*2*2*2;        // size of computed vertices array
pt[] P = new pt [cap];         // vertices of the control polyloop
pt[] C = new pt [scap];        // verticves of the computed polyloop
vec[] CL = new vec [scap];     // laplace vectors for the computed vertices

float tuck=0.5, untuck=1.0, tuckChange=0.125;    // fraction of laplace vector for tuck, untuck, and the increment for changing them

int bi=-1;                      // index of selected mouse-vertex, -1 if none selected
pt Mouse = new pt(0,0);         // current mouse position
pt Last = new pt(0,0);          // last point drawn
                                
color soft = color(250, 230, 140), red = color(200, 10, 10), blue = color(10, 10, 200), green = color(0, 150, 0); 
color black = color(10, 10, 10), magenta = color(250, 150, 200), brown = color(100, 50, 20), yellow = color(250, 250, 20); 
boolean dots = true, numbers = false, laplace=false;           // toggles display of dots and numbers
boolean saveNew = false;         // toggles between saving control polygon or new polygon 
boolean samples = false;     // true to show samples as dots
boolean move = false;     // true when animation
int ai=0;                  // index of moving dot


void setup() {   size(600, 600);  // initialization
  PFont font = loadFont("Courier-14.vlw"); textFont(font, 12);
  for (int i=0; i<cap; i++) {P[i]=new pt(0,0);};
  for (int i=0; i<scap; i++) {C[i]=new pt(0,0); CL[i]=new vec(0,0); };
  for (int i=0; i<vn; i++) {P[i].setFromValues(-sin((i+0.5)*TWO_PI/vn)*(width*0.45)+width/2.0,cos((i+0.5)*TWO_PI/vn)*(height*0.45)+height/2.0);};
  copyPts();
  }; 
 
void draw() { background(255); 
  if (bi!= -1) {P[bi].setFromMouse();};    // snap selected vertex to mouse position during dragging
  drawControlCurve(); drawNewCurve();  
  if (samples) drawSamples();
  if (move) {ai=sn(ai); fill(black); stroke(black); C[ai].show(9); noFill();};
  };
  
void drawNewCurve() { 
    stroke(red); strokeWeight(2);
    beginShape(POLYGON); for (int i=0; i<svn; i++) {C[i].vert(); };  endShape(); noFill();
    if (laplace) {stroke(blue); for (int i=0; i<svn; i++) {CL[i].show(C[i]);};}; 
    if (dots) {fill(red); stroke(red); for (int i=0; i<svn; i++) {C[i].show(3);}; noFill(); };     
    }; 
       
void drawControlCurve() {       
    stroke(green); strokeWeight(1);
    beginShape(POLYGON); for (int i=0; i<vn; i++) {P[i].vert(); };  endShape(); 
    if (numbers) {fill(10,10,100); for (int i=0; i<vn; i++) {
       vec V = P[ip(i)].vecTo(P[in(i)]); V.unit(); V.left(); V.mul(-15); vec U = new vec(-2,5); V.add(U);
       P[i].label(str(i),V );};};
    for (int i=0; i<vn; i++) {P[i].show(6); pt A = average(P[i],P[in(i)]); A.show(4);}; 
    };  
  
void copyPts () {for (int i=0; i<vn; i++) {C[i].setFromPt(P[i]);}; svn=vn;};
void refine () {for (int i=svn-1; 0<=i; i--) {C[2*i+1].setFromPt(average(C[i],C[sn(i)])); C[2*i].setFromPt(C[i]);   }; svn*=2;  };
void decimate () {for (int i=0; i<svn/2; i++) {C[i].setFromPt(C[2*i+1]); }; svn/=2;  };
void computeLaplace () {for (int i=0; i<svn; i++) {CL[i].setFromVec(C[i].vecToMid( C[sp(i)],C[sn(i)] ));};};
void applyLaplace (float s) {for (int i=0; i<svn; i++) {C[i].addScaledVec(s,CL[i]);};};
void tuck () {computeLaplace(); applyLaplace(tuck); };
void untuck () {computeLaplace(); applyLaplace(-untuck);};
void jarek() {refine(); tuck(); untuck(); };
void update() {copyPts(); for (int i=0; i<4; i++) {jarek();}; };
    
//**************************************
//**** utilities for polyloops
//**************************************
int in(int j) {  if (j==vn-1) {return (0);}  else {return(j+1);}  };  // next vertex in control loop
int ip(int j) {  if (j==0) {return (vn-1);}  else {return(j-1);}  };  // previous vertex in control loop

int sn(int j) {  if (j==svn-1) {return (0);}  else {return(j+1);}  };  // next vertex in current loop
int sp(int j) {  if (j==0) {return (svn-1);}  else {return(j-1);}  };  // previous vertex in current loop

//**************************************
// **** GUI FOR EDITING THE CONTROL CURVE
//**************************************
void mousePressed() {                                                   // to do when mouse is pressed  
  float bd=900;                                                     // init square of smallest distance to selected point
  Mouse.setFromMouse();                                                   // save current mouse location
   for (int i=0; i<vn; i++) { if (d2(i)<bd) {bd=d2(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 (dm(i)<bd) {bd=dm(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].setFromMouse(); vn++;                                  // insert new vertex at mouse position
          println("inserted vertex "+bi);
          }
        else {bi=-1;};                                                 // nothing selected
      };
  }

float d2(int j) {return (Mouse.disTo(P[j]));};                      //  squared distance from mouse to vertex P[j]
float dm(int j) {return (Mouse.disTo(average(P[j],P[in(j)])));};   // squared distance from mouse to mid-edge point

void mouseReleased() {                                      // do this when mouse released
  if ( (bi!=-1) &&  P[bi].isOut() ) {                  // if outside of port
      for (int i=bi; i<vn; i++) {P[i].setFromPt(P[in(i)]);};        // shift up to delete selected vertex
      vn--; 
      println("deleted vertex "+bi);
      };                                           // reduce vertex vn
  bi= -1;   
  };
 

//**********************************
//***      CONTROL WITH KEYS
//**********************************
void keyPressed() {  
  if (key=='0') {untuck=0; println("untuck = "+int(untuck*8)+"/8");}; 
  if (key=='1') {untuck=1*tuckChange; println("untuck = "+int(untuck*8)+"/8");}; 
  if (key=='2') {untuck=2*tuckChange; println("untuck = "+int(untuck*8)+"/8");}; 
  if (key=='3') {untuck=3*tuckChange; println("untuck = "+int(untuck*8)+"/8");}; 
  if (key=='4') {untuck=4*tuckChange; println("untuck = "+int(untuck*8)+"/8");}; 
  if (key=='5') {untuck=5*tuckChange; println("untuck = "+int(untuck*8)+"/8");}; 
  if (key=='6') {untuck=6*tuckChange; println("untuck = "+int(untuck*8)+"/8");}; 
  if (key=='7') {untuck=7*tuckChange; println("untuck = "+int(untuck*8)+"/8");}; 
  if (key=='8') {untuck=8*tuckChange; println("untuck = "+int(untuck*8)+"/8");};
  if (key=='c') {copyPts(); computeLaplace(); };
  if (key=='r') {refine(); computeLaplace();};
  if (key=='d') {decimate(); computeLaplace();};
  if (key=='t') {tuck(); computeLaplace();};
  if (key=='u') {untuck(); computeLaplace();};
  if (key=='f') {tuck(); untuck();};
  if (key=='j') {jarek(); computeLaplace();};
  if (key=='y') {update(); computeLaplace();};
  if (key=='>') {tuck+=tuckChange; println("tuck = "+int(tuck*8)+"/8"); };
  if (key=='<') {tuck-=tuckChange; println("tuck = "+int(tuck*8)+"/8"); };
  if (key=='+') {untuck+=tuckChange; println("untuck = "+int(untuck*8)+"/8"); };
  if (key=='-') {untuck-=tuckChange; println("untuck = "+int(untuck*8)+"/8"); };
  if (key=='p') {dots=!dots;};
  if (key=='P') {laplace=!laplace;};
  if (key=='n') {numbers=!numbers;};
  if (key=='w') {writePts();};
  if (key=='W') {writeNewPts();};
  if (key=='s') {xvn=vn; saveNew=false; savePts(); };
  if (key=='S') {xvn=svn; saveNew=true; savePts(); };
  if (key=='l') {loadPts();};
  if (key=='i') {saveFrame("pix-####.tif");};   
  if (key=='a') {                          // axis aligns the edges
      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;}
         };
     };
  if (key=='h') { 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;};
     };
   if (key=='g') {move=!move; };                            // stops / starts animation
   if (key=='x') {selectSamples(); samples=true;};          // selects a sample at every 16th point
   if (key=='z') {for (int k=0; k<400; k++) pushSamples();};// distributes the samples along the refined curve
   if (key=='q') {samples=false; copySamples();};           // makes new curve from these samples
   if (key=='e') {                                          // uniform resampling (poor man's version)
      for (int k=0; k<4; k++) {jarek(); computeLaplace();};  // refines the curve 4 times
      selectSamples();                                       // selects a sample at every 16th point
      for (int k=0; k<400; k++) pushSamples();               // distributes the samples along the refined curve
      copySamples();                                         // makes new curve from these samples
      };
   if (key=='E') {myUniformSampling();};                    // student's version
      };