import java.util.*;

PImage img;
float scale=4;

double temp=100;
double cooling=0.99999;
int coolCount=2000;

float[][] outp;
void setup() {
  size(1000, 1000);
  selectInput("Select a file to process:", "fileSelected");
  background(0);
};

void draw() {
  background(0);
  if (pf!=null) {
    pf.improvePath();
    pf.drawPath();
    //image(img, 0, 0);
  }
};

float[][] diff1={{0, 1}, {1, 0}};
float[][] diff2={{0, 0, 7}, {3, 5, 1}};

Pathfinder pf;
float zf=1;
void keyPressed() {
  background(0);
  if (key=='f') {
    ditherErrDiff(img, outp, diff2);
    pf=new Pathfinder(outp);
  }
  if (key=='i') {
    //pf.improvePath();
  }
  if (keyCode==UP) {
    zf*=1.1;
  }
  if (keyCode==DOWN) {
    zf/=1.1;
  }
  stroke(color(255));
  strokeWeight(1);
  //pf.drawPoints();
  pf.drawPath();
};

void ditherErrDiff(PImage src, float[][] aim, float[][]diffmask) {
  if (aim!=null) {
    for (int i =0; i<aim.length; i++) {
      for (int j=0; j<aim[i].length; j++) {
        aim[i][j]=0;
        //println(aim[i][j]);
      }
    }
    float maskSum=0;
    float[][] maskNorm=new float[diffmask.length][diffmask[0].length];
    for (int i =0; i<diffmask.length; i++) {
      for (int j=0; j<diffmask[i].length; j++) {
        maskSum+=diffmask[i][j];
      }
    }
    for (int i =0; i<diffmask.length; i++) {
      for (int j=0; j<diffmask[i].length; j++) {
        maskNorm[i][j]=diffmask[i][j]/maskSum;
      }
    }
    src.loadPixels();
    loadPixels();
    for (int i =0; i<aim.length; i++) {
      for (int j=0; j<aim[i].length; j++) {
        float val=brightness(src.pixels[j*src.width+i])+aim[i][j];
        //println(val,aim[i][j]);
        aim[i][j]=val>128?255:0;
        float err=val-aim[i][j];

        //println(i,j,err);
        /*try {
         pixels[j*width+i]=color(aim[i][j]);
         }
         catch(ArrayIndexOutOfBoundsException e) {
         }*/
        for (int k =0; k<maskNorm.length&&i+k<aim.length; k++) {
          for (int l=0; l<maskNorm[k].length&&j+l<aim[i+k].length; l++) {

            aim[i+k][j+l]+=maskNorm[k][l]*err;
            //println(maskNorm[k][l],aim[i+k][j+l]);
          }
        }
      }
    }
    updatePixels();
  } else {
    println("ayyy");
  }
}

void fileSelected(File selection) {
  if (selection == null) {
    println("Window was closed or the user hit cancel.");
  } else {
    println("User selected " + selection.getAbsolutePath());
    img=loadImage(selection.getAbsolutePath());



    println(img.height, displayHeight);
    while (img.height>displayHeight) {
      println("DIVIDE!");
      img.resize(img.width/2, img.height/2);
    }
    println(img.width/2, displayWidth);
    while (img.width*2>displayWidth) {
      println("DIVIDE!");
      img.resize(img.width/2, img.height/2);
    }
    img.resize(int(img.width/scale), int(img.height/scale));
  }
  outp=new float[img.width][img.height];
}


class Pathfinder {
  int[] path;
  PVector[] points;

  Pathfinder(float[][] src) {
    ArrayList<PVector> pzw=new ArrayList<PVector>();
    for (int i =0; i<src.length; i++) {
      for (int j=0; j<src[i].length; j++) {
        if (src[i][j]==0) {
          if (random(1)>0.5) {
            pzw.add(new PVector(i*scale, j*scale).add(PVector.random2D().mult(random(scale/2))));
          }
        }
      }
    }
    Collections.shuffle(pzw);

    points=new PVector[pzw.size()];
    path=new int[pzw.size()];
    int i=0;
    for (PVector p : pzw) {
      points[i]=p;
      path[i]=points.length-i-1;
      i++;
    }
  }


  int count=0;
  void improvePath() {
    for (int i=0; i<1000000; i++) {
      int a=int(random(path.length-2)+1);
      int b=int(random(path.length-2)+1);
      if (abs(a-b)>1) {
        float d1=points[path[a-1]].dist(points[path[a]])+
          points[path[a]].dist(points[path[a+1]])+
          points[path[b-1]].dist(points[path[b]])+
          points[path[b]].dist(points[path[b+1]]);
        float d2=points[path[a-1]].dist(points[path[b]])+
          points[path[b]].dist(points[path[a+1]])+
          points[path[b-1]].dist(points[path[a]])+
          points[path[a]].dist(points[path[b+1]]);
        //println(d1,d2);
        if (d2-d1<temp) {
          //print(path[a],path[b]," old ");
          int zw=path[a];
          path[a]=path[b];
          path[b]=zw;
          //println(a, b, " " ,path[a],path[b], "swap");
        }
        count++;
        if (count%coolCount==0) {
          temp*=cooling;
          count=0;
        }
      }
    }
  }

  void drawPoints() {
    for (PVector p : points) {
      point(p.x, p.y);
    }
  };

  void drawPath() {
    PVector last=points[path[0]];
    PVector n;
    float totalLength=0;
    for (int i=1; i<path.length; i++) {
      n=points[path[i]];
      line(last.x*zf, last.y*zf, n.x*zf, n.y*zf);
      totalLength+=last.dist(n);

      last=n;
    }
    println("total length: " +totalLength+ " temp: " +temp);
  };
}