// segment names, my numbering scheme
static final int HEAD_NECK=0;
static final int LEFT_SHOULDER_LEFT_ELBOW=1; 
static final int LEFT_ELBOW_LEFT_HAND=2; 
static final int LEFT_HIP_LEFT_KNEE=3;
static final int LEFT_KNEE_LEFT_FOOT=4;
static final int RIGHT_SHOULDER_RIGHT_ELBOW=5; 
static final int RIGHT_ELBOW_RIGHT_HAND=6;
static final int RIGHT_HIP_RIGHT_KNEE=7;
static final int RIGHT_KNEE_RIGHT_FOOT=8;
static final int SHOULDERS_HIPS=9;
static final int LEFT_HIP_RIGHT_HIP=10;


//int[] attachX = {
//  -150, 
//  // left arm
//  0, //65, 
//  0, //0,//65, 
//  // left leg
//  -60, //-100, 
//  -120, //-200, //-120,//45, 
//  // right arm
//  0, //-65, 
//  0, //-65, 
//  // right leg
//  60, //100, 
//  120, //200,//120,//-45, 
//  0, 
//  0, 
//  0
//};
//
//int[] attachY = {
//  -25, 
//  // left arm
//  -10, 
//  -10, 
//  // left leg
//  -150,//-120, 
//  -200,//-170, 
//  // right arm
//  -10, 
//  -10, 
//  // right leg
//  -150,//-120, 
//  -200,//-170, 
//  0, 
//  0, 
//  0
//};


int[] attachX = {
  -150, 
  // left arm
  0, //65, 
  0, //0,//65, 
  // left leg
  -10, 
  0, //-200, //-120,//45, 
  // right arm
  0, //-65, 
  0, //-65, 
  // right leg
  10, 
  0, //200,//120,//-45, 
  0, 
  0, 
  0
};

int[] attachY = {
  -25, 
  // left arm
  0,//-10, 
  0,//-10, 
  // left leg
  -0,//-150,//-120, 
  0,//-200,//-170, 
  // right arm
  0,//-10, 
  0,//-10, 
  // right leg
  -0, //-150,//-120, 
  0,//-200,//-170, 
  0, 
  0, 
  0
};

class PaperDoll { 

  // joint names, osceleton numbering scheme
  static final int HEAD=0;
  static final int NECK=1;
  static final int RIGHT_COLLAR=2;
  static final int RIGHT_SHOULDER=3; 
  static final int RIGHT_ELBOW=4;
  static final int RIGHT_WRIST=5; 
  static final int RIGHT_HAND=6; 
  static final int RIGHT_FINGER=7;
  static final int LEFT_COLLAR=8;
  static final int LEFT_SHOULDER=9; 
  static final int LEFT_ELBOW=10; 
  static final int LEFT_WRIST=11;
  static final int LEFT_HAND=12;
  static final int LEFT_FINGER=13;
  static final int TORSO=14;
  static final int RIGHT_HIP=15;
  static final int RIGHT_KNEE=16;
  static final int RIGHT_ANKLE=17;
  static final int RIGHT_FOOT=18;//18;  
  static final int LEFT_HIP=19;
  static final int LEFT_KNEE=20;
  static final int LEFT_ANKLE=21;
  static final int LEFT_FOOT=22;//22;


  //static final int numSegments = 2;
  //static final int numLimbs=5;
  static final int numSegments=23;//15;

  float SCALE_FACTOR=0.1;

  float[] sx = new float[numSegments];
  float[] sy = new float[numSegments];

  float[] x = new float[numSegments];
  float[] y = new float[numSegments];
  float[] angle = new float[numSegments];
  float[] len = new float[numSegments];

  int[] texNums = new int[numSegments];

  float segLength = 100;

  float targetX, targetY;

  PImage bodyTextures[];// = new PImage[11];

  PaperDoll() {

    // assign texture indices
    texNums[0]=HEAD_NECK;
    texNums[1]=RIGHT_SHOULDER_RIGHT_ELBOW; 
    texNums[2]=RIGHT_ELBOW_RIGHT_HAND;
    texNums[3]=RIGHT_HIP_RIGHT_KNEE;
    texNums[4]=RIGHT_KNEE_RIGHT_FOOT;
    texNums[5]=LEFT_SHOULDER_LEFT_ELBOW;
    texNums[6]=LEFT_ELBOW_LEFT_HAND;
    texNums[7]=LEFT_HIP_LEFT_KNEE;
    texNums[8]=LEFT_KNEE_LEFT_FOOT;
    texNums[9]=SHOULDERS_HIPS;

    bodyTextures = new PImage[11];
    println("doll constructed");
  }
  

  void calcScreenCoords(Skeleton skelly) {

    // convert from Kinect 3d skeleton coordinates
    // to 2d screen space coorddinates.

    for (int i=0;i<numSegments;i++) {

      PVector jointPos1 = new PVector();
      //println(userId);
      //println(jointTypes[i]);

      //float confidence = context.getJointPositionSkeleton(userId, jointTypes[i], jointPos1);
      jointPos1.x=skelly.allCoords[i][0];
      jointPos1.y=skelly.allCoords[i][1];
      jointPos1.z=skelly.allCoords[i][2];

      //println(jointPos1);

      float x=screenX(jointPos1.x, jointPos1.y, jointPos1.z);
      float y=screenY(jointPos1.x, jointPos1.y, jointPos1.z);

      //      print(x); print(","); println(y);
      sx[i]=x;
      sy[i]=y;
    }
    //    println("***");
  }

  void constrainCoords() {
    // constrain screen coords to paper doll model

    float x1, y1, x2, y2;
    x1=sx[NECK];
    y1=sy[NECK];
    x2=sx[TORSO];
    y2=sy[TORSO];

    // calculate angle of torso from neck and torso control points
    angle[SHOULDERS_HIPS]=atan2(y2-y1, x2-x1);

    SCALE_FACTOR = dist(x1, y1, x2, y2)/len[SHOULDERS_HIPS]*3.5;

    //    print(dist(x1,y1,x2,y2)); print(" ");
    //    print(len[SHOULDERS_HIPS]); print(" ");
    //    println(SCALE_FACTOR);

    // make length invariate
    x2=x1+cos(angle[SHOULDERS_HIPS])*len[SHOULDERS_HIPS]*SCALE_FACTOR;
    y2=y1+sin(angle[SHOULDERS_HIPS])*len[SHOULDERS_HIPS]*SCALE_FACTOR;
    x1=x1+cos(angle[SHOULDERS_HIPS]-PI)*len[SHOULDERS_HIPS]*SCALE_FACTOR*0.07;
    y1=y1+sin(angle[SHOULDERS_HIPS]-PI)*len[SHOULDERS_HIPS]*SCALE_FACTOR*0.07;

    x[HEAD_NECK]=x1;
    y[HEAD_NECK]=y1;
    angle[HEAD_NECK]=angle[SHOULDERS_HIPS]-PI;

    x[SHOULDERS_HIPS]=x2;
    y[SHOULDERS_HIPS]=y2;

    // shoulders
    x[LEFT_SHOULDER_LEFT_ELBOW]=sx[LEFT_SHOULDER];
    y[LEFT_SHOULDER_LEFT_ELBOW]=sy[LEFT_SHOULDER];
    x[RIGHT_SHOULDER_RIGHT_ELBOW]=sx[RIGHT_SHOULDER];
    y[RIGHT_SHOULDER_RIGHT_ELBOW]=sy[RIGHT_SHOULDER];

    // hips
    x[LEFT_HIP_LEFT_KNEE]=sx[LEFT_HIP]-attachX[LEFT_HIP_LEFT_KNEE];
    y[LEFT_HIP_LEFT_KNEE]=sy[LEFT_HIP]-attachY[LEFT_HIP_LEFT_KNEE];
    x[RIGHT_HIP_RIGHT_KNEE]=sx[RIGHT_HIP]-attachX[RIGHT_HIP_RIGHT_KNEE];
    y[RIGHT_HIP_RIGHT_KNEE]=sy[RIGHT_HIP]-attachY[RIGHT_HIP_RIGHT_KNEE];

    // reachLimbs
    reachLimbs();
  }

  void reachLimbs() {
    // left arm
    
    reachSegment(LEFT_SHOULDER_LEFT_ELBOW, sx[LEFT_HAND], sy[LEFT_HAND]);
    reachSegment(LEFT_ELBOW_LEFT_HAND, targetX, targetY);
    positionSegment(LEFT_SHOULDER_LEFT_ELBOW, LEFT_ELBOW_LEFT_HAND);

    // right arm
    
    reachSegment(RIGHT_SHOULDER_RIGHT_ELBOW, sx[RIGHT_HAND], sy[RIGHT_HAND]);
    reachSegment(RIGHT_ELBOW_RIGHT_HAND, targetX, targetY);
    positionSegment(RIGHT_SHOULDER_RIGHT_ELBOW, RIGHT_ELBOW_RIGHT_HAND);

    // left leg
    
    reachSegment(LEFT_HIP_LEFT_KNEE, sx[LEFT_FOOT], sy[LEFT_FOOT]);
    reachSegment(LEFT_KNEE_LEFT_FOOT, targetX, targetY);
    positionSegment(LEFT_HIP_LEFT_KNEE, LEFT_KNEE_LEFT_FOOT);

    // right leg
    
    reachSegment(RIGHT_HIP_RIGHT_KNEE, sx[RIGHT_FOOT], sy[RIGHT_FOOT]);
    reachSegment(RIGHT_KNEE_RIGHT_FOOT, targetX, targetY);
    positionSegment(RIGHT_HIP_RIGHT_KNEE, RIGHT_KNEE_RIGHT_FOOT);
  }


  void reachSegment(int seg, float xin, float yin) {
    float dx = xin - x[seg];
    float dy = yin - y[seg];
    angle[seg] = atan2(dy, dx);  

    //    targetX = xin - (cos(angle[seg]) * len[seg] + attachX[seg])*SCALE_FACTOR;
    //    targetY = yin - (sin(angle[seg]) * len[seg] + attachY[seg])*SCALE_FACTOR;
    targetX = xin - (cos(angle[seg]) * len[seg])*SCALE_FACTOR;
    targetY = yin - (sin(angle[seg]) * len[seg])*SCALE_FACTOR;
  }


  void positionSegment(int seg1, int seg2) {
    //x[seg2] = x[seg1]+ (cos(angle[seg1]) * len[seg1] + attachX[seg2] )*SCALE_FACTOR;
    //y[seg2] = y[seg1] + (sin(angle[seg1]) * len[seg1] + attachY[seg2] )*SCALE_FACTOR;
    x[seg2] = x[seg1] + (cos(angle[seg1]) * len[seg1])*SCALE_FACTOR;
    y[seg2] = y[seg1] + (sin(angle[seg1]) * len[seg1])*SCALE_FACTOR;
  
}



  // OSC methods
  
  void sendCoords(int charnum) {
    //for(int i=0;i<numSegments; i++) {
    for(int i=0;i<10; i++) {
        
      /* in the following different ways of creating osc messages are shown by example */
      OscMessage myMessage = new OscMessage("/character"+charnum+"/joint"+i);
      
      if(i==9) {
        myMessage.add(x[0]); /* add an int to the osc message */
        myMessage.add(y[0]); /* add an int to the osc message */
        myMessage.add(PI-angle[9]);
      } else {
        myMessage.add(x[i]); /* add an int to the osc message */
        myMessage.add(y[i]); /* add an int to the osc message */
        myMessage.add(angle[i]);
      }
      
      if(printOSC) {
        println(charnum+" "+i+" "+x[i]+" "+y[i]+" "+angle[i]);
        myMessage.print();
      }
      
      /* send the message */
      oscP5Send.send(myMessage, myRemoteLocation);
    }
  }
  


  // drawing methods

  void drawSticks() {
    stroke(255, 255, 0);
    strokeWeight(3.0);

    line(sx[HEAD], sy[HEAD], sx[NECK], sy[NECK]);
    line(sx[NECK], sy[NECK], sx[TORSO], sy[TORSO]);

    line(sx[NECK], sy[NECK], sx[LEFT_SHOULDER], sy[LEFT_SHOULDER]);
    line(sx[LEFT_ELBOW], sy[LEFT_ELBOW], sx[LEFT_SHOULDER], sy[LEFT_SHOULDER]);
    line(sx[LEFT_ELBOW], sy[LEFT_ELBOW], sx[LEFT_HAND], sy[LEFT_HAND]);

    line(sx[NECK], sy[NECK], sx[RIGHT_SHOULDER], sy[RIGHT_SHOULDER]);    
    line(sx[RIGHT_ELBOW], sy[RIGHT_ELBOW], sx[RIGHT_SHOULDER], sy[RIGHT_SHOULDER]);    
    line(sx[RIGHT_ELBOW], sy[RIGHT_ELBOW], sx[RIGHT_HAND], sy[RIGHT_HAND]);    


    line(sx[RIGHT_HIP], sy[RIGHT_HIP], sx[RIGHT_KNEE], sy[RIGHT_KNEE]);    
    line(sx[RIGHT_FOOT], sy[RIGHT_FOOT], sx[RIGHT_KNEE], sy[RIGHT_KNEE]);    

    line(sx[LEFT_HIP], sy[LEFT_HIP], sx[LEFT_KNEE], sy[LEFT_KNEE]);    
    line(sx[LEFT_FOOT], sy[LEFT_FOOT], sx[LEFT_KNEE], sy[LEFT_KNEE]);    

    line(sx[LEFT_HIP], sy[LEFT_HIP], sx[RIGHT_HIP], sy[RIGHT_HIP]);    

    noStroke();
  }

  // drawing textured doll to screen

  void drawDoll() {
    drawTorso();
    drawHead();
    drawLimbs();

    fill(255);

    //text("sf "+SCALE_FACTOR, 20, 120);
  }

  void drawTorso() {

    int tex=SHOULDERS_HIPS;

    // rotate a rectangle around a point: (0, 0)
    //
    //    newX=(xr-xn)*cos(theta) - (yr-yn)*sin(theta) + xr
    //    newY=(yr-yn)*cos(theta) + (xr-xn)*sin(theta) + yr

    float dx=x[SHOULDERS_HIPS]-x[HEAD_NECK];
    float dy=y[SHOULDERS_HIPS]-y[HEAD_NECK];
    float theta=atan2(dy, dx)-HALF_PI;
    float costheta=cos(theta);
    float sintheta=sin(theta);
    float halfTexWidth=SCALE_FACTOR*bodyTextures[tex].width/2;
    float texHeight=SCALE_FACTOR*bodyTextures[tex].height;

    // calculate four corners of torso
    float x1, y1, x2, y2, x3, y3, x4, y4;

    // shoulder corners
    x1=x[HEAD_NECK]-halfTexWidth*costheta;
    y1=y[HEAD_NECK]-halfTexWidth*sintheta;
    x4=x[HEAD_NECK]+halfTexWidth*costheta;
    y4=y[HEAD_NECK]+halfTexWidth*sintheta;

    // hip corners
    x2=x[SHOULDERS_HIPS]-halfTexWidth*costheta;
    y2=y[SHOULDERS_HIPS]-halfTexWidth*sintheta;
    
    x3=x[SHOULDERS_HIPS]+halfTexWidth*costheta;
    y3=y[SHOULDERS_HIPS]+halfTexWidth*sintheta;
    
    if(drawDollTexture) {
      noStroke();
      beginShape();
      texture(bodyTextures[tex]);
      vertex(x1, y1, 0.0, 0.0, 0.0);
      vertex(x2, y2, 0.0, 0.0, (float)bodyTextures[tex].height);
      vertex(x3, y3, 0.0, (float)bodyTextures[tex].width, (float)bodyTextures[tex].height);
      vertex(x4, y4, 0.0, (float) bodyTextures[tex].width, 0.0);
      endShape();
    }
    
    if(drawDollOutline) {
      stroke(255,0,0, 64);
      noFill();
      beginShape();
      vertex(x1, y1, 0.0);
      vertex(x2, y2, 0.0);
      vertex(x3, y3, 0.0);
      vertex(x4, y4, 0.0);
      vertex(x1, y1, 0.0);
      endShape();
      stroke(255, 0, 255);
      line(x[HEAD_NECK], y[HEAD_NECK], 0.0, x[HEAD_NECK]+texHeight*cos(theta+HALF_PI), y[HEAD_NECK]+texHeight*sin(theta+HALF_PI), 0);  
    }
  }

  void drawHead() {

    // calc head coords
    // from neck position and head angle
    int tex=HEAD_NECK;

    float tw=SCALE_FACTOR*2.0*(float)bodyTextures[tex].width*cos((angle[HEAD_NECK]-HALF_PI));//bodyTextures[currtex].width;
    float th=SCALE_FACTOR*2.0*(float)bodyTextures[tex].width*sin((angle[HEAD_NECK]-HALF_PI));

    float x2=x[HEAD_NECK]-attachX[HEAD_NECK]*SCALE_FACTOR;
    float y2=y[HEAD_NECK]-attachY[HEAD_NECK]*SCALE_FACTOR;

    float x1=x2+len[HEAD_NECK]*SCALE_FACTOR*cos(angle[HEAD_NECK]);
    float y1=y2+len[HEAD_NECK]*SCALE_FACTOR*sin(angle[HEAD_NECK]);

    // draw head
    if(drawDollTexture) {
      noStroke();
      beginShape();
      texture(bodyTextures[tex]);
      vertex(x1, y1, 0.0, 0.0, 0.0);
      vertex(x2, y2, 0.0, 0.0, (float)bodyTextures[tex].height);
      vertex(x2+tw, y2+th, 0.0, (float)bodyTextures[tex].width, (float)bodyTextures[tex].height);
      vertex(x1+tw, y1+th, 0.0, (float) bodyTextures[tex].width, 0.0);    
      endShape();
    }
    
    if(drawDollOutline) {
      stroke(255,0,0, 64);
      noFill();
      beginShape();
      vertex(x1, y1, 0.0);
      vertex(x2, y2, 0.0);
      vertex(x2+tw, y2+th, 0.0);
      vertex(x1+tw, y1+th, 0.0);    
      vertex(x1, y1, 0.0);
      endShape();
    
      stroke(255, 0, 255);
      line(x[HEAD_NECK], y[HEAD_NECK], 0.0, x[HEAD_NECK]+len[tex]*SCALE_FACTOR*cos(angle[HEAD_NECK]), y[HEAD_NECK]+len[tex]*SCALE_FACTOR*sin(angle[HEAD_NECK]), 0.0);  
   
    }
  }

  void drawLimbs() {
    // left arm
    drawTexturedSegment(LEFT_SHOULDER_LEFT_ELBOW, x[LEFT_SHOULDER_LEFT_ELBOW], y[LEFT_SHOULDER_LEFT_ELBOW], angle[LEFT_SHOULDER_LEFT_ELBOW]);
    drawTexturedSegment(LEFT_ELBOW_LEFT_HAND, x[LEFT_ELBOW_LEFT_HAND], y[LEFT_ELBOW_LEFT_HAND], angle[LEFT_ELBOW_LEFT_HAND]);

    // right arm
    drawTexturedSegment(RIGHT_SHOULDER_RIGHT_ELBOW, x[RIGHT_SHOULDER_RIGHT_ELBOW], y[RIGHT_SHOULDER_RIGHT_ELBOW], angle[RIGHT_SHOULDER_RIGHT_ELBOW]);
    drawTexturedSegment(RIGHT_ELBOW_RIGHT_HAND, x[RIGHT_ELBOW_RIGHT_HAND], y[RIGHT_ELBOW_RIGHT_HAND], angle[RIGHT_ELBOW_RIGHT_HAND]);

    // left leg
    drawTexturedSegment(LEFT_HIP_LEFT_KNEE, x[LEFT_HIP_LEFT_KNEE], y[LEFT_HIP_LEFT_KNEE], angle[LEFT_HIP_LEFT_KNEE]);
    drawTexturedSegment(LEFT_KNEE_LEFT_FOOT, x[LEFT_KNEE_LEFT_FOOT], y[LEFT_KNEE_LEFT_FOOT], angle[LEFT_KNEE_LEFT_FOOT]);

    // right leg
    drawTexturedSegment(RIGHT_HIP_RIGHT_KNEE, x[RIGHT_HIP_RIGHT_KNEE], y[RIGHT_HIP_RIGHT_KNEE], angle[RIGHT_HIP_RIGHT_KNEE]);
    drawTexturedSegment(RIGHT_KNEE_RIGHT_FOOT, x[RIGHT_KNEE_RIGHT_FOOT], y[RIGHT_KNEE_RIGHT_FOOT], angle[RIGHT_KNEE_RIGHT_FOOT]);
  }

  void drawTexturedSegment(int seg, float x, float y, float a) {

    int currtex = texNums[seg];
    x=x-attachX[seg]*SCALE_FACTOR;
    y=y-attachY[seg]*SCALE_FACTOR;
    float tw=SCALE_FACTOR*(float)bodyTextures[currtex].width*cos((a-HALF_PI));//bodyTextures[currtex].width;
    float th=SCALE_FACTOR*(float)bodyTextures[currtex].width*sin((a-HALF_PI));

    float x2=x+len[seg]*cos(a)*SCALE_FACTOR;
    float y2=y+len[seg]*sin(a)*SCALE_FACTOR;

    if(drawDollTexture) {
      noStroke();
      beginShape();
      texture(bodyTextures[currtex]);
      vertex(x-tw, y-th, 0.0, 0.0, 0.0);
      vertex(x2-tw, y2-th, 0.0, 0.0, (float)bodyTextures[currtex].height);
      vertex(x2+tw, y2+th, 0.0, (float)bodyTextures[currtex].width, (float)bodyTextures[currtex].height);
      vertex(x+tw, y+th, 0.0, (float) bodyTextures[currtex].width, 0.0);
      endShape();
    }
    
    if(drawDollOutline) {
      stroke(255,0,0, 64);
      noFill();
      beginShape();
      vertex(x-tw, y-th, 0.0);
      vertex(x2-tw, y2-th, 0.0);
      vertex(x2+tw, y2+th, 0.0);
      vertex(x+tw, y+th, 0.0);
      vertex(x-tw, y-th, 0.0);
      endShape();
      
      stroke(255, 0, 255);
      //line(x, y, 0.0, x+bodyTextures[currtex].height*SCALE_FACTOR*cos(a), y+bodyTextures[currtex].height*SCALE_FACTOR*sin(a), 0.0);  
      line(x, y, 0.0, x+len[currtex]*SCALE_FACTOR*cos(a), y+len[currtex]*SCALE_FACTOR*sin(a), 0.0);
    }
  }


  // file loading

  void loadBodyTextures() {

    println("hello");

    String basepath = "warrior_princess_screen/";

    bodyTextures[HEAD_NECK]=loadImage(basepath+"HEAD_NECK.png");
    bodyTextures[LEFT_SHOULDER_LEFT_ELBOW]=loadImage(basepath+"LEFT_SHOULDER_LEFT_ELBOW.png"); 
    bodyTextures[LEFT_ELBOW_LEFT_HAND]=loadImage(basepath+"LEFT_ELBOW_LEFT_HAND.png");
    bodyTextures[LEFT_HIP_LEFT_KNEE]=loadImage(basepath+"LEFT_HIP_LEFT_KNEE.png");
    bodyTextures[LEFT_KNEE_LEFT_FOOT]=loadImage(basepath+"LEFT_KNEE_LEFT_FOOT.png");
    bodyTextures[RIGHT_SHOULDER_RIGHT_ELBOW]=loadImage(basepath+"RIGHT_SHOULDER_RIGHT_ELBOW.png"); 
    bodyTextures[RIGHT_ELBOW_RIGHT_HAND]=loadImage(basepath+"RIGHT_ELBOW_RIGHT_HAND.png");
    bodyTextures[RIGHT_HIP_RIGHT_KNEE]=loadImage(basepath+"RIGHT_HIP_RIGHT_KNEE.png");
    bodyTextures[RIGHT_KNEE_RIGHT_FOOT]=loadImage(basepath+"RIGHT_KNEE_RIGHT_FOOT.png");
    bodyTextures[SHOULDERS_HIPS]=loadImage(basepath+"SHOULDERS_HIPS.png");

    println("done loading body textures.");

    len[HEAD_NECK]=bodyTextures[HEAD_NECK].height;
    len[LEFT_SHOULDER_LEFT_ELBOW]=bodyTextures[LEFT_SHOULDER_LEFT_ELBOW].height;
    len[RIGHT_SHOULDER_RIGHT_ELBOW]=bodyTextures[RIGHT_SHOULDER_RIGHT_ELBOW].height;
    len[LEFT_ELBOW_LEFT_HAND]=bodyTextures[LEFT_ELBOW_LEFT_HAND].height;
    len[RIGHT_ELBOW_RIGHT_HAND]=bodyTextures[RIGHT_ELBOW_RIGHT_HAND].height;
    len[LEFT_HIP_LEFT_KNEE]=bodyTextures[LEFT_HIP_LEFT_KNEE].height*1.6;
    len[RIGHT_HIP_RIGHT_KNEE]=bodyTextures[RIGHT_HIP_RIGHT_KNEE].height*1.6;
    len[LEFT_KNEE_LEFT_FOOT]=bodyTextures[LEFT_KNEE_LEFT_FOOT].height*0.6;
    len[RIGHT_KNEE_RIGHT_FOOT]=bodyTextures[RIGHT_KNEE_RIGHT_FOOT].height*0.6;
    len[SHOULDERS_HIPS]=bodyTextures[SHOULDERS_HIPS].height;
    
    //print(len[SHOULDERS_HIPS]);
    
  }


  // printing methods


  void sayHello() {
    println("stupid message.");
  }


  void printScreenCoords() {

    // convert from Kinect 3d skeleton coordinates
    // to 2d screen space coorddinates.

    println("*** screen coords *** ");

    for (int i=0;i<numSegments;i++) {
      print(sx[i]); 
      print(","); 
      println(sy[i]);
    }
    println("***");
  }


  void printConstrainedCoords() {

    println("*** constrained coords *** ");
    for (int i=0;i<10;i++) {
      print(x[i]); 
      print(","); 
      println(y[i]);
    }
    println("***");
  }
}