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