nice

1 files changed, 92 insertions, 72 deletions

diff --git a/offsetProject/src/ofApp.cpp b/offsetProject/src/ofApp.cpp
index 51795f5..c5163f9 100644
--- a/offsetProject/src/ofApp.cpp
+++ b/offsetProject/src/ofApp.cpp
@@ -5,27 +5,9 @@ so far so good, NOW
 
 threading
 
-parse response and identify new pictures
-save pictures & metadata - rather than reloading each time?
-local images format
-do we need any metadata? I guess not other than to know the tag id
-could save with the tag id as the name of file, simpler
-
-how exactly do we parse or mipmap the images
-do we worry about memory - I guess not
-
-identify the images
-
-image save- reload system (? even necessary ?)
 camera + button
 transitions
 
-should the loader own the images?
-should the whole image bank be locked while loading?
-alternatively each image could have a lock? - threadedImage
-
-or true mip map via drawsubsection?
-
 start with a max size say 64 - should be 16k inc mip maps
 
 graphics card has 2048MB
@@ -33,38 +15,29 @@ graphics card has 2048MB
 117964 textures
 I wonder is this faster with shared memory..
 
-load app
-get list of images in defined folder
-load them and create mip maps
-store indexed by file stub
-
-start thread
-when a new image comes in
-load and create mip maps
-
-how to store pictures
-threaded loader works away in the background
-when a new picture comes in 
+performance?
 
-a data structure which is part of the threaded object
-each image contains a mutex to enable the threaded object to be accessed
-the instagram id is just used to match against incoming - there needs to be the pattern matching algorithm
-
-how to draw pictures
-need to search the db for pictures of a certain colour
+use opencv to convert to floats? its a quick one..
 
 */
 //--------------------------------------------------------------
 void ofApp::setup() {
 	ofSetLogLevel(OF_LOG_WARNING);
-		
+
 	ofSetFrameRate(60);
 
-	kinect.setRegistration(true); 
+	kinect.setRegistration(true);
 	kinect.init();
 	kinect.open();
-	colourImage.allocate(kinect.width, kinect.height);
-	depthImage.allocate(kinect.width, kinect.height);
+	//colourImage.allocate(kinect.width, kinect.height);
+	//depthImage.allocate(kinect.width, kinect.height);
+	//floatImage.setNativeScale(0.0f,255.0f);
+	int h=ceil(ofGetHeight()/MAX_TILE_SIZE);
+	//int w=(h*4)/3;
+	//floatImage.allocate(w*FLANN_MATRIX_SIZE,h*FLANN_MATRIX_SIZE);
+	floatImage=new float[h*FLANN_MATRIX_SIZE*h*FLANN_MATRIX_SIZE*3];
+	//cerr<<"floatImage: "<<h<<"*"<<FLANN_MATRIX_SIZE<<"*"<<h<<"*"<<FLANN_MATRIX_SIZE<<"*3"<<endl;
+
 	farThreshold = 70;
 	angle = 0;
 	kinect.setCameraTiltAngle(angle);
@@ -72,27 +45,28 @@ void ofApp::setup() {
 	kinect.setDepthClipping(0,4000);
 
 	store.start();
-	
+
 	mode=MODE_COLOURTILES;
 
 	fullscreen=false;
 
 	tiledata=new float[FLANN_MATRIX_SIZE*FLANN_MATRIX_SIZE*3];
+	frametiledata=new float[FLANN_MATRIX_SIZE*FLANN_MATRIX_SIZE*3*h*h];
 }
 
 //--------------------------------------------------------------
 void ofApp::update() {
-	
+
 	ofSetWindowTitle(ofToString(ofGetFrameRate()));
-	
+
 	kinect.update();
-	
+
 	// there is a new frame and we are connected
 	if(kinect.isFrameNew()) {
-		
+
 		depthImage.setFromPixels(kinect.getDepthPixels(), kinect.width, kinect.height);
 		colourImage.setFromPixels(kinect.getPixels(), kinect.width, kinect.height);
-		
+
 		depthImage.threshold(farThreshold);
 
 		//threshold needs to be multiplied by the original
@@ -105,11 +79,49 @@ void ofApp::update() {
 		int h=ceil(ofGetHeight()/MAX_TILE_SIZE);
 		int w=(h*4)/3;
 		depthImage.resize(w,h);
-		colourImage.resize(w*FLANN_MATRIX_SIZE,h*FLANN_MATRIX_SIZE);
 		
+
+		int fh=h*FLANN_MATRIX_SIZE;
+		int fw=w*FLANN_MATRIX_SIZE;
+		colourImage.resize(fw,fh);
+
+		//cerr<<"needed: "<<h<<"*"<<FLANN_MATRIX_SIZE<<"*"<<h<<"*"<<FLANN_MATRIX_SIZE<<"*3"<<endl;
+
+
+		int kinexstart=(colourImage.getWidth()/2)+(colourImage.getHeight()/2);
+		uint8_t* cptr=colourImage.getPixels();
+		for (int i=0;i<fh;i++){
+			for (int j=0;j<fh;j++){
+				floatImage[(i*fh+j)*3]=cptr[(((i*fw)+kinexstart)-j)*3];
+				floatImage[(i*fh+j)*3+1]=cptr[(((i*fw)+kinexstart)-j)*3+1];
+				floatImage[(i*fh+j)*3+2]=cptr[(((i*fw)+kinexstart)-j)*3+2];
+			}
+		}
+/*
+		store.flann(cptr,w,h);
+
+		int tilestep=(FLANN_MATRIX_SIZE*FLANN_MATRIX_SIZE*3);
+		for (int i=0;i<h;i++){
+			for (int j=0;j<w;j++){
+				for (int k=0;k<FLANN_MATRIX_SIZE;k++){
+					for (int l=0;l<FLANN_MATRIX_SIZE;l++){
+						frametiledata[((k*FLANN_MATRIX_SIZE+l)*3)+(tilestep*(j*w+i))]=cptr[((i*FLANN_MATRIX_SIZE+k)*fw+kinexstart)-(j*FLANN_MATRIX_SIZE+l))*3];
+						frametiledata[((k*FLANN_MATRIX_SIZE+l)*3)+(tilestep*(j*w+i))]=cptr[((i*FLANN_MATRIX_SIZE+k)*fw+kinexstart)-(j*FLANN_MATRIX_SIZE+l))*3];
+						frametiledata[((k*FLANN_MATRIX_SIZE+l)*3)+(tilestep*(j*w+i))]=cptr[((i*FLANN_MATRIX_SIZE+k)*fw+kinexstart)-(j*FLANN_MATRIX_SIZE+l))*3];
+					}
+				}
+			}
+		}
+*/
+
+		//floatImage.allocate(w*FLANN_MATRIX_SIZE,h*FLANN_MATRIX_SIZE);
+		//floatImage=colourImage;
+		//floatImage.scaleIntoMe(colourImage);
+
 		// mark pixels and texture dirty
 		depthImage.flagImageChanged();
-		colourImage.flagImageChanged();
+		//colourImage.flagImageChanged();
+		//floatImage.flagImageChanged();
 
 		/*
 		ofxCvColorImage *prevCol=&colourImage;
@@ -129,8 +141,8 @@ void ofApp::update() {
 	}
 
 	store.update();
-	
-	
+
+
 }
 
 
@@ -142,7 +154,7 @@ void ofApp::draw() {
 
 	ofSetColor(255, 255, 255);
 
-	int w,xstart,ystart,kinexstart;
+	int fw,w,xstart,ystart,kinexstart;
 
 	switch(mode){
 		case MODE_COLOURTILES:
@@ -153,18 +165,25 @@ void ofApp::draw() {
 			ofPushMatrix();
 				ofTranslate(xstart,ystart);
 				w=colourImage.getWidth();
+				fw=colourImage.getHeight();
 				for (int i=0;i<depthImage.getHeight();i++){
 					for (int j=0;j<depthImage.getHeight();j++){
 						//uint8_t* ppt=&colourImage.getPixels()[((j*FLANN_MATRIX_SIZE)*w+(w-((i*FLANN_MATRIX_SIZE)+kinexstart)))*3];
-						
+
 						for (int k=0;k<FLANN_MATRIX_SIZE;k++){
 							for (int l=0;l<FLANN_MATRIX_SIZE;l++){
-								tiledata[(l*FLANN_MATRIX_SIZE+k)*3]=colourImage.getPixels()[((j*FLANN_MATRIX_SIZE+l)*w+(w-((i*FLANN_MATRIX_SIZE+k)+kinexstart)))*3];
-								tiledata[(l*FLANN_MATRIX_SIZE+k)*3+1]=colourImage.getPixels()[((j*FLANN_MATRIX_SIZE+l)*w+(w-((i*FLANN_MATRIX_SIZE+k)+kinexstart)))*3+1];
-								tiledata[(l*FLANN_MATRIX_SIZE+k)*3+2]=colourImage.getPixels()[((j*FLANN_MATRIX_SIZE+l)*w+(w-((i*FLANN_MATRIX_SIZE+k)+kinexstart)))*3+2];
+								
+								//tiledata[(l*FLANN_MATRIX_SIZE+k)*3]=colourImage.getPixels()[((j*FLANN_MATRIX_SIZE+l)*w+(w-((i*FLANN_MATRIX_SIZE+k)+kinexstart)))*3];
+								//tiledata[(l*FLANN_MATRIX_SIZE+k)*3+1]=colourImage.getPixels()[((j*FLANN_MATRIX_SIZE+l)*w+(w-((i*FLANN_MATRIX_SIZE+k)+kinexstart)))*3+1];
+								//tiledata[(l*FLANN_MATRIX_SIZE+k)*3+2]=colourImage.getPixels()[((j*FLANN_MATRIX_SIZE+l)*w+(w-((i*FLANN_MATRIX_SIZE+k)+kinexstart)))*3+2];
+								
+								tiledata[(l*FLANN_MATRIX_SIZE+k)*3]=floatImage[(((j*FLANN_MATRIX_SIZE+l)*fw)+(i*FLANN_MATRIX_SIZE)+k)*3];
+								tiledata[(l*FLANN_MATRIX_SIZE+k)*3+1]=floatImage[(((j*FLANN_MATRIX_SIZE+l)*fw)+(i*FLANN_MATRIX_SIZE)+k)*3+1];
+								tiledata[(l*FLANN_MATRIX_SIZE+k)*3+2]=floatImage[(((j*FLANN_MATRIX_SIZE+l)*fw)+(i*FLANN_MATRIX_SIZE)+k)*3+2];
+								
 							}
 						}
-						
+
 						//ofImage& im=store.get_image(ofColor(ppt[0],ppt[1],ppt[2]));
 						//ofSetColor(ppt[0],ppt[1],ppt[2]);
 						//ofRect(i*MAX_TILE_SIZE,j*MAX_TILE_SIZE,MAX_TILE_SIZE,MAX_TILE_SIZE);
@@ -188,7 +207,7 @@ void ofApp::draw() {
 			//colourImage.draw(640,0, 640,480);
 			break;
 	}
-    
+
 }
 
 
@@ -196,6 +215,7 @@ void ofApp::draw() {
 //--------------------------------------------------------------
 void ofApp::exit() {
 	delete tiledata;
+	delete floatImage;
 	kinect.setCameraTiltAngle(0); // zero the tilt on exit
 	kinect.close();
 }
@@ -203,70 +223,70 @@ void ofApp::exit() {
 //--------------------------------------------------------------
 void ofApp::keyPressed (int key) {
 	switch (key) {
-			
+
 		case '>':
 		case '.':
 			farThreshold ++;
 			if (farThreshold > 255) farThreshold = 255;
 			break;
-			
+
 		case '<':
 		case ',':
 			farThreshold --;
 			if (farThreshold < 0) farThreshold = 0;
 			break;
-			
-			
+
+
 		case 'w':
 			kinect.enableDepthNearValueWhite(!kinect.isDepthNearValueWhite());
 			break;
-			
+
 		case 'o':
 			kinect.setCameraTiltAngle(angle); // go back to prev tilt
 			kinect.open();
 			break;
-			
+
 		case 'c':
 			kinect.setCameraTiltAngle(0); // zero the tilt
 			kinect.close();
 			break;
-			
+
 		case '1':
 			kinect.setLed(ofxKinect::LED_GREEN);
 			break;
-			
+
 		case '2':
 			kinect.setLed(ofxKinect::LED_YELLOW);
 			break;
-			
+
 		case '3':
 			kinect.setLed(ofxKinect::LED_RED);
 			break;
-			
+
 		case '4':
 			kinect.setLed(ofxKinect::LED_BLINK_GREEN);
 			break;
-			
+
 		case '5':
 			kinect.setLed(ofxKinect::LED_BLINK_YELLOW_RED);
 			break;
-			
+
 		case '0':
 			kinect.setLed(ofxKinect::LED_OFF);
 			break;
-			
+
 		case OF_KEY_UP:
 			angle++;
 			if(angle>30) angle=30;
 			kinect.setCameraTiltAngle(angle);
 			break;
-			
+
 		case OF_KEY_DOWN:
 			angle--;
 			if(angle<-30) angle=-30;
 			kinect.setCameraTiltAngle(angle);
 			break;
-		
+
 		case OF_KEY_LEFT:
 			mode--;
 			if (mode<0) mode=NUM_MODES-1;