// Corner table representation and operations for triangle meshes
// Written by Jarek Rossignac on October 1, 2005, revised on October 5.

int nv = 7;                  // number of  vertices
int nt = 6;                  // umber of tirangles
int maxnv = 100;              // max number of vertices
int maxnt = 200;              // max number of triangles
pt[] G = new pt [maxnv];           // vertices
vec[] D = new vec [maxnv];           // vertex corrction vectors
int [] valence = new int [maxnv];           // vertices valence
boolean [] isBorder = new boolean [maxnv];
corner[] C = new corner [3*maxnt]; // corner table
corner border = new corner(-1,0);      // border identifier
int cc = 0;                  // corner counter
corner c;
    
int bi=-1;                       // index of selected vertex, -1 if none selected
pt Mouse = new pt(0,0);           // current mouse position

color grey = color(200, 200, 210); color red = color(200, 10, 10); color blue = color(10, 10, 200); color lightblue = color(100, 100, 255); 
color green = color(10, 200, 20); color black = color(10, 10, 10); color magenta = color(250, 150, 200); color brown = color(150, 100, 50); 
color banana = color(100, 255, 50); 

void setup() 
{ size(700, 700);  
  for (int i=0; i<maxnv; i++) {G[i]=new pt(0,0); D[i]=new vec(0,0);};
  G[0].setTo(width/2,height/2);
  for (int i=1; i<nv; i++) {G[i].setTo( -sin((i+0.5)*TWO_PI/(nv-1))*(width/4)+width/2 , cos((i+0.5)*TWO_PI/(nv-1))*(width/4)+height/2); };
    for (int i=0; i<maxnt*3-1; i++) {C[i]=new corner(cc++,0); };
  cc=0; 
  C[cc]=new corner(cc++,0);   C[cc]=new corner(cc++,1);   C[cc]=new corner(cc++,2);  
  C[cc]=new corner(cc++,0);   C[cc]=new corner(cc++,2);   C[cc]=new corner(cc++,3);  
  C[cc]=new corner(cc++,0);   C[cc]=new corner(cc++,3);   C[cc]=new corner(cc++,4);  
  C[cc]=new corner(cc++,0);   C[cc]=new corner(cc++,4);   C[cc]=new corner(cc++,5);  
  C[cc]=new corner(cc++,0);   C[cc]=new corner(cc++,5);   C[cc]=new corner(cc++,6);  
  C[cc]=new corner(cc++,0);   C[cc]=new corner(cc++,6);   C[cc]=new corner(cc++,1);  
  c=C[0];
  cacheCorners();
  strokeJoin(ROUND); strokeCap(ROUND);
  PFont font = loadFont("Courier-14.vlw"); textFont(font, 12);
} 
 
void draw() { 
  background(255); //translate(width/2,height/2); // scale(1.0,-1.0); reverses text labels
  if (bi!= -1) {G[bi].setToMouse();};                    // snap selected vertex to mouse position during dragging
  stroke(grey); strokeWeight(1); fill(250,240,120); drawTriangles();
  stroke(red); strokeWeight(2); drawBorders();
  stroke(blue); strokeWeight(1); fill(0,0,100); drawVertices(); labelVertices();
  stroke(red); strokeWeight(1); fill(50,100,0); labelCorners(); c.drawDot();
  stroke(blue); strokeWeight(2); resetDisplacementsAndValence(); addDisplacements(); NormalizeDisplacements(0.5); showDisplacements();
  };
  
void drawVertices() {for (int i=0; i<nv; i++) {G[i].show(6); }; };   
void drawCorners() {for (int i=0; i<3*nt; i++) {C[i].drawDot(); }; };    
void cacheCorners() {
  for (int i=0; i<3*nt; i++) {C[i].cachenpt(); };
  for (int i=0; i<3*nt; i++) {C[i].cacheo(); }; 
  for (int i=0; i<3*nt; i++) {C[i].cacherl(); }; 
  for (int i=0; i<3*nt; i++) {corner c=C[i]; isBorder[c.v]=false; }; 
  for (int i=0; i<3*nt; i++) {corner c=C[i]; if (c.o==border) {isBorder[c.n.v]=true; }; }; 
  };    
void labelCorners() {for (int i=0; i<3*nt; i++) {C[i].label(); };}; 
void labelVertices() {vec D=new vec(3,10); for (int i=0; i<nv; i++) {G[i].label(str(i),D); }; };  
void drawTriangles() {for (int t=0; t<nt; t++) {drawTriangle(t); }; };
void drawTriangle (int t) {beginShape();  G[C[3*t].v].vert(); G[C[3*t+1].v].vert(); G[C[3*t+2].v].vert(); endShape();  }; 
void drawBorders() {for (int i=0; i<3*nt; i++) {if(C[i].o==border) {G[C[i].n.v].showLineTo(G[C[i].p.v]);}; };}; 

//**************************************
// **** CORNER CLASS
//**************************************
class corner { 
    int i;          // index of this corner
    int v;          // index of the vertex of this corner
    int t;          // index of the corner's triangle
    corner n;          // next corner
    corner p;          // previous corner
    corner o;          // opposite corner
    corner l;          // left corner
    corner r;          // right corner
    int m;             // mark
 corner (int pi, int pv) {i=pi; v=pv;};
 void cacherl() {r=p.o; l=n.o; };
 void cachenpt () {t=floor(i/3); if (i==3*t+2) {n=C[i-2];} else {n=C[i+1];}; if (i==3*t) {p=C[i+2];} else {p=C[i-1];}; };
 void cacheo () {o=border; corner b; for (int i=0; i<3*nt; i++) {b=C[i]; if((b.n.v==this.p.v)&&(b.p.v==this.n.v)) {o=b;}; };  };
 void write(){print("corner["+i+"]: "+"t="+t+", p="+p.i+", n="+n.i+", o="+o.i+", vertex "+v+"="); G[v].write(); };
 void drawDot() {if (i!=-1) {pt P= G[v].make();  vec D=P.vecToMid(G[n.v],G[p.v]); P.addScaledVec(0.30,D); P.show(8);};};
 void label() {vec D=G[v].vecToMid(G[n.v],G[p.v]); D.mul(0.2); D.add(new vec(-3,3)); G[v].label(str(i),D);}; 
 };
 
 void saveTriangles() {
  String [] inppts = new String [3*nt+1];
  int s=0;
  inppts[s++]=str(nt);
  for (int i=0; i<nt*3; i++) {println("i="+i); inppts[s++]=str(C[i].v);};
  saveStrings("triangles.v",inppts);
  };

void loadTriangles() {
  String [] ss = loadStrings("triangles.v");
  String subpts;
  int s=0;
  int comma;
  nt = floor(int(ss[s++]));
  for (int i=0; i<nt*3; i++) { C[i].i=i; C[i].v=int(ss[s++]); };
  c=C[0];
  };

//**************************************
// **** GUI FOR EDITING THE CONTROL CURVE
//**************************************
void mousePressed() {                                                   // to do when mouse is pressed  
  float bd=width;                                                     // init square of smallest distance to selected point
  Mouse.setToMouse();                                                   // save current mouse location
  for (int i=0; i<nv; i++) { if (d2(i)<bd) {bd=d2(i); bi=i;  };};       // select closeest vertex
  if (bd>30) { bi=-1;}                                                       // if closest vertex is too far
  };

float d2(int j) {return (Mouse.disTo(G[j]));};   //  squared distance from mouse to vertex P[i]
//float dm(int j) {return (Mouse.vecToMid(G[j],G[in(j)]).norm());};

void mouseReleased() {                                      // do this when mouse released
  bi= -1;   
  };

//**********************************
//***      CONTROL WITH KEYS
//**********************************
void keyPressed() {  
  if (key=='C') { cc=3*nt; nt++;  
                  C[cc]= new corner(cc,c.p.v); 
                  cc++; C[cc]= new corner(cc,c.n.v);
                  cc++; G[nv]=G[c.n.v].make(); 
                  G[nv].addVec(G[c.v].vecTo(G[c.p.v])); 
                  C[cc]=new corner(cc,nv++); C[cc].o=c; c.o=C[cc]; 
                  c=C[cc];
                  cacheCorners();
                   };
  if (key=='L') { cc=3*nt; nt++;  
                  C[cc]= new corner(cc,c.p.v); 
                  cc++; C[cc]= new corner(cc,c.n.v);
                  c = c.p; while (c.o!=border) {c=c.o.p;}; 
                  cc++; C[cc]=new corner(cc,c.n.v);  
                  c=C[cc];
                  cacheCorners();
                   };
  if (key=='R') { cc=3*nt; nt++;  
                  C[cc]= new corner(cc,c.p.v); 
                  cc++; C[cc]= new corner(cc,c.n.v);
                  c = c.n; while (c.o!=border) {c=c.o.n;}; 
                  cc++; C[cc]=new corner(cc,c.p.v);  
                  c=C[cc];
                  cacheCorners();
                   };
  if (key=='g') {loadVertices(); loadTriangles(); cacheCorners();};
  if (key=='s') {saveVertices(); saveTriangles();};
  if (key=='f') { float sx=600.0; float sy=600.0; float bx=0.0; float by=0.0; 
     for (int i=0; i<nv; i++) {if (G[i].x>bx) {bx=G[i].x;}; if (G[i].x<sx) {sx=G[i].x;}; if (G[i].y>by) {by=G[i].y;}; if (G[i].y<sy) {sy=G[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<nv; i++) {G[i].x=(G[i].x-sx+dx)*4*width/5/m+width/10;  G[i].y=(G[i].y-sy+dy)*4*height/5/m+height/10;};
     };
  if (key=='w') {println(3*nt+" corners"); for (int i=0; i<3*nt; i++) {C[i].write();};};
   if (c!=border) {
    if (key=='?') { c.write(); };
    if (key=='n') { c=c.n; };
    if (key=='p') { c=c.p; };
    if (key=='o') { if (c.o!=border) {c=c.o;}; };
    if (key=='l') { if (c.l!=border) {c=c.l;}; };
    if (key=='r') { if (c.r!=border) {c=c.r;}; };
    if (key=='e') { ApplyDisplacements(0.1); };
    };
  };                                                                 

//**************************************
//**** utilities for vertices
//**************************************
void writeVertices() { for (int i=0; i<nv; i++) {G[i].write();};};

void saveVertices() {
  String [] inppts = new String [nv+1];
  int s=0;
  inppts[s++]=str(nv);
  for (int i=0; i<nv; i++) {inppts[s++]=str(G[i].x)+","+str(G[i].y);};
  saveStrings("vertices.g",inppts);
  };

void loadVertices() {
  String [] ss = loadStrings("vertices.g");
  String subpts;
  int s=0;
  int comma;
  nv = int(ss[s]);
  for(int i=0;i<nv; i++) {
      comma=ss[++s].indexOf(',');
      G[i]=new pt (float(ss[s].substring(0, comma)), float(ss[s].substring(comma+1, ss[s].length())));
    };
  };
  
//**************************************
//**** smoothing
//**************************************




  
void   resetDisplacementsAndValence() {for (int i=0; i<nv; i++) {D[i].setTo(0,0); valence[i]=0; }; }; 
  
void   addDisplacements() {for (int i=0; i<3*nt; i++) {corner c; c=C[i]; D[c.v].add(G[c.v].vecTo(G[c.n.v])); D[c.v].add(G[c.v].vecTo(G[c.p.v])); valence[c.v]++;};  };
  
void   NormalizeDisplacements(float s) {for (int i=0; i<nv; i++) {D[i].mul(s/valence[i]);}; };
  
void   showDisplacements() { for (int i=0; i<nv; i++) {if (isBorder[i]==false) {D[i].show(G[i]);};};   };
  
void   ApplyDisplacements(float s) {for (int i=0; i<nv; i++) {if (isBorder[i]==false) {G[i].addScaledVec(s,D[i]);};};
  };