#include "ofxTrackedUser.h"
#include "ofxDepthGenerator.h"
#include "ofxUserGenerator.h"
 
float xL;
float yL;
float xR;
float yR;
float zDEPTH;
 
ofxTrackedUser::ofxTrackedUser(
	 ofxUserGenerator* pUserGenerator
	,ofxDepthGenerator* pDepthGenerator
) 
:neck(XN_SKEL_HEAD, XN_SKEL_NECK)
 
// left arm + shoulder
,left_shoulder(XN_SKEL_NECK, XN_SKEL_LEFT_SHOULDER)
,left_upper_arm(XN_SKEL_LEFT_SHOULDER, XN_SKEL_LEFT_ELBOW)
,left_lower_arm(XN_SKEL_LEFT_ELBOW, XN_SKEL_LEFT_HAND)
 
// right arm + shoulder
,right_shoulder(XN_SKEL_NECK, XN_SKEL_RIGHT_SHOULDER)
,right_upper_arm(XN_SKEL_RIGHT_SHOULDER, XN_SKEL_RIGHT_ELBOW)
,right_lower_arm(XN_SKEL_RIGHT_ELBOW, XN_SKEL_RIGHT_HAND)
 
// upper torso
,left_upper_torso(XN_SKEL_LEFT_SHOULDER, XN_SKEL_TORSO)
,right_upper_torso(XN_SKEL_RIGHT_SHOULDER, XN_SKEL_TORSO)
 
// left lower torso + leg
,left_lower_torso(XN_SKEL_TORSO, XN_SKEL_LEFT_HIP)
,left_upper_leg(XN_SKEL_LEFT_HIP, XN_SKEL_LEFT_KNEE)
,left_lower_leg(XN_SKEL_LEFT_KNEE, XN_SKEL_LEFT_FOOT)
 
// right lower torso + leg
,right_lower_torso(XN_SKEL_TORSO, XN_SKEL_RIGHT_HIP)
,right_upper_leg(XN_SKEL_RIGHT_HIP, XN_SKEL_RIGHT_KNEE)
,right_lower_leg(XN_SKEL_RIGHT_KNEE, XN_SKEL_RIGHT_FOOT)
 
,hip(XN_SKEL_LEFT_HIP, XN_SKEL_RIGHT_HIP)
,user_generator(pUserGenerator)
,depth_generator(pDepthGenerator) 
,xn_user_generator(&user_generator->getXnUserGenerator())
,is_tracked(false)
{
}
 
void ofxTrackedUser::updateBonePositions() {
	updateLimb(neck);
 
	// left arm + shoulder
	updateLimb(left_shoulder);
	updateLimb(left_upper_arm);
	updateLimb(left_lower_arm);
 
	// right arm + shoulder
	updateLimb(right_shoulder);
	updateLimb(right_upper_arm);
	updateLimb(right_lower_arm);
 
	// upper torso
	updateLimb(left_upper_torso);
	updateLimb(right_upper_torso);
 
	// left lower torso + leg
	updateLimb(left_lower_torso);
	updateLimb(left_upper_leg);
	updateLimb(left_lower_leg);
 
	// right lower torso + leg
	updateLimb(right_lower_torso);
	updateLimb(right_upper_leg);
	updateLimb(right_lower_leg);
 
	updateLimb(hip);	
}
 
void ofxTrackedUser::updateLimb(ofxLimb& rLimb) {
	if(!xn_user_generator->GetSkeletonCap().IsTracking(id)) {
		//printf("Not tracking this user: %d\n", id);
		return;
	}
 
	XnSkeletonJointPosition a,b;
	xn_user_generator->GetSkeletonCap().GetSkeletonJointPosition(id, rLimb.start_joint, a);
	xn_user_generator->GetSkeletonCap().GetSkeletonJointPosition(id, rLimb.end_joint, b);
	if(a.fConfidence < 0.3f || b.fConfidence < 0.3f) {
		rLimb.found = false; 
		return;
	}
 
	XnPoint3D pos[2];
	pos[0] = a.position;
	pos[1] = b.position;
	depth_generator->getXnDepthGenerator()
		.ConvertRealWorldToProjective(2, pos, pos);
 
	rLimb.found = true;
	rLimb.begin.set(pos[0].X, pos[0].Y);
	rLimb.end.set(pos[1].X, pos[1].Y);
	ofSetColor(255, 0, 0);
	//ofCircle(pos[0].X, pos[0].Y, 5);
 
	float xL = left_upper_arm.begin.x;
	float yL = left_upper_arm.begin.y;
 
	float xR = right_upper_arm.begin.x;
	float yR = right_upper_arm.begin.y;
 
	zDEPTH = xR - xL;
 
}
 
void ofxTrackedUser::debugDraw() {
	neck.debugDraw();
 
	// left arm + shoulder
	left_shoulder.debugDraw();
	left_upper_arm.debugDraw();
	left_lower_arm.debugDraw();
 
	// right arm + shoulder
	right_shoulder.debugDraw();
	right_upper_arm.debugDraw();
	right_lower_arm.debugDraw();
 
	// upper torso
	left_upper_torso.debugDraw();
	right_upper_torso.debugDraw();
 
	// left lower torso + leg
	left_lower_torso.debugDraw();
	left_upper_leg.debugDraw();
	left_lower_leg.debugDraw();
 
	// right lower torso + leg
	right_lower_torso.debugDraw();
	right_upper_leg.debugDraw();
	right_lower_leg.debugDraw();
 
	hip.debugDraw();
	ofDrawBitmapString(ofToString((int)id),neck.begin.x+ 10, neck.begin.y);
 
	ofCircle(neck.begin.x, neck.begin.y, zDEPTH);
 
}

// Text Rain (Processing cover version)
// Original by Camille Utterback and Romy Achituv (1999):
// http://camilleutterback.com/projects/text-rain/
// Implemented in Processing 1.2.1 by Golan Levin
 
import processing.video.*;
Capture video;
 
float brightnessThreshold = 50;
TextRainLetter poemLetters[];
int nLetters;
 
//-----------------------------------
void setup() {
  size(320,240); 
  video = new Capture(this, width, height);
 
  String poemString = "A poem about bodies";
  nLetters = poemString.length();
  poemLetters = new TextRainLetter[nLetters];
  for (int i=0; i<nLetters; i++) {
    char c = poemString.charAt(i);
    float x = width * (float)(i+1)/(nLetters+1);
    float y = 10;
    poemLetters[i] = new TextRainLetter(c,x,y);
  }
}
 
//-----------------------------------
void draw() {
  if (video.available()) {
    video.read();
    video.loadPixels();
    image (video, 0, 0, width, height); 
    for (int i=0; i<nLetters; i++) {
      poemLetters[i].update();
      poemLetters[i].draw();
    }
  }
}
 
 
 
//===================================================================
class TextRainLetter {
 
  float gravity = 1.5;
  char  c;
  float x; 
  float y;
  TextRainLetter (char cc, float xx, float yy) {
    c = cc;
    x = xx;
    y = yy;
  }
 
  //-----------------------------------
  void update() {
    // Update the position of a TextRainLetter. 
 
    // 1. Compute the pixel index corresponding to the (x,y) location of the particle.
    int index = width*(int)y + (int)x;
    index = constrain (index, 0, width*height-1);
 
    // 2. Fetch the color of the pixel there, and compute its brightness.
    float pixelBrightness = brightness(video.pixels[index]);
 
    // 3. If we're in a bright area, move downwards.
    //    If we're in a dark area, move up until we're in a light area.
    if (pixelBrightness > brightnessThreshold) {
      y += gravity; //move downward
 
    } else {
      while ((y > 0) && (pixelBrightness <= brightnessThreshold)){
        y -= gravity; // travel up intil it's bright 
        index = width*(int)y + (int)x;
        index = constrain (index, 0, width*height-1);
        pixelBrightness = brightness(video.pixels[index]);
      }
    }
 
    if ((y >= height-1) || (y < 0)){
      y = 0;
    }
  }
 
  //-----------------------------------
  void draw() {
    // Draw the letter. Use a simple black "drop shadow"
    // to achieve improved contrast for the typography. 
    fill(0);
    text (""+c, x+1,y+1); 
    text (""+c, x-1,y+1); 
    text (""+c, x+1,y-1); 
    text (""+c, x-1,y-1); 
    fill(255);
    text (""+c, x,y);
  }
}

#ifndef _TEST_APP
#define _TEST_APP
 
#include "ofMain.h"
 
class TextRainLetter {
public:
	char  c;
	float x; 
	float y;
 
	TextRainLetter (char cc, float xx, float yy);
	float getPixelBrightness (unsigned char *rgbPixels, int baseIndex);
	void update (unsigned char *rgbPixels, int width, int height, float threshold);
	void draw();
};
 
 
class testApp : public ofBaseApp {
 
	public:
 
		void setup();
		void update();
		void draw();
 
		void keyPressed(int key);
		void keyReleased(int key);
		void mouseMoved(int x, int y );
		void mouseDragged(int x, int y, int button);
		void mousePressed(int x, int y, int button);
		void mouseReleased(int x, int y, int button);
		void windowResized(int w, int h);
 
		ofVideoGrabber vidGrabber;
		int camWidth;
		int camHeight;
 
		float brightnessThreshold;
		vector <TextRainLetter>  poemLetters; 
		int nLetters;
};
 
#endif

#include "testApp.h"
 
//--------------------------------------------------------------
void testApp::setup(){	 
 
	camWidth  = 320;	
	camHeight = 240;
	vidGrabber.setVerbose(true);
	vidGrabber.initGrabber(camWidth,camHeight);
 
	brightnessThreshold = 50;
 
	string poemString = "A poem about bodies";
	nLetters = poemString.length();
	for (int i=0; i<nLetters; i++) {
		char  c = poemString[i];
		float x = camWidth * (float)(i+1)/(nLetters+1);
		float y = 10;
		poemLetters.push_back( TextRainLetter(c,x,y) );
	}
}
 
//--------------------------------------------------------------
void testApp::update(){
	vidGrabber.grabFrame();
	if (vidGrabber.isFrameNew()){
		unsigned char *videoPixels = vidGrabber.getPixels();
		for (int i=0; i<nLetters; i++) {
			poemLetters[i].update(videoPixels, camWidth, camHeight, brightnessThreshold);
		}
	}
}
 
//--------------------------------------------------------------
void testApp::draw(){
	ofBackground(100,100,100);
	ofSetHexColor(0xffffff);
	vidGrabber.draw(0,0);
 
	for (int i=0; i<nLetters; i++) {
		poemLetters[i].draw();
	}
}
 
//--------------------------------------------------------------
void testApp::keyPressed  (int key){}
void testApp::keyReleased(int key){}
void testApp::mouseMoved(int x, int y ){}
void testApp::mouseDragged(int x, int y, int button){}
void testApp::mousePressed(int x, int y, int button){}
void testApp::mouseReleased(int x, int y, int button){}
void testApp::windowResized(int w, int h){}
 
 
 
//=====================================================================
TextRainLetter::TextRainLetter (char cc, float xx, float yy) {
    // Constructor function
    c = cc;
    x = xx;
    y = yy;
}
 
//-----------------------------------
void TextRainLetter::draw(){
	char drawStr[1];
	sprintf(drawStr, "%c", c);
 
	ofSetColor(0,0,0);
	ofDrawBitmapString(drawStr, x-1,y-1);
	ofDrawBitmapString(drawStr, x+1,y-1);
	ofDrawBitmapString(drawStr, x-1,y+1);
	ofDrawBitmapString(drawStr, x+1,y+1);
 
	ofSetColor(255,255,255);
	ofDrawBitmapString(drawStr, x,y);
}
 
//-----------------------------------
void TextRainLetter::update (unsigned char *rgbPixels, int width, int height, float threshold) {
    int index = 3* (width*(int)y + (int)x);
    index = (int) ofClamp (index, 0, 3*width*height-1);
    float pixelBrightness = getPixelBrightness(rgbPixels, index);
 
    float gravity = 2.0;
    if (pixelBrightness > threshold) {
	y += gravity; 
 
    } else {
	while ((y > 0) && (pixelBrightness <= threshold)){
		y -= gravity; 
		index = 3* (width*(int)y + (int)x);
		index = (int) ofClamp (index, 0, 3*width*height-1);
		pixelBrightness = getPixelBrightness(rgbPixels, index);
	}
    }
 
    if ((y >= height-1) || (y < 10)){
	y = 10;
    }
}
 
//-----------------------------------
float TextRainLetter::getPixelBrightness (unsigned char *rgbPixels, int baseIndex){
	// small utility function
	int r = rgbPixels[baseIndex + 0];
	int g = rgbPixels[baseIndex + 1];
	int b = rgbPixels[baseIndex + 2];
	float pixelBrightness = (r+g+b)/3.0;
	return pixelBrightness;
}

// Schotter (1965) by Georg Nees.
// http://www.mediaartnet.org/works/schotter/
// Processing version by Golan Levin
 
// There are versions by other people at
// http://nr37.nl/software/georgnees/index.html
// http://www.openprocessing.org/visuals/?visualID=10429
// But IMHO these are inferior implementations;
// note e.g the misplaced origins for square rotation.
 
//-------------------------------
boolean go = true;
void setup() {
  size(325,565);
}
 
//-------------------------------
void draw() {
  if (go) {
    background (255);
    smooth();
    noFill();
 
    int nRows = 24;
    int nCols = 12;
    float S = 20;
    float marginX = (width  - (nCols*S))/2.0;
    float marginY = (height - (nRows*S))/2.0; 
 
    float maxRotation = (abs(mouseX)/(float)width) * 0.06; //radians
    float maxOffset =  (abs(mouseY)/(float)height) * 0.6;
 
    for (int i=0; i<nRows; i++) {
      for (int j=0; j<nCols; j++) {
        float x = marginX + j*S;
        float y = marginY + i*S;
 
        float rotationAmount = (i+1)*random(0-maxRotation, maxRotation); 
        float offsetX = i*random(0-maxOffset, maxOffset); 
        float offsetY = i*random(0-maxOffset, maxOffset); 
 
        pushMatrix();
        translate(S/2, S/2);
        translate(x+offsetX, y+offsetY);
        rotate(rotationAmount);
        translate(0-S/2, 0-S/2);
        rect(0,0,S,S);
        popMatrix();
      }
    }
  }
}
 
//-------------------------------
void keyPressed() {
  go = !go;
}

#include "testApp.h"
 
bool go;
//--------------------------------------------------------------
void testApp::setup(){
	go = true;
}
 
//--------------------------------------------------------------
void testApp::draw(){
 
	ofBackground(255,255,255);
	glEnable(GL_LINE_SMOOTH);
	ofSetColor(0,0,0);
	ofNoFill();
 
	int nRows = 24;
	int nCols = 12;
	float S = 20;
	float marginX = (ofGetWidth()  - (nCols*S))/2.0;
	float marginY = (ofGetHeight() - (nRows*S))/2.0; 
 
	float maxRotation = (abs(mouseX)/(float)ofGetWidth()) * 0.06; //radians
	float maxOffset =  (abs(mouseY)/(float)ofGetHeight()) * 0.6;
 
	for (int i=0; i < nRows; i++) {
		for (int j=0; j < nCols; j++) {
			float x = marginX + j*S;
			float y = marginY + i*S;
 
			float rotationAmount = (i+1)*ofRandom (0-maxRotation, maxRotation); 
			float offsetX = i* ofRandom (0-maxOffset, maxOffset); 
			float offsetY = i* ofRandom (0-maxOffset, maxOffset); 
 
			ofPushMatrix();
			ofTranslate (S/2, S/2, 0);
			ofTranslate (x+offsetX, y+offsetY);
			ofRotateZ   (RAD_TO_DEG * rotationAmount);
			ofTranslate (0-S/2, 0-S/2);
			ofRect(0,0,S,S);
			ofPopMatrix();
		}
	}
}
 
//--------------------------------------------------------------
void testApp::keyPressed(int key){
	go = !go;
	if (!go){
		ofSetFrameRate(1);
	} else {
		ofSetFrameRate(60);
	}
}
 
//--------------------------------------------------------------
void testApp::update(){}
void testApp::keyReleased(int key){}
void testApp::mouseMoved(int x, int y ){}
void testApp::mouseDragged(int x, int y, int button){}
void testApp::mousePressed(int x, int y, int button){}
void testApp::mouseReleased(int x, int y, int button){}
void testApp::windowResized(int w, int h){}