int count =6;                  // number of control vertices
int cap=128;                    // size of control arrays
pt[] P = new pt [6]; 
int bi=-1;                       
pt Mouse = new pt(0,0);         
color soft = color(200, 200, 210); color red = color(200, 10, 10); color blue = color(10, 10, 200); color green = color(0, 150, 0); 
color black = color(10, 10, 10); color magenta = color(250, 150, 200); color brown = color(100, 50, 20); 
boolean firstTime = true; 
Arc arc1, arc2;

void setup() {  
  size(600, 600);  
  for (int i=0; i<count; i++) {P[i]=new pt(-sin((i+0.5)*TWO_PI/count)*(250)+300,cos((i+0.5)*TWO_PI/count)*(250)+300);};
  strokeJoin(ROUND); strokeCap(ROUND);
  PFont font = loadFont("Courier-14.vlw"); textFont(font, 12);
  P[0] = new pt(500, 400);   P[1] = new pt(300, 200);  P[2] = new pt(100, 400);
  P[3] = new pt(100, 100);   P[4] = new pt(200, 400);   P[5] = new pt(500, 500); /**/
  arc1 = new Arc(P[0],P[2],0.5);
  arc2 = new Arc(P[3],P[5],0.5);
  };

float computea(pt A, pt B, pt C) {vec V=A.vecToMid(A,C); float n = V.norm(); vec N=V.make(); N.left(); float aa=dot(N,A.vecTo(B))/sq(n); return(aa); };

void draw() { background(255); 
  if (bi!= -1) {P[bi].setToMouse();};                    // snap selected vertex to mouse position during dragging
  adjust(P[0],P[1],P[2]);  adjust(P[3],P[4],P[5]);
  stroke(black); strokeWeight(1); for(int i=0; i<6; i++) {P[i].show(5);};
  stroke(220); strokeWeight(1); drawArc(P[0],P[1],P[2],0); drawArc(P[3],P[4],P[5],0);
  strokeWeight(2); 
  stroke(green); drawArc(P[0],P[1],P[2],5);
  stroke(red);  drawBezier(P[3],P[4],P[5]);
  if (firstTime) {    }; firstTime=false;
  };
  
void adjust(pt A, pt B, pt C) {
  float e = 0.5-dot(A.vecTo(B),A.vecTo(C))/dot(A.vecTo(C),A.vecTo(C));
  B.addScaledVec(e,A.vecTo(C));
  };
  
//**************************************************************************************************************************
//*** interesting extension of circualr arc subdivision to more general cases where the control triangle is not isosceles
//**************************************************************************************************************************
 void drawArc(pt A, pt B, pt C, int rec) {
   if (rec==0) { B.showLineTo(A); B.showLineTo(C); } 
   else { 
     float w = (A.vecTo(B).norm()+C.vecTo(B).norm())/2;
     float l = A.vecTo(C).norm()/2;
     float t = l/(w+l);
     pt L = A.make(); L.addScaledVec(t,A.vecTo(B)); 
     pt R = C.make(); R.addScaledVec(t,C.vecTo(B)); 
     pt M = midPt(L,R);
     drawArc(A,L, M,rec-1); drawArc(M,R, C,rec-1); 
     };
   };

//**************************************************************************************************************************
//*** draws arc as rational bezier quadratic 
//**************************************************************************************************************************
 void drawBezier(pt A, pt B, pt C) {
   float l=A.vecTo(C).norm()/2.0;
   float w=A.vecTo(B).norm();
   float h=midVec( A.vecTo(B) , C.vecTo(B) ).norm();
   float d = l*sqrt( (w-l) / (w+l) )/h;
   float a=1,c=1; 
   float b=d/(1.0-d);
   float den=1;
   pt lastP = A.make();
   for( float t=0; t<=1; t+=0.02 ) {
     pt PA = A.make(); PA.mul(a*sq(1-t));
     pt PB = B.make(); PB.mul(2*b*t*(1-t));
     pt PC = C.make(); PC.mul(c*sq(t));
     den=a*sq(1-t)+2*b*t*(1-t)+c*sq(t);
     pt P = add3divide(PA,PB,PC,den);
     lastP.showLineTo(P);
     lastP.setTo(P);
     }; 
   };

//**************************************
// **** circular arcs 
//**************************************
class Arc { pt S, E; float a; pt M;
  Arc (pt PS, pt PE, float pa)  {S = PS; E = PE; a = pa; this.setM();  };
  void setTo (pt PS, pt PE, float pa)  {S = PS; E = PE; a = pa; this.setM(); };
  void showHat() { M.showLineTo(S); M.showLineTo(E); }; 
  void showArc(int rec) { if (rec==0) {this.showHat();} else {}; }; 
  void setM() {vec V=S.vecToMid(S,E); float n = V.norm(); vec N=V.make(); N.left(); M = midPt(S,E); M.addScaledVec(a,N); };
  };

       

//**************************************
// **** 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.setToMouse();                                                   // save current mouse location
   for (int i=0; i<count; 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<count; i++) {if (dm(i)<bd) {bd=dm(i); bi=i;};};   // closest mid-edge point
      if (bd<20) {  
          for (int i=count-1; i>bi; i--) {P[i+1].setTo(P[i]);};                // shift down the rest 
          bi++;  P[bi].setTo(Mouse); count++;                                  // insert new vertex at mouse position
          }
        else {bi=-1;};                                                 // nothing selected
      };
  }

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

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

//**********************************
//***      CONTROL WITH KEYS
//**********************************
void keyPressed() {  
  if (key=='f') {firstTime=!firstTime;};
  if (key=='w') {writePts();};
     };                                                                 

//**************************************
//**** utilities for polyloops
//**************************************
int in(int j) {  if (j==count-1) {return (0);}  else {return(j+1);}  };  // next vertex in control loop
int ip(int j) {  if (j==0) {return (count-1);}  else {return(j-1);}  };  // next vertex in control loop

void writePts() { for (int i=0; i<count; i++) {P[i].write();};};