/*
 * volumatrix
 * Fredrik Bridell 2007-01-22
 * 
 * This is a Processing sketch done for an installation that may or not
 * be produced. It loads images (regular jpegs) and maps them onto a 
 * low-resolution three-dimensional pixel grid. There are two versions,
 * one where the grid is a sort of curved shape (the depth is proportional
 * to the distance to the middle). The other vesion is just a cube where
 * each pixel gets a random depth. You can turn the shape using the mouse
 * or press 0 (zero) to see it rotate automatically.
 *
 * Note: this is a SKETCH. My apologies for the particularly ugly code. 
 *
 * use mouse to rotate the shape or push some key controls:
 * RETURN or ENTER to toggle image
 * x/X to decrease/INCREASE number of rows
 * y/Y ti decrease/INCREASE number of columns
 * z/Z to decrease/INCREASE the z scaling
 * d/D to decrease/INCREASE the distance (spacing) between pixels
 * SPACE to print out your current variable settings (in Processing)
 * p to toggle parabolic mode
 * b to toggle balls or ellipses (balls are A LOT slower)
 * 1 - preset, flat image
 * 2 - preset, at an angle
 * 0 - toggle automatic rotation
 */

// angles of rotation
float ax=0; 
float ay=0;
float az=0;
boolean autorotate=true;
boolean explodedMode=false; // if false, show parabolic mode, if true, exploded
boolean drawBalls = false;
int oldMouseX;
int oldMouseY;

PImage img;           // source image
int numCols = 24;     // number of cells (x)
int numRows = 24;     // number of rows (y)
int spacing = 5;      // spacing between grid rows and columns
float spacingZ = 3.0; // larger values give taller chandelier
float cellx, celly;   // size of each cell...

int imageNumber;
String[] imageList = {
  "puppy.jpg", "innocentx.jpg", "joconde.jpg", "frankenstein.jpg"
};

float[][] depth;       // stores cell depths for exploded mode, not parabolic

void setup(){ 
  background(0);
  size(800, 600, P3D); 
  noStroke();
  imageNumber=int(random(imageList.length));
  toggleImage();
  
  oldMouseX=mouseX;
  oldMouseY=mouseY;
}

// calculates new values 
// call this method after you change the x/y resolution of the grid
// or the pixel dimensions of the source image
void changeResolution(){
  cellx = img.width / float(numCols);
  celly = img.height / float(numRows);
  
  // calculate random depths for exploded mode
  depth = new float[numCols][numRows];
  for(int x=0; x<numCols; x++){
    for (int y=0; y<numRows; y++){
        depth[x][y]=random(10.0);
    }      
  }  
}

// loads another image from the (hardcoded) imageList 
void toggleImage(){
  int nmax = imageList.length;
  imageNumber = (imageNumber + 1) % nmax;
  String imgFile = imageList[imageNumber];
  img = loadImage(imgFile);
  changeResolution();
}


// this draws the "chandelier"
void draw(){
  background(0);
  
  if(autorotate){
    ax = ax + PI/64;
  }
  
  pushMatrix();
  translate(int(float(width)/2.0), int(float(height)/2.0), 0);
 
  rotateX(ax);
  rotateY(ay);
  rotateZ(az);
  
  for (int x=0; x<numCols; x++){
    for (int y=0; y<numRows; y++){
      
      float z;
      if (explodedMode){
        z=depth[x][y] * spacingZ;
      } else {
      
        // calculate depth based on where in the grid we are
        float xr = abs(x-numCols/2.0);
        float yr = abs(y-numCols/2.0);
        z = sqrt(xr*xr+yr*yr) * spacingZ;
      }
      pushMatrix();     
      
        // grab the pixel color from the image
        int imgx = int(x*cellx);
        int imgy = int(y*celly); 
        color c = img.get(imgx, imgy);      

        int tx = x - numCols/2;
        int ty = y - numRows/2; 
        translate(tx*spacing, ty*spacing, z*spacing);
        fill(c);
        if (drawBalls){
          sphere(2);
        } else {
          ellipse(0,0,5,5);
        }
      popMatrix();
    }
  }
  popMatrix();
}

void mousePressed(){
  oldMouseX=mouseX;
  oldMouseY=mouseY;
}


void mouseDragged(){
  int deltax = mouseX - oldMouseX;
  int deltay = mouseY - oldMouseY;
  
  float dx = deltay / 50.0;
  float dy = 0;
  float dz = deltax / 100.0;

  ax = ax + dx;
  ay = ay + dy;
  az = az + dz;
  
  oldMouseX = mouseX;
  oldMouseY = mouseY;
}

// handle key presses
void keyPressed(){
  switch(key){
    case ' ': // SPACE: dump
      println("ax= " + ax);
      println("ay= " + ay);
      println("az= " + az);
      println("dimensions " + numCols + " x " + numRows + " = " + numCols * numRows);
      break;      
    case 'b': // toggle balls
      drawBalls = !drawBalls;
      break;
    case 'd': // less spacing
      spacing = max(1, spacing-1);  
      break;
    case 'D': // more spacing
      spacing=spacing+1;
      break;      
    case 'x': // less x columns
        numCols = max(1, numCols-1);
        break;
    case 'X': // more x columns
      numCols = numCols + 1;
      break;
    case 'y': // less y rows
      numRows = max(1, numRows-1);
      break;
    case 'Y': // more y rows
      numRows = numRows + 1;
      break;
    case 'z': // less depth
      spacingZ = max(0.0, spacingZ-0.5);      
      break;
    case 'Z': // more depth
      spacingZ = spacingZ + 0.5;
      break;

    case '1': // preset 1
      ax=0;
      ay=0;
      az=0;
      break;
    case '2': // preset 2
      ax=-HALF_PI; 
      ay=0;
      az=0.5;
      break;
    case '0': // toggle autorotate
      autorotate = !autorotate;    
      break;
    case 'p': // togglö parabolic / exploded mode
      explodedMode = !explodedMode;
      break;
  }

  if (keyCode==RETURN || keyCode==ENTER){
    toggleImage();
  }
  
  changeResolution();
}