PImage src, img; //src: the source panoramic image, img: the image that is displayed
float pitch, yaw, vAngle; //angles of the camera. 
int panoramaIndex;
String[] panoramaList;
float[] fov; //FieldOfView: an array with 3D coordinates for 3 corners of the viewscreen
//0,1,2: coordinates for top left corner
//3,4,5: vector from top left to top right corner
//6,7,8: vector from top left to bottom left corner
//the camera is presumed to be at (0,0,0);

//------------------------------------------------
void setup() {
  panoramaList = new String[] { "trees.jpg", "ocean.jpg", "red.jpg" };
  panoramaIndex = 0;
  src = loadImage(panoramaList[panoramaIndex]);
  pitch = 0;
  yaw = 0;
  vAngle = 1.8;
  size(200,130);
  setFov(vAngle,width,height);
  updatePanorama();
}
//------------------------------------------------
void setFov(float fovAngle, int fWidth, int fHeight) {
  float screenHeight = fHeight/(float)fWidth;
  float screenDist = 1 / tan( fovAngle/2 );
  fov = new float[] { -0.5, -screenHeight/2, screenDist,    1f, 0f, 0f,    0f, screenHeight, 0f};
}
//------------------------------------------------
void draw(){
  if(keyPressed){
    if(key == 'c'){
      panoramaIndex = (panoramaIndex+1) % panoramaList.length;
      src = loadImage(panoramaList[panoramaIndex]);
    }
    if(key == 's') pitch = constrain( pitch-0.05, -HALF_PI, HALF_PI);
    if(key == 'a') yaw -= 0.05;
    if(key == 'w') pitch = constrain( pitch+0.05, -HALF_PI, HALF_PI);
    if(key == 'd') yaw += 0.05;
    if(key == 'z') vAngle = constrain( vAngle+0.05, 0.2, 2.8);
    if(key == 'x') vAngle = constrain( vAngle-0.05, 0.2, 28);
    setFov(vAngle,width,height);
    updatePanorama();
  }
}
//------------------------------------------------
void updatePanorama() {
  img = new PImage(width, height);
  loadPixels();
  float[] ang, cang;
  int pixNr;
  int halfW = width/2;

  for (int x=0; x<width; x++) {
    for (int y=0; y<height; y++) {;
      ang = cartesianToSpherical( pixelToCartesian(x,y) );
      cang = new float[] { 2*yaw-ang[0], ang[1] };
      img.pixels[x+width*y] = getPanoramicPixel(ang);
      //img.pixels[width-x+width*y-1] = getPanoramicPixel(cang);
    }
  }
  
  updatePixels();
  image( img, 0, 0);
}
//------------------------------------------------
// returns the color of the pixel at the position defined by
// the spherical coordinate pair ang = [a,b]
color getPanoramicPixel(float[] ang){
  int x = (int) (ang[0]*src.width/TWO_PI) + src.width/2;
  int y = (int) (ang[1]*src.height/PI) + src.height/2;
  return src.get( x, y );
}
//------------------------------------------------
// returns [x,y,z] , a cartesian coordinate vector
// that points to the [x,y] pixel of the projection screen
float[] pixelToCartesian(int x, int y){
  float[] tFov = getRotatedFov();
  float i = x/(float)width;
  float j = y/(float)height;
  float vx = tFov[0] + i*tFov[3] + j*tFov[6];
  float vy = tFov[1] + i*tFov[4] + j*tFov[7];
  float vz = tFov[2] + i*tFov[5] + j*tFov[8];
  float[] vec = new float[] { vx , vy , vz };
  return vec;
}
//------------------------------------------------
// returns [a,b] where a,b are angles in a spherical coordinate system
// that points to the supplied cartesian coordinate point
float[] cartesianToSpherical(float[] vec){
  float[] ang = new float[] { atan2(vec[0],vec[2]) , atan2( vec[1] , sqrt(sq(vec[0])+sq(vec[2])) ) };
  return ang;
}
//------------------------------------------------
// returns a rotated (apply pitch and yaw) copy of fov
float[] getRotatedFov(){
  float[] pFov = new float[9];
  float[] yFov = new float[9];
  float c=cos(pitch), s=sin(pitch);
  // rotate around X-axis : pitch
  pFov[0] = fov[0];
  pFov[1] = fov[1]*c - fov[2]*s;
  pFov[2] = fov[1]*s + fov[2]*c;
  pFov[3] = fov[3];
  pFov[4] = fov[4]*c - fov[5]*s;
  pFov[5] = fov[4]*s + fov[5]*c;
  pFov[6] = fov[6];
  pFov[7] = fov[7]*c - fov[8]*s;
  pFov[8] = fov[7]*s + fov[8]*c;
  
  c=cos(yaw); s=sin(yaw);
  // rotate around Y-axis : yaw
  yFov[0] = pFov[2]*s + pFov[0]*c;
  yFov[1] = pFov[1];
  yFov[2] = pFov[2]*c - pFov[0]*s;
  yFov[3] = pFov[5]*s + pFov[3]*c;
  yFov[4] = pFov[4];
  yFov[5] = pFov[5]*c - pFov[3]*s;
  yFov[6] = pFov[8]*s + pFov[6]*c;
  yFov[7] = pFov[7];
  yFov[8] = pFov[8]*c - pFov[6]*s;
  
  return yFov;
}
//------------------------------------------------
//------------------------------------------------