boolean loopIsClosed = true;
int n=4;                        // current number of points
pt [] P = new pt[1000];            // decalres an array of  vertices
int p=0;                         // index to the currently selected vertex being dragged
int next(int j) {  if (j==n-1) {return (0);}  else {return(j+1);}  };  // next point in loop
int prev(int j) {  if (j==0) {return (n-1);}  else {return(j-1);}  };  // previous point in loop                                                     
void declarePoints() {for (int i=0; i<P.length; i++) P[i]=new pt();} // init the vertices to be on a circle
void resetPoints() {for (int i=0; i<n; i++) {P[i]=new pt(width/2,height/7.); P[i].rotateBy(2.*PI*i/n, screenCenter());}; } // init the points to be on a circle
void appendPoint(pt Q)  { P[n++].setTo(Q);  }; // add point at end of list
// ************************************** EDITING *********************************
void clickPolygon() {pickClosestPoint();}
void dragPolygon() {dragPoint(); };
void pickClosestPoint(pt M) {if(mouseIsInWindow()) { p=0; for (int i=1; i<n; i++) if (M.disTo(P[i])<M.disTo(P[p])) p=i; };}
void pickClosestPoint() {pt M = mouse(); p=0; for (int i=1; i<n; i++) if (M.disTo(P[i])<M.disTo(P[p])) p=i;}
void dragPoint() { P[p].moveWithMouse(); P[p].clipToWindow(); }      // moves selected point (index p) by amount mouse moved recently
void dragPoint(vec V) {P[p].translateBy(V);}
void deletePoint() { for (int i=p; i<n-1; i++) P[i].setTo(P[next(i)]); n--; p=prev(p);}
void translatePoints(vec V) {for (int i=0; i<n; i++) P[i].translateBy(V); };   
void scalePoints(float s) {for (int i=0; i<n; i++) P[i].translateTowards(s,screenCenter());};  
// ************************************** VIEWING *********************************
void showPoints() {for (int i=0; i<n; i++) P[i].show();}
void showPoints(int r) {for (int i=0; i<n; i++) P[i].show(r);}
void drawPointIDs() {for (int i=0; i<n; i++) {vec V=P[i].makeVecToAverage(P[prev(i)],P[next(i)]); V.normalize(); V.scaleBy(-10); V.add(-3,5); P[i].showLabel(str(i),V); };}; 
void drawPolygon() {beginShape();  for (int i=0; i<n; i++) P[i].v(); endShape(CLOSE); }    
void drawPolygon(boolean closed) {beginShape();  for (int i=0; i<n; i++) P[i].v(); if(closed) endShape(CLOSE); else endShape();} 
void drawEdge(int i) {if((0<=i)&&(i<n)) P[i].to(P[next(i)]);}
// ************************************** PROCESSING *********************************
float length () {float L=0; 
    if (!loopIsClosed) for (int i=2; i<n-3; i++) L+=P[i].disTo(P[next(i)]); 
    else for (int i=0; i<n; i++) L+=P[i].disTo(P[next(i)]); 
    return(L); }
pt projectionOfPoint(pt M) {
     int v=0; for (int i=1; i<n; i++) if (M.disTo(P[i])<M.disTo(P[v])) v=i; 
     int e=-1;
     float d = M.disTo(P[v]);
     for (int i=0; i<n; 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[v].makeClone());
     }
 float distanceToPoint(pt M) {return(M.disTo(projectionOfPoint(M)));}
 boolean contains(pt M) {boolean isIn=false; for (int i=1; i<n-1; i++) if (M.isInTriangle(P[0],P[i],P[next(i)])) isIn=!isIn; return(isIn); }

void refine(float s) { 
      pt[] Q = new pt [2*n];     
      for (int i=0; i<n; i++) { Q[2*i]= b(P[prev(i)],P[i],P[next(i)],s); Q[2*i+1]=f(P[prev(i)],P[i],P[next(i)],P[next(next(i))],s); };
      n*=2; for (int i=0; i<n; i++) P[i].setTo(Q[i]);
     }
void coarsen() {n/=2; for (int i=0; i<n; i++) P[i].setTo(P[2*i+1]); } 
boolean stabbed(pt A, pt B) {boolean stab=false;  for (int i=0; i<n; i++) if(edgesIntersect(A,B,P[i],P[next(i)])) stab=true; return stab; }
boolean stabbed(pt A, pt B, int j) {boolean stab=false;  for (int i=0; i<n; i++) if ((i!=j)&&(edgesIntersect(A,B,P[i],P[next(i)]))) stab=true; return stab; }
int stabbed(RAY R) {return stabbed(R,-1); }     // returns -1 if no edge stabbed, otherwise return edge number between 0 and n-1 of first edge stabbed
int stabbed(RAY R, int j) {           // returns -1 if no edge stabbed, otherwise return edge number between 0 and n-1 of first edge stabbed (ignoring edge j)
   int e=-1;                         // stabbed edge
   float md=100000;                  // distance to intersection
   for (int i=0; i<n; i++) if(i!=j) if (R.hitsEdge(P[i],P[next(i)])) {float d=R.disToEdge(P[i],P[next(i)]); if (d<md) {md=d; e=i;};};
   return e;  
   }
  // ************************** NOT DEBUGGED *********************
RAY hitSurfelOnEdge(RAY R, int i) {                                            // returns ray with point and normal to hit point on edge (i, next(i))
    RAY surfel = ray(R.at(R.disToEdge(P[i],P[next(i)])),R(V(P[i],P[next(i)])));
   if (dot(surfel.T,R.T)>0) surfel.T.back();
   return surfel;  
   }
 
RAY bounced(RAY I, RAY N) {float d = -dot(N.T,V(N.Q,I.Q))/dot(N.T,I.T); return ray(N.Q,I.T.makeReflectedVec(N.T),I.d-d(I.Q,N.Q)); }

// ************************************** ARCHIVAL *********************************
void savePts() {savePts("P.pts");}
void savePts(String fn) { String [] inppts = new String [n+1];
    int s=0; inppts[s++]=str(n); for (int i=0; i<n; i++) {inppts[s++]=str(P[i].x)+","+str(P[i].y);};
    saveStrings(fn,inppts);  };
void loadPts() {loadPts("P.pts");}
void loadPts(String fn) { String [] ss = loadStrings(fn);
    String subpts;
    int s=0; int comma; n = int(ss[s]);
    for(int i=0;i<n; i++) { comma=ss[++s].indexOf(',');
      P[i]=new pt (float(ss[s].substring(0, comma)), float(ss[s].substring(comma+1, ss[s].length()))); }; };