Merge branch 'master' of https://github.com/stimlab/stim

David Mayerich
2 parents 93503ec6 79143d0b
Showing 9 changed files with 587 additions and 56 deletions Show diff stats
envi/binary.h
grids/grid_data.cuh
grids/grid_data.h
grids/image_stack.h
image/image.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);
-	}*/
  
 };
  
-#ifndef STIM_GRID_DATA_CUH
-#define STIM_GRID_DATA_CUH
-
-#include <vector>
-#include <string>
-#include <sstream>
-
-#include "../cuda/threads.h"
-#include "../cuda/error.h"
-#include "../cuda/devices.h"
-
-
-namespace stim{
-
-//This object describes a generic D-dimensional grid containing data of type T
-	// data can be stored on the GPU or CPU (and transferred between the two)
-	// data can be loaded in the form of images
-	// data can be saved in the form of binary files
-template<typename T, unsigned int D = 1>
-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
-
-};
-
-}
-
-
-#endif
 \ No newline at end of file
+#ifndef STIM_GRID_DATA_CUH
+#define STIM_GRID_DATA_CUH
+
+#include <vector>
+#include <string>
+#include <sstream>
+#include <fstream>
+
+#include "../cuda/threads.h"
+#include "../cuda/error.h"
+#include "../cuda/devices.h"
+#include "../math/vector.h"
+
+
+namespace stim{
+
+//This object describes a generic D-dimensional grid containing data of type T
+	// data can be loaded in the form of images
+	// data can be saved in the form of binary files
+template<typename T, unsigned int D = 1>
+class grid_data{
+
+protected:
+
+	stim::vec<unsigned long, D> R;		//elements in each dimension
+	T* ptr;									//pointer to the data (on the GPU or CPU)
+
+	//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){
+
+		std::fstream file;
+
+		//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 *)ptr, samples() * sizeof(T));
+	}
+
+	//load a binary file from disk
+	//		header size is in bytes
+	void read(std::string filename, stim::vec<unsigned long, D> S, unsigned long header = 0){
+
+		R = S;	//set the sample resolution
+
+		std::fstream file;
+
+		//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 *)ptr, samples() * sizeof(T));
+	}
+
+
+
+};
+
+}
+
+
+#endif
 #ifndef STIM_IMAGE_STACK_H
 #define STIM_IMAGE_STACK_H
  
+#include "../parser/wildcards.h"
+#include "../parser/filename.h"
+#include "../grids/grid_data.h"
+#include "../image/image.h"
  
 namespace stim{
  
 //this creates a class that can be used to load 3D grid data from stacks of images
+//	The class uses a 4D grid_data object, where the first dimension is color
 template<typename T>
-class image_stack : public virtual grid_data<T, 3>{
+class image_stack : public virtual grid_data<T, 4>{
+
+	enum image_type {stimAuto, stimMono, stimRGB, stimRGBA};
+
+protected:
+	using grid_data<T, 4>::R;
+	using grid_data<T, 4>::ptr;
+	using grid_data<T, 4>::samples;
+
+public:
+
+	void load_images(std::string file_mask){
+
+		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);
+		}
+
+		//get the list of files
+		std::vector<stim::filename> file_list = file_path.get_list();
+
+		//if there are no matching files, exit
+		if(file_list.size() == 0){
+			std::cout<<"STIM ERROR (image_stack): No matching files for loading a stack."<<std::endl;
+			exit(1);
+		}
+
+		//load the first image and set all of the image_stack properties
+		std::cout<<"File to Load: "<<file_list[0].str()<<std::endl;
+		stim::image<T> I(file_list[0].str());
+
+		//set the image resolution and number of channels
+		R[0] = I.channels();
+		R[1] = I.width();
+		R[2] = I.height();
+		R[3] = file_list.size();
+
+		//allocate storage space
+		ptr = (T*)malloc(sizeof(T) * samples());
+
+		//load and copy each image into the grid
+		for(unsigned int i = 0; i<R[3]; i++){
+
+			//load the image
+			stim::image<T> I(file_list[i].str());
+
+			//retrieve the interlaced data from the image - store it in the grid
+			I.data_interleaved(&ptr[ i * R[0] * R[1] * R[2] ]);
+		}
+	}
+
+	void save_image(std::string file_name, unsigned int i){
+
+		//create an image
+		stim::image<T> I;
+
+		//retrieve the interlaced data from the image - store it in the grid
+		I.set_interleaved(&ptr[ i * R[0] * R[1] * R[2] ], R[1], R[2], R[0]);
+
+		I.save(file_name);
+	}
+
+	void save_images(std::string file_mask){
+
+		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);
+		}
+
+		//create a list of file names
+		std::vector<std::string> file_list = stim::wildcards::increment(file_path.str(), 0, R[3]-1, 1);
+
+		for(int i=0; i<R[3]; i++)
+			save_image(file_list[i], i);
+	}
+
+
+
+	
  
 };
  
  
 }
  
-#endif
 \ No newline at end of file
+#endif
@@ -37,7 +37,7 @@ public:
 		img.save(filename.c_str());
 	}
  
-	//create an image from an interlaced buffer
+	//create an image from an interleaved buffer
 	void set_interleaved(T* buffer, unsigned int width, unsigned int height, unsigned int channels = 1){
  
 		unsigned char* non_interleaved = (unsigned char*)malloc(width * height * 3);
@@ -53,8 +53,34 @@ public:
 	}
  
 	//returns a pointer to the first pixel of the image data
-	T* data(){
-		return img.data();
+	void data_noninterleaved(T* data){
+		memcpy(data, img.data(), sizeof(T) * size());
+	}
+
+	void data_interleaved(T* data){
+
+		unsigned int C = channels();
+		unsigned int X = size();
+
+		T* ptr = img.data();
+
+		//for each channel
+		for(unsigned int c = 0; c < C; c++)
+			//convert each pixel
+			for(unsigned int x = 0; x < X; x++)
+				data[x * C + c] = ptr[c * X + x];
+	}
+
+	unsigned int channels(){
+		return (unsigned int)img.spectrum();
+	}
+
+	unsigned int width(){
+		return img.width();
+	}
+
+	unsigned int height(){
+		return img.height();
 	}
  
 	//returns the size (number of values) of the image
@@ -417,7 +417,7 @@ namespace stim{
         {
             int i = find(opts.begin(), opts.end(), _name) - opts.begin();
  
-            if(i < 0)
+            if(i < 0 || i >= opts.size())
             {
                 std::cout<<"ERROR - Unspecified parameter name: "<<_name<<std::endl;
                 exit(1);
+#ifndef STIM_FILENAME_H
+#define STIM_FILENAME_H
+
+#include <stdio.h>  /* defines FILENAME_MAX */
+#ifdef _WIN32
+    #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(){
+
+		absolute = false;
+
+	}
+
+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
+
+	bool absolute;					//filename is an absolute path
+
+	//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] == ':'){
+				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(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;
+
+		//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();
+
+	}
+
+	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);
+		 }
+
+		 std::cout<<cCurrentPath<<std::endl;
+		 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 = *this;
+		result.path = result_path;
+		result.set_name(rel_path.back());
+
+		return result;
+	}
+
+	bool is_relative(){
+		return !absolute;
+	}
+
+	bool is_absolute(){
+		return absolute;
+	}
+
+
+
+
+
+
+
+
+
+};
+
+
+}	//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