// ----------------------------------
// for sorting paths
class Path {
  int num;
  boolean flipped;

  Path(int _num, boolean _flipped) {
    num=_num;
    _flipped=flipped;
  }
}

// buffer for upcoming moves
class PathBuffer {
  ArrayList paths;
  
  PathBuffer() {
    paths= new ArrayList();
  }

  void addPoint(float x, float y) {
    paths.add(new PVector(x, y));
  }

  void removeFront() {
    paths.remove(0);
  }

  float getFrontX() {
    PVector front=(PVector) paths.get(0);
    return front.x;
  }

  float getFrontY() {
    PVector front=(PVector) paths.get(0);
    return front.y;
  }

  void draw() {
    draw(0, paths.size());
  }
  
  void draw(int start, int stop) {
    int pathlen = paths.size();
    int end=min(pathlen-1, stop);
    strokeWeight(1);
    stroke(192, 0, 0, 128);
    for (int i=start; i<end; i++) {
      PVector p1 = (PVector) paths.get(i);
      PVector p2 = (PVector) paths.get(i+1);

      line(p1.x*onScreenScale, p1.y*onScreenScale, p2.x*onScreenScale, p2.y*onScreenScale);
    }
  }
  
  
  int getLength() {
    return paths.size();
  }
}

// SVG and Path Planning Code

//void readSVGFile(String filename) {
////  if (printToConsole)println("initializing geomerative library...");
////
////  RG.init(this);
////  RG.ignoreStyles(true);
////
////  //RG.setPolygonizer(RG.ADAPTATIVE);
////  RG.setPolygonizer(RG.UNIFORMLENGTH);
////  //RCommand.setSegmentLength(1.25*PPI);
////  RCommand.setSegmentLength(0.125*PPI);
////  //grp = RG.loadShape("treemesh.svg");
////  //grp = RG.loadShape("exploded_pocket_knife_simplified.svg");
////  //grp = RG.loadShape("/Users/rtwomey/Documents/exploded_pocket_knife.svg");
////  //grp = RG.loadShape("/Users/rtwomey/Documents/eye nerves outline.svg");
////  //grp = RG.loadShape("/Users/rtwomey/Documents/sign of the snake.svg");
////  grp = RG.loadShape(filename);
////  //grp = RG.loadShape("cal39.svg");
////  //grp = RG.loadShape("/Users/rtwomey/Documents/blood_storage_container_and_methods_fig3.svg");
////  //grp = RG.loadShape("slit lamp diagram.svg");
////  //grp = RG.loadShape("/Users/rtwomey/Documents/rocking_horse.svg");
////  //grp = RG.loadShape("/Users/rtwomey/Documents/schechner_the_fan.svg");
////  //grp = RG.loadShape("/Users/rtwomey/Documents/bedroom_laurel_hatched_simplified.svg");
////  //grp = RG.loadShape("/Users/rtwomey/Documents/svgs/threshold_20_blur_hatch.svg");
////  //grp = RG.loadShape("/Users/rtwomey/Documents/ankle_brace.svg");
////  //grp = RG.loadShape("box.svg");
////
////  grp.centerIn(g, 0, 0, 0);
////  grpW = grp.getWidth();
////  grpH = grp.getHeight();
////  grpX = grp.getX();
////  grpY = grp.getY();
////
////  if (printToConsole) {
////    print("width X height: "+grpW+" "+grpH);
////    println(" (inches "+(grpW/PPI)+" "+(grpH/PPI)+")");
////    println("on screen scale: "+onScreenScale);
////    println("grpX,Y "+grpX+" "+grpY);
////  }
////
////  pointPaths = grp.getPointsInPaths();
////
////  if (printToConsole) println("image has "+pointPaths.length+" paths");
////  paths = new Path[pointPaths.length];
////
////  for (int i=0;i<pointPaths.length; i++)
////    paths[i]=new Path(i, false);
////
////  // nearest neighbor sort
////  sortPointPaths();
////
////  drawSortedPointPaths();
////
////  if (printToConsole) println("done reading SVG data.");
//}
//
//// ---------------------------------------------------- //
//// sorting pointpaths by nearest neighbor
////
//
//void sortPointPaths() {
//  if (printToConsole) {
//    print("sorting pointpaths by nearest begin-end points, starting in upper left. ");
//    println("("+pointPaths.length+" paths)");
//  }
//
//  boolean [] pathUsed = new boolean[pointPaths.length];
//  for (i=0; i<pointPaths.length; i++)
//    pathUsed[i]=false;
//
//  boolean done=false;
//  boolean flipped=false;
//  int i=0;
//  int count=0;
//  while (!done) {
//    paths[count].num=i;
//    paths[count].flipped=flipped;
//    //  paths[count].num = new Path(i, flipped);
//    //if(flipped) println("FLIPPED!");
//    RPoint finish;
//    //    RPoint start;
//
//    int pathlen=pointPaths[i].length;
//    if (flipped) {
//      finish=pointPaths[i][0];
//      //start=pointPaths[i][pathlen-1];
//    } 
//    else {
//      ///start=pointPaths[i][0];
//      finish=pointPaths[i][pathlen-1];
//    }
//
//    //    print(i+": start "+start.x+", "+start.y);
//    //    println("  finish "+finish.x+", "+finish.y+" "+pathlen+" points.");
//
//    pathUsed[i]=true;
//
//    float testdist = 999999;
//    boolean testflipped=false;   
//    int testindex=-1;
//
//    for (j=0; j<pointPaths.length; j++) {
//      if (!pathUsed[j] && pointPaths[j]!=null) {
//        RPoint testStart, testFinish;
//        testStart = pointPaths[j][0];
//        testFinish = pointPaths[j][pointPaths[j].length-1];      
//        float distFS=dist(finish.x, finish.y, testStart.x, testStart.y);
//        float distFF=dist(finish.x, finish.y, testFinish.x, testFinish.y);
//
//        if (distFS < testdist) {
//          testdist=distFS;
//          testflipped=false;
//          testindex=j;
//        }
//
//        if (distFF < testdist) {
//          testdist=distFF;
//          testflipped=true;
//          testindex=j;
//        }
//      }
//    }
//
//    if (testindex > 0) {
//      pathUsed[testindex]=true;
//
//      i=testindex;
//      flipped=testflipped;
//
//      count++;
//      if (count>=pointPaths.length)
//        done=true;
//    } 
//    else {
//      done=true;
//    }
//  }
//  if (printToConsole) println("done sorting.");
//}
//
//
//// display the sorted plotting path on screen
//
//void drawSortedPointPaths() {
//  float xstart, ystart, xend, yend;
//  float lastx=0, lasty=0;
//
//  for (int i=0; i<paths.length-1; i++) {
//    int pathlen = pointPaths[paths[i].num].length;
//    RPoint first, last;
//    first=pointPaths[paths[i].num][0];
//    last=pointPaths[paths[i].num][pathlen-1];
//
//    if (paths[i].flipped) {
//      xstart=last.x;
//      ystart=last.y;
//      xend=first.x;
//      yend=first.y;
//      //      println("FLIPPED!");
//    } 
//    else {
//      xstart=first.x;
//      ystart=first.y;
//      xend=last.x;
//      yend=last.y;
//    }
//    noStroke();
//    //fill(255, 0, 0, 128);
//    //ellipse(xstart*onScreenScale, ystart*onScreenScale, 5, 5);
//    //text(i, xstart*onScreenScale+5, ystart*onScreenScale+5);
//
//    //fill(128, 0, 0, 128);
//    //ellipse(xend*onScreenScale, yend*onScreenScale, 5, 5);
//
//    strokeWeight(2);
//    stroke(128, 128, 128, 64);
//    line(xstart*onScreenScale, ystart*onScreenScale, xend*onScreenScale, yend*onScreenScale);
//
//    stroke(0, 64, 0, 64);
//    line(xstart*onScreenScale, ystart*onScreenScale, lastx, lasty);
//    lastx=xend*onScreenScale;
//    lasty=yend*onScreenScale;
//
//    for (int j=0; j<pathlen-1; j++) {
//      stroke(0, 0, 64, 64);
//      line(pointPaths[paths[i].num][j].x*onScreenScale, pointPaths[paths[i].num][j].y*onScreenScale, 
//      pointPaths[paths[i].num][j+1].x*onScreenScale, pointPaths[paths[i].num][j+1].y*onScreenScale);
//    }
//  }
//}
//
void drawScaledSegment(float x1, float y1, float x2, float y2) {
  stroke(0, 192);
  line(x1*onScreenScale, y1*onScreenScale, x2*onScreenScale, y2*onScreenScale);
};

void drawCrossHairs(float x, float y) {
  float px, py;
  px=x*onScreenScale;
  py=y*onScreenScale;
  //  stroke(128, 0, 0, 128);
  //  line(px-3, py, px+3, py);
  //  line(px, py-3, px, py+3);

  stroke(192, 0, 0, 128);
  line(px-1, py, px+1, py);
  line(px, py-1, px, py+1);
};
//
//int findClosestPath(float testx, float testy) {
//  int closest=-1;
//  float mindist=999999;
//  for (int i=0; i<pointPaths.length; i++) {
//    float testdist=dist(testx, testy, pointPaths[i][0].x, pointPaths[i][0].y);
//
//    if (testdist<mindist) {
//      mindist=testdist;
//      closest=i;
//    }
//  }
//  return closest;
//}