Pavel Govyadinov · Pavel Govyadinov · Pavel Govyadinov
Showing 2 changed files Show diff stats
stim/biomodels/network.h
stim/visualization/cylinder.h
@@ -12,10 +12,9 @@
 #include <stim/visualization/obj.h>
 #include <stim/visualization/swc.h>
 #include <stim/visualization/cylinder.h>
-#include <stim/structures/kdtree.cuh>
 #include <stim/cuda/cudatools/timer.h>
 #include <stim/cuda/cudatools/callable.h>
-
+#include <stim/structures/kdtree.cuh>
 //********************help function********************
 // gaussian_function
 CUDA_CALLABLE float gaussianFunction(float x, float std = 25) { return exp(-x / (2 * std*std)); }  // std default sigma value is 25
@@ -64,13 +63,21 @@ class network{
 	class edge : public cylinder<T>
 	{
 		public:
-		unsigned v[2];		//unique id's designating the starting and ending
+		unsigned int v[2];		//unique id's designating the starting and ending
 		// default constructor
 		edge() : cylinder<T>() {
 			v[1] = (unsigned)(-1); v[0] = (unsigned)(-1);
 		}
 		/// Constructor - creates an edge from a list of points by calling the stim::fiber constructor
+/*
+		///@param v0, the starting index.
+		///@param v1, the ending index.
+		///@param sz, the number of point in the fiber.
+		edge(unsigned int v0, unsigned int v1, unsigned int sz) : cylinder<T>(
+		{
  
+		}
+*/
 		///@param p is an array of positions in space
 		edge(stim::centerline<T> p) : cylinder<T>(p){}
  
@@ -106,6 +113,51 @@ class network{
 			return E;
 		}
  
+		/// operator for writing the edge information into a binary .nwt file.
+		friend std::ofstream& operator<<(std::ofstream& out, const edge& e)
+		{
+			out.write(reinterpret_cast<const char*>(&e.v[0]), sizeof(unsigned int));	///write the starting point.
+			out.write(reinterpret_cast<const char*>(&e.v[1]), sizeof(unsigned int));	///write the ending point.
+			unsigned int sz = e.size();	///write the number of point in the edge.
+			out.write(reinterpret_cast<const char*>(&sz), sizeof(unsigned int));
+			for(int i = 0; i < sz; i++)	///write each point
+			{
+				stim::vec3<T> point = e[i];
+				out.write(reinterpret_cast<const char*>(&point[0]), 3*sizeof(T));
+			//	for(int j = 0; j < nmags(); j++)	//future code for multiple mags
+			//	{
+				out.write(reinterpret_cast<const char*>(&e.R[i]), sizeof(T));	///write the radius
+				std::cout << point.str() << " " << e.R[i] << std::endl;
+			//	}
+			}
+			return out;	//return stream
+		}
+
+		/// operator for reading an edge from a binary .nwt file.
+		friend std::ifstream& operator>>(std::ifstream& in, edge& e)
+		{
+			unsigned int v0, v1, sz;
+			in.read(reinterpret_cast<char*>(&v0), sizeof(unsigned int));	//read the staring point.
+			in.read(reinterpret_cast<char*>(&v1), sizeof(unsigned int));	//read the ending point
+			in.read(reinterpret_cast<char*>(&sz), sizeof(unsigned int));	//read the number of points in the edge
+			stim::centerline<T> temp = stim::centerline<T>(sz);		//allocate the new edge
+			e = edge(temp);		
+			e.v[0] = v0; e.v[1] = v1;
+			for(int i = 0; i < sz; i++)		//set the points and radii to the newly read values
+			{
+				stim::vec3<T> point;
+				in.read(reinterpret_cast<char*>(&point[0]), 3*sizeof(T));
+				e[i] = point;
+				T mag;
+		//				for(int j = 0; j < nmags(); j++)		///future code for mags
+		//				{
+				in.read(reinterpret_cast<char*>(&mag), sizeof(T));	
+				e.set_r(0, mag);
+				std::cout << point.str() << " " << mag << std::endl;
+		//				}
+			}
+			return in;
+		}
 	};
  
 	///Node class that stores the physical position of the node as well as the edges it is connected to (edges that connect to it), As well as any additional data necessary.
@@ -115,12 +167,16 @@ class network{
 			//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.
-
+			//default constructor
+			vertex() : stim::vec3<T>()
+			{
+			}
 			//constructor takes a stim::vec
 			vertex(stim::vec3<T> p) : stim::vec3<T>(p){}
  
 			/// Output the vertex information as a string
-			std::string	str(){
+			std::string 
+			str(){
 				std::stringstream ss;
 				ss<<"\t(x, y, z) = "<<stim::vec3<T>::str();
  
@@ -137,6 +193,36 @@ class network{
  
 				return ss.str();
 			}
+			///operator for writing the edge into the stream;
+			friend std::ofstream& operator<<(std::ofstream& out, const vertex& v)
+			{
+				unsigned int s0, s1;
+				s0 = v.e[0].size();
+				s1 = v.e[1].size();
+				out.write(reinterpret_cast<const char*>(&v.ptr[0]), 3*sizeof(T));	///write physical vertex location
+				out.write(reinterpret_cast<const char*>(&s0), sizeof(unsigned int));	///write the number of "incoming edges"
+				out.write(reinterpret_cast<const char*>(&s1), sizeof(unsigned int));	///write the number of "outgoing edges"	
+				out.write(reinterpret_cast<const char*>(&v.e[0][0]), sizeof(unsigned int)*v.e[0].size());	///write the "incoming edges"
+				out.write(reinterpret_cast<const char*>(&v.e[1][0]), sizeof(unsigned int)*v.e[1].size());	///write the "outgoing edges"
+				return out;
+			}
+
+			///operator for reading the edge out of the stream;
+			friend std::ifstream& operator>>(std::ifstream& in, vertex& v)
+			{
+				in.read(reinterpret_cast<char*>(&v[0]), 3*sizeof(T));	///read the physical position
+				unsigned int s[2];					
+				in.read(reinterpret_cast<char*>(&s[0]), 2*sizeof(unsigned int));	///read the sizes of incoming and outgoing edge arrays
+
+				std::vector<unsigned int> one(s[0]);
+				std::vector<unsigned int> two(s[1]);
+				v.e[0] = one;
+				v.e[1] = two;
+				in.read(reinterpret_cast<char*>(&v.e[0][0]),s[0]*sizeof(unsigned int));		///read the arrays of "incoming edges"
+				in.read(reinterpret_cast<char*>(&v.e[1][0]),s[1]*sizeof(unsigned int));		///read the arrays of "outgoing edges"
+				return in;
+			}
+
 	};
  
 protected:
@@ -445,6 +531,95 @@ public:
 		}
 	}
  
+	///loads a .nwt file. Reads the header and loads the data into the network according to the header.
+	void
+	loadNwt(std::string filename)
+	{
+		int dims[2];		///number of vertex, number of edges
+		readHeader(filename, &dims[0]);		//read header
+		std::ifstream file;
+		file.open(filename, std::ios::in | std::ios::binary);		///skip header information.
+		file.seekg(14+58+4+4, file.beg);
+		vertex v;
+		for(int i = 0; i < dims[0]; i++)		///for every vertex, read vertex, add to network.
+		{
+			file >> v;
+			V.push_back(v);
+//			std::cout << i << " " << v.str() << std::endl;
+		}
+
+		std::cout << std::endl;
+		for(int i = 0; i < dims[1]; i++)		///for every edge, read edge, add to network.
+		{
+			edge e;
+			file >> e;
+			E.push_back(e);
+			std::cout << i << " " << E[i].str() << std::endl;
+		}
+		file.close();
+	}
+
+	///saves a .nwt file. Writes the header in raw text format, then saves the network as a binary file.
+	void
+	saveNwt(std::string filename)
+	{
+		writeHeader(filename);
+		std::ofstream file;
+		file.open(filename, std::ios::out | std::ios::binary | std::ios::app);	///since we have written the header we are not appending.
+		for(int i = 0; i < V.size(); i++)	///look through the Vertices and write each one.
+		{
+//			std::cout << i << " " << V[i].str() << std::endl;
+			file << V[i];
+		}
+		for(int i = 0; i < E.size(); i++)	///loop through the Edges and write each one.
+		{
+			std::cout << i << " " << E[i].str() << std::endl;
+			file << E[i];
+		}
+		file.close();
+	}
+
+
+	///Writes the header information to a .nwt file.
+	void
+	writeHeader(std::string filename)
+	{
+		std::string magicString = "nwtFileFormat ";		///identifier for the file.
+		std::string desc = "fileid(14B), desc(58B), #vertices(4B), #edges(4B): bindata";
+		int hNumVertices = V.size();		///int byte header storing the number of vertices in the file
+		int hNumEdges = E.size();		///int byte header storing the number of edges.
+		std::ofstream file;
+		file.open(filename, std::ios::out | std::ios::binary);
+		std::cout << hNumVertices << " " << hNumEdges << std::endl;
+		file.write(reinterpret_cast<const char*>(&magicString.c_str()[0]), 14);	//write the file id
+		file.write(reinterpret_cast<const char*>(&desc.c_str()[0]), 58);	//write the description
+		file.write(reinterpret_cast<const char*>(&hNumVertices), sizeof(int));	//write #vert.
+		file.write(reinterpret_cast<const char*>(&hNumEdges), sizeof(int));	//write #edges
+//		file << magicString.c_str() << desc.c_str() << hNumVertices << hNumEdges;
+		file.close();
+		
+	}
+
+	///Reads the header information from a .nwt file.
+	void
+	readHeader(std::string filename, int *dims)
+	{
+		char magicString[14];		///id
+		char desc[58];			///description
+		int hNumVertices;		///#vert
+		int hNumEdges;			///#edges
+		std::ifstream file;		////create stream
+		file.open(filename, std::ios::in | std::ios::binary);
+		file.read(reinterpret_cast<char*>(&magicString[0]), 14);	///read the file id.
+		file.read(reinterpret_cast<char*>(&desc[0]), 58);		///read the description
+		file.read(reinterpret_cast<char*>(&hNumVertices), sizeof(int));	///read the number of vertices
+		file.read(reinterpret_cast<char*>(&hNumEdges), sizeof(int));	///read the number of edges
+//		std::cout << magicString << desc << hNumVertices << " " <<  hNumEdges << std::endl;
+		file.close();							///close the file.
+		dims[0] = hNumVertices;						///fill the returned reference.
+		dims[1] = hNumEdges;
+	}
+
 	//load a network from an SWC file
 	void load_swc(std::string filename) {
 		stim::swc<T> S;										// create swc variable
@@ -724,7 +899,7 @@ public:
 			T* query = new T[3 * n];
 			T* m1 = new T[n];
 			T* dists = new T[n];
-			size* nnIdx = new size_t[n];
+			size_t* nnIdx = new size_t[n];
  
 			edge2array(query, R.E[e]);
  
@@ -1002,7 +1177,7 @@ public:
 		stim::vec3<T> p0, p1;
 		T* queryPt = new T[3];
  
-		for(unsigned e = 0; e < R.E.size(); e++){			// for each edge in A
+		for(unsigned int e = 0; e < R.E.size(); e++){			// for each edge in A
 			T M;											// the sum of metrics of current edge
 			for(unsigned p = 0; p < R.E[e].size(); p++)
 				M += A.E[e].r(p);
@@ -1136,4 +1311,4 @@ public:
 	}
 };		//end stim::network class
 };		//end stim namespace
-#endif
 \ No newline at end of file
+#endif
@@ -46,7 +46,7 @@ public:
 	cylinder(centerline<T>c) : centerline<T>(c) {
 		init();
 	}
-
+	
 	//cylinder(centerline<T>c, T r) : centerline(c) {
 	//	init();
 	//	//add_mag(r);
@@ -711,4 +711,4 @@ public:
 };
  
 }
-#endif
 \ No newline at end of file
+#endif