Merge branch 'Dev' of git.stim.ee.uh.edu:codebase/stimlib into Dev

Pavel Govyadinov
2 parents 27b826a8 db3c28c9
Showing 6 changed files with 917 additions and 291 deletions Show diff stats
FindSTIM.cmake
gl/gl_spider.h
stim/cuda/cost.h
stim/gl/gl_spider.h
stim/gl/gl_texture.h
stim/math/vector.h
+include(FindPackageHandleStandardArgs)
+
+set(STIM_INCLUDE_DIR $ENV{STIMLIB_PATH})
+
+find_package_handle_standard_args(STIM DEFAULT_MSG STIM_INCLUDE_DIR)
+
+if(STIM_FOUND)
+    set(STIM_INCLUDE_DIRS ${STIM_INCLUDE_DIR})
+endif()
 \ No newline at end of file
+#ifndef STIM_GL_SPIDER_H
+#define STIM_GL_SPIDER_H
+
+#include <GL/glew.h>
+#include <GL/glut.h>
+#include <cuda.h>
+#include <cuda_gl_interop.h>
+#include <cudaGL.h>
+#include "gl_texture.h"
+#include "../visualization/camera.h"
+#include "./error.h"
+#include "../math/vector.h"
+#include "../math/rect.h"
+#include "../cuda/cost.h"
+#include "../cuda/glbind.h"
+
+namespace stim
+{
+
+template<typename T>
+class gl_spider : public virtual gl_texture<T>
+{
+	//doen't use gl_texture really, just needs the GLuint id.
+	//doesn't even need the texture iD really.
+	private:
+		stim::camera rotator;
+		stim::vec<float> position;  	//vector designating the position of the spider.
+		stim::vec<float> direction;	//vector designating the orientation of the spider
+						//always a unit vector.
+		stim::vec<float> magnitude;	//magnitude of the direction vector.
+						//mag[0] = length.
+						//mag[1] = width.
+		using gl_texture<T>::texID;
+		//using image_stack<T>::S;
+		cudaArray* c_Array;
+		//void** devPtr;
+		//size_t size;
+		cudaGraphicsResource_t resource;
+		GLuint fboID;
+		GLuint texbufferID;
+
+		void
+		findOptimalDirection()
+		{
+			/* Method for finding the best direction for the spider.
+			   Uses the camera to rotate. Then Calls Evaluate to find new cost.
+			*/
+		}
+
+		void
+		findOptimalPosition()
+		{
+			/* Method for finding the best direction for the spider.
+			   Not sure if necessary since the next position for the spider
+			   will be at direction * magnitude. */
+		}
+	
+		void
+		findOptimalScale()
+		{
+			/* Method for finding the best scale for the spider.
+			   changes the x, y, z size of the spider to minimize the cost
+			   function. */
+		}
+
+		void
+		Evaluate()
+		{	
+			/* Uses uniform sampler2D in order to take a difference between
+			   the colors of two textures. 1st texture is the spider template,
+			   the 2nd is the location of the spider's overlap with the
+			   gl_template 
+	
+			   does the spider need to track it's location? Prob not since
+			   position can be set with gl_texture coordinates */
+		
+		}
+		
+		void
+		Optimize()
+		{
+			/*find the optimum direction and scale */ 
+		}
+		/*
+		void
+		Step()
+		{
+			// move to the new position 
+		}
+		*/
+	public:
+
+		stim::rect<float> hor;
+		stim::rect<float> ver;	
+
+
+
+		gl_spider
+		()
+		{
+			setPosition(0.0,0.0,0.0);
+			setDirection(1.0,1.0,1.0);
+			setMagnitude(0.1,0.1);
+			//GenerateFBO(400,200);
+			//Update();
+		}
+
+		gl_spider
+		(vec<float> pos, vec<float> dir, vec<float> mag)
+		{
+			position = pos;
+			direction = dir;
+			magnitude = mag;
+			//GenerateFBO(400,200);
+			//Update();
+		}
+		//temporary cost for convenience.	
+		gl_spider
+		(float pos_x, float pos_y, float pos_z, float dir_x, float dir_y, float dir_z,
+			float mag_x, float mag_y)
+		{
+			setPosition(pos_x, pos_y, pos_z);
+			setDirection(dir_x, dir_y, dir_z);
+			setMagnitude(mag_x, mag_y);
+			//GenerateFBO(400,200);
+			//Update();
+		}
+		
+		void
+		attachSpider(GLuint id)
+		{
+			texID = id;
+			GenerateFBO(400,200);
+			Update();
+		}
+
+		void
+		Update()
+		{
+			vec<float> Y(1.0,0.0,0.0);
+			if(cos(Y.dot(direction))< 0.087){
+				Y[0] = 0.0; Y[1] = 1.0;}
+			hor = stim::rect<float>(magnitude, position, direction.norm(),
+				((Y.cross(direction)).cross(direction)).norm());
+			ver = stim::rect<float>(magnitude, position, direction.norm(),
+				 hor.n());
+			UpdateBuffer();
+		}
+		
+		vec<float>
+		getPosition()
+		{
+			return position;
+		}
+	
+		vec<float>
+		getDirection()
+		{
+			return direction;
+		}
+
+		vec<float>
+		getMagnitude()
+		{
+			return magnitude;
+		}
+	
+		void
+		setPosition(vec<float> pos)
+		{
+			position = pos;
+		}
+		
+		void
+		setPosition(float x, float y, float z)
+		{
+			position[0] = x;
+			position[1] = y;
+			position[2] = z;
+		}
+
+		void
+		setDirection(vec<float> dir)
+		{
+			direction = dir;
+		}
+		
+		void
+		setDirection(float x, float y, float z)
+		{
+			direction[0] = x;
+			direction[1] = y;
+			direction[2] = z;
+		}
+		
+		void
+		setMagnitude(vec<float> mag)
+		{
+			magnitude = mag;
+		}
+		
+		void
+		setMagnitude(float x, float y)
+		{
+			magnitude[0] = x;
+			magnitude[1] = y;
+		}
+	
+		GLuint
+		getFB()
+		{
+			return fboID;
+		}
+
+		void
+		Step()
+		{
+			std::cout << position[0] << "," << position[1] << "," << position[1]
+				<< std::endl;
+			setPosition(direction*magnitude[1]/2+position);
+			Update();
+			std::cout << position[0] << "," << position[1] << "," << position[1]
+				<< std::endl;
+			
+		}
+
+		void
+		UpdateBuffer()
+		{	
+			stim::vec<float>p1; 
+        	        stim::vec<float>p2; 
+	                stim::vec<float>p3; 
+                	stim::vec<float>p4;	
+			glBindFramebuffer(GL_FRAMEBUFFER, fboID);
+			glFramebufferTexture2D(
+				GL_FRAMEBUFFER,
+				GL_COLOR_ATTACHMENT0,
+				GL_TEXTURE_2D,
+				texbufferID,
+				0);
+			glBindFramebuffer(GL_FRAMEBUFFER, fboID);
+			GLenum DrawBuffers[1] = {GL_COLOR_ATTACHMENT0};
+			glDrawBuffers(1, DrawBuffers);
+			glBindTexture(GL_TEXTURE_2D, texbufferID);
+			glClearColor(0,0,0,0);
+			glClear(GL_COLOR_BUFFER_BIT);
+			glMatrixMode(GL_PROJECTION);
+			glLoadIdentity();
+			glMatrixMode(GL_MODELVIEW);
+			glLoadIdentity();
+			glViewport(0,0,400,200);
+			gluOrtho2D(0.0,2.0,0.0,2.0);
+			glEnable(GL_TEXTURE_3D);
+			glBindTexture(GL_TEXTURE_3D, texID);
+			p1 = hor.p(1,1);
+			p2 = hor.p(1,0);
+			p3 = hor.p(0,0);
+			p4 = hor.p(0,1);
+			glBegin(GL_QUADS);
+				glTexCoord3f(
+					p1[0],
+					p1[1],
+					p1[2]
+					);
+				glVertex2f(0.0,0.0);
+				glTexCoord3f(
+					p2[0],
+					p2[1],
+					p2[2]
+					);
+				glVertex2f(1.0, 0.0);
+				glTexCoord3f(
+					p3[0],
+					p3[1],
+					p3[2]
+					);
+				glVertex2f(1.0, 2.0);
+				glTexCoord3f(
+					p4[0],
+					p4[1],
+					p4[2]
+					);
+				glVertex2f(0.0, 2.0);
+			 glEnd();
+			 p1 = ver.p(1,1);
+			 p2 = ver.p(1,0);
+			 p3 = ver.p(0,0);
+			 p4 = ver.p(0,1);
+		 	 glBegin(GL_QUADS);
+				glTexCoord3f(
+					p1[0],
+					p1[1],
+					p1[2]
+					);
+				glVertex2f(1.0, 0.0);
+				glTexCoord3f(
+					p2[0],
+					p2[1],
+					p2[2]
+					);
+				glVertex2f(2.0, 0.0);
+				glTexCoord3f(
+					p3[0],
+					p3[1],
+					p3[2]
+					);
+				glVertex2f(2.0, 2.0);
+				glTexCoord3f(
+					p4[0],
+					p4[1],
+					p4[2]
+					);
+				glVertex2f(1.0, 2.0);
+			glEnd();
+			glBindTexture(GL_TEXTURE_3D, 0);                      
+			glDisable(GL_TEXTURE_3D);
+			glBindFramebuffer(GL_FRAMEBUFFER,0);
+			glBindTexture(GL_TEXTURE_2D, 0);
+		}
+                                                                   
+
+		void
+		GenerateFBO(unsigned int width, unsigned int height)
+		{
+			glGenFramebuffers(1, &fboID);
+			glBindFramebuffer(GL_FRAMEBUFFER, fboID);
+			int numChannels = 1;
+			unsigned char* texels = new unsigned char[width * height * numChannels];
+			glGenTextures(1, &texbufferID);
+			glBindTexture(GL_TEXTURE_2D, texbufferID);
+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+			glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE,
+				 width, height, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, texels);   
+			delete[] texels;
+			glBindFramebuffer(GL_FRAMEBUFFER, 0); 
+		}
+
+
+		void
+		initCuda()
+		{	
+	/*		cudaDeviceProp prop;
+			int device;
+			memset( &prop, 0, sizeof(cudaDeviceProp) );
+			prop.major = 1;
+			prop.minor = 0;
+			HANDLE_ERROR( cudaChooseDevice (&device, &prop ) );
+			HANDLE_ERROR( cudaGetDeviceProperties(&prop, device));
+			printf("  device number: %d\n", device);
+    			printf("  device name: %s\n", prop.name);
+			printf("  device maxTexture3D: %d %d %d\n", prop.maxTexture3D[0] ,prop.maxTexture3D[0], prop.maxTexture3D[2]) ;
+			HANDLE_ERROR( cudaGLSetGLDevice (device)); */
+			stim::cudaSetDevice();
+/*			HANDLE_ERROR(
+				cudaGraphicsMapResources(1, &resource, 0)
+				    ); 
+			HANDLE_ERROR(
+				cudaGraphicsResourceGetMappedPointer(
+					&devPtr,
+					size,
+					resource));              
+			HANDLE_ERROR(
+				cudaGraphicsSubResourceGetMappedArray(
+					 &c_Array,
+					 resource,
+					 0,0) 
+				    );
+			HANDLE_ERROR(
+				cudaBindTextureToArray(fboID, c_Array)
+				    );
+			HANDLE_ERROR(
+				cudaGraphicsUnmapResources(1, &resource, 0)
+				    );	
+			//need to move the constants to video memory.
+*/			
+		}
+		
+		void
+		createResource()
+		{
+			HANDLE_ERROR(
+				cudaGraphicsGLRegisterImage(
+					 &resource,
+				 	fboID,
+				 	GL_TEXTURE_2D,
+				 	CU_GRAPHICS_REGISTER_FLAGS_NONE)
+			);
+		} 
+		
+		void
+		destroyResource()
+		{
+			HANDLE_ERROR(
+				cudaGraphicsUnregisterResource(resource)
+			);		
+		}
+
+		float
+		getCost()
+		{	
+			createResource();
+			float cost = 	get_cost(resource);
+			destroyResource();
+			return cost;
+		}
+};
+}
+#endif
@@ -6,8 +6,8 @@
 #include "../visualization/colormap.h"
 #include <sstream>
-#define DIM_Y 10890
-#define DIM_X 20
+
+///Cost function that works with the gl-spider class to find index of the item with min-cost.
 typedef unsigned char uchar;
 texture<uchar, cudaTextureType2D, cudaReadModeElementType> texIn;
 float *result;
@@ -24,7 +24,9 @@ inline void checkCUDAerrors(const char *msg)
 		}
 }
-
+///Finds the sum of all the pixes in a gives template element.
+///Returns the abosolute value.
+///@param *diff, a pointer to the memory block that holds the pixel-differences.
 float get_sum(float *diff)
 {
@@ -39,6 +41,9 @@ float get_sum(float *diff)
 	return out;
 }
+///A virtual representation of a uniform template.
+///Returns the value of the template pixel.
+///@param x, location of a pixel.
 __device__ float Template(int x)
 {
 	if(x < 20/6 || x > 20*5/6 || (x > 20*2/6 && x < 20*4/6)){
@@ -49,27 +54,29 @@ __device__ float Template(int x)
 }
+///Find the difference of the given set of samples and the template
+///using cuda acceleration.
+///@param *result, a pointer to the memory that stores the result.
 __global__
 void get_diff (float *result)
 {	
 	//cuPrintf("Hello");
 	int x 	= threadIdx.x + blockIdx.x * blockDim.x;
 	int y 	= threadIdx.y + blockIdx.y * blockDim.y;
-	int idx = y*DIM_X+x;	
+	int idx = y*20+x;	
-	//float valIn		= tex2D(texIn, x, y);
 	float valIn		= tex2D(texIn, x, y)/255.0;
 	float valTemp		= Template(x);
-	result[idx] 		= abs(valIn-valTemp);
-//	#if __CUDA_ARCH__>=200
-//		printf("Value is : %f\n and the result is : %f\n", valIn, result[idx]);
-//	#endif
+	result[idx]		= abs(valIn-valTemp);
 }
-
-void initArray(cudaGraphicsResource_t src)
+///Initialization function, allocates the memory and passes the necessary
+///handles from OpenGL and Cuda.
+///@param src, cudaGraphicsResource that handles the shared OpenGL/Cuda Texture
+///@param DIM_Y, integer controlling how much memory to allocate.
+void initArray(cudaGraphicsResource_t src, int DIM_Y)
 {
 	//cudaChannelFormatDesc channelDesc = cudaCreateChannelDesc<uchar> ();
 	//cudaMallocArray(&result, &channelDesc, DIM_X, DIM_Y, 0);
@@ -86,7 +93,7 @@ void initArray(cudaGraphicsResource_t src)
 	HANDLE_ERROR(
 		cudaBindTextureToArray(texIn, srcArray)
 		);
-	cudaMalloc( (void**) &result, DIM_X*DIM_Y*sizeof(float));
+	cudaMalloc( (void**) &result, 20*DIM_Y*sizeof(float));
         checkCUDAerrors("Memory Allocation Issue 1");	
 	cudaMalloc((void **) &v_dif, 20*10*sizeof(float));
         checkCUDAerrors("Memory Allocation Issue 2");	
@@ -94,7 +101,9 @@ void initArray(cudaGraphicsResource_t src)
 	//	cudaBindTextureToArray(texIn, ptr, &channelDesc)
 	//	    );		
 }
-
+///Deinit function that frees the memery used and releases the texture resource
+///back to OpenGL.
+///@param src, cudaGraphicsResource that handles the shared OpenGL/Cuda Texture
 void cleanUP(cudaGraphicsResource_t src)
 {
 	HANDLE_ERROR(
@@ -110,20 +119,23 @@ void cleanUP(cudaGraphicsResource_t src)
 		cudaFree(v_dif)
 	);
 }
-
+///External access-point to the cuda function
+///@param src, cudaGraphicsResource that handles the shared OpenGL/Cuda Texture
+///@param DIM_Y, the number of samples in the template.
+///@inter temporary paramenter that tracks the number of times cost.h was called.
 extern "C"
-int get_cost(cudaGraphicsResource_t src, int inter)
+int get_cost(cudaGraphicsResource_t src, int inter, int DIM_Y)
 {
-	float output[1089];
+	float output[DIM_Y];
 	float mini = 10000000000000000.0;
 	int idx;
-	stringstream name;
-	initArray(src);
-	dim3 grid(20, 10890);
+	stringstream name;	//for debugging
+	initArray(src, DIM_Y*10);
+	dim3 grid(20, DIM_Y*10);
 	dim3 block(1, 1);
 	get_diff <<< grid, block >>> (result);
-	stim::gpu2image<float>(result, "test.bmp", 20,10890,0,1);
-	for (int i = 0; i < 1089; i++){
+	stim::gpu2image<float>(result, "test.bmp", 20,DIM_Y*10,0,1);
+	for (int i = 0; i < DIM_Y; i++){
 		output[i] = get_sum(result+(20*10*i));
 		if(output[i] <= mini){
 			mini = output[i];
@@ -7,18 +7,24 @@
 #include <cuda_gl_interop.h>
 #include <cudaGL.h>
 #include <math.h>
-#include "../gl/gl_texture.h"
-#include "../visualization/camera.h"
-#include "./error.h"
-#include "../math/vector.h"
-#include "../math/rect.h"
-#include "../cuda/cost.h"
-#include "../cuda/glbind.h"
+#include "stim/gl/gl_texture.h"
+#include "stim/visualization/camera.h"
+#include "stim/gl/error.h"
+#include "stim/math/vector.h"
+#include "stim/math/rect.h"
+#include "stim/math/matrix.h"
+#include "stim/cuda/cost.h"
+#include "stim/cuda/glbind.h"
 #include <vector>
 #include <iostream>
 #include <fstream>
+
+
+/* Technically since gl_spider inherits from gl_texture, we could
+	call the init with a path to an image stack, and upload
+	the images while creating the spider (calling init) */
 namespace stim
 {
@@ -37,84 +43,271 @@ class gl_spider : public virtual gl_texture&lt;T&gt;
 		std::vector<stim::vec<float> > dirVectors;
 		std::vector<stim::vec<float> > posVectors;
 		std::vector<stim::vec<float> > magVectors;
+		stim::matrix<float, 4> currentTransform;
 		using gl_texture<T>::texID;
 		using gl_texture<T>::S;
-		cudaArray* c_Array;
-		//void** devPtr;
-		//size_t size;
+		using gl_texture<T>::R;
 		cudaGraphicsResource_t resource;
+
+		GLuint dList;
+		GLubyte list[3];
 		GLuint fboID;
 		GLuint texbufferID;
-		int iter = 0;			//temporary for testing
+		int iter;		//temporary for testing
+		int numSamples;
+		/// Method for finding the best scale for the spider.
+		/// changes the x, y, z size of the spider to minimize the cost
+		/// function. 
+		void
+		findOptimalDirection()
+		{
+			//genTemplate(dirVectors, 0);
+			Bind();
+			positionTemplate();
+			glCallList(dList);
+			int best = getCost();
+			stim::vec<float, 4> next;
+ 			next[0] = dirVectors[best][0]*S[1]*R[1];
+			next[1] = dirVectors[best][1]*S[2]*R[2];
+			next[2] = dirVectors[best][2]*S[3]*R[3];
+			next[3] = 1;
+			next = (currentTransform*next).norm();
+			setPosition(	position[0]+next[0]*magnitude[0]/3,
+					position[1]+next[1]*magnitude[0]/3,
+					position[2]+next[2]*magnitude[0]/3);
+			setDirection(next[0], next[1], next[2]);
+			Unbind();
+		}
+
+		/// Method for finding the best direction for the spider.
+		/// Not sure if necessary since the next position for the spider
+		/// will be at direction * magnitude.
 		void
 		findOptimalPosition()
 		{
-			/* Method for finding the best direction for the spider.
-			   Not sure if necessary since the next position for the spider
-			   will be at direction * magnitude. */
-			genTemplate(posVectors, 1);
+			Bind();
+			positionTemplate();
+			glCallList(dList+1);
 			int best = getCost();
+			stim::vec<float, 4> next;
+ 			next[0] = posVectors[best][0];
+			next[1] = posVectors[best][1];
+			next[2] = posVectors[best][2];
+			next[3] = 1;
+			next = currentTransform*next;
+			std::cout << "Optimal Position:"<< next << std::endl;
+			setPosition(	next[0]*S[1]*R[1],
+					next[1]*S[2]*R[2],
+					next[2]*S[3]*R[3]);
+			Unbind();
 		}
+		/// Method for finding the best scale for the spider.
+		/// changes the x, y, z size of the spider to minimize the cost
+		/// function. */
 		void
 		findOptimalScale()
 		{
-			/* Method for finding the best scale for the spider.
-			   changes the x, y, z size of the spider to minimize the cost
-			   function. */
-			genTemplate(magVectors, 1);
+			Bind();
+			positionTemplate();
+			glCallList(dList+2);
 			int best = getCost();
+			stim::vec<float, 4> next;
+ 			next[0] = magVectors[best][0]*S[1]*R[1];
+			next[1] = magVectors[best][1]*S[2]*R[2];
+			next[2] = magVectors[best][2]*S[3]*R[3];
+			next[3] = 1;
+			next = currentTransform*next;
+			std::cout << "Optimal Scale:"<< next << std::endl;
+			setMagnitude(next[0]);
+			Unbind();
 		}
+
+		
 		void
-		findOptimalDirection()
+		Optimize()
 		{
-			/* Method for finding the best scale for the spider.
-			   changes the x, y, z size of the spider to minimize the cost
-			   function. */
-			genTemplate(dirVectors, 1);
-			int best = getCost();
+			/*find the optimum direction and scale */ 
 		}
+		
+		
+//--------------------------------------------------------------------------//
+//---------------------TEMPLATE CREATION METHODS----------------------------//
+//--------------------------------------------------------------------------//
+
+		///@param solidAngle, the size of the arc to sample.
+		///Method for populating the vector arrays with sampled vectors.
+		///uses the default direction vector <0,0,1>
 		void
-		Optimize()
+		genDirectionVectors(float solidAngle = M_PI)
 		{
-			/*find the optimum direction and scale */ 
+			vec<float> d_s = direction.cart2sph().norm();
+			vec<float> temp;
+			int dim = (sqrt(numSamples)-1)/2;
+			float p0  	= -M_PI;
+			float dt  	= solidAngle/(2.0 * ((float)dim + 1.0));
+			float dp  	= p0/(2.0*((float)dim + 1.0));
+	
+			for(int i = -dim; i <= dim; i++){
+				for(int j = -dim; j <= dim; j++){
+					//Create linear index
+					
+					temp[0] = d_s[0]; 			//rotate vector
+					temp[1] = d_s[1]+dp*(float) i;
+					temp[2] = d_s[2]+dt*(float) j;
+					
+					temp = (temp.sph2cart()).norm();	//back to cart
+					dirVectors.push_back(temp);
+				}
+			}
 		}
-		/*
+
+		///@param solidAngle, the size of the arc to sample.
+		///Method for populating the buffer with the sampled texture.
+		///uses the default vector <0,0,0>
 		void
-		Step()
+		genPositionVectors(float delta = 0.2)
 		{
-			// move to the new position 
+			ofstream file;
+			//file.open("dvectors.txt");	
+			vec<float> temp;
+			int dim = (sqrt(numSamples)-1)/2;
+			stim::rect<float> samplingPlane =
+				 stim::rect<float>(magnitude[0]*delta, position, direction);
+			float step = 1.0/(dim);
+			//Loop over the samples, keeping the original position sample
+			//in the center of the resulting texture.
+
+			for(int i = -dim; i <= dim; i++){
+				for(int j = -dim; j <= dim; j++){
+					//Create linear index
+
+					temp = samplingPlane.p(
+							0.5+step*i,
+								 0.5+step*j
+										);
+					//file << temp[0] << ";" << temp[1]
+					//	 << ";" << temp[2] << endl;
+					posVectors.push_back(temp);
+				}
+			}
 		}
-		*/
-		
+
+		///@param solidAngle, the size of the arc to sample.
+		///Method for populating the buffer with the sampled texture.
+		///uses the default magnitude <1,1,0>
 		void
-		GenerateFBO(unsigned int width, unsigned int height)
+		genMagnitudeVectors(float delta = 0.5)
 		{
-			glGenFramebuffers(1, &fboID);
-			glBindFramebuffer(GL_FRAMEBUFFER, fboID);
-			int numChannels = 1;
-			unsigned char* texels = new unsigned char[width * height * numChannels];
-			glGenTextures(1, &texbufferID);
-			glBindTexture(GL_TEXTURE_2D, texbufferID);
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-			glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE,
-				 width, height, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, texels);   
-			delete[] texels;
-			glBindFramebuffer(GL_FRAMEBUFFER, 0); 
-			glBindTexture(GL_TEXTURE_2D, 0);
+			
+			int dim = (sqrt(numSamples)-1)/2;
+			float min 	= 1.0-delta;
+			float max 	= 1.0+delta;
+			float step	= (max-min)/(numSamples-1);
+			float factor;
+			vec<float> temp;
+
+			for(int i = 0; i < numSamples; i++){
+				//Create linear index
+				factor = (min+step*i)*magnitude[0];
+				temp = factor;
+				magVectors.push_back(temp);	
+			}
 		}
+		///@param vector of stim::vec in that stores all of the samplable vectors.
+		///@param type, one of three operations, 0 for Direction vectors
+		///	1 for Position, 2 for Magnitude.
+		///Function for filling the buffer up with the data based on the vectors
+		///Each vector represents a two rectangular templates.
+		///Loops through all of the vectors and transfers rect. associated with it
+		///Into buffer-space.
+		void
+		genTemplate(std::vector<stim::vec<float> > in, int type)
+		{
+			float x = 0.0;
+			vec<float> Y(1.0,0.0,0.0);
+			vec<float> pos(0.0,0.0,0.0);
+			vec<float> mag(1.0, 1.0, 1.0);
+			vec<float> dir(0.0, 0.0, 1.0);
+                        switch(type) {
+				case 0:          //Direction
+					Bind();
+					glNewList(dList+type, GL_COMPILE);
+					for(int i = 0; i < in.size(); i++)
+					{
+					 	if(cos(Y.dot(in[i]))< 0.087){                                                                             Y[0] = 0.0; Y[1] = 1.0;}
+						else{Y[0] = 1.0; Y[1] = 0.0;}
+
+                                         	hor = stim::rect<float>(mag,
+							 pos, in[i],
+                        				((Y.cross(in[i])).cross(in[i])).norm());
+              				 	ver = stim::rect<float>(mag,
+							 pos, in[i],
+                        				hor.n());
+						UpdateBuffer(x, x+i*10.0);
+					 }
+					 glEndList();
+					 Unbind();
+               				 break;
+        			case 1:		 //Position
+					Bind();	
+					glNewList(dList+type, GL_COMPILE);
+					if(cos(Y.dot(direction))< 0.087){                                                                             Y[0] = 0.0; Y[1] = 1.0;}
+					else{Y[0] = 1.0; Y[1] = 0.0;}
+
+					for(int i = 0; i < in.size(); i++)
+					{
+                				hor = stim::rect<float>(mag,
+							 in[i], dir,
+                      					((Y.cross(direction)).cross(direction))
+							.norm());
+                				ver = stim::rect<float>(mag,
+							 in[i], dir,
+                        				hor.n());
+						UpdateBuffer(x, x+i*10.0);
+					 }
+					 glEndList();
+					 Unbind();
+                			 break;
+        			case 2:		  //Scale
+					Bind();	
+					glNewList(dList+type, GL_COMPILE);
+					if(cos(Y.dot(direction))< 0.087){                                                                             Y[0] = 0.0; Y[1] = 1.0;}
+					else{Y[0] = 1.0; Y[1] = 0.0;}
+                			for(int i = 0; i < in.size(); i++)
+					{
+						hor = stim::rect<float>(in[i],
+							 pos, dir,
+                      					((Y.cross(direction)).cross(direction))
+							.norm());
+                				ver = stim::rect<float>(in[i],
+							 pos, dir,
+                        				hor.n());
+						UpdateBuffer(x, x+i*10.0);
+					}
+					glEndList();
+					Unbind();
+					break;
+        			default:
+                			 std::cout << "unknown case have been passed"
+                         			<< std::endl;
+					 break;
+			}               
+		Unbind();
+		CHECK_OPENGL_ERROR
+		}
+		///@param v_x x-coordinate in buffer-space,
+		///@param v_y y-coordinate in buffer-space.
+		///Samples the texturespace and places a sample in the provided coordinates
+		///of bufferspace.
 		void
 		UpdateBuffer(float v_x, float v_y)
 		{	
-			//std::cout << v_y << std::endl;
 			float len = 10.0;
 			stim::vec<float>p1; 
         	        stim::vec<float>p2; 
@@ -126,158 +319,97 @@ class gl_spider : public virtual gl_texture&lt;T&gt;
 			p4 = hor.p(0,1);
 			glBegin(GL_QUADS);
 				glTexCoord3f(
-				//	p1[0]/S[1],
-				//	p1[1]/S[2],
-				//	p1[2]/S[3]
-				//	);
 					p1[0],
 					p1[1],
 					p1[2]
 					);
-				//glVertex2f(0.0,0.0);
 				glVertex2f(v_x,v_y);
 				glTexCoord3f(
-				//	p2[0]/S[1],
-				//	p2[1]/S[2],
-				//	p2[2]/S[3]
 					p2[0],
 					p2[1],
 					p2[2]
 					);
-				//glVertex2f(1.0, 0.0);
 				glVertex2f(v_x+len, v_y);
 				glTexCoord3f(
-				//	p2[0]/S[1],
-				//	p2[1]/S[2],
-				//	p2[2]/S[3]
 					p3[0],
 					p3[1],
 					p3[2]
 					);
-				//glVertex2f(1.0, 2.0);
 				glVertex2f(v_x+len, v_y+len);
 				glTexCoord3f(
-				//	p4[0]/S[1],
-				//	p4[1]/S[2],
-				//	p4[2]/S[3]
 					p4[0],
 					p4[1],
 					p4[2]
 					);
-				//glVertex2f(0.0, 2.0);
 				glVertex2f(v_x, v_y+len);
 			 glEnd();
+
 			 p1 = ver.p(1,1);
 			 p2 = ver.p(1,0);
 			 p3 = ver.p(0,0);
 			 p4 = ver.p(0,1);
 		 	 glBegin(GL_QUADS);
 				glTexCoord3f(
-				//	p1[0]/S[1],
-				//	p1[1]/S[2],
-				//	p1[2]/S[3]
 					p1[0],
 					p1[1],
 					p1[2]
 					);
-				//glVertex2f(1.0, 0.0);
 				glVertex2f(v_x+len, v_y);
 				glTexCoord3f(
-				//	p2[0]/S[1],
-				//	p2[1]/S[2],
-				//	p2[2]/S[3]
 					p2[0],
 					p2[1],
 					p2[2]
 					);
-				//glVertex2f(2.0, 0.0);
 				glVertex2f(v_x+2*len, v_y);
 				glTexCoord3f(
-				//	p3[0]/S[1],
-				//	p3[1]/S[2],
-				//	p3[2]/S[3]
 					p3[0],
 					p3[1],
 					p3[2]
 					);
-				//glVertex2f(2.0, 2.0);
 				glVertex2f(v_x+2*len, v_y+len);
 				glTexCoord3f(
-				//	p4[0]/S[1],
-				//	p4[1]/S[2],
-				//	p4[2]/S[3]
 					p4[0],
 					p4[1],
 					p4[2]
 					);
-				//glVertex2f(1.0, 2.0);
 				glVertex2f(v_x+len, v_y+len);
-			glEnd();
+			glEnd(); 
+			CHECK_OPENGL_ERROR
 		}
+		
-		void
-		genTemplate(std::vector<stim::vec<float> > in, int type = 0)
-		{
-			float x = 0.0;
-			vec<float> Y(1.0,0.0,0.0);
-			Bind();	
-                        switch(type) {
-				case 0:          //Direction
-					for(int i = 0; i < in.size(); i++)
-					{
-					 	if(cos(Y.dot(in[i]))< 0.087){                                                                             Y[0] = 0.0; Y[1] = 1.0;}
-						else{Y[0] = 1.0; Y[1] = 0.0;}
-
-                                         	hor = stim::rect<float>(magnitude,
-							 position, in[i],
-                        				((Y.cross(in[i])).cross(in[i])).norm());
-              				 	ver = stim::rect<float>(magnitude,
-							 position, in[i],
-                        				hor.n());
-						UpdateBuffer(x, x+i*10.0);
-					 }
-               				 break;
-        			case 1:		 //Position
-					if(cos(Y.dot(direction))< 0.087){                                                                             Y[0] = 0.0; Y[1] = 1.0;}
-					else{Y[0] = 1.0; Y[1] = 0.0;}
-					for(int i = 0; i < in.size(); i++)
-					{
-                				hor = stim::rect<float>(magnitude, in[i], direction,
-                      					((Y.cross(direction)).cross(direction))
-							.norm());
-                				ver = stim::rect<float>(magnitude, in[i], direction,
-                        				hor.n());
-						UpdateBuffer(x, x+i*10.0);
-					 }
-                			 break;
-        			case 2:		  //Scale
-					if(cos(Y.dot(direction))< 0.087){                                                                             Y[0] = 0.0; Y[1] = 1.0;}
-					else{Y[0] = 1.0; Y[1] = 0.0;}
+//--------------------------------------------------------------------------//
+//--------------------------------GL METHODS--------------------------------//
+//--------------------------------------------------------------------------//
-                			for(int i = 0; i < in.size(); i++)
-					{
-						hor = stim::rect<float>(in[i], position, direction,
-                      					((Y.cross(direction)).cross(direction))
-							.norm());
-                				ver = stim::rect<float>(in[i], position, direction,
-                        				hor.n());
-					}
-					break;
-        			default:
-                			 std::cout << "unknown case have been passed"
-                         			<< std::endl;
-					 break;
-			}               
-		Unbind();
+		///@param width sets the width of the buffer.
+		///@param height sets the height of the buffer.
+		///Function for setting up the 2D buffer that stores the samples.
+		void
+		GenerateFBO(unsigned int width, unsigned int height)
+		{
+			glGenFramebuffers(1, &fboID);
+			glBindFramebuffer(GL_FRAMEBUFFER, fboID);
+			int numChannels = 1;
+			unsigned char* texels = new unsigned char[width * height * numChannels];
+			glGenTextures(1, &texbufferID);
+			glBindTexture(GL_TEXTURE_2D, texbufferID);
+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+			glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE,
+				 width, height, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, texels);   
+			delete[] texels;
+			glBindFramebuffer(GL_FRAMEBUFFER, 0); 
+			glBindTexture(GL_TEXTURE_2D, 0);
 		}
-		
-		/*
-		Method for controling the buffer and texture binding in order to properly
-		do the render to texture.
-		*/
+
+		///Method for controling the buffer and texture binding in order to properly
+		///do the render to texture.
 		void
-		Bind(int numSamples = 1089)
+		Bind()
 		{
 			float len = 10.0;
 			glBindFramebuffer(GL_FRAMEBUFFER, fboID);//set up GL buffer		
@@ -291,7 +423,7 @@ class gl_spider : public virtual gl_texture&lt;T&gt;
 			GLenum DrawBuffers[1] = {GL_COLOR_ATTACHMENT0};
 			glDrawBuffers(1, DrawBuffers);
 			glBindTexture(GL_TEXTURE_2D, texbufferID);
-			glClearColor(0,0,0,0);
+			glClearColor(1,1,1,1);
 			glClear(GL_COLOR_BUFFER_BIT);
 			glMatrixMode(GL_PROJECTION);
 			glLoadIdentity();
@@ -301,11 +433,11 @@ class gl_spider : public virtual gl_texture&lt;T&gt;
 			gluOrtho2D(0.0,2.0*len,0.0,numSamples*len);
 			glEnable(GL_TEXTURE_3D);
 			glBindTexture(GL_TEXTURE_3D, texID);
+
+			CHECK_OPENGL_ERROR
 		}
-		/*
-		Method for Unbinding all of the texture resources
-		*/	
+		///Method for Unbinding all of the texture resources
 		void
 		Unbind()
 		{
@@ -316,88 +448,42 @@ class gl_spider : public virtual gl_texture&lt;T&gt;
 			glBindTexture(GL_TEXTURE_2D, 0);
 		}
-		/*
-		Method for populating the buffer with the sampled texture.
-		usually uses the default direction vector and then
-		*/
-		void
-		genDirectionVectors(int numSamples = 1089, float solidAngle = M_PI/1.5)
+		///Method for using the gl manipulation to alighn templates from
+		///Template space (-0.5 0.5) to Texture space (0.0, 1.0),
+		///Based on the position of the spider in real space (arbitrary).
+		void positionTemplate()
 		{
-			
-			vec<float> d_s = direction.cart2sph();
-			dirVectors.resize(1089);
-			vec<float> temp;
-			int dim = (sqrt(numSamples)-1)/2;
-			float p0  	= M_PI/3;
-			float dt  	= solidAngle/(1.0 * dim);
-			float dp  	= p0/(1.0*dim);
-	
-			for(int i = -dim; i <= dim; i++){
-				for(int j = -dim; j <= dim; j++){
-					//Create linear index
-					
-					temp[0] = d_s[0]; 			//rotate vector
-					temp[1] = d_s[1]+dt*i;
-					temp[2] = d_s[2]+dp*j;
-
-					temp = (temp.sph2cart()).norm();		//back to cart
-					dirVectors.push_back(temp);
-				}
-			}
-		}
+			stim::vec<float, 4> rot = getRotation(direction);
+			glMatrixMode(GL_TEXTURE);
+			glLoadIdentity();
-		void
-		genPositionVectors(int numSamples = 1089, float delta = 0.2)
-		{
+			glRotatef(rot[0], rot[1], rot[2], rot[3]);
+			glScalef(1.0/S[1]/R[1], 1.0/S[2]/R[2], 1.0/S[3]/R[3]);
+			glTranslatef(position[0],
+				     position[1],
+				     position[2]);
+			glScalef(magnitude[0],
+				 magnitude[1],
+				 magnitude[0]);
+
+			float curTrans[16];
+			glGetFloatv(GL_TEXTURE_MATRIX, curTrans);
+			fillTransform(curTrans);
+			printTransform();
-			vec<float> temp;
-			int dim = (sqrt(numSamples)-1)/2;
-			stim::rect<float> samplingPlane =
-				 stim::rect<float>(magnitude[0]*delta, position, direction);
-			float step = 1.0/(dim);
-			//Loop over the samples, keeping the original position sample
-			//in the center of the resulting texture.
-
-			int idx;
-			for(int i = -dim; i <= dim; i++){
-				for(int j = -dim; j <= dim; j++){
-					//Create linear index
-
-					temp = samplingPlane.p(
-							0.5+step*i,
-								 0.5+step*j
-										);
-					dirVectors.push_back(temp);
-				}
-			}
+			CHECK_OPENGL_ERROR
+			glMatrixMode(GL_MODELVIEW);
 		}
+		
+		
-		void
-		genMagnitudeVectors(int numSamples = 1089, float delta = 0.5)
-		{
-			
-			int dim = (sqrt(numSamples)-1)/2;
-			float min 	= 1.0-delta;
-			float max 	= 1.0+delta;
-			float step	= (max-min)/(numSamples-1);
-			float factor;
-			vec<float> temp;
-
-			for(int i = 0; i < numSamples; i++){
-				//Create linear index
-				factor = (min+step*i)*magnitude[0];
-				temp[0] = factor;
-				temp[1] = factor;
-				magVectors.push_back(temp);	
-			}
-		}
 //--------------------------------------------------------------------------//
 //--------------------------------CUDA METHODS------------------------------//
 //--------------------------------------------------------------------------//
-		/* Method for registering the texture with Cuda for shared
-			access */
+		/// Method for registering the texture with Cuda for shared
+		///	access.
 		void
 		createResource()
 		{
@@ -411,7 +497,7 @@ class gl_spider : public virtual gl_texture&lt;T&gt;
 			);
 		} 
-		/* Method for freeing the texture from Cuda for gl access */
+		///Method for freeing the texture from Cuda for gl access.
 		void
 		destroyResource()
 		{
@@ -420,23 +506,27 @@ class gl_spider : public virtual gl_texture&lt;T&gt;
 			);		
 		}
-		/* Entry-point into the cuda code for calculating the cost
-			of a given samples array (in texture form) */
+		///Entry-point into the cuda code for calculating the cost
+		///	of a given samples array (in texture form) 
 		int
 		getCost()
 		{
 			createResource();
-			int cost = 	get_cost(resource, iter);
+			int cost = 	get_cost(resource, iter, numSamples);
 			destroyResource();
 			iter++;
 			return cost;
 		}
 	public:
-
 		stim::rect<float> hor;
 		stim::rect<float> ver;	
+//--------------------------------------------------------------------------//
+//-----------------------------CONSTRUCTORS---------------------------------//
+//--------------------------------------------------------------------------//
+
+
 		///Default Constructor
 		gl_spider
 		()
@@ -444,6 +534,19 @@ class gl_spider : public virtual gl_texture&lt;T&gt;
 			setPosition(0.0,0.0,0.0);
 			setDirection(0.0,0.0,1.0);
 			setMagnitude(1.0);
+			numSamples = 1089;
+			//numSamples = 9;
+		}
+		///@param samples, the number of samples this spider is going to use.
+		///best results if samples is can create a perfect root.
+		///Default Constructor
+		gl_spider
+		(int samples)
+		{
+			setPosition(0.0,0.0,0.0);
+			setDirection(0.0,0.0,1.0);
+			setMagnitude(1.0);
+			numSamples = samples;
 		}
 		///temporary constructor for convenience, will be removed in further updates.	
@@ -451,38 +554,39 @@ class gl_spider : public virtual gl_texture&lt;T&gt;
 		(float pos_x, float pos_y, float pos_z, float dir_x, float dir_y, float dir_z,
 			float mag_x)
 		{
-			//setPosition(pos_x, pos_y, pos_z);
-			//setDirection(dir_x, dir_y, dir_z);
-			//setMagnitude(mag_x);
+			setPosition(pos_x, pos_y, pos_z);
+			setDirection(dir_x, dir_y, dir_z);
+			setMagnitude(mag_x);
+		
 		}
 		///@param GLuint id texture that is going to be sampled.
-		///@param numSamples number of samples per operation.
 		///Attached the spider to the texture with the given GLuint ID.
-		///Samples in the default direction acting as the init method.	
+		///Samples in the default direction acting as the init method.
+		///Also acts an init.	
 		void
-		attachSpider(GLuint id, int numSamples = 1089)
+		attachSpider(GLuint id)
 		{
 			texID = id;
+			iter = 0; ///for debugging purposes
 			GenerateFBO(20, numSamples*10);
-			//sampleDirection();
 			genDirectionVectors();
+			genPositionVectors();
+			genMagnitudeVectors();
+
 			gl_texture<T>::setDims(0.6, 0.6, 1.0);
-			//gl_texture<T>::setDims(1.0, 1.0,1.0);
+			setSize(512, 512, 426);
+
+			dList = glGenLists(3);