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

Laila Saadatifard
2 parents 03428452 9f5c0d4a
Showing 17 changed files with 1315 additions and 391 deletions Show diff stats
stim/biomodels/network.h
stim/cuda/cuda_texture.cuh
stim/cuda/filter.cuh
stim/cuda/ivote/down_sample.cuh
stim/envi/agilent_binary.h
stim/envi/bip.h
stim/gl/gl_spider.h
stim/grids/image_stack.h
stim/math/matrix.h
stim/math/vec3.h
stim/optics/scalarbeam.h
stim/optics/scalarfield.h
stim/parser/filename.h
stim/parser/filename_old.h
stim/parser/table.h
stim/visualization/colormap.h
stim/visualization/gl_aaboundingbox.h
@@ -33,7 +33,10 @@ class network{
 		public:
 		unsigned v[2];		//unique id's designating the starting and ending
 		// default constructor
-		 edge() : cylinder<T>(){v[1] = -1; v[0] = -1;}
+		edge() : cylinder<T>()
+		{
+			v[1] = -1; v[0] = -1;
+		}
 		/// Constructor - creates an edge from a list of points by calling the stim::fiber constructor
  
 		///@param p is an array of positions in space
@@ -54,7 +57,7 @@ class network{
 		/// Output the edge information as a string
 		std::string str(){
 			std::stringstream ss;
-			ss<<"("<<cylinder<T>::size()<<")\tl = "<<length()<<"\t"<<v[0]<<"----"<<v[1];
+			ss<<"("<<cylinder<T>::size()<<")\tl = "<<this.length()<<"\t"<<v[0]<<"----"<<v[1];
 			return ss.str();
 		}
  
@@ -64,9 +67,9 @@ class network{
 	class vertex : public stim::vec3<T>
 	{
 		public:
-			//std::vector<unsigned int> edges;		//indices of edges connected to this node.
-			std::vector<unsigned int> e[2];			//indices of edges going out (e[0]) and coming in (e[1])
-			//stim::vec3<T> p;						//position of this node in physical space.
+			//std::vector<unsigned int> edges;					//indices of edges connected to this node.
+			std::vector<unsigned int> e[2];						//indices of edges going out (e[0]) and coming in (e[1])
+			//stim::vec3<T> p;							//position of this node in physical space.
  
 			//constructor takes a stim::vec
 			vertex(stim::vec3<T> p) : stim::vec3<T>(p){}
@@ -90,6 +93,7 @@ class network{
 				return ss.str();
 			}
  
+
 	};
  
 protected:
@@ -99,6 +103,18 @@ protected:
  
 public:
  
+	///default constructor
+	network()
+	{
+		
+	}
+
+	///constructor with a file to load.
+	network(std::string fileLocation)
+	{
+		load_obj(fileLocation);
+	}
+
 	///Returns the number of edges in the network.
 	unsigned int edges(){
 		return E.size();
@@ -109,72 +125,219 @@ public:
 		return V.size();
 	}
  
+	std::vector<vertex> operator*(T s){
+		for (unsigned i=0; i< vertices; i ++ ){
+			V[i] = V[i] * s;
+		}
+		return V;
+	}
+
+	std::vector<vertex> operator*(vec<T> s){
+		for (unsigned i=0; i< vertices; i ++ ){
+			for (unsigned dim = 0 ; dim< 3; dim ++){
+				V[i][dim] = V[i][dim] * s[dim];
+			}
+		}
+		return V;
+	}
+
+	// Returns an average of branching index in the network
+
+	double BranchingIndex(){
+		double B=0;
+		for(unsigned v=0; v < V.size(); v ++){
+			B += ((V[v].e[0].size()) + (V[v].e[1].size()));
+		}
+		B = B / V.size();
+		return B;
+
+	}
+
+	// Returns number of branch points in thenetwork
+
+	unsigned int BranchP(){
+		unsigned int B=0;
+		unsigned int c;
+		for(unsigned v=0; v < V.size(); v ++){
+			c = ((V[v].e[0].size()) + (V[v].e[1].size()));
+			if (c > 2){
+			B += 1;}
+		}		
+		return B;
+
+	}
+
+	// Returns number of end points (tips) in thenetwork
+
+	unsigned int EndP(){
+		unsigned int B=0;
+		unsigned int c;
+		for(unsigned v=0; v < V.size(); v ++){
+			c = ((V[v].e[0].size()) + (V[v].e[1].size()));
+			if (c == 1){
+			B += 1;}
+		}		
+		return B;
+
+	}
+
+	//// Returns a dictionary with the key as the vertex
+	//std::map<std::vector<vertex>,unsigned int> DegreeDict(){
+	//	std::map<std::vector<vertex>,unsigned int> dd;
+	//	unsigned int c = 0;
+	//	for(unsigned v=0; v < V.size(); v ++){
+	//		c = ((V[v].e[0].size()) + (V[v].e[1].size()));
+	//		dd[V[v]] = c;
+	//	}
+	//	return dd;
+	//}
+
+	//// Return number of branching stems
+	//unsigned int Stems(){
+	//	unsigned int s = 0;
+	//	std::map<std::vector<vertex>,unsigned int> dd;
+	//	dd = DegreeDict();
+	//	//for(unsigned v=0; v < V.size(); v ++){
+	//	//	V[v].e[0].
+	//	return s;
+	//}
+
+
+	// Returns an average of fiber/edge lengths in the network
+	double Lengths(){
+		stim::vec<T> L;double sumLength = 0;
+		for(unsigned e = 0; e < E.size(); e++){				//for each edge in the network
+			L.push_back(E[e].length());						//append the edge length
+			sumLength = sumLength + E[e].length();
+		}
+		double avg = sumLength / E.size();
+		return avg;
+	}
+
+
+	// Returns an average of tortuosities in the network
+	double Tortuosities(){
+		stim::vec<T> t;
+		stim::vec<T> id1, id2;                        // starting and ending vertices of the edge
+		double distance;double tortuosity;double sumTortuosity = 0;
+		for(unsigned e = 0; e < E.size(); e++){				//for each edge in the network
+			id1 = E[e][0];									//get the edge starting point
+			id2 = E[e][E[e].size() - 1];					//get the edge ending point
+			distance = (id1 - id2).len();                   //displacement between the starting and ending points
+			if(distance > 0){
+				tortuosity = E[e].length()/	distance	;		// tortuoisty = edge length / edge displacement
+			}
+			else{
+				tortuosity = 0;}
+			t.push_back(tortuosity);
+			sumTortuosity += tortuosity;
+		}
+		double avg = sumTortuosity / E.size();
+		return avg;
+	}
+
+	// Returns average contraction of the network
+	double Contractions(){
+	stim::vec<T> t;
+	stim::vec<T> id1, id2;                        // starting and ending vertices of the edge
+	double distance;double contraction;double sumContraction = 0;
+	for(unsigned e = 0; e < E.size(); e++){				//for each edge in the network
+		id1 = E[e][0];									//get the edge starting point
+		id2 = E[e][E[e].size() - 1];					//get the edge ending point
+		distance = (id1 - id2).len();                   //displacement between the starting and ending points
+		contraction = distance / E[e].length();		// tortuoisty = edge length / edge displacement
+		t.push_back(contraction);
+		sumContraction += contraction;
+	}
+	double avg = sumContraction / E.size();
+	return avg;
+	}
+
+	// returns average fractal dimension of the branches of the network
+	double FractalDimensions(){
+	stim::vec<T> t;
+	stim::vec<T> id1, id2;                        // starting and ending vertices of the edge
+	double distance;double fract;double sumFractDim = 0;
+	for(unsigned e = 0; e < E.size(); e++){				//for each edge in the network
+		id1 = E[e][0];									//get the edge starting point
+		id2 = E[e][E[e].size() - 1];					//get the edge ending point
+		distance = (id1 - id2).len();                   //displacement between the starting and ending points
+		fract = std::log(distance) / std::log(E[e].length());		// tortuoisty = edge length / edge displacement
+		t.push_back(sumFractDim);
+		sumFractDim += fract;
+	}
+	double avg = sumFractDim / E.size();
+	return avg;
+	}
 	stim::cylinder<T> get_cylinder(unsigned f){
-		return E[f];					//return the specified edge (casting it to a fiber)
+		return E[f];									//return the specified edge (casting it to a fiber)
 	}
  
 	//load a network from an OBJ file
 	void load_obj(std::string filename){
  
-		stim::obj<T> O;			//create an OBJ object
-		O.load(filename);		//load the OBJ file as an object
+		stim::obj<T> O;									//create an OBJ object
+		O.load(filename);								//load the OBJ file as an object
  
-		std::vector<unsigned> id2vert;	//this list stores the OBJ vertex ID associated with each network vertex
+		std::vector<unsigned> id2vert;							//this list stores the OBJ vertex ID associated with each network vertex
  
-		unsigned i[2];					//temporary, IDs associated with the first and last points in an OBJ line
+		unsigned i[2];									//temporary, IDs associated with the first and last points in an OBJ line
  
 		//for each line in the OBJ object
 		for(unsigned int l = 1; l <= O.numL(); l++){
  
-			std::vector< stim::vec<T> > c;				//allocate an array of points for the vessel centerline
+			std::vector< stim::vec<T> > c;						//allocate an array of points for the vessel centerline
 			O.getLine(l, c);							//get the fiber centerline
  
 			std::vector< stim::vec3<T> > c3(c.size());
 			for(size_t j = 0; j < c.size(); j++)
 				c3[j] = c[j];
  
-			edge new_edge = c3;							//create an edge from the given centerline
-			unsigned int I = new_edge.size();			//calculate the number of points on the centerline
+	//		edge new_edge = c3;		///This is dangerous.
+			edge new_edge(c3);
+					
+			//create an edge from the given centerline
+			unsigned int I = new_edge.size();					//calculate the number of points on the centerline
  
 			//get the first and last vertex IDs for the line
-			std::vector< unsigned > id;					//create an array to store the centerline point IDs
+			std::vector< unsigned > id;						//create an array to store the centerline point IDs
 			O.getLinei(l, id);							//get the list of point IDs for the line
 			i[0] = id.front();							//get the OBJ ID for the first element of the line
 			i[1] = id.back();							//get the OBJ ID for the last element of the line
  
-			std::vector<unsigned>::iterator it;			//create an iterator for searching the id2vert array
+			std::vector<unsigned>::iterator it;					//create an iterator for searching the id2vert array
 			unsigned it_idx;							//create an integer for the id2vert entry index
  
 			//find out if the nodes for this fiber have already been created
 			it = find(id2vert.begin(), id2vert.end(), i[0]);	//look for the first node
-			it_idx = std::distance(id2vert.begin(), it);
 			if(it == id2vert.end()){							//if i[0] hasn't already been used
 				vertex new_vertex = new_edge[0];				//create a new vertex, assign it a position
-				new_vertex.e[0].push_back(E.size());			//add the current edge as outgoing
-				new_edge.v[0] = V.size();						//add the new vertex to the edge
-				V.push_back(new_vertex);						//add the new vertex to the vertex list
-				id2vert.push_back(i[0]);						//add the ID to the ID->vertex conversion list
+				new_vertex.e[0].push_back(E.size());				//add the current edge as outgoing
+				new_edge.v[0] = V.size();					//add the new edge to the edge
+				V.push_back(new_vertex);					//add the new vertex to the vertex list
+				id2vert.push_back(i[0]);					//add the ID to the ID->vertex conversion list
 			}
-			else{												//if the vertex already exists
+			else{									//if the vertex already exists
+				it_idx = std::distance(id2vert.begin(), it);
 				V[it_idx].e[0].push_back(E.size());				//add the current edge as outgoing
 				new_edge.v[0] = it_idx;
 			}
  
-			it = find(id2vert.begin(), id2vert.end(), i[1]);	//look for the second ID
-			it_idx = std::distance(id2vert.begin(), it);
-			if(it == id2vert.end()){							//if i[1] hasn't already been used
-				vertex new_vertex = new_edge[I-1];							//create a new vertex, assign it a position
-				new_vertex.e[1].push_back(E.size());						//add the current edge as incoming
-				new_edge.v[1] = V.size();
-				V.push_back(new_vertex);									//add the new vertex to the vertex list
-				id2vert.push_back(i[1]);						//add the ID to the ID->vertex conversion list
+			it = find(id2vert.begin(), id2vert.end(), i[1]);			//look for the second ID
+			if(it == id2vert.end()){						//if i[1] hasn't already been used
+				vertex new_vertex = new_edge[I-1];				//create a new vertex, assign it a position
+				new_vertex.e[1].push_back(E.size());				//add the current edge as incoming
+				new_edge.v[1] = V.size();                                  	//add the new vertex to the edge
+				V.push_back(new_vertex);					//add the new vertex to the vertex list
+				id2vert.push_back(i[1]);					//add the ID to the ID->vertex conversion list
 			}
-			else{												//if the vertex already exists
+			else{									//if the vertex already exists
+				it_idx = std::distance(id2vert.begin(), it);
 				V[it_idx].e[1].push_back(E.size());				//add the current edge as incoming
 				new_edge.v[1] = it_idx;
 			}
  
-			E.push_back(new_edge);								//push the edge to the list
+			E.push_back(new_edge);							//push the edge to the list
  
 		}
 	}
@@ -199,17 +362,17 @@ public:
 	/// This function resamples all fibers in a network given a desired minimum spacing
 	/// @param spacing is the minimum distance between two points on the network
 	stim::network<T> resample(T spacing){
-		stim::network<T> n;					//create a new network that will be an exact copy, with resampled fibers
-		n.V = V;							//copy all vertices
+		stim::network<T> n;								//create a new network that will be an exact copy, with resampled fibers
+		n.V = V;									//copy all vertices
  
-		n.E.resize(edges());				//allocate space for the edge list
+		n.E.resize(edges());								//allocate space for the edge list
  
 		//copy all fibers, resampling them in the process
-		for(unsigned e = 0; e < edges(); e++){				//for each edge in the edge list
-			n.E[e] = E[e].resample(spacing);				//resample the edge and copy it to the new network
+		for(unsigned e = 0; e < edges(); e++){						//for each edge in the edge list
+			n.E[e] = E[e].resample(spacing);					//resample the edge and copy it to the new network
 		}
  
-		return n;							              //return the resampled network
+		return n;							              	//return the resampled network
 	}
  
  
@@ -236,14 +399,14 @@ public:
 	/// @param m is the magnitude value to use. The default is 0 (usually radius).
 	T average(unsigned m = 0){
  
-		T M, L;												//allocate space for the total magnitude and length
-		M = L = 0;											//initialize both the initial magnitude and length to zero
-		for(unsigned e = 0; e < E.size(); e++){				//for each edge in the network
+		T M, L;										//allocate space for the total magnitude and length
+		M = L = 0;									//initialize both the initial magnitude and length to zero
+		for(unsigned e = 0; e < E.size(); e++){						//for each edge in the network
 			M += E[e].integrate(m);							//get the integrated magnitude
-			L += E[e].length();								//get the edge length
+			L += E[e].length();							//get the edge length
 		}
  
-		return M / L;					//return the average magnitude
+		return M / L;									//return the average magnitude
 	}
  
 	/// This function compares two networks and returns the percentage of the current network that is missing from A.
@@ -256,17 +419,17 @@ public:
 		R = (*this);									//initialize the result with the current network
  
 		//generate a KD-tree for network A
-		float metric = 0.0;                               // initialize metric to be returned after comparing the networks
-		ANNkd_tree* kdt;                                 // initialize a pointer to a kd tree
-		double **c;						                 // centerline (array of double pointers) - points on kdtree must be double
-		unsigned int n_data = A.total_points();          // set the number of points
-		c = (double**) malloc(sizeof(double*) * n_data); // allocate the array pointer
-		for(unsigned int i = 0; i < n_data; i++)		 // allocate space for each point of 3 dimensions
+		float metric = 0.0;                               				// initialize metric to be returned after comparing the networks
+		ANNkd_tree* kdt;                                 				// initialize a pointer to a kd tree
+		double **c;						                 	// centerline (array of double pointers) - points on kdtree must be double
+		unsigned int n_data = A.total_points();          				// set the number of points
+		c = (double**) malloc(sizeof(double*) * n_data); 				// allocate the array pointer
+		for(unsigned int i = 0; i < n_data; i++)		 			// allocate space for each point of 3 dimensions
 			c[i] = (double*) malloc(sizeof(double) * 3);
  
 		unsigned t = 0;
 		for(unsigned e = 0; e < A.E.size(); e++){					//for each edge in the network
-			for(unsigned p = 0; p < A.E[e].size(); p++){			//for each point in the edge
+			for(unsigned p = 0; p < A.E[e].size(); p++){				//for each point in the edge
 				for(unsigned d = 0; d < 3; d++){				//for each coordinate
  
 					c[t][d] = A.E[e][p][d];
@@ -276,27 +439,27 @@ public:
 		}
  
 		//compare each point in the current network to the field produced by A
-		ANNpointArray pts = (ANNpointArray)c;           // create an array of data points of type double
-		kdt = new ANNkd_tree(pts, n_data, 3);			// build a KD tree using the annpointarray
+		ANNpointArray pts = (ANNpointArray)c;           				// create an array of data points of type double
+		kdt = new ANNkd_tree(pts, n_data, 3);						// build a KD tree using the annpointarray
 		double eps = 0; // error bound
-		ANNdistArray dists = new ANNdist[1];     // near neighbor distances
-		ANNidxArray nnIdx = new ANNidx[1];				// near neighbor indices // allocate near neigh indices
+		ANNdistArray dists = new ANNdist[1];     					// near neighbor distances
+		ANNidxArray nnIdx = new ANNidx[1];						// near neighbor indices // allocate near neigh indices
  
 		stim::vec3<T> p0, p1;
 		float m1;
-		float M = 0;											//stores the total metric value
-		float L = 0;											//stores the total network length
+		float M = 0;									//stores the total metric value
+		float L = 0;									//stores the total network length
 		ANNpoint queryPt = annAllocPt(3);
 		for(unsigned e = 0; e < R.E.size(); e++){					//for each edge in A
-			R.E[e].add_mag(0);									//add a new magnitude for the metric
+			R.E[e].add_mag(0);							//add a new magnitude for the metric
  
-			for(unsigned p = 0; p < R.E[e].size(); p++){			//for each point in the edge
+			for(unsigned p = 0; p < R.E[e].size(); p++){				//for each point in the edge
  
-				p1 = R.E[e][p];									//get the next point in the edge
+				p1 = R.E[e][p];							//get the next point in the edge
 				stim2ann(queryPt, p1);
-				kdt->annkSearch( queryPt, 1, nnIdx, dists, eps);	//find the distance between A and the current network
+				kdt->annkSearch( queryPt, 1, nnIdx, dists, eps);		//find the distance between A and the current network
 				m1 = 1.0f - gaussianFunction((float)dists[0], sigma);		//calculate the metric value based on the distance
-				R.E[e].set_mag(m1, p, 1);						//set the error for the second point in the segment
+				R.E[e].set_mag(m1, p, 1);					//set the error for the second point in the segment
  
 			}
 		}
@@ -308,8 +471,106 @@ public:
 	unsigned nmags(){
 		return E[0].nmags();
 	}
+	// split a string in text by the character sep
+	stim::vec<T> split(std::string &text, char sep) 
+	{
+		stim::vec<T> tokens;
+		std::size_t start = 0, end = 0;
+		while ((end = text.find(sep, start)) != std::string::npos) {
+		tokens.push_back(atof(text.substr(start, end - start).c_str()));
+		start = end + 1;
+		}
+		tokens.push_back(atof(text.substr(start).c_str()));
+		return tokens;
+	}
+	// load a network in text file to a network class
+	void load_txt(std::string filename)
+	{
+		std::vector <std::string> file_contents;
+		std::ifstream file(filename);
+		std::string line;
+		std::vector<unsigned> id2vert;	//this list stores the vertex ID associated with each network vertex
+		//for each line in the text file, store them as strings in file_contents
+		while (std::getline(file, line))
+		{
+			std::stringstream ss(line);
+			file_contents.push_back(ss.str());
+		}
+		unsigned int numEdges = atoi(file_contents[0].c_str()); //number of edges in the network
+		unsigned int I = atoi(file_contents[1].c_str()) ;		//calculate the number of points3d on the first edge
+		unsigned int count = 1; unsigned int k = 2; // count is global counter through the file contents, k is for the vertices on the edges
+		// for each edge in the network.
+		for (unsigned int i = 0; i < numEdges; i ++ )
+		{
+			// pre allocate a position vector p with number of points3d on the edge p
+			std::vector< stim::vec<T> > p(0, I);
+			// for each point on the nth edge
+		  for (unsigned int j = k; j < I + k; j++)
+		  {
+			 // split the points3d of floats with separator space and form a float3 position vector out of them
+			  p.push_back(split(file_contents[j], ' '));
+		  }
+			count += p.size() + 1; // increment count to point at the next edge in the network
+			I = atoi(file_contents[count].c_str()); // read in the points3d at the next edge and convert it to an integer
+			k = count + 1;
+			edge new_edge = p; // create an edge with a vector of points3d  on the edge
+			E.push_back(new_edge); // push the edge into the network
+		}
+		unsigned int numVertices = atoi(file_contents[count].c_str()); // this line in the text file gives the number of distinct vertices
+		count = count + 1; // this line of text file gives the first verrtex
+		// push each vertex into V
+		for (unsigned int i = 0; i < numVertices; i ++)
+		{
+			vertex new_vertex = split(file_contents[count], ' ');
+			V.push_back(new_vertex);
+			count += atoi(file_contents[count + 1].c_str()) + 2; // Skip number of edge ids + 2 to point to the next vertex
+		}
+	} // end load_txt function
  
-
+	// strTxt returns a string of edges
+	std::string
+	strTxt(std::vector< stim::vec<T> > p)
+	{
+		std::stringstream ss;
+		std::stringstream oss;
+		for(unsigned int i = 0; i < p.size(); i++){
+			ss.str(std::string());
+			for(unsigned int d = 0; d < 3; d++){
+				ss<<p[i][d];
+			}
+			ss < "\n";
+		}
+		return ss.str();
+	}
+	// removes specified character from string
+	void removeCharsFromString(std::string &str, char* charsToRemove ) {
+	   for ( unsigned int i = 0; i < strlen(charsToRemove); ++i ) {
+		  str.erase( remove(str.begin(), str.end(), charsToRemove[i]), str.end() );
+	   }
+	}
+	//exports network to txt file
+	void
+	to_txt(std::string filename)
+	{
+		std::ofstream ofs(filename, std::ofstream::out | std::ofstream::app);
+		int num;
+		ofs << (E.size()).str() << "\n";
+		for(unsigned int i = 0; i < E.size(); i++)
+		{
+			 std::string str;
+			 ofs << (E[i].size()).str() << "\n";
+			 str = E[i].strTxt();
+             ofs << str << "\n";
+		} 
+		for(int i = 0; i < V.size(); i++)
+		{
+			std::string str;
+			str = V[i].str();
+			removeCharsFromString(str, "[],");
+			ofs << str << "\n";
+		}
+		ofs.close();
+	}
 };		//end stim::network class
 };		//end stim namespace
 #endif
@@ -134,15 +134,15 @@ namespace stim
 		void
 		UnmapCudaTexture()
 		{
-			HANDLE_ERROR(
-				cudaGraphicsUnmapResources(1, &resource)
-			);
-			HANDLE_ERROR(
-				cudaGraphicsUnregisterResource(resource)
-			);	
-			HANDLE_ERROR(
-				cudaDestroyTextureObject(tObj)
-			);
+		//	HANDLE_ERROR(
+		//		cudaGraphicsUnmapResources(1, &resource)
+		//	);
+		//	HANDLE_ERROR(
+		//		cudaGraphicsUnregisterResource(resource)
+		//	);	
+		//	HANDLE_ERROR(
+		//		cudaDestroyTextureObject(tObj)
+		//	);
 //			HANDLE_ERROR(
 //				cudaFreeArray(srcArray)
 //			);
@@ -7,6 +7,7 @@
 #include <stdio.h>
 #include <stim/visualization/colormap.h>
 #include <sstream>
+#include <stim/math/constants.h>
 #include <stim/cuda/cudatools/devices.h>
 #include <stim/cuda/cudatools/threads.h>
 #include <stim/cuda/cuda_texture.cuh>
@@ -14,7 +15,6 @@
 #include <stim/cuda/arraymath.cuh>
  
 #define IMAD(a,b,c) ( __mul24((a), (b)) + (c) )
-#define M_PI 3.141592654f
  
  
 namespace stim
@@ -73,7 +73,7 @@ namespace stim
 				idx = j*kl+i;
 				x = i - kr - 0.5;
 				y = j - kr - 0.5;
-				LoG[idx] = (-1.0/M_PI/powf(sigma, 4))* (1 - (powf(x,2)+powf(y,2))/2.0/powf(sigma, 2))
+				LoG[idx] = (-1.0/PI/powf(sigma, 4))* (1 - (powf(x,2)+powf(y,2))/2.0/powf(sigma, 2))
 						*expf(-(powf(x,2)+powf(y,2))/2/powf(sigma,2));	
 				t +=LoG[idx];
 			}
@@ -98,7 +98,7 @@ namespace stim
 		int y = blockIdx.y;
 		int xi = threadIdx.x;
 		int yi = threadIdx.y;
-		float val = 0;
+	//	float val = 0;
 		float tu = (x-kr+xi)/(float)DIM_X;
 		float tv = (y-kr+yi)/(float)DIM_Y;
 		shared[xi][yi] = gpuLoG[yi*kl+xi]*(255.0-(float)tex2D<unsigned char>(texIn, tu, tv));
@@ -111,7 +111,7 @@ namespace stim
 		//y = min(y, height - 1);
  
 		int idx = y*DIM_X+x;
-		int k_idx;
+	//	int k_idx;
                 for(unsigned int step = blockDim.x/2; step >= 1; step >>= 1)
                 {
                         __syncthreads();
@@ -44,7 +44,7 @@ namespace stim{
 			unsigned int y_ds = (y/sigma_ds + (y %sigma_ds == 0 ? 0:1));
  
 			//get the number of pixels in the image
-			unsigned int pixels_ds = x_ds * y_ds;
+//			unsigned int pixels_ds = x_ds * y_ds;
  
 			unsigned int max_threads = stim::maxThreadsPerBlock();
 			dim3 threads(max_threads, 1);
@@ -97,4 +97,4 @@ namespace stim{
 	}
 }
  
-#endif
 \ No newline at end of file
+#endif
+//make sure that this header file is only loaded once
+#ifndef STIM_AGILENT_BINARY_H
+#define STIM_AGILENT_BINARY_H
+
+#include <string>
+#include <fstream>
+
+//CUDA
+#ifdef CUDA_FOUND
+	#include <cuda_runtime.h>
+	#include "cufft.h"
+	#include <stim/cuda/cudatools/error.h>
+#endif
+
+namespace stim{
+
+template<typename T>
+class agilent_binary{
+
+protected:
+	std::string fname;
+	T* ptr;
+	size_t R[3];
+	static const size_t header = 1020;
+	double Z[2];
+
+public:
+	size_t size(){
+		return (size_t)R[0] * (size_t)R[1] * (size_t)R[2];
+	}
+
+	size_t bytes(){
+		return size() * sizeof(T);
+	}
+	void alloc(){
+		ptr = (T*) malloc(bytes());
+	}
+	void alloc(short x, short y, short z){
+		R[0] = x;
+		R[1] = y;
+		R[2] = z;
+		alloc();
+	}
+
+	void deep_copy(agilent_binary<T>* dst, const agilent_binary<T>* src){
+		dst->alloc(src->R[0], src->R[1], src->R[2]);			//allocate memory
+		memcpy(dst->ptr, src->ptr, bytes());					//copy the data
+		memcpy(dst->Z, src->Z, sizeof(double) * 2);				//copy the data z range
+	}
+
+	agilent_binary(){
+		memset(R, 0, sizeof(short) * 3);				//set the resolution to zero
+		ptr = NULL;
+	}
+
+	/// Constructor with resolution
+	agilent_binary(short x, short y, short z){
+		alloc(x, y, z);
+	}
+
+	/// Constructor with filename
+	agilent_binary(std::string filename){
+		ptr = NULL;
+		load(filename);
+	}
+	
+	/// Copy constructor
+	agilent_binary(const agilent_binary<T> &obj){
+		deep_copy(this, &obj);
+	}
+
+	agilent_binary<T>& operator=(const agilent_binary<T> rhs){
+		if(this != &rhs){								//check for self-assignment
+			deep_copy(this, &rhs);						//make a deep copy
+		}
+		return *this;									//return the result
+	}
+
+	~agilent_binary(){
+		free(ptr);
+	}
+
+	void load(std::string filename){
+		if(ptr != NULL) free(ptr);						//if memory has been allocated, free it
+
+		fname = filename;						//save the filename
+
+		short x, y, z;
+
+		std::ifstream infile(fname, std::ios::binary);				//open the input file
+		infile.seekg(9, std::ios::beg);				//seek past 9 bytes from the beginning of the file
+
+		infile.read((char*)(&z), 2);							//read two bytes of data (the number of samples is stored as a 16-bit integer)
+
+		infile.seekg(13, std::ios::cur);				//skip another 13 bytes
+		infile.read((char*)(&x), 2);				//read the X and Y dimensions
+		infile.read((char*)(&y), 2);
+
+		infile.seekg(header, std::ios::beg);			//seek to the start of the data
+
+		alloc(x, y, z);
+		ptr = (T*) malloc(bytes());							//allocate space for the data
+		infile.read((char*)ptr, bytes());				//read the data		
+		infile.close();
+	}
+
+	void save(std::string filename){
+		std::ofstream outfile(filename, std::ios::binary);			//create an output file
+
+		char zero = 0;
+		for(size_t i = 0; i < 9; i++) outfile.write(&zero, 1);		//write 9 zeros
+		outfile.write((char*)&R[0], 2);
+		for(size_t i = 0; i < 13; i++) outfile.write(&zero, 1);		//write 13 zeros
+		outfile.write((char*)&R[1], 2);
+		outfile.write((char*)&R[2], 2);
+		for(size_t i = 0; i < 992; i++) outfile.write(&zero, 1);		//write 992 zeros
+		//char zerovec[1020];
+		//outfile.write((char*)zerovec, 1020);
+
+		size_t b = bytes();
+		outfile.write((char*)ptr, b);							//write the data to the output file
+		outfile.close();
+	}
+
+	stim::envi_header create_header(){
+		stim::envi_header header;
+		header.samples = R[0];
+		header.lines = R[1];
+		header.bands = R[2];
+
+		double z_delta = (double)(Z[1] - Z[0]) / (double)(R[2] - 1);
+		header.wavelength.resize(R[2]);
+		for(size_t i = 0; i < R[2]; i++)
+			header.wavelength[i] = i * z_delta + Z[0];
+
+		return header;
+	}
+
+	/// Calculate the absorbance spectrum from the transmission spectrum given a background
+	void absorbance(stim::agilent_binary<T>* background){
+		size_t N = size();											//calculate the number of values to be ratioed
+		if(N != background->size()){
+			std::cerr<<"ERROR in stim::agilent_binary::absorbance() - transmission image size doesn't match background"<<std::endl;
+			exit(1);
+		}
+		for(size_t i = 0; i < N; i++)
+			ptr[i] = -log10(ptr[i] / background->ptr[i]);
+	}
+
+#ifdef CUDA_FOUND
+	/// Perform an FFT and return a binary file with bands in the specified range
+	agilent_binary<T> fft(float band_min, float band_max){
+		auto total_start = std::chrono::high_resolution_clock::now();
+
+		auto start = std::chrono::high_resolution_clock::now();
+		T* cpu_data = (T*) malloc( bytes() );										//allocate space for the transposed data
+		for(size_t b = 0; b < R[2]; b++){
+			for(size_t x = 0; x < R[0] * R[1]; x++){
+				cpu_data[x * R[2] + b] = ptr[b * R[0] * R[1] + x];
+			}
+		}
+		auto end = std::chrono::high_resolution_clock::now();
+		std::chrono::duration<double> diff = end-start;
+       // std::cout << "Transpose data: " << diff.count() << " s\n";
+
+		start = std::chrono::high_resolution_clock::now();
+		cufftHandle plan;															//allocate space for a cufft plan
+		cufftReal* gpu_data;														//create a pointer to the data
+		size_t batch = R[0] * R[1];													//calculate the batch size (X * Y)
+		HANDLE_ERROR(cudaMalloc((void**)&gpu_data, bytes()));						//allocate space on the GPU
+		HANDLE_ERROR(cudaMemcpy(gpu_data, cpu_data, bytes(), cudaMemcpyHostToDevice));	//copy the data to the GPU
+		cufftComplex* gpu_fft;
+		HANDLE_ERROR(cudaMalloc((void**)&gpu_fft, R[0] * R[1] * (R[2]/2 + 1) * sizeof(cufftComplex)));
+		end = std::chrono::high_resolution_clock::now();
+		diff = end-start;
+		//std::cout << "Allocate/copy: " << diff.count() << " s\n";
+
+		start = std::chrono::high_resolution_clock::now();
+		int N[1];					//create an array with the interferogram size (required for cuFFT input)
+		N[0] = R[2];				//set the only array value to the interferogram size
+		if(cufftPlanMany(&plan, 1, N, NULL, 1, R[2], NULL, 1, R[2], CUFFT_R2C, batch) != CUFFT_SUCCESS){
+			std::cout<<"cuFFT Error: unable to create 1D plan."<<std::endl;
+			exit(1);
+		}
+		end = std::chrono::high_resolution_clock::now();
+		diff = end-start;
+		//std::cout << "Create a plan: " << diff.count() << " s\n";
+
+		start = std::chrono::high_resolution_clock::now();
+		if (cufftExecR2C(plan, gpu_data, gpu_fft) != CUFFT_SUCCESS){		//execute the (implicitly forward) transform
+			std::cout<<"CUFFT error: ExecR2C Forward failed";
+			exit(1);
+		}
+		end = std::chrono::high_resolution_clock::now();
+		diff = end-start;
+		//std::cout << "Perform FFT: " << diff.count() << " s\n";
+
+		start = std::chrono::high_resolution_clock::now();
+		std::complex<T>* cpu_fft = (std::complex<T>*) malloc( R[0] * R[1] * (R[2]/2+1) * sizeof(std::complex<T>) );
+		HANDLE_ERROR(cudaMemcpy(cpu_fft, gpu_fft, R[0] * R[1] * (R[2]/2+1) * sizeof(cufftComplex), cudaMemcpyDeviceToHost));	//copy data from the host to the device
+
+		double int_delta = 0.00012656;									//interferogram sample spacing in centimeters
+		double int_length = int_delta * R[2];							//interferogram length in centimeters
+		double fft_delta = 1/int_length;								//spectrum spacing (in inverse centimeters, wavenumber
+
+		size_t start_i = std::ceil(band_min / fft_delta);				//calculate the first band to store
+		size_t size_i = std::floor(band_max / fft_delta) - start_i;		//calculate the number of bands to store
+		size_t end_i = start_i + size_i;								//last band number
+		agilent_binary<T> result(R[0], R[1], size_i);
+		result.Z[0] = start_i * fft_delta;								//set the range for the FFT result
+		result.Z[1] = end_i * fft_delta;
+
+		for(size_t b = start_i; b < end_i; b++){
+			for(size_t x = 0; x < R[0] * R[1]; x++){
+				result.ptr[(b - start_i) * R[0] * R[1] + x] = abs(cpu_fft[x * (R[2]/2+1) + b]);
+			}
+		}
+		end = std::chrono::high_resolution_clock::now();
+		diff = end-start;
+		//std::cout << "Transpose/Crop: " << diff.count() << " s\n";
+
+		auto total_end = std::chrono::high_resolution_clock::now();
+		diff = total_end-total_start;
+
+		cufftDestroy(plan);
+		HANDLE_ERROR(cudaFree(gpu_data));
+		HANDLE_ERROR(cudaFree(gpu_fft));
+		free(cpu_data);
+		free(cpu_fft);
+
+		return result;
+	}
+#endif
+
+};
+
+}
+
+#endif
 \ No newline at end of file
@@ -235,6 +235,7 @@ public:
  
 		for(unsigned long long i = 0; i < B; i++)						//for each element of the spectrum
 			p[i] = (double) temp[i];							//cast each element to a double value
+		free(temp);												//free temporary memory
 		return true;
 	}
  
@@ -14,6 +14,7 @@
 #include <stim/math/vec3.h>
 #include <stim/math/rect.h>
 #include <stim/math/matrix.h>
+#include <stim/math/constants.h>
 #include <stim/cuda/spider_cost.cuh>
 #include <stim/cuda/cudatools/glbind.h>
 #include <stim/cuda/arraymath.cuh>
@@ -369,7 +370,7 @@ class gl_spider : public virtual gl_texture&lt;T&gt;
 		///Stored in a display list.
 		///uses the default d vector <0,0,1>
 		void
-		genDirectionVectors(float solidAngle = 5/M_PI*4)
+		genDirectionVectors(float solidAngle = M_PI/2)
 		{
  
 			//Set up the vectors necessary for Rectangle creation.
@@ -584,7 +585,7 @@ class gl_spider : public virtual gl_texture&lt;T&gt;
 			glDeleteFramebuffers(1, &framebufferID);
 			glGenFramebuffers(1, &framebufferID);
 			glBindFramebuffer(GL_FRAMEBUFFER, framebufferID);
-			int numChannels = 1;
+//			int numChannels = 1;
 //			unsigned char* texels = new unsigned char[width * height * numChannels];
 			glGenTextures(1, &textureID);
 			glBindTexture(GL_TEXTURE_2D, textureID);
@@ -609,7 +610,7 @@ class gl_spider : public virtual gl_texture&lt;T&gt;
 		{
 			glGenFramebuffers(1, &fboID);
 			glBindFramebuffer(GL_FRAMEBUFFER, fboID);
-			int numChannels = 1;
+//			int numChannels = 1;
 //			unsigned char* texels = new unsigned char[width * height * numChannels];
 			glGenTextures(1, &texbufferID);
 			glBindTexture(GL_TEXTURE_2D, texbufferID);
@@ -938,7 +939,7 @@ class gl_spider : public virtual gl_texture&lt;T&gt;
 			network_time = 0;
 			hit_time = 0;
 #endif
-			stepsize = 3.0;
+			stepsize = 2.5;
 			t_length = 16.0;
  
 			srand(100);	
@@ -1392,13 +1393,9 @@ class gl_spider : public virtual gl_texture&lt;T&gt;
  
 			Z[0] = cos(PHI[0]);
 			Z[1] = cos(PHI[1]);
-
  
 			range = Z[0] - Z[1];
  
-
-			float z, theta, phi;
-			
 			std::vector<stim::vec3<float> > vecsUni;
 			for(int i = 0; i < numSamplesPos; i++)
 			{
@@ -1490,8 +1487,6 @@ class gl_spider : public virtual gl_texture&lt;T&gt;
 		void
 		trace(int min_cost)
 		{	
-			bool sEmpty = true;
-			float lastmag = 16.0;;
 			stim::vec3<float> curSeed; 
 			stim::vec3<float> curSeedVec;			
 			float curSeedMag;
@@ -1527,7 +1522,7 @@ class gl_spider : public virtual gl_texture&lt;T&gt;
 				gpuStartTimer();
 			#endif
  
-			float s = 3.0;
+//			float s = 3.0;
 			GLuint selectBuf[2048];
 			GLint hits;
 			glSelectBuffer(2048, selectBuf);
@@ -1541,17 +1536,17 @@ class gl_spider : public virtual gl_texture&lt;T&gt;
 			CHECK_OPENGL_ERROR
 		//What would that vessel see in front of it.
 				camSel.setPosition(loc);
-				camSel.setFocalDistance(mag/s);
-				camSel.LookAt((loc[0]+dir[0]*mag/s),
-					 (loc[1]+dir[1]*mag/s),
-					 (loc[2]+dir[2]*mag/s));
+				camSel.setFocalDistance(mag/stepsize);
+				camSel.LookAt((loc[0]+dir[0]*mag/stepsize),
+					 (loc[1]+dir[1]*mag/stepsize),
+					 (loc[2]+dir[2]*mag/stepsize));
 				ps  = camSel.getPosition();
 				ups = camSel.getUp();
 				ds  = camSel.getLookAt();
 				glMatrixMode(GL_PROJECTION);
 				glPushMatrix();
 				glLoadIdentity();
-				glOrtho(-mag/s/2.0, mag/s/2.0, -mag/s/2.0, mag/s/2.0, 0.0, mag/s/2.0);
+				glOrtho(-mag/stepsize/2.0, mag/stepsize/2.0, -mag/stepsize/2.0, mag/stepsize/2.0, 0.0, mag/stepsize/2.0);
 				glMatrixMode(GL_MODELVIEW);
 				glPushMatrix();
 				glLoadIdentity();
@@ -1597,21 +1592,11 @@ class gl_spider : public virtual gl_texture&lt;T&gt;
 		int
 		processHits(GLint hits, GLuint buffer[])
 		{
-			GLuint names, *ptr;
-			//printf("hits = %u\n", hits);
+			GLuint *ptr;
 			ptr = (GLuint *) buffer;
-		//	for (int i = 0; i < hits; i++) { /*  for each hit  */
-			names = *ptr;
-		//		printf (" number of names for hit = %u\n", names);
 			ptr++;
 			ptr++; //Skip the minimum depth value.  
 			ptr++; //Skip the maximum depth value.
-		//		printf ("   the name is ");                                                        
-		//		for (int j = 0; j < names; j++) {     /*  for each name */
-		//			printf ("%u ", *ptr); ptr++;
-		//		}
-		//		printf ("\n");
-	//		}
  
  
 			if(hits == 0)
@@ -1675,11 +1660,18 @@ class gl_spider : public virtual gl_texture&lt;T&gt;
 			}		
  
 			#ifdef TIMING
-				double network_time = (std::clock() - s) / (double) CLOCKS_PER_SEC;
-				network_time += network_time * 1000.0;
+				double nt = (std::clock() - s) / (double) CLOCKS_PER_SEC;
+				network_time += nt * 1000.0;
 			#endif
 		}
  
+//		void
+//		addToNetwork(pair<stim::fiber<float>, int> in, stim::vec3<float> spos, 
+//				stim::vec<float> smag, stim::vec3<float> sdir)
+//		{
+//
+//		}
+
  
 		void
 		printSizes()
@@ -1783,9 +1775,6 @@ class gl_spider : public virtual gl_texture&lt;T&gt;
                  		}
          		}
 		}
-
-			
-
 };
 }
 #endif
@@ -33,10 +33,10 @@ public:
 		stim::filename file_path(file_mask);
  
 		//if the file path is relative, update it with the current working directory
-		if(file_path.is_relative()){
-			stim::filename wd = stim::filename::cwd();
-			file_path = wd.get_relative(file_mask);
-		}
+//		if(file_path.is_relative()){
+//			stim::filename wd = stim::filename::cwd();
+//			file_path = wd.get_relative(file_mask);
+//		}
  
 		//get the list of files
 		std::vector<stim::filename> file_list = file_path.get_list();
@@ -134,10 +134,10 @@ public:
 		stim::filename file_path(file_mask);
  
 		//if the file path is relative, update it with the current working directory
-		if(file_path.is_relative()){
-			stim::filename wd = stim::filename::cwd();
-			file_path = wd.get_relative(file_mask);
-		}
+//		if(file_path.is_relative()){
+//			stim::filename wd = stim::filename::cwd();
+//			file_path = wd.get_relative(file_mask);
+//		}
  
 		//create a list of file names
 		std::vector<std::string> file_list = stim::wildcards::increment(file_path.str(), 0, R[3]-1, 1);
@@ -53,13 +53,13 @@ struct matrix
  
 	template<typename Y>
 	vec<Y> operator*(vec<Y> rhs){
-		unsigned int N = rhs.size();
+		unsigned int M = rhs.size();
  
 		vec<Y> result;
-		result.resize(N);
+		result.resize(M);
  
-		for(int r=0; r<N; r++)
-			for(int c=0; c<N; c++)
+		for(int r=0; r<M; r++)
+			for(int c=0; c<M; c++)
 				result[r] += (*this)(r, c) * rhs[c];
  
 		return result;
@@ -3,6 +3,7 @@
  
  
 #include <stim/cuda/cudatools/callable.h>
+#include <cmath>
  
  
 namespace stim{
@@ -216,7 +217,6 @@ public:
 		return result;
 	}
  
-#ifndef __NVCC__
 	/// Outputs the vector as a string
 	std::string str() const{
 		std::stringstream ss;
@@ -234,7 +234,6 @@ public:
  
 		return ss.str();
 	}
-#endif
  
 	size_t size(){ return 3; }
  
@@ -121,12 +121,12 @@ CUDA_CALLABLE void lut_lookup(T* lut_values, T* lut, T val, size_t N, T min_val,
  
 template <typename T>
 CUDA_CALLABLE stim::complex<T> clerp(stim::complex<T> v0, stim::complex<T> v1, T t) {
-    return stim::complex<T>( fma(t, v1.r, fma(-t, v0.r, v0.r)), fma(t, v1.i, fma(-t, v0.i, v0.i)) );
+    return stim::complex<T>( fmaf(t, v1.r, fmaf(-t, v0.r, v0.r)), fmaf(t, v1.i, fmaf(-t, v0.i, v0.i)) );
 }
  
 template <typename T>
 CUDA_CALLABLE T lerp(T v0, T v1, T t) {
-    return fma(t, v1, fma(-t, v0, v0));
+    return fmaf(t, v1, fmaf(-t, v0, v0));
 }
  
 #ifdef CUDA_FOUND
@@ -293,6 +293,8 @@ protected:
 	stim::complex<T>* E;
 	size_t R[2];
 	locationType loc;
+	using rect<T>::X;
+	using rect<T>::Y;
  
 	T* p[3];											//scalar position for each point in E
  
@@ -2,218 +2,295 @@
 #define STIM_FILENAME_H
  
 #include <stdio.h>  /* defines FILENAME_MAX */
+#include <sstream>
+#include <vector>
+#include <algorithm>
+#include <iostream>
+#include <iomanip>
+
+#include <stim/parser/parser.h>
+
+// set OS dependent defines, including:
+//	1) path division character ('/' or '\') used for output only
+//	2) command for getting the current working directory
+//	3) header files for getting the current working directory
+//	4) include BOOST filesystem class if compiling on GCC
+#define STIM_DIV '/'
 #ifdef _WIN32
 	#include <windows.h>
-    #include <direct.h>
-    #define GetCurrentDir _getcwd
-	#define STIM_FILENAME_DIV '/'
+	#include <direct.h>
+	#define GetCurrentDir _getcwd
+	#define STIM_FILENAME_DIV '\\'
 #else
-    #include <unistd.h>
-    #define GetCurrentDir getcwd
+	#ifdef BOOST_PRECOMPILED
+		#include <boost/filesystem.hpp>
+	#endif
+	#include <unistd.h>
+	#define GetCurrentDir getcwd
 	#define STIM_FILENAME_DIV '/'
  #endif
  
-#include <string>
-#include <sstream>
-#include <iomanip>
-#include <vector>
-#include <stack>
-#include <algorithm>
-#include <iostream>
-
-#include "../parser/parser.h"
-#ifdef BOOST_PRECOMPILED
-#include <boost/filesystem.hpp>
-#endif
 namespace stim{
  
-//filename class designed to work with both Windows and Unix
+class filepath{
+protected:
+	std::string _drive;					//drive on which the file is located (used for Windows)
+	std::vector<std::string> _path;		//path for the specified file (list of hierarchical directories)
  
-class filename{
+	/// replaces win32 dividers with the Linux standard (used internally by default)
+	std::string unix_div(std::string s) {
+		std::replace( s.begin(), s.end(), '\\', '/');
+		return s;
+	}
  
-private:
-	void init(){
+	/// gets the directory hierarchy for the current working directory
+	static std::string cwd(){
+		char cCurrentPath[FILENAME_MAX];
  
-		absolute = false;
+		 if (!GetCurrentDir(cCurrentPath, sizeof(cCurrentPath))){
+			 std::cout<<"ERROR getting current working directory."<<std::endl;
+			 exit(1);
+		 }
  
+		 std::stringstream ss;
+		 ss<<cCurrentPath;
+		 return ss.str();
 	}
  
-protected:
+	/// convert a relative path to an absolute path
+	void get_absolute(std::string &drive, std::vector<std::string> &absolute, std::vector<std::string> relative){
  
-	std::string drive;				//drive letter (for Windows)
-	std::vector<std::string> path;	//directory hierarchy
-	std::string prefix;				//file prefix (without extension)
-	std::string	ext;				//file extension
+		std::string current = cwd();						//get the current directory as a string
  
-	bool absolute;					//filename is an absolute path
+		std::string current_drive;
+		std::vector<std::string> current_dir;
+		parse_path(current_drive, current_dir, current);			//get the current drive and directories
  
-	//replaces win32 dividers with the Linux standard
-	std::string unix_div(std::string s) {
-		std::replace( s.begin(), s.end(), '\\', '/');
-		return s;
-	}
-
-	//break up a filename into a prefix and extension
-	void parse_name(std::string fname){
+		// step through each directory in the relative path, adjusting the current directory
+		//		index depending on whether the relative path is specified with '.' or '..'
+		int current_i = (int)current_dir.size() - 1;
+		int relative_i;
+		for(relative_i = 0; relative_i < relative.size(); relative_i++){
+			if(relative[relative_i] == "..") current_i--;
+			else if(relative[relative_i] != ".") break;
+		}
+		if(current_i < 0){
+			std::cerr<<"ERROR stim::filepath - relative path is incompatible with working directory"<<std::endl;
+			exit(1);
+		}
  
-		//find the extension
-		size_t xpos = fname.find_last_of('.');			//find the position of the extension period (if there is one)
-		if(xpos != std::string::npos){						//split the prefix and extension
-			prefix = fname.substr(0, xpos);
-			ext = fname.substr(xpos + 1);
+		absolute.clear();
+		for(size_t i = 0; i <= current_i; i++){
+			absolute.push_back(current_dir[i]);
+		}
+		for(size_t i = relative_i; i < relative.size(); i++){
+			absolute.push_back(relative[i]);
 		}
-		else
-			prefix = fname;
 	}
  
-	//parse a file locator string
-	void parse(std::string loc){
-		if(loc.size() == 0) return;
-
-		loc = unix_div(loc);
-
-		//determine the drive (if Windows)
-		drive = "";
-		#ifdef _WIN32
-			//if the second character is a colon, the character right before it is the drive
-			if(loc[1] == ':'){
-				absolute = true;			//this is an absolute path
-				drive = loc[0];				//copy the drive letter
-				loc = loc.substr(3);		//remove the drive information from the locator string
+	/// Parses a directory string into a drive (NULL if not Windows) and list of hierarchical directories
+	/// Returns true if the path is relative, false if it is absolute
+	void parse_path(std::string &drive, std::vector<std::string> &absolute, std::string dir){
+		drive = "";						//initialize the drive to NULL (it will stay that way for Windows)
+		std::vector<std::string> path;
+		bool relative = true;			//the default path is relative
+
+		if(dir.length() == 0) return;					//return if the file locator is empty
+		std::string unix_dir = unix_div(dir);				//replace any Windows division characters with Unix
+
+		if(unix_dir.length() > 1 && unix_dir[1] == ':'){	//if a drive identifier is given
+			if(unix_dir[0] > 64 && unix_dir[0] < 91)		//if the drive letter is upper case
+				_drive = unix_dir[0] + 32;					//convert it to lower case
+			else if(unix_dir[0] > 96 && unix_dir[0] < 123)	//if the drive character is lower case
+					_drive = unix_dir[0];					//store it as-is
+			else{											//otherwise throw an error
+				std::cerr<<"ERROR stim::filename - drive letter is invalid: "<<unix_dir[0]<<std::endl;
+				exit(1);
 			}
-		#else
-			if(loc[0] == STIM_FILENAME_DIV){
-				absolute = true;
-				loc = loc.substr(1);
-			}
-		#endif
-
-		//determine the file name
-		std::string fname = loc.substr( loc.find_last_of('/') + 1 );	//find the file name (including extension)
+			unix_dir = unix_dir.substr(2, unix_dir.length()-2);	//extract the directory structure
+		}
  
-		//parse the file name
-		parse_name(fname);
+		if(unix_dir.front() == '/'){						//if there is a leading slash
+			relative = false;								//the path is not relative
+			unix_dir = unix_dir.substr(1, unix_dir.length() - 1);	//remove the slash
+		}
+		if(unix_dir.back() == '/')
+			unix_dir = unix_dir.substr(0, unix_dir.length() - 1);
  
-		//find the directory hierarchy
-		std::string dir = loc.substr(0, loc.find_last_of('/') + 1 );
-		path = stim::parser::split(dir, '/');
+		path = stim::parser::split(unix_dir, '/');					//split up the directory structure
+		
+		if(relative)
+			get_absolute(drive, absolute, path);
+		else
+			absolute = path;
 	}
  
-public:
+	
  
-	filename(){
-		init();
+public:
+	filepath(){
+		_drive = "";
 	}
  
-	filename(std::string loc){
-		init();
-		parse(loc);
+	filepath(const stim::filepath& p){
+		*this = p;
 	}
  
+	filepath(const std::string s){
+		parse_path(_drive, _path, s);
+	}
  
-	/// Outputs the file name (including prefix and extension)
-	std::string get_name(){
-		if(prefix == "" && ext == "")
-			return "";
-		else
-			return prefix + "." + ext;
+	stim::filepath& operator=(const std::string s){
+		parse_path(_drive, _path, s);		//parse the string to get the drive and relative path
+		return *this;
 	}
  
-	/// Output the file extension only (usually three characters after a '.')
-	std::string get_extension(){
-		return ext;
+	std::string str(){
+		std::stringstream ss;
+		if(_drive != "")							//if a drive letter is specified
+			ss<<_drive<<":";						//add it to the string
+		for(size_t i = 0; i < _path.size(); i++)
+			ss<<STIM_FILENAME_DIV<<_path[i];
+		ss<<STIM_FILENAME_DIV;
+		return ss.str();
+	}	
+};				//end filepath
+
+class filename : public filepath{
+protected:
+	std::string _prefix;				//filename prefix
+	std::string _extension;				//filename extension
+
+	void set_filename(std::string fname){
+		size_t ext_i = fname.find_last_of('.');								//calculate the index of the '.'
+		if(ext_i != std::string::npos){											//if there is an extension
+			_prefix = fname.substr(0, ext_i);				//store the prefix
+			_extension = fname.substr(ext_i + 1, fname.size() - ext_i - 1);	//store the extension
+		}
+		else												//otherwise just store the prefix
+			_prefix = fname;
 	}
  
-	/// Output the file prefix only (name before the extension)
-	std::string get_prefix(){
-		return prefix;
+public:
+	filename(){}
+
+	filename(stim::filepath p, std::string fname) : stim::filepath(p){
+		set_filename(fname);
 	}
  
-	/// Output the entire path (not including the filename)
-	///		ex. "c:\this\is\the\directory\"
-	std::string dir(){
-		std::stringstream ss;
+	stim::filename& operator=(const std::string s){
+		std::string unix_s = unix_div(s);					//convert dividers to unix
+		size_t name_i = unix_s.find_last_of('/');		//find the index of the last divider
  
-		//if the path is absolute
-		if(absolute){
-			//output the drive letter if in Windows
-			#ifdef _WIN32
-				ss<<drive<<":";
-			#endif
-			ss<<STIM_FILENAME_DIV;
+		if(name_i == std::string::npos){					//if there is no divider, this is just a filename
+			unix_s = "./" + unix_s;							//append a ./ to the beginning so that the working directory is used
+			name_i = 1;
 		}
  
-		//output the directory
-		for(unsigned int d = 0; d < path.size(); d++)
-			ss<<path[d]<<STIM_FILENAME_DIV;
+		name_i++;
  
-		return ss.str();
  
+		std::string filename = unix_s.substr(name_i, unix_s.size() - name_i);	//extract the filename
+		std::string filepath = unix_s.substr(0, name_i-1);						//extract the filepath
+
+		filepath::operator=(filepath);						//parse and store the file path
+
+		set_filename(filename);
+		return *this;
 	}
  
-	void clear()
-	{
-		drive = "";				//drive letter (for Windows)
-		path.resize(0);
-		prefix= "";				//file prefix (without extension)
-		ext = "";				//file extension
+	filename(std::string s){
+		operator=(s);
 	}
  
-	/// Output the entire string, including the path and filename
-	///		ex. "c:\this\is\a\directory\file.txt"
-	std::string str(){
-		std::stringstream ss;					//create a string stream
-		ss<<dir()<<get_name();					//push the directory and filename to that stream
-		return ss.str();						//convert the stream to a string and return it
+	bool is_relative(){
+		return false;
 	}
  
-	//*****************************************************************************************************************
-	// output is the directory and the prefix and the extension of the files, which are looking for in that directory.
-	/// David: I have no idea what this is doing. It looks identical to dir()
-	std::string dir_fname(){
-		std::stringstream ss;
  
-		//if the path is absolute
-		if(absolute){
-			//output the drive letter if in Windows
-			#ifdef _WIN32
-				ss<<drive<<":";
-			#endif
-			ss<<STIM_FILENAME_DIV;
-		}
+	std::string str(){
+		std::stringstream ss;
+		ss<<filepath::str()<<_prefix;
+		if(_extension.size() != 0)
+			ss<<"."<<_extension;
+		return ss.str();
+	}
  
+	/// Create a matching file locator with a prefix s
+	stim::filename prefix(std::string s){
+		stim::filename result = *this;
+		result._prefix = s;
+		return result;
+	}
  
-		for(unsigned int d = 0; d < path.size(); d++)
-			ss<<path[d]<<STIM_FILENAME_DIV;
-		ss<<get_name();
+	std::string prefix(){
+		return _prefix;
+	}
  
-		return ss.str();
+	std::string get_prefix(){
+		return _prefix;
+	}
  
+	/// Create a matching file locator with the extension changed to s
+	stim::filename extension(std::string s){
+		stim::filename result = *this;
+		result._extension = s;
+		return result;
 	}
  
-	// output is the directory and the name of the file which are found in that given directory
-	std::string f_name(std::string file_name){
-		std::stringstream ss;
+	std::string extension(){
+		return _extension;
+	}
  
-		if(absolute){ 								//if the path is absolute
-			#ifdef _WIN32
-				ss<<drive<<":";						//output the drive letter if in Windows
-			#endif
-			ss<<STIM_FILENAME_DIV;					//output a path divider
+	stim::filename fname(std::string s){
+		stim::filename result = *this;
+		size_t ext_i = s.find_last_of('.');								//calculate the index of the '.'
+		if(ext_i != std::string::npos){											//if there is an extension
+			result._prefix = s.substr(0, ext_i);				//store the prefix
+			result._extension = s.substr(ext_i + 1, s.size() - ext_i - 1);	//store the extension
 		}
+		else												//otherwise just store the prefix
+			result._prefix = s;
+		return result;
+	}
+
+	/// create a matching file locator with the path changed to s
+	stim::filename path(std::string s){
+		stim::filename result = *this;
+		result.parse_path(result._drive, result._path, s);
+		return result;
+	}
  
-		for(unsigned int d = 0; d < path.size(); d++)	//for each directory in the current path
-			ss<<path[d]<<STIM_FILENAME_DIV;				//add that directory, interspersing path dividers
+	std::string path(){
+		return filepath::str();
+	}
  
-		stim::filename fn = file_name;					
-			std::string fn_prefix = fn.prefix;
-			std::string fn_ext = fn.ext;
-		ss<<fn_prefix + '.' + fn_ext;
+	/// Casting operator, casts to a string
+	operator std::string(){
+		return str();
+	}
  
-		return ss.str();
+	/// This function replaces a wildcard in the prefix with the specified string
+	stim::filename insert(std::string str){
  
+		stim::filename result = *this;				//initialize the result filename to the current filename
+		size_t loc = result._prefix.find('*');		//find a wild card in the string
+		if(loc == std::string::npos)						//if a wildcard isn't found
+			result._prefix += str;							//append the value to the prefix
+		else
+			result._prefix.replace(loc, 1, str);			//replace the wildcard with the string
+		return result;								//return the result
 	}
  
+	/// This function replaces a wildcard in the prefix with the specified integer (with a padding of n)
+	stim::filename insert(size_t i, size_t n = 2){
+
+		std::stringstream ss;
+		ss << std::setw(n) << std::setfill('0') << i;
+		return insert(ss.str());
+	}
+
+	
 	/// Returns a list of files using the current filename as a template.
 	/// For example:
 	///			C:\this\is\a\path\file*.txt
@@ -223,28 +300,33 @@ public:
 		//the Unix version requires Boost
  
 #ifdef _WIN32
-		stim::filename filepath(dir_fname());									//initialize filepath with the mask					
  
 		HANDLE            hFind = INVALID_HANDLE_VALUE;							//allocate data structures for looping through files
 		WIN32_FIND_DATAA   FindFileData;
 		std::vector<stim::filename> file_list;									//initialize a list to hold all matching filenames
  
-		hFind = FindFirstFileA((filepath.str().c_str()), &FindFileData);		//find the first file that matches the specified file path
+		std::string path_string = str();
+		hFind = FindFirstFileA(path_string.c_str(), &FindFileData);		//find the first file that matches the specified file path
  
 		if (hFind == INVALID_HANDLE_VALUE) { 									//if there are no matching files
-			printf ("Invalid file handle. Error is %u.\n", GetLastError());		//print an error
+			//printf ("Invalid file handle. Error is %u.\n", GetLastError());		//print an error
+			return file_list;
 		}
 		else {
 			std::string file_name = FindFileData.cFileName;						//save the file name
-			std::string file_path = dir();										//the file is in the specified directory, so save it
+			std::string file_path = path();										//the file is in the specified directory, so save it
 			stim::filename current_file(file_path + file_name);					//create a stim::filename structure representing this file
-			file_list.push_back(current_file);									//push the new stim::filename to the file list
+			if(!(FindFileData.cFileName[0] == '.' && FindFileData.cFileName[1] == '\0'))
+				file_list.push_back(current_file);									//push the new stim::filename to the file list
+
  
 			// List all the other files in the directory.
 			while (FindNextFileA(hFind, &FindFileData) != 0){ 					//iterate until there are no more matching files
-				file_name = FindFileData.cFileName;								//save the next file
-				current_file = (f_name(file_name));								//append the directory
-				file_list.push_back(current_file);								//push it to the list
+				if(!(FindFileData.cFileName[0] == '.' && FindFileData.cFileName[1] == '.' && FindFileData.cFileName[2] == '\0')){	//account for the possibility of the '..' filename
+					file_name = FindFileData.cFileName;								//save the next file
+					current_file = fname(file_name);								//append the directory
+					file_list.push_back(current_file);								//push it to the list
+				}
 			}
 			FindClose(hFind);													//close the file data structure
 		}
@@ -252,7 +334,7 @@ public:
  
 #elif BOOST_PRECOMPILED
  
-		boost::filesystem::path p(dir());	//create a path from the current filename
+		boost::filesystem::path p(path());	//create a path from the current filename
 		std::vector<stim::filename> file_list;
 		if(boost::filesystem::exists(p)){
 			if(boost::filesystem::is_directory(p)){
@@ -265,9 +347,9 @@ public:
 				for (vec::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it)
 				{
 					//if the filename is a wild card *or* it matches the read file name
-					if( prefix == "*" || prefix == (*it).filename().stem().string()){
+					if( _prefix == "*" || _prefix == (*it).filename().stem().string()){
 						//if the extension is a wild card *or* it matches the read file extension
-						if( ext == "*" || "." + ext == (*it).filename().extension().string()){
+						if( _extension == "*" || "." + _extension == (*it).filename().extension().string()){
 							file_list.push_back((*it).string());	//include it in the final list
 						}
  
@@ -287,108 +369,6 @@ public:
 #endif
  
 	}
-	//**************************************************************************************************
-
-	//gets the current working directory
-	static stim::filename cwd(){
-
-
-		char cCurrentPath[FILENAME_MAX];
-
-		 if (!GetCurrentDir(cCurrentPath, sizeof(cCurrentPath))){
-			 std::cout<<"ERROR getting current working directory."<<std::endl;
-			 exit(1);
-		 }
-
-		 std::cout<<cCurrentPath<<std::endl;
-		 return stim::filename(std::string(cCurrentPath) + STIM_FILENAME_DIV);
-	}
-
-	void set_name(std::string fname){
-		parse_name(fname);
-	}
-
-	//append a string to the filename and return a new filename
-	stim::filename append(std::string s){
-		stim::filename result = *this;		//create a new filename, copy the current filename
-		result.prefix = prefix + s;			//append the string to the filename
-		return result;
-	}
-
-	//get a path relative to the current one
-	stim::filename get_relative(std::string rel){
-
-		std::vector<std::string> rel_path = stim::parser::split(rel, STIM_FILENAME_DIV);
-
-		//if the relative path doesn't contain a file, add a blank string to be used as the filename
-		if(rel[rel.size()-1] == STIM_FILENAME_DIV)
-			rel_path.push_back("");
-
-		//create a stack representing the current absolute path
-		std::stack<std::string, std::vector<std::string> > s(path);
-
-		//for each token in the relative path
-		for(int d=0; d<rel_path.size() - 1; d++){
-
-			//if the token is a double-dot, pop a directory off of the stack
-			if(rel_path[d] == "..")
-				s.pop();
-			else
-				s.push(rel_path[d]);
-		}
-
-		std::string* end   = &s.top() + 1;
-		std::string* begin = end - s.size();
-		std::vector<std::string> result_path(begin, end);
-
-		//create a new path to be returned
-		stim::filename result = *this;
-		result.path = result_path;
-		result.set_name(rel_path.back());
-
-		return result;
-	}
-
-	/// This function replaces a wildcard in the prefix with the specified string
-	stim::filename insert(std::string str){
-
-		stim::filename result = *this;				//initialize the result filename to the current filename
-		size_t loc = result.prefix.find('*');		//find a wild card in the string
-		if(loc == std::string::npos)						//if a wildcard isn't found
-			result.prefix += str;							//append the value to the prefix
-		else
-			result.prefix.replace(loc, 1, str);			//replace the wildcard with the string
-		return result;								//return the result
-	}
-
-	stim::filename insert(size_t i, size_t n = 2){
-
-		std::stringstream ss;
-		ss << std::setw(n) << std::setfill('0') << i;
-		return insert(ss.str());
-	}
-
-	bool is_relative(){
-		return !absolute;
-	}
-
-	bool is_absolute(){
-		return absolute;
-	}
-
-
-
-
-
-
-
-
-
-};
-
-
-}	//end namespace stim
-
-
+};				//end filename
+}				//end namespace stim
 #endif
-
+#ifndef STIM_FILENAME_H
+#define STIM_FILENAME_H
+
+#include <stdio.h>  /* defines FILENAME_MAX */
+#ifdef _WIN32
+	#include <windows.h>
+    #include <direct.h>
+    #define GetCurrentDir _getcwd
+	#define STIM_FILENAME_DIV '/'
+#else
+    #include <unistd.h>
+    #define GetCurrentDir getcwd
+	#define STIM_FILENAME_DIV '/'
+ #endif
+
+#include <string>
+#include <sstream>
+#include <iomanip>
+#include <vector>
+#include <stack>
+#include <algorithm>
+#include <iostream>
+
+#include "../parser/parser.h"
+#ifdef BOOST_PRECOMPILED
+#include <boost/filesystem.hpp>
+#endif
+namespace stim{
+
+//filename class designed to work with both Windows and Unix
+
+class filename{
+
+private:
+	void init(){
+
+		absolute = false;
+
+	}
+
+protected:
+
+	std::string drive;				//drive letter (for Windows)
+	std::vector<std::string> path;	//directory hierarchy
+	std::string pref;				//file prefix (without extension)
+	std::string	ext;				//file extension
+
+	bool absolute;					//filename is an absolute path
+
+	//replaces win32 dividers with the Linux standard
+	std::string unix_div(std::string s) {
+		std::replace( s.begin(), s.end(), '\\', '/');
+		return s;
+	}
+
+	//break up a filename into a prefix and extension
+	void parse_name(std::string fname){
+
+		//find the extension
+		size_t xpos = fname.find_last_of('.');			//find the position of the extension period (if there is one)
+		if(xpos != std::string::npos){						//split the prefix and extension
+			pref = fname.substr(0, xpos);
+			ext = fname.substr(xpos + 1);
+		}
+		else
+			pref = fname;
+	}
+
+	/// Parse a file locator into its component parts
+	void parse(std::string &dr, std::vector<std::string> &p, std::string &pre, std::string &ex, bool &abs, std::string loc){
+		dr = "";					//initialize the drive to NULL (in a Unix system, this will always be NULL)
+		p.clear();					//empty out the path array
+		pre = "";					//initialize the file prefix to NULL (if no file name is given, this will remain NULL)
+		ex = "";					//initialize the file extension to NULL (if no extension exists, this will remain NULL)
+		abs = false;				//the default path is relative
+
+		loc = unix_div(loc);		//convert to unix style divisions (default representation)
+
+		if(loc.size() == 0) return;	//if the locator is NULL, just return (everything else will be NULL)
+
+		//determine the drive (if Windows)
+		#ifdef _WIN32			
+			if(loc[1] == ':'){				//if the second character is a colon, the character right before it is the drive
+				abs = true;			//this is an absolute path
+				dr = loc[0];				//copy the drive letter
+				loc = loc.substr(3);		//remove the drive information from the locator string
+			}
+		#else
+			if(loc[0] == STIM_FILENAME_DIV){
+				absolute = true;
+				loc = loc.substr(1);
+			}
+		#endif
+
+		std::string fname = loc.substr( loc.find_last_of('/') + 1 );	//find the file name (including extension)
+
+		//find the extension and prefix
+		size_t xpos = fname.find_last_of('.');				//find the position of the extension period (if there is one)
+		if(xpos != std::string::npos){						//split the prefix and extension
+			pre = fname.substr(0, xpos);
+			ex = fname.substr(xpos + 1);
+		}
+		else
+			pre = fname;
+	}
+
+	//parse a file locator string
+	void parse(std::string loc){
+		if(loc.size() == 0) return;
+
+		loc = unix_div(loc);
+
+		//determine the drive (if Windows)
+		drive = "";
+		#ifdef _WIN32
+			//if the second character is a colon, the character right before it is the drive
+			if(loc[1] == ':'){
+				absolute = true;			//this is an absolute path
+				drive = loc[0];				//copy the drive letter
+				loc = loc.substr(3);		//remove the drive information from the locator string
+			}
+		#else
+			if(loc[0] == STIM_FILENAME_DIV){
+				absolute = true;
+				loc = loc.substr(1);
+			}
+		#endif
+
+		//determine the file name
+		std::string fname = loc.substr( loc.find_last_of('/') + 1 );	//find the file name (including extension)
+
+		//parse the file name
+		parse_name(fname);
+
+		//find the directory hierarchy
+		std::string dir = loc.substr(0, loc.find_last_of('/') + 1 );
+		path = stim::parser::split(dir, '/');
+	}
+
+public:
+
+	filename(){
+		init();
+	}
+
+	filename(std::string loc){
+		init();
+		parse(loc);
+	}
+
+
+	/// Outputs the file name (including prefix and extension)
+	std::string get_name(){
+		if(pref == "" && ext == "")
+			return "";
+		else
+			return pref + "." + ext;
+	}
+
+	/// Output the file extension only (usually three characters after a '.')
+	std::string get_extension(){
+		return ext;
+	}
+
+	std::string extension(){
+		return ext;
+	}
+
+	void extension(std::string e){
+		ext = e;
+	}
+
+	/// Output the file prefix only (name before the extension)
+	std::string get_prefix(){
+		return pref;
+	}
+
+	std::string prefix(){
+		return pref;
+	}
+
+	void prefix(std::string p){
+		pref = p;
+	}
+
+	/// Output the entire path (not including the filename)
+	///		ex. "c:\this\is\the\directory\"
+	std::string dir(){
+		std::stringstream ss;
+
+		//if the path is absolute
+		if(absolute){
+			//output the drive letter if in Windows
+			#ifdef _WIN32
+				ss<<drive<<":";
+			#endif
+			ss<<STIM_FILENAME_DIV;
+		}
+
+		//output the directory
+		for(unsigned int d = 0; d < path.size(); d++)
+			ss<<path[d]<<STIM_FILENAME_DIV;
+
+		return ss.str();
+
+	}
+
+	void clear()
+	{
+		drive = "";				//drive letter (for Windows)
+		path.resize(0);
+		pref= "";				//file prefix (without extension)
+		ext = "";				//file extension
+	}
+
+	/// Output the entire string, including the path and filename
+	///		ex. "c:\this\is\a\directory\file.txt"
+	std::string str(){
+		std::stringstream ss;					//create a string stream
+		ss<<dir()<<get_name();					//push the directory and filename to that stream
+		return ss.str();						//convert the stream to a string and return it
+	}
+
+	//*****************************************************************************************************************
+	// output is the directory and the prefix and the extension of the files, which are looking for in that directory.
+	/// David: I have no idea what this is doing. It looks identical to dir()
+	std::string dir_fname(){
+		std::stringstream ss;
+
+		//if the path is absolute
+		if(absolute){
+			//output the drive letter if in Windows
+			#ifdef _WIN32
+				ss<<drive<<":";
+			#endif
+			ss<<STIM_FILENAME_DIV;
+		}
+
+
+		for(unsigned int d = 0; d < path.size(); d++)
+			ss<<path[d]<<STIM_FILENAME_DIV;
+		ss<<get_name();
+
+		return ss.str();
+
+	}
+
+	// output is the directory and the name of the file which are found in that given directory
+	std::string f_name(std::string file_name){
+		std::stringstream ss;
+
+		if(absolute){ 								//if the path is absolute
+			#ifdef _WIN32
+				ss<<drive<<":";						//output the drive letter if in Windows
+			#endif
+			ss<<STIM_FILENAME_DIV;					//output a path divider
+		}
+
+		for(unsigned int d = 0; d < path.size(); d++)	//for each directory in the current path
+			ss<<path[d]<<STIM_FILENAME_DIV;				//add that directory, interspersing path dividers
+
+		stim::filename fn = file_name;					
+			std::string fn_prefix = fn.pref;
+			std::string fn_ext = fn.ext;
+		ss<<fn_prefix + '.' + fn_ext;
+
+		return ss.str();
+
+	}
+
+	/// Returns a list of files using the current filename as a template.
+	/// For example:
+	///			C:\this\is\a\path\file*.txt
+	///		can be used as a template to find a series of files file001.txt, file002.txt, file003.txt, etc.
+	std::vector<stim::filename> get_list(){
+		//this is OS dependent, so we're starting with Windows
+		//the Unix version requires Boost
+
+#ifdef _WIN32
+		stim::filename filepath(dir_fname());									//initialize filepath with the mask					
+
+		HANDLE            hFind = INVALID_HANDLE_VALUE;							//allocate data structures for looping through files
+		WIN32_FIND_DATAA   FindFileData;
+		std::vector<stim::filename> file_list;									//initialize a list to hold all matching filenames
+
+		hFind = FindFirstFileA((filepath.str().c_str()), &FindFileData);		//find the first file that matches the specified file path
+
+		if (hFind == INVALID_HANDLE_VALUE) { 									//if there are no matching files
+			printf ("Invalid file handle. Error is %u.\n", GetLastError());		//print an error
+		}
+		else {
+			std::string file_name = FindFileData.cFileName;						//save the file name
+			std::string file_path = dir();										//the file is in the specified directory, so save it
+			stim::filename current_file(file_path + file_name);					//create a stim::filename structure representing this file
+			file_list.push_back(current_file);									//push the new stim::filename to the file list
+
+			// List all the other files in the directory.
+			while (FindNextFileA(hFind, &FindFileData) != 0){ 					//iterate until there are no more matching files
+				file_name = FindFileData.cFileName;								//save the next file
+				current_file = (f_name(file_name));								//append the directory
+				file_list.push_back(current_file);								//push it to the list
+			}
+			FindClose(hFind);													//close the file data structure
+		}
+		return file_list;														//return the list of files
+
+#elif BOOST_PRECOMPILED
+
+		boost::filesystem::path p(dir());	//create a path from the current filename
+		std::vector<stim::filename> file_list;
+		if(boost::filesystem::exists(p)){
+			if(boost::filesystem::is_directory(p)){
+				typedef std::vector<boost::filesystem::path> vec;             // store paths,
+				vec v;                                // so we can sort them later
+				std::copy(boost::filesystem::directory_iterator(p), boost::filesystem::directory_iterator(), back_inserter(v));
+				std::sort(v.begin(), v.end());             // sort, since directory iteration
+				  // is not ordered on some file systems
+				//compare file names to the current template (look for wild cards)
+				for (vec::const_iterator it(v.begin()), it_end(v.end()); it != it_end; ++it)
+				{
+					//if the filename is a wild card *or* it matches the read file name
+					if( prefix == "*" || prefix == (*it).filename().stem().string()){
+						//if the extension is a wild card *or* it matches the read file extension
+						if( ext == "*" || "." + ext == (*it).filename().extension().string()){
+							file_list.push_back((*it).string());	//include it in the final list
+						}
+
+					}
+
+
+
+				}
+
+			}
+
+		}
+		return file_list;
+#else
+		std::cout<<"ERROR: UNIX systems don't support file lists without the Boost precompiled libraries."<<std::endl;
+		exit(1);
+#endif
+		
+	}
+	//**************************************************************************************************
+
+	//gets the current working directory
+	static stim::filename cwd(){
+
+
+		char cCurrentPath[FILENAME_MAX];
+
+		 if (!GetCurrentDir(cCurrentPath, sizeof(cCurrentPath))){
+			 std::cout<<"ERROR getting current working directory."<<std::endl;
+			 exit(1);
+		 }
+
+		 std::cout<<cCurrentPath<<std::endl;
+		 return stim::filename(std::string(cCurrentPath) + STIM_FILENAME_DIV);
+	}
+
+	void set_name(std::string fname){
+		parse_name(fname);
+	}
+
+	//append a string to the filename and return a new filename
+	stim::filename append(std::string s){
+		stim::filename result = *this;		//create a new filename, copy the current filename
+		result.pref = pref + s;			//append the string to the filename
+		return result;
+	}
+
+	//get a path relative to the current one
+	stim::filename get_relative(std::string rel){
+
+		std::vector<std::string> rel_path = stim::parser::split(rel, STIM_FILENAME_DIV);
+
+		//if the relative path doesn't contain a file, add a blank string to be used as the filename
+		if(rel[rel.size()-1] == STIM_FILENAME_DIV)
+			rel_path.push_back("");
+
+		//create a stack representing the current absolute path
+		std::stack<std::string, std::vector<std::string> > s(path);
+
+		//for each token in the relative path
+		for(int d=0; d<rel_path.size() - 1; d++){
+
+			//if the token is a double-dot, pop a directory off of the stack
+			if(rel_path[d] == "..")
+				s.pop();
+			else
+				s.push(rel_path[d]);
+		}
+
+		std::string* end   = &s.top() + 1;
+		std::string* begin = end - s.size();
+		std::vector<std::string> result_path(begin, end);
+
+		//create a new path to be returned
+		stim::filename result = *this;
+		result.path = result_path;
+		result.set_name(rel_path.back());
+
+		return result;
+	}
+
+	/// This function replaces a wildcard in the prefix with the specified string
+	stim::filename insert(std::string str){
+
+		stim::filename result = *this;				//initialize the result filename to the current filename
+		size_t loc = result.pref.find('*');		//find a wild card in the string
+		if(loc == std::string::npos)						//if a wildcard isn't found
+			result.pref += str;							//append the value to the prefix
+		else
+			result.pref.replace(loc, 1, str);			//replace the wildcard with the string
+		return result;								//return the result
+	}
+
+	stim::filename insert(size_t i, size_t n = 2){
+
+		std::stringstream ss;
+		ss << std::setw(n) << std::setfill('0') << i;
+		return insert(ss.str());
+	}
+
+	bool is_relative(){
+		return !absolute;
+	}
+
+	bool is_absolute(){
+		return absolute;
+	}
+
+
+
+
+
+
+
+
+
+};
+
+
+}	//end namespace stim
+
+
+#endif
+
@@ -55,7 +55,7 @@ namespace stim{
 		}
  
 		void save_ascii(std::string filename, char col_delim = ',', char row_delim = '\n'){
-			ofstream outfile(filename);
+			std::ofstream outfile(filename);
 			for(size_t yi = 0; yi < TABLE.size(); yi++){
 				if(yi != 0 && TABLE[yi].size() > 0) outfile<<row_delim;
 				for(size_t xi = 0; xi < TABLE[yi].size(); xi++){
@@ -66,7 +66,7 @@ namespace stim{
 		}
  
 		void read_ascii(std::string filename, char col_delim = ',', char row_delim = '\n'){
-			ifstream infile(filename);						//open an ascii file for reading
+			std::ifstream infile(filename);						//open an ascii file for reading
 			TABLE.clear();									//empty out the table
  
 			std::string line;
@@ -253,7 +253,9 @@ static void gpu2image(T* gpuSource, std::string fileDest, unsigned int x_size, u
 	HANDLE_ERROR( cudaMemcpy(&v_min, gpuSource + i_min, sizeof(T), cudaMemcpyDeviceToHost) );		//copy the min and max values from the device to the CPU
 	HANDLE_ERROR( cudaMemcpy(&v_max, gpuSource + i_max, sizeof(T), cudaMemcpyDeviceToHost) );
  
-	gpu2image<T>(gpuSource, fileDest, x_size, y_size, v_min, v_max, cm);
+
+
+	gpu2image<T>(gpuSource, fileDest, x_size, y_size, min(v_min, v_max), max(v_min, v_max), cm);
 }
  
 #endif
@@ -11,6 +11,9 @@ class gl_aaboundingbox : public aaboundingbox&lt;T&gt;{
  
 public:
  
+	using stim::aaboundingbox<T>::A;
+	using stim::aaboundingbox<T>::B;
+
 	//default constructor
 	gl_aaboundingbox() : stim::aaboundingbox<T>(){}
  
@@ -57,4 +60,4 @@ public:
  
 };		//end namespace stim
  
-#endif
 \ No newline at end of file
+#endif