added parser and filename processing

David Mayerich
1 parent 81e0d221
Showing 7 changed files with 423 additions and 20 deletions Show diff stats
envi/binary.h
grids/grid_data.cuh → grids/grid_data.h
grids/image_stack.h
ui/arguments.h → parser/arguments.h
parser/filename.h
parser/parser.h
parser/wildcards.h
@@ -112,21 +112,21 @@ public:
 	}
  
 	//save one band from the memory to the file
-	bool writeZ( T * p, unsigned int page){
+	bool write_page( T * p, unsigned int page){
  
 		if(p == NULL){
 			std::cout<<"ERROR: unable to write into file, empty pointer"<<std::endl;
 			exit(1);
 		}
  
-		file.seekg(R[1] * R[0] * page * sizeof(T), std::ios::beg);   //write into memory from the binary file
-		file.write((char *)p, R[0] * R[1] * sizeof(T));
+		file.seekg(R[1] * R[0] * page * sizeof(T), std::ios::beg);   //seek to the desired location on disk
+		file.write((char *)p, R[0] * R[1] * sizeof(T));				 //write binary data
  
 		return true;
 	}
  
 	//save one band of the file into the memory, and return the pointer
-	bool saveZ( T * p, unsigned int page){
+	bool read_page( T * p, unsigned int page){
  
 		if (page >= R[2]){										//make sure the bank number is right
 			std::cout<<"ERROR: page out of range"<<std::endl;
@@ -140,7 +140,7 @@ public:
 	}
  
 	//saves a hyperplane orthogonal to dimension d at intersection n
-	bool getSlice(T * dest, unsigned int d, unsigned int n){
+	bool read_plane(T * dest, unsigned int d, unsigned int n){
  
 		//reset the file pointer back to the beginning of the file
 		file.seekg(0, std::ios::beg);
@@ -167,7 +167,7 @@ public:
 	}
  
 	//save one pixel of the file into the memory, and return the pointer
-	bool saveXY(T * p, unsigned x, unsigned y){
+	bool read_spectrum(T * p, unsigned x, unsigned y){
  
 		unsigned int i;
  
@@ -186,17 +186,6 @@ public:
 		return true;	
 	}
  
-	/*bool open(std::string filename, unsigned int X, unsigned int h = 0){
-		return open(filename, vec<unsigned int, 1>(X), h);
-	}
-
-	bool open(std::string filename, unsigned int X, unsigned int Y, unsigned int h = 0){
-		return open(filename, vec<unsigned int, 2>(X, Y), h);
-	}
-
-	bool open(std::string filename, unsigned int X, unsigned int Y, unsigned int Z, unsigned int h = 0){
-		return open(filename, vec<unsigned int, 3>(X, Y, Z), h);
-	}*/
  
 };
  
@@ -8,6 +8,7 @@
 #include "../cuda/threads.h"
 #include "../cuda/error.h"
 #include "../cuda/devices.h"
+#include "../math/vector.h"
  
  
 namespace stim{
@@ -21,9 +22,50 @@ class grid_data{
  
 protected:
  
-	unsigned long R[D];		//elements in each dimension
-	T* ptr;					//pointer to the data (on the GPU or CPU)
-	bool gpu;				//true if the data is on the GPU
+	stim::vector<unsigned long, D> R;		//elements in each dimension
+	T* ptr;									//pointer to the data (on the GPU or CPU)
+	bool gpu;								//true if the data is on the GPU
+
+	//return the total number of values in the binary file
+	unsigned long samples(){
+
+		unsigned long s = 1;
+		for(unsigned int d = 0; d < D; d++)
+			s *= R[d];
+
+		return s;
+
+	}
+
+public:
+
+	//write data to disk
+	void write(std::string filename){
+
+		//open the file as binary for reading
+		file.open(filename.c_str(), std::ios::out | std::ios::binary);
+
+		//write file to disk
+		file.write((char *)p, samples() * sizeof(T));
+	}
+
+	//load a binary file from disk
+	//		header size is in bytes
+	void read(std::string filename, stim::vector<unsigned long, D> S, unsigned long header = 0){
+
+		R = S;	//set the sample resolution
+
+		//open the file as binary for writing
+		file.open(filename.c_str(), std::ios::in | std::ios::binary);
+
+		//seek past the header
+		file.seekg(header, std::ios::beg);
+
+		//read the data
+		file.read((char *)p, samples() * sizeof(T));
+	}
+
+
  
 };
  
@@ -8,6 +8,14 @@ namespace stim{
 template<typename T>
 class image_stack : public virtual grid_data<T, 3>{
  
+public:
+
+	void load(std::string wild_name){
+
+	}
+
+	
+
 };
  
  
+#ifndef STIM_FILENAME_H
+#define STIM_FILENAME_H
+
+#include <stdio.h>  /* defines FILENAME_MAX */
+#ifdef WINDOWS
+    #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 <vector>
+#include <stack>
+#include <algorithm>
+
+#include "../parser/parser.h"
+
+#include <boost/filesystem.hpp>
+
+namespace stim{
+
+//filename class designed to work with both Windows and Unix
+
+class filename{
+
+private:
+	void init(){
+
+
+	}
+
+protected:
+
+	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
+
+	//replace any incorrect dividers with the appropriate version for the OS
+	std::string parse_div(std::string s) {
+		#ifdef _WIN32
+			std::replace( s.begin(), s.end(), '/', '\\');
+		#else
+			std::replace( s.begin(), s.end(), '\\', '/');
+		#endif
+
+		return s;
+	}
+
+	//parse the file name (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
+			prefix = fname.substr(0, xpos);
+			ext = fname.substr(xpos + 1);
+		}
+		else
+			prefix = fname;
+	}
+
+	//parse a file locator string
+	void parse(std::string 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] == ':'){
+				drive = loc[0];				//copy the drive letter
+				loc = loc.substr(2);		//remove the drive information from the locator string
+			}
+		#endif
+
+		//remove the initial divider
+		if(loc[0] == STIM_FILENAME_DIV)
+			loc = loc.substr(1);
+
+		//determine the file name
+		std::string fname = loc.substr( loc.find_last_of(STIM_FILENAME_DIV) + 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(STIM_FILENAME_DIV) + 1 );
+		path = stim::parser::split(dir, STIM_FILENAME_DIV);
+	}
+
+public:
+
+	filename(){
+		init();
+	}
+
+	filename(std::string loc){
+		init();
+		parse(loc);
+	}
+
+
+
+	std::string get_name(){
+		if(prefix == "" && ext == "")
+			return "";
+		else
+			return prefix + "." + ext;
+	}
+
+	std::string get_extension(){
+		return ext;
+	}
+
+	std::string get_prefix(){
+		return prefix;
+	}
+
+	std::string dir(){
+		std::stringstream ss;
+
+		//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();
+
+	}
+
+	std::string str(){
+
+		std::stringstream ss;
+
+		ss<<dir()<<get_name();
+
+		return ss.str();
+	}
+
+	//get a list of files matching the current tamplate
+	std::vector<stim::filename> get_list(){
+
+		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;
+	}
+
+	//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);
+		 }
+
+		 return stim::filename(std::string(cCurrentPath) + STIM_FILENAME_DIV);
+	}
+
+	void set_name(std::string fname){
+		parse_name(fname);
+	}
+
+	//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;
+		result.path = result_path;
+		result.set_name(rel_path.back());
+
+		return result;
+	}
+
+
+
+
+
+
+
+
+};
+
+
+}	//end namespace stim
+
+#endif
+#ifndef STIM_PARSER_H
+#define STIM_PARSER_H
+
+namespace stim{
+
+class parser{
+
+public:
+
+	static std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems) {
+		std::stringstream ss(s);
+		std::string item;
+		while (std::getline(ss, item, delim)) {
+			elems.push_back(item);
+		}
+		return elems;
+	}
+
+	static std::vector<std::string> split(const std::string &s, char delim) {
+		std::vector<std::string> elems;
+		split(s, delim, elems);
+		return elems;
+	}
+
+};
+
+}	//end namespace stim
+
+#endif
 \ No newline at end of file
+#ifndef STIM_WILDCARDS_H
+#define STIM_WILDCARDS_H
+
+#include <sstream>
+#include <iomanip>
+
+
+//#include <boost/regex.hpp>
+
+namespace stim{
+
+class wildcards{
+public:
+	//generate a sequence of strings where '?' is replaced by integer increments
+	static std::vector<std::string> increment(std::string input,
+											  unsigned int start,
+											  unsigned int end,
+											  unsigned int step){
+
+		size_t a = input.find_first_of('?');	//find the first ?
+		size_t b = input.find_last_of('?');		//find the last ?
+		size_t n = b - a + 1;					//calculate the number of ?
+
+		std::string str_a = input.substr(0, a);		//split the strings along the wildcard
+		std::string str_b = input.substr(b + 1, std::string::npos);
+
+		//create a vector to hold the output strings
+		std::vector<std::string> out;
+
+		//create a stringstream to handle the padding
+		for (unsigned int i = start; i <= end; i += step){
+
+			std::stringstream ss;
+			ss << str_a
+				<< std::setfill('0')
+				<< std::setw(n)
+				<< i
+				<< str_b;
+
+			out.push_back(ss.str());
+		}
+
+		return out;
+
+
+	}
+/*
+	//returns a list of files that match the specified wildcards in 'd'
+	static std::vector<std::string> get_file_list(std::string s){
+
+		stim::filename f(s);
+		std::string target_path(f.dir());
+		boost::regex filter(f.name());
+
+		std::vector< std::string > all_matching_files;
+
+		boost::filesystem::directory_iterator end_itr; // Default ctor yields past-the-end
+		for( boost::filesystem::directory_iterator i( target_path ); i != end_itr; ++i )
+		{
+			// Skip if not a file
+			if( !boost::filesystem::is_regular_file( i->status() ) ) continue;
+
+			boost::smatch what;
+
+			// Skip if no match
+			if( !boost::regex_match( i->path().filename().string(), what, filter ) ) continue;
+
+			// File matches, store it
+			all_matching_files.push_back( i->path().filename().string() );
+		}
+
+		return all_matching_files;
+
+	}
+*/
+
+};
+
+
+}	//end namespace stim
+
+#endif