import sms.*;
int[] vals = new int[2];              // RAW VALUES FROM THE SENSOR
int[] maximum = new int[2];           // MAXIUM VALUE SENSED
int[] minimum = new int[2];           // MINIMUM VALUE SENSED
int[] range = new int[2];             // TOTAL RANGE SENSED, THERE ARE 3 VALUES FOR X,Y,Z AXES
float[] attitude = new float[2];      // CURRENT VALUE AS AN ALTITUDE OF WINDOW HEIGHT
float[] position = new float[2];      // CURRENT VALUE AS AN ATTITUDE OF WINDOW HEIGHT
float rectSize;                       // RECTANGLE SIZE
int numImages = 10;
int MaxRangeX = 150;
int MaxRangeY = 150;
int MinRangeX = -150;
int MinRangeY = -150;
boolean onXaxis = true;
int threshold;

PImage currentImage;

PImage[] XimagesRight = new PImage[10];    // IMAGES FOR THE X AXIS TO THE RIGHT
PImage[] XimagesLeft = new PImage[10];    // IMAGES FOR THE X AXIS TO THE LEFT
PImage[] YimagesBack = new PImage[14];    // IMAGES FOR THE Y AXIS TO THE FRONT
PImage[] YimagesFront = new PImage[10];    // IMAGES FOR THE Y AXIS TO THE BACK

//********************************************  SETUP  ********************************************
void setup () {
  size(400, 266);                        // DRAW THE WINDOW
  //  rectSize = width/4;                         // SET THE SIZE OF THE RECTANGLE
  background(0);                              // SET THE BACKGROUND COLOR
  /*  for (int i = 0; i < 2; i++) {               // SET THE MAX AND MIN VALUES
   maximum[i] = 667;
   minimum[i] = -667;
   range[i] = maximum[i] - minimum[i];       // CALCULATE THE TOTAL CURRENT RANGE
   }*/

  //****************************************** LOAD ALL X AXIS IMAGES  ******************************

  XimagesRight[0] = loadImage("image1.jpg");
  XimagesRight[1] = loadImage("image2.jpg");
  XimagesRight[2] = loadImage("image3.jpg");
  XimagesRight[3] = loadImage("image4.jpg");
  XimagesRight[4] = loadImage("image5.jpg");
  XimagesRight[5] = loadImage("image6.jpg");
  XimagesRight[6] = loadImage("image7.jpg");
  XimagesRight[7] = loadImage("image8.jpg");
  XimagesRight[8] = loadImage("image9.jpg");
  XimagesRight[9] = loadImage("image10.jpg");


  XimagesLeft[0] = loadImage("image11.jpg");
  XimagesLeft[1] = loadImage("image12.jpg");
  XimagesLeft[2] = loadImage("image13.jpg");
  XimagesLeft[3] = loadImage("image14.jpg");
  XimagesLeft[4] = loadImage("image15.jpg");
  XimagesLeft[5] = loadImage("image16.jpg");
  XimagesLeft[6] = loadImage("image17.jpg");
  XimagesLeft[7] = loadImage("image18.jpg");
  XimagesLeft[8] = loadImage("image19.jpg");
  XimagesLeft[9] = loadImage("image20.jpg");



  //****************************************** LOAD ALL Y AXIS IMAGES  ******************************
  YimagesBack[0] = loadImage("image21.jpg");
  YimagesBack[1] = loadImage("image22.jpg");
  YimagesBack[2] = loadImage("image23.jpg");
  YimagesBack[3] = loadImage("image24.jpg");
  YimagesBack[4] = loadImage("image25.jpg");
  YimagesBack[5] = loadImage("image26.jpg");
  YimagesBack[6] = loadImage("image27.jpg");
  YimagesBack[7] = loadImage("image28.jpg");
  YimagesBack[8] = loadImage("image29.jpg");
  YimagesBack[9] = loadImage("image30.jpg");
  YimagesBack[10] = loadImage("image31.jpg");
  YimagesBack[11] = loadImage("image32.jpg");
  YimagesBack[12] = loadImage("image33.jpg");
  YimagesBack[13] = loadImage("image34.jpg");

  YimagesFront[0] = loadImage("image35.jpg");
  YimagesFront[1] = loadImage("image36.jpg");
  YimagesFront[2] = loadImage("image37.jpg");
  YimagesFront[3] = loadImage("image38.jpg");
  YimagesFront[4] = loadImage("image39.jpg");
  YimagesFront[5] = loadImage("image40.jpg");
  YimagesFront[6] = loadImage("image41.jpg");
  YimagesFront[7] = loadImage("image42.jpg");
  YimagesFront[8] = loadImage("image43.jpg");
  YimagesFront[9] = loadImage("image44.jpg");
}
//*********************************************  DRAW  ********************************************
void draw () {
  background(0);
  vals = Unimotion.getSMSArray();              // GET THE VALUES
  
  checkLimits();                               // CHECK TO SEE IF THERE ARE NEW PEAK VALUES
  SetImage();
  println(vals[0] + " " + vals[1] + " " + onXaxis);
 
 /* setXImagesRight();
  setXImagesLeft();
  setYImagesBack();
  setYImagesFront();*/


  //****************************  DISPLAY IMAGES ACCORDING TO THE X Y & Z AXES ****************************  

  image(currentImage,0,0,width,height);
}
//************************************ DISPLAY IMAGES ON THE X-AXIS  ******************************
void setX(){
  setXImagesRight();
  setXImagesLeft();
}
void setY(){
  setYImagesBack();
  setYImagesFront();
}
void SetImage(){
  threshold = 30;
  
  int absX = abs(vals[0]);
  int absY = abs(vals[1]);
  
  if (absX < threshold && onXaxis) {   // check if axis should switch to Y 
    if(absY > absX  && absY > threshold) {
      onXaxis = false;
    }
  }
   if (absY < threshold && !onXaxis) {   // check if axis should switch to X 
    if(absX > absY && absX > threshold) {
      onXaxis = true;
    }  
  }     
  if(onXaxis){    // set the appropriate image based on the current axis
    setX();
    }
  else {
    setY();
    }
  }

  void setXImagesLeft(){
    if(vals[0] == 0){
      vals[0] = 2;
    }
    if(vals[0]>0 && vals[0]<MaxRangeX/numImages * 1){
      currentImage = XimagesLeft[0];
    }
    else if(vals[0]>0 && vals[0]<MaxRangeX/numImages * 2){
      currentImage = XimagesLeft[1];
    }
    else if(vals[0]>0 && vals[0]<MaxRangeX/numImages * 3){
      currentImage = XimagesLeft[2];
    }
    else if(vals[0]>0 && vals[0]<MaxRangeX/numImages * 4){
      currentImage = XimagesLeft[3];
    }
    else if(vals[0]>0 && vals[0]<MaxRangeX/numImages * 5){
      currentImage = XimagesLeft[4];
    }
    else if(vals[0]>0 && vals[0]<MaxRangeX/numImages * 6){
      currentImage = XimagesLeft[5];
    }
    else if(vals[0]>0 && vals[0]<MaxRangeX/numImages * 7){
      currentImage = XimagesLeft[6];
    }
    else if(vals[0]>0 && vals[0]<MaxRangeX/numImages * 8){
      currentImage = XimagesLeft[7];
    }
    else if(vals[0]>0 && vals[0]<MaxRangeX/numImages * 9){
      currentImage = XimagesLeft[8];
    }
    else if (vals[0]>0){
      currentImage = XimagesLeft[9];
    }
  }
void setXImagesRight(){
  if(vals[0] == 0){
    vals[0] = -2;
  }
  if(vals[0]< 0 && vals[0]>MinRangeX/numImages * 1){
    print("..1..");
    currentImage = XimagesRight[0];
  }
  else if(vals[0]< 0 && vals[0]>MinRangeX/numImages * 2){
    print("..2..");
    currentImage = XimagesRight[1];
  }
  else if(vals[0]< 0 && vals[0]>MinRangeX/numImages * 3){
    print("..3..");
    currentImage = XimagesRight[2];
  }
  else if(vals[0]< 0 && vals[0]>MinRangeX/numImages * 4){
    print("..4..");
    currentImage = XimagesRight[3];
  }
  else if(vals[0]< 0 && vals[0]>MinRangeX/numImages * 5){
    print("..5..");
    currentImage = XimagesRight[4];
  }
  else if(vals[0]< 0 && vals[0]>MinRangeX/numImages * 6){
    currentImage = XimagesRight[5];
  }
  else if(vals[0]< 0 && vals[0]>MinRangeX/numImages * 7){
    currentImage = XimagesRight[6];
  }
  else if(vals[0]< 0 && vals[0]>MinRangeX/numImages * 8){
    currentImage = XimagesRight[7];
  }
  else if(vals[0]< 0 && vals[0]>MinRangeX/numImages * 9){
    currentImage = XimagesRight[8];
  }
  else {
    currentImage = XimagesRight[9];
  }
}
void setYImagesFront(){  
  if(vals[1] == 0){
    vals[1] = 2;
  }
  if(vals[1]> 0 && vals[1]<MaxRangeY/numImages * 1){
    print("..1..");
    currentImage = YimagesFront[0];
  }
  else if(vals[1]> 0 && vals[1]<MaxRangeY/numImages * 2){
    print("..2..");
    currentImage = YimagesFront[1];
  }
  else if(vals[1]> 0 && vals[1]<MaxRangeY/numImages * 3){
    print("..3..");
    currentImage = YimagesFront[2];
  }
  else if(vals[1]> 0 && vals[1]<MaxRangeY/numImages * 4){
    print("..4..");
    currentImage = YimagesFront[3];
  }
  else if(vals[1]> 0 && vals[1]<MaxRangeY/numImages * 5){
    currentImage = YimagesFront[4];
  }
  else if(vals[1]> 0 && vals[1]<MaxRangeY/numImages * 6){
    currentImage = YimagesFront[5];
  }
  else if(vals[1]> 0 && vals[1]<MaxRangeY/numImages * 7){
    currentImage = YimagesFront[6];
  }
  else if(vals[1]> 0 && vals[1]<MaxRangeY/numImages * 8){
    currentImage = YimagesFront[7];
  }
  else if(vals[1]> 0 && vals[1]<MaxRangeY/numImages * 9){
    currentImage = YimagesFront[8];
  }
  else if (vals[1]>0){
    currentImage = YimagesFront[9];
  }
}

void setYImagesBack(){  
  if(vals[1] == 0){
    vals[1] = -2;
  }  
  if(vals[1]< 0 && vals[1]>MinRangeY/numImages * 1){
    currentImage = YimagesBack[0];
  }
  else if(vals[1]< 0 && vals[1]>MinRangeY/numImages * 2){
    currentImage = YimagesBack[1];
  }
  else if(vals[1]< 0 && vals[1]>MinRangeY/numImages * 3){
    currentImage = YimagesBack[2];
  }
  else if(vals[1]< 0 && vals[1]>MinRangeY/numImages * 4){
    currentImage = YimagesBack[3];
  }
  else if(vals[1]< 0 && vals[1]>MinRangeY/numImages * 5){
    currentImage = YimagesBack[4];
  }
  else if(vals[1]< 0 && vals[1]>MinRangeY/numImages * 6){
    currentImage = YimagesBack[5];
  }
  else if(vals[1]< 0 && vals[1]>MinRangeY/numImages * 7){
    currentImage = YimagesBack[6];
  }
  else if(vals[1]< 0 && vals[1]>MinRangeY/numImages * 8){
    currentImage = YimagesBack[7];
  }
  else if(vals[1]< 0 && vals[1]>MinRangeY/numImages * 9){
    currentImage = YimagesBack[8];
  }
  else if(vals[1]< 0 && vals[1]>MinRangeY/numImages * 10){
    currentImage = YimagesBack[9];
  }
  else if(vals[1]< 0 && vals[1]>MinRangeY/numImages * 11){
    currentImage = YimagesBack[10];
  }
  else if(vals[1]< 0 && vals[1]>MinRangeY/numImages * 12){
    currentImage = YimagesBack[11];
  }
  else if(vals[1]< 0 && vals[1]>MinRangeY/numImages * 13){
    currentImage = YimagesBack[12];
  }
  else {
    currentImage = YimagesBack[13];
  }
}
// ****************************************  CHECK LIMITS  ****************************************
void checkLimits() {
  for (int i = 0; i < 2; i++) {                                        // CALCULATE THE CURRENT ALTITUDE AS A PERCENTAGE OF 2*PI
    // BASED ON THE CURRENT RANGE
    attitude[i] = PI * float(vals[i] - minimum[i]) /float(range[i]);
  }                                                                    // CALCULATE THE CURRENT POSITION AS A PERCENTAGE
  position[0] = width * float(vals[0] - minimum[0]) /float(range[0]);  // OF THE WINDOW HEIGHT BASED ON THE CURRENT IMAGE 
  position[1] = height * float(vals[1] - minimum[1]) /float(range[1]) + minimum[1]; 
}