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