codebase / stimlib

  #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 <math.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;

  		//float (*S)[][];

  		//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 

  		}

  		*/

  		
  		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);
  		}
  
  		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; 
  	                stim::vec<float>p3; 
                  	stim::vec<float>p4;	
  			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);
  				glVertex2f(v_x,v_y);
  				glTexCoord3f(
  					p2[0],
  					p2[1],
  					p2[2]
  					);
  				//glVertex2f(1.0, 0.0);
  				glVertex2f(v_x+len, v_y);
  				glTexCoord3f(
  					p3[0],
  					p3[1],
  					p3[2]
  					);
  				//glVertex2f(1.0, 2.0);
  				glVertex2f(v_x+len, v_y+len);
  				glTexCoord3f(
  					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],
  					p1[1],
  					p1[2]
  					);
  				//glVertex2f(1.0, 0.0);
  				glVertex2f(v_x+len, v_y);
  				glTexCoord3f(
  					p2[0],
  					p2[1],
  					p2[2]
  					);
  				//glVertex2f(2.0, 0.0);
  				glVertex2f(v_x+2*len, v_y);
  				glTexCoord3f(
  					p3[0],
  					p3[1],
  					p3[2]
  					);
  				//glVertex2f(2.0, 2.0);
  				glVertex2f(v_x+2*len, v_y+len);
  				glTexCoord3f(
  					p4[0],
  					p4[1],
  					p4[2]
  					);
  				//glVertex2f(1.0, 2.0);
  				glVertex2f(v_x+len, v_y+len);
  			glEnd();
  		}
  
  		void
  		Update(float v_x, float v_y, vec<float> dir)
  		{
  			vec<float> Y(1.0,0.0,0.0);
  			if(cos(Y.dot(dir))< 0.087){
  				Y[0] = 0.0; Y[1] = 1.0;}
  			hor = stim::rect<float>(magnitude, position, dir.norm(),
  				((Y.cross(dir)).cross(dir)).norm());
  			ver = stim::rect<float>(magnitude, position, dir.norm(),
  				 hor.n());
  			UpdateBuffer(v_x, v_y);
  		}
  
  
  		void
  		Sample(vec<float> in = (0,0,1), int numSamples = 1089, int solidAngle = M_PI/2)
  		{
  			GenerateFBO(20, numSamples*10);
  
  			float samples[numSamples][3];    	//Set up the variables
  							 	//necessary for sample generation
  			vec<float> d_s = in.cart2sph();
  			vec<float> temp;
  			int dim = (sqrt(numSamples)-1)/2;
  			std::cout << dim << std::endl;
  			float y_0 	= 0.0;
  			float len 	= 10.0;
  			float p0  	= M_PI/3;
  			float dt  	= solidAngle/(1.0 * dim);
  			float dp  	= p0/(1.0*dim);
  	
  			
  			glBindFramebuffer(GL_FRAMEBUFFER, fboID);//set up GL buffer		
  			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,2.0*len, numSamples*len);
  			gluOrtho2D(0.0,2.0*len,0.0,numSamples*len);
  			glEnable(GL_TEXTURE_3D);
  			glBindTexture(GL_TEXTURE_3D, texID);
  			
  			//Loop over the samples
  			int idx;
  			for(int i = -dim; i <= dim; i++){
  				for(int j = -dim; j <= dim; j++){
  					//Create linear index
  					idx = (i+dim)*(dim*2+1) + (j+dim);
  		//			std::cerr << i+dim << "," << j+dim << ":" << idx << std::endl;
  
  					temp[0] = 1; 			//rotate vector
  					temp[1] = d_s[1]+dt*i;
  					temp[2] = d_s[2]+dp*j;
  
  					temp = temp.sph2cart();		//back to cart
  					samples[idx][0] = temp[0];	//save sample vector
  					samples[idx][1] = temp[1];
  					samples[idx][2] = temp[2];
  
  					Update(0.0, y_0+(idx)*10, temp); 
  				}
  			}
  			//Finalize GL_buffer
  			glBindTexture(GL_TEXTURE_3D, 0);                      
  			glDisable(GL_TEXTURE_3D);
  			glBindFramebuffer(GL_FRAMEBUFFER,0);
  			glBindTexture(GL_TEXTURE_2D, 0);
  		}
  

  	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;

  			Sample(direction);
  			//GenerateFBO(20,10000);

  		//	Update();

  		//	generateVectorField(direction, 4.0);

  		}
  
  		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();
  			generateVectorField(direction, 4.0);

  		}

  		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
  		generateVectorField(stim::vec<float> d, float dim)
  		{

  			vec<float> d_s = d.cart2sph();

  			vec<float> temp;
  			float Dim 	= (float) dim;
  			float y_0 	= 0.0;
  			float x_0 	= 0.0;
  			float len 	= 4.0/(2.0*Dim+1.0);
  			float t0  	= M_PI/2;
  			float p0  	= M_PI/3;

  			float dt  	= t0/Dim;
  			float dp  	= p0/Dim;

  			for(int i = -dim; i <= dim; i++){
  				for(int j = -dim; j <= dim; j++){
  					//field[i+dim][j+dim][0] = d[0];
  					//field[i+dim][j+dim][1] = d[1]+dt*i;
  					//field[i+dim][j+dim][2] = d[2]+dp*j;
  					temp[0] = 1;
  					temp[1] = d_s[1]+dt*i;
  					temp[2] = d_s[2]+dp*j;

  					temp = temp.sph2cart();
  					Update(x_0+2.0*(i+dim)*len, y_0+(j+dim)*len, temp); 

  				}
  			}
  			
  		}
  		                                                                   

  
  
  		void
  		initCuda()
  		{	

  			stim::cudaSetDevice();

  			GLint max;
  			glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max);
  			std::cout << max << std::endl;

  		}
  		
  		void
  		createResource()
  		{
  			HANDLE_ERROR(
  				cudaGraphicsGLRegisterImage(
  					 &resource,

  				 	texbufferID,

  				 	GL_TEXTURE_2D,

  				 	//CU_GRAPHICS_REGISTER_FLAGS_NONE)
  					cudaGraphicsMapFlagsReadOnly)

  			);

  		} 
  		
  		void
  		destroyResource()
  		{
  			HANDLE_ERROR(
  				cudaGraphicsUnregisterResource(resource)
  			);		

  		}
  

  		int

  		getCost()

  		{

  			createResource();

  			int cost = 	get_cost(resource);

  			destroyResource();
  			return cost;
  		}

  };

  }
  #endif