int x_size = 80;
int y_size = 80;

float[] cityMagFacs = {70,50,70};
String[] displacements = {
  "SF_displacements.txt","LA_displacements.txt","NY_displacements.txt"};
String[] streetMaps = {
  "SF_st_map.jpg","LA_st_map.jpg","NY_st_map.jpg"};
String[] transitMaps = {
  "SF_transit.jpg","LA_transit.jpg","NY_transit.jpg"};
String[] satelliteMaps = {
  "SF_satellite.jpg","LA_satellite.jpg","NY_satellite.jpg"};
String[] neighborhoodMaps = {
  "SF_neighborhoods.jpg","LA_neighborhoods.jpg","NY_neighborhoods.jpg"};

String[][] warpLayers = {
  satelliteMaps,streetMaps,neighborhoodMaps};

int currWarp = 0;

int currMap = 0;
float globalDistort = 0.0;
float infRad = 20;
float radFactor = 2;

float dispX,dispY,dispX2,dispY2;

PImage texture;
PImage overlay;
PImage skin;
float gridUSize,gridVSize;

boolean reverse = false;
boolean displacementsShown = false;

boolean start = true;
float addx = 0; 
float addy = 0;

boolean showOverlay = false;


MVertex[][] vertices = new MVertex[x_size][y_size];
ArrayList baseDisplace = new ArrayList();

void setup(){
  //basic sketch stuff
  size(1024,768,P2D);

  dispX = 200;
  dispY = 20;

  setupButtons();
  dispX2 = width-20;
  dispY2 = height-20;

  skin = loadImage("skin.png");

  //smooth();
  stroke(255);


  textureMode(NORMALIZED);
  gridUSize = 1f/(x_size-1);
  gridVSize = 1f/(y_size-1);
  //initialize the grid of vertices
  initialize();
}

void draw(){
  background(0);
  drawVerts();
  if(showOverlay){
    tint(255, 80);
    image(overlay,dispX,dispY);
    noTint();
  }
  drawDisplacements();
  image(skin,0,0);
  distortSlider.draw();
  drawButtons();
}

void initVerts(){
  float x_spacing = (dispX2-dispX)/((float)x_size-1);
  float y_spacing = (dispY2-dispY)/((float)y_size-1);
  for (int i=0; i<x_size;i++){
    for (int j=0; j<y_size;j++){
      vertices[i][j] = new MVertex(dispX+x_spacing*i,dispY+y_spacing*j);
    }
  } 
}

void drawVerts(){
  for (int i=0; i<x_size;i++){
    for (int j=0; j<y_size;j++){
      if (j > 0) {
        line(vertices[i][j].x,vertices[i][j].y,vertices[i][j-1].x,vertices[i][j-1].y);
      }

      if (i > 0) {
        line(vertices[i][j].x,vertices[i][j].y,vertices[i-1][j].x,vertices[i-1][j].y);
      }
    }
  } 

  noStroke();
  for (int i = 0; i < x_size-1; i++)
  {
    for (int j=0; j < y_size-1; j++){

      beginShape();
      texture(texture);
      vertex(vertices[i][j].x,vertices[i][j].y, i*gridUSize,j*gridVSize);
      vertex(vertices[i+1][j].x,vertices[i+1][j].y,(i+1)*gridUSize,j*gridVSize);
      vertex(vertices[i+1][j+1].x,vertices[i+1][j+1].y, (i+1)*gridUSize,(j+1)*gridVSize);
      vertex(vertices[i][j+1].x,vertices[i][j+1].y, (i)*gridUSize,(j+1)*gridVSize);

      endShape();
    }
  }


}

void moveVerts(){

  for (int i=0; i<x_size;i++){
    for (int j=0; j<y_size;j++){
      float sumVal = 0.0001;
      float[] values = new float[baseDisplace.size()];
      for (int bv = 0;bv<baseDisplace.size();bv++){
        float value = 0;
        Displacement disp = (Displacement)baseDisplace.get(bv);
        float distance = dist(vertices[i][j].ox,vertices[i][j].oy,disp.x,disp.y);
        value = (disp.v.mag()*radFactor)-distance;
        if (value < 0) value = 0;
        value = (disp.v.mag()*radFactor) - value;
        value /= (disp.v.mag()*radFactor);
        value = 1-value;
        values[bv] = value;
        sumVal += value;

      }
      if (sumVal < 1) {
        sumVal = 1;
      } 
      else {
        sumVal = 1/sumVal;
      }
      for (int bv = 0;bv<baseDisplace.size();bv++){

        vertices[i][j].move(((Displacement)baseDisplace.get(bv)).v,values[bv]*sumVal);

      }
    }
  }
}




void scaleShift(){
  for (int i=0; i<x_size;i++){
    for (int j=0; j<y_size;j++){
      vertices[i][j].shift(globalDistort);

    }
  }
}

void initialize(){

  if(reverse){
    overlay = loadImage(warpLayers[currWarp][currMap]); 
  } 
  else {
    overlay = loadImage(transitMaps[currMap]); 
  }


  if(reverse){
    texture = loadImage(transitMaps[currMap]);
  } 
  else {
    texture = loadImage(warpLayers[currWarp][currMap]); 
  }
  initVerts();
  baseDisplace = new ArrayList();
  new DistortReader(displacements[currMap]);
  moveVerts();
}

void drawDisplacements(){
  if(displacementsShown){
    for (int i=0; i<x_size;i++){
      for (int j=0; j<y_size;j++){
        float magnitude = dist(vertices[i][j].ox,vertices[i][j].oy,vertices[i][j].dx,vertices[i][j].dy);
        magnitude = magnitude/cityMagFacs[currMap];
        if(magnitude>1) magnitude = 1;
        
        ellipseMode(CENTER);
        smooth();
        if(reverse||currWarp>0){
                 fill(0,magnitude*120);
        } else {
        fill(255,magnitude*200);
        }
        float radius = magnitude*5+2;
        ellipse(vertices[i][j].x,vertices[i][j].y,radius,radius);
        noSmooth();

      }
    }
  }
}