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;

  		//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(800,400);
  		//	Update();

  			generateVectorField(direction, 25.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();

  		}

  
  		void
  		Update(float v_x, float v_y, vec<float> dir, float dim)
  		{
  			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, dim);
  		}

  		stim::vec<float>
  		toSpherical(vec<float> in)
  		{
  			vec<float> out;
  			out[0] = sqrt(pow(in[0],2) + pow(in[1],2) + pow(in[2],2));
  			out[1] = atan(in[1]/in[0]);
  			out[2] = acos(in[2]/out[0]);
  			return out;
  		}		
  
  		stim::vec<float>
  		toCartesian(vec<float> in)
  		{
  			vec<float> out;
  			out[0] = cos(in[1])*sin(in[2]);
  			out[1] = sin(in[1])*sin(in[2]);
  			out[2] = cos(in[2]);
  			return out;
  		}
  
  				
  

  		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
  		UpdateBuffer(float v_x, float v_y, float len)
  		{	

  			//std::cout << v_x << "," << v_y << std::endl;

  			//float len = dim;
  			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,800,400);
  			gluOrtho2D(0.0,8.0,0.0,4.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);
  				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();

  			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 = toSpherical(d);
  			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 = toCartesian(temp);

  					//std::cout << i <<"," << j << std::endl;

  					Update(x_0+2.0*(i+dim)*len, y_0+(j+dim)*len, temp, len); 
  				}
  			}
  			
  		}
  		                                                                   

  
  		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
  		initCuda()
  		{	

  			stim::cudaSetDevice();

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

  				 	texbufferID,

  				 	GL_TEXTURE_2D,

  				 	//CU_GRAPHICS_REGISTER_FLAGS_NONE)
  					cudaGraphicsMapFlagsReadOnly)

  			);

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

  		}
  

  		float
  		getCost()

  		{

  			createResource();
  			float cost = 	get_cost(resource);
  			destroyResource();
  			return cost;
  		}

  };

  }
  #endif