added OBJ class

David Mayerich
1 parent 27b826a8
Showing 2 changed files with 528 additions and 0 deletions Show diff stats
stim/envi/binary.h
stim/visualization/obj.h
@@ -71,6 +71,16 @@ protected:
 		//open the file as binary for reading and writing
 		file.open(filename.c_str(), std::ios::in | std::ios::out | std::ios::binary);
  
+		//if the file isn't open, the user may only have read access
+		if(!file.is_open()){
+			std::cout<<"class BINARY - failed to open file, trying for read only"<<std::endl;
+			file.open(filename.c_str(), std::ios::in | std::ios::binary);
+			if(!file.is_open()){
+				std::cout<<"               still unable to load the file"<<std::endl;
+				return false;
+			}
+		}
+
 		//if the file is successful
 		if(file){
 			name = filename;		//set the name
+#ifndef STIM_OBJ_H
+#define STIM_OBJ_H
+
+#include <vector>
+#include <sstream>
+#include <fstream>
+#include <stdlib.h>
+#include <stim/parser/parser.h>
+
+namespace stim{
+
+/** This class provides an interface for loading, saving, and working with Wavefront OBJ files.
+ *  The class structure uses similar terminology to the OBJ file structure, so one familiar with it
+ *  should be able to work well with this class.
+ *
+ *  This class currently provides the ability to load explicitly defined geometric objects, including point lists,
+ *  lines, and faces with positions, texture coordinates, and normals. This data is stored in a protected series
+ *  of lists that are accessible to classes that extend this one.
+ *
+ *  Multiple helper classes are used to facilitate loading, storing, and saving geometry. These are protected
+ *  and therefore only designed to be used within the confines of the class. These helper classes include:
+ *
+ *  vertex class - contains methods for loading, saving, and storing 1, 2, 3, and 4 component vectors
+ *  triplet class - contains methods for loading, saving, and storing indexed vertices used for geometric objects
+ *  geometry class - contains a list of triplets used to define a geometric structure, such as a face or line
+ */
+
+enum obj_type { OBJ_NONE, OBJ_LINE, OBJ_FACE, OBJ_POINTS };
+
+template <typename T>
+class obj{
+
+protected:
+
+	enum token_type { OBJ_INVALID, OBJ_V, OBJ_VT, OBJ_VN, OBJ_P, OBJ_L, OBJ_F };
+
+	struct vertex : public std::vector<T>{
+
+		using std::vector<T>::push_back;
+		using std::vector<T>::size;
+		using std::vector<T>::at;
+
+		vertex(){}
+
+		//constructors for quickly building vertices with arbitrary numbers of components
+		vertex(T x){
+			push_back(x);
+		}
+
+		vertex(T x, T y){
+			push_back(x);
+			push_back(y);
+		}
+
+		vertex(T x, T y, T z){
+			push_back(x);
+			push_back(y);
+			push_back(z);
+		}
+
+		vertex(T x, T y, T z, T w){
+			push_back(x);
+			push_back(y);
+			push_back(z);
+			push_back(w);
+		}
+
+		//constructor creates a vertex from a line string
+		vertex(std::string line){
+
+			//create a temporary vector used to store string tokens
+			std::vector<std::string> tokens = stim::parser::split(line, ' ');
+
+			//create temporary storage for casting the token values
+			T val;
+
+			//for each token (skipping the first)
+			for(unsigned int i =  1; i < tokens.size(); i++){
+				std::stringstream ss(tokens[i]);				//create a stringstream object for casting
+				ss>>val;										//cast the token to the correct numerical value
+				push_back(val);									//push the coordinate into the vertex
+			}
+		}
+
+		//output the vertex as a string
+		std::string str(){
+
+			std::stringstream ss;
+			
+			for(int i = 0; i < size(); i++){
+				if(i > 0)
+					ss<<' ';
+
+				ss<<at(i);
+			}
+
+			return ss.str();	//return the vertex string
+		}
+
+
+	};	//end vertex
+
+	//triplet used to specify geometric vertices consisting of a position vertex, texture vertex, and normal
+	struct triplet : public std::vector<unsigned int>{
+		
+		//create a triplet given a parameter list (OBJ indices start at 1, so 0 can be used to indicate no value)
+		triplet(unsigned int v, unsigned int vt = 0, unsigned int vn = 0){
+			push_back(v);
+			if(vn != 0){
+				push_back(vt);
+				push_back(vn);
+			}
+			else if(vt != 0)
+				push_back(vt);
+		}
+
+		//build a triplet from a string
+		triplet(std::string s){
+
+			//create a temporary vector used to store string tokens
+			std::vector<std::string> tokens = stim::parser::split(s, '\\');
+
+			//std::cout<<"processing triplet: "<<s<<std::endl;
+			if(tokens.size() >= 1)
+				push_back( atoi( tokens[0].c_str() ) );
+
+			if(tokens.size() >= 2){
+				if(tokens[1].length())
+					push_back( atoi( tokens[1].c_str() ) );
+				else
+					push_back(0);
+			}
+
+			if(tokens.size() == 3)
+				push_back( atoi( tokens[2].c_str() ) );
+
+		}
+
+		//output the geometry as a string
+		std::string str(){
+
+			std::stringstream ss;
+
+			ss<<at(0);	//the vertex is always the first value
+
+			if(size() == 3){
+				if(at(1) == 0)
+					ss<<"\\\\"<<at(2);
+				else
+					ss<<'\\'<<at(1)<<'\\'<<at(2);
+			}
+			else if(size() == 2)
+				ss<<"\\"<<at(1);
+
+			return ss.str();
+		}
+
+	};	//end triplet
+
+	//geometry used to specify a geometric structure consisting of several triplets
+	struct geometry : public std::vector<triplet>{
+
+		using std::vector<triplet>::size;
+		using std::vector<triplet>::at;
+		using std::vector<triplet>::push_back;
+
+		geometry(){}
+
+		//constructs a geometry object from a line read from an OBJ file
+		geometry(std::string line){
+
+			//create a temporary vector used to store string tokens
+			std::vector<std::string> tokens = stim::parser::split(line, ' ');
+
+			//for each triplet in the line
+			for(unsigned int i = 1; i < tokens.size(); i++){
+				//construct the triplet and push it to the geometry
+				push_back( triplet(tokens[i]) );
+			}
+
+		}
+
+		std::string str(){
+
+			std::stringstream ss;
+
+			for(unsigned int i = 0; i < size(); i++){
+
+				if(i != 0)
+					ss<<' ';
+
+				ss<<at(i).str();
+			}
+
+			return ss.str();
+		}
+	};
+
+	std::vector<vertex> V;		//vertex spatial position
+	std::vector<vertex> VN;
+	std::vector<vertex> VT;
+
+	//structure lists
+	std::vector<geometry> L;	//list of lines
+	std::vector<geometry> P;	//list of points structures
+	std::vector<geometry> F;	//list of faces
+
+	//information for the current geometric object
+	geometry current_geo;
+	vertex current_vt;
+	vertex current_vn;
+
+		//flags for the current geometric object
+		obj_type current_type;
+		bool geo_flag_vt;
+		bool geo_flag_vn;
+		bool vert_flag_vt;
+		bool vert_flag_vn;
+
+	void update_vt(vertex vt){
+		current_vt = vt;
+
+		//the geometry vertex texture flag can only be set for the first vertex
+		if(current_geo.size() == 0)
+			geo_flag_vt = true;
+
+		vert_flag_vt = true;
+	}
+
+	void update_vn(vertex vn){
+		current_vn = vn;
+
+		//the geometry normal flag can only be set for the first vertex
+		if(current_geo.size() == 0)
+			geo_flag_vn = true;
+
+		vert_flag_vn = true;
+	}
+
+	//create a triple and add it to the current geometry
+	void update_v(vertex vv){
+
+		unsigned int v;
+		unsigned int vt = 0;
+		unsigned int vn = 0;
+
+		//if the current geometry is using a texture coordinate, add the current texture coordinate to the geometry
+		if(geo_flag_vt){
+			if(vert_flag_vt)				//don't add it more than once
+				VT.push_back(current_vt);
+			vt = VT.size();
+		}
+
+		//if the current geometry is using a normal, add the current texture coordinate to the geometry
+		if(geo_flag_vn){
+			if(vert_flag_vn)				//don't add it more than once
+				VN.push_back(current_vn);
+			vn = VN.size();
+		}
+
+		//add the current vertex position to the geometry
+		V.push_back(vv);
+		v = V.size();
+
+		//create a triplet and add it to the current geometry
+		current_geo.push_back(triplet(v, vt, vn));
+
+		//clear the vertex flags
+		vert_flag_vt = false;
+		vert_flag_vn = false;
+	}
+
+	void init(){
+		//clear all lists
+		V.clear();
+		VT.clear();
+		VN.clear();
+		P.clear();
+		L.clear();
+		F.clear();
+
+		//initialize all of the flags
+		current_type = OBJ_NONE;
+		geo_flag_vt = false;
+		geo_flag_vn = false;
+		vert_flag_vt = false;
+		vert_flag_vn = false;
+	}
+
+	//gets the type of token representing the entry in the OBJ file
+	token_type get_token(std::string s){
+
+		//if the line contains a vertex
+		if(s[0] == 'v'){
+			if(s[1] == ' ') return OBJ_V;
+			if(s[1] == 't') return OBJ_VT;
+			if(s[1] == 'n') return OBJ_VN;
+		}
+
+		if(s[0] == 'l' && s[1] == ' ') return OBJ_L;
+		if(s[0] == 'p' && s[1] == ' ') return OBJ_P;
+		if(s[0] == 'f' && s[1] == ' ') return OBJ_F;
+
+		return OBJ_INVALID;
+	}
+
+public:
+	//functions for setting the texture coordinate for the next vertex
+	void TexCoord(T x){ update_vt(vertex(x));}
+	void TexCoord(T x, T y){ update_vt(vertex(x, y));}
+	void TexCoord(T x, T y, T z){ update_vt(vertex(x, y, z));}
+	void TexCoord(T x, T y, T z, T w){ update_vt(vertex(x, y, z, w));}
+
+	//functions for setting the normal for the next vertex
+	void Normal(T x){ update_vn(vertex(x));}
+	void Normal(T x, T y){ update_vn(vertex(x, y));}
+	void Normal(T x, T y, T z){ update_vn(vertex(x, y, z));}
+	void Normal(T x, T y, T z, T w){ update_vn(vertex(x, y, z, w));}
+
+	//functions for setting the next vertex position (note that this updates the current geometry)
+	void Vertex(T x){ update_v(vertex(x));}
+	void Vertex(T x, T y){ update_v(vertex(x, y));}
+	void Vertex(T x, T y, T z){ update_v(vertex(x, y, z));}
+	void Vertex(T x, T y, T z, T w){ update_v(vertex(x, y, z, w));}
+
+	///This function starts drawing of a primitive object, such as a line, face, or point set
+
+	/// @param t is the type of object to be drawn: OBJ_POINTS, OBJ_LINE, OBJ_FACE
+	void Begin(obj_type t){
+		current_type = t;
+	}
+
+	/// This function terminates drawing of a primitive object, such as a line, face, or point set
+	void End(){
+
+		//copy the current object to the appropriate list
+		switch(current_type){
+
+		case OBJ_NONE:
+			std::cout<<"STIM::OBJ error, objEnd() called before objBegin()."<<std::endl;
+			break;
+
+		case OBJ_POINTS:
+			P.push_back(current_geo);
+			break;
+
+		case OBJ_LINE:
+			L.push_back(current_geo);
+			break;
+
+		case OBJ_FACE:
+			F.push_back(current_geo);
+		}
+
+		//clear everything
+		current_type = OBJ_NONE;
+		current_geo.clear();
+		vert_flag_vt = false;
+		vert_flag_vn = false;
+		geo_flag_vt = false;
+		geo_flag_vn = false;
+	}
+
+	//output the OBJ structure as a string
+	std::string str(){
+
+		std::stringstream ss;
+
+		unsigned int i;
+		
+		//output all of the vertices
+		if(V.size()){
+			ss<<"#vertex positions"<<std::endl;
+			for(i = 0; i < V.size(); i++){
+				ss<<"v "<<V[i].str()<<std::endl;
+			}
+		}
+
+		//output all of the texture coordinates
+		if(VT.size()){
+			ss<<std::endl<<"#vertex texture coordinates"<<std::endl;
+			for(i = 0; i < VT.size(); i++){
+				ss<<"vt "<<VT[i].str()<<std::endl;
+			}
+		}
+
+		//output all of the normals
+		if(VN.size()){
+			ss<<std::endl<<"#vertex normals"<<std::endl;
+			for(i = 0; i < VN.size(); i++){
+				ss<<"vn "<<VN[i].str()<<std::endl;
+			}
+		}
+
+		//output all of the points
+		if(P.size()){
+			ss<<std::endl<<"#point structures"<<std::endl;
+			for(i = 0; i < P.size(); i++){
+				ss<<"p "<<P[i].str()<<std::endl;
+			}
+		}
+
+		//output all of the lines
+		if(L.size()){
+			ss<<std::endl<<"#line structures"<<std::endl;
+			for(i = 0; i < L.size(); i++){
+				ss<<"l "<<L[i].str()<<std::endl;
+			}
+		}
+
+		//output all of the lines
+		if(F.size()){
+			ss<<std::endl<<"#face structures"<<std::endl;
+			for(i = 0; i < F.size(); i++){
+				ss<<"f "<<F[i].str()<<std::endl;
+			}
+		}
+
+		return ss.str();	//return the constructed string
+	}
+
+	obj(){
+		init();		//private function that initializes everything
+	}
+
+	void clear(){
+		init();
+	}
+
+	/// This function saves the current structure as a Wavefront OBJ file
+
+	/// @param filename is the name of the file to be saved
+	bool save(std::string filename){
+
+		std::ofstream outfile(filename.c_str());
+
+		if(!outfile){
+			std::cout<<"STIM::OBJ error opening file for writing"<<std::endl;
+			return false;
+		}
+
+		//output the OBJ data to the file
+		outfile<<str();
+
+		//close the file
+		outfile.close();
+
+		return true;
+	}
+
+	/// Load a Wavefront OBJ file (support for faces, lines, and point lists)
+
+	/// @param filename is the name of the OBJ file to load
+	bool load(std::string filename){
+
+		//load the file
+		std::ifstream infile(filename.c_str());
+
+		//if the file is invalid, throw an error
+		if(!infile){
+			std::cout<<"STIM::OBJ Error loading file "<<filename<<std::endl;
+			return false;
+		}
+
+		std::string line;
+		while(infile){
+
+			//create a variable to store a single line
+			getline(infile, line);
+
+			//get the token representing the first parameter
+			token_type token = get_token(line);
+
+			switch(token){
+
+			case OBJ_INVALID:
+				break;
+
+			case OBJ_V:
+				V.push_back(vertex(line));
+				break;
+
+			case OBJ_VT:
+				VT.push_back(vertex(line));
+				break;
+
+			case OBJ_VN:
+				VN.push_back(vertex(line));
+				break;
+
+			case OBJ_F:
+				F.push_back(geometry(line));
+				break;
+
+			};
+		}
+
+
+
+		//close the file
+		infile.close();
+
+		return true;
+
+	}
+
+
+};
+
+
+
+
+
+
+};
+
+
+#endif