From 95d6f9293939cfe068c0ab95ed4534e7982ff4ae Mon Sep 17 00:00:00 2001
From: Tim Redfern <tim@eclectronics.org>
Date: Wed, 12 Mar 2014 17:41:13 +0000
Subject: image searching

---
 offsetProject/src/imageStore.h | 104 ++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 102 insertions(+), 2 deletions(-)

(limited to 'offsetProject/src/imageStore.h')

diff --git a/offsetProject/src/imageStore.h b/offsetProject/src/imageStore.h
index 1db0ee2..5f30163 100644
--- a/offsetProject/src/imageStore.h
+++ b/offsetProject/src/imageStore.h
@@ -24,6 +24,10 @@ class imageStore : public ofThread{
 		imageStore(){
 			instagram_url = "https://api.instagram.com/v1/tags/tycleeson/media/recent?client_id=c1d74d701fdf4ddd9f8d30ee9e8f944b";
 			interval=5.00f;
+			ofImage img;
+			img.allocate(MAX_TILE_SIZE,MAX_TILE_SIZE,OF_IMAGE_COLOR);
+			images["000000"]=img;
+			colours["000000"]=ofColor(0,0,0);
 		}
 
 		void set_interval(float _interval){
@@ -38,6 +42,92 @@ class imageStore : public ofThread{
             stopThread();
         }
 
+        //naive implementation
+        //too slow!
+        //looks shit!
+
+        //how to make the search algorithm faster and better
+        //http://www.semanticmetadata.net/lire/
+
+     	/*
+		1. The box nature of the image matching isn't appealing
+		2. The way that the images flip quickly isn't appealing
+
+		can we improve this by changing the screen gradually in some way?
+
+		search tree/ octree
+
+		each node associates an image, start with a black image
+
+		a node owns a volume of RGB space
+
+		new image: determine which octant it lands in
+		subdivide the octant in R, G or B and give half to each image
+		
+		Q: does this lead to the possibility that images end up in the wrong place?
+
+		with the naive algorithm, we measure distance between the colours in RGB space
+
+		it becomes a long process because the number of calculations increases exponentially
+
+		space partitioning: we observe that the image will often be nearest to an image in the same box
+		although it may not be if they are at the edges
+
+		so at each level, each node of the tree contains a list of images
+
+		we traverse the tree and try to find the lowest level box with a match
+		if the lowest level box with a match has more than 1 we compute distance?
+
+		a difference algorithm
+		minimise the error
+		this involves comparing every pixel though
+
+		gpu?
+
+		put every quarter of every image into an image tree
+
+		every image has an entry on levels 1-8
+		start at level 8 (most detailed)
+		check the leaf node ie 10110101 01101001 00110101
+		if there are 1 or more images here choose one
+		if none go to the next level...
+
+		ie 1011010 0110100 0011010
+		if there are more than 1 images here find the nearest
+		if there is 1 choose it
+		if there are none go to the next level
+
+     	*/
+
+
+        std::map<std::string,ofColor> colours;
+        ofImage& get_image(const ofColor& col){
+        	//float shortest_dist=999999.0f;
+        	int sd=1000;
+        	ofImage& im=images.begin()->second;
+        	std::string s=images.begin()->first;
+        	for (map<string,ofImage>::iterator it=images.begin();it!=images.end();++it){
+        		ofColor& c=colours[it->first];
+        		int rd=c.v[0]-col.v[0];
+        		int gd=c.v[1]-col.v[1];
+        		int bd=c.v[2]-col.v[2];
+        		//float dist=pow((float)((rd*rd)+(gd*gd)+(bd*bd)),0.5);
+        		int dist=abs(rd)+abs(gd)+abs(bd);
+        		if (dist<sd){
+        			sd=dist;
+        			im=it->second;
+        			s=it->first;
+        		}
+        	}
+        	//cerr<<"got image "<<s<<endl;
+        	return im;
+        }
+        ofColor get_colour(const ofImage& _img){
+        	ofImage img=_img;
+        	img.resize(1,1);
+        	return ofColor(img.getPixels()[0],img.getPixels()[1],img.getPixels()[2]);
+        }
+
 		//--------------------------
 		void threadedFunction(){
 
@@ -54,7 +144,9 @@ class imageStore : public ofThread{
 					img.loadImage(ofToString(IMAGE_STORE_SIZE)+"/"+image_path.getFiles()[i].getFileName());
 					img.resize(MAX_TILE_SIZE,MAX_TILE_SIZE);
 					if( lock() ){
+						colours[image_path.getFiles()[i].getBaseName()]=get_colour(img);
 						images[image_path.getFiles()[i].getBaseName()]=img;
+						cerr<<image_path.getFiles()[i].getBaseName()<<": "<<colours[image_path.getFiles()[i].getBaseName()]<<endl;
 						to_update.push_back(image_path.getFiles()[i].getBaseName());
 						unlock();
 					}
@@ -92,6 +184,7 @@ class imageStore : public ofThread{
 							img.saveImage(ofToString(IMAGE_STORE_SIZE)+"/"+id+".png");
 							img.resize(MAX_TILE_SIZE,MAX_TILE_SIZE);
 							if( lock() ){
+								colours[id]=get_colour(img);
 								images[id]=img;
 								to_update.push_back(id);
 								unlock();
@@ -103,8 +196,8 @@ class imageStore : public ofThread{
 			}
 		}
 
-		//--------------------------
-		void draw(){
+		void update(){
+			//loads one texture
 			if( lock() ){
 				if (to_update.size()){
 					std::string im = to_update.front();
@@ -129,6 +222,13 @@ class imageStore : public ofThread{
 					//}
 					//cout<<"loaded "<<im<<" "<<ofToLong(im)%(long)(ofGetWidth()-images[im].getWidth()+1)<<","<<ofToLong(im)%(long)(ofGetHeight()-images[im].getHeight()+1)<<endl;
 				}
+				unlock();
+			}
+		}
+
+		//--------------------------
+		void draw(){
+			if( lock() ){
 				/*
 				for (map<string,ofImage>::iterator i=images.begin();i!=images.end();++i){
 					if(i->second.isUsingTexture()){
-- 
cgit v1.2.3