implemented saving and loading of image stacks

David Mayerich
1 parent 8157c392
Showing 4 changed files with 145 additions and 24 deletions Show diff stats
grids/grid_data.h
grids/image_stack.h
image/image.h
parser/filename.h
@@ -4,6 +4,7 @@
 #include <vector>
 #include <string>
 #include <sstream>
+#include <fstream>
  
 #include "../cuda/threads.h"
 #include "../cuda/error.h"
@@ -14,7 +15,6 @@
 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>
@@ -22,9 +22,8 @@ class grid_data{
  
 protected:
  
-	stim::vector<unsigned long, D> R;		//elements in each dimension
+	stim::vec<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(){
@@ -42,19 +41,23 @@ 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 *)p, samples() * sizeof(T));
+		file.write((char *)ptr, 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){
+	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);
  
@@ -62,7 +65,7 @@ public:
 		file.seekg(header, std::ios::beg);
  
 		//read the data
-		file.read((char *)p, samples() * sizeof(T));
+		file.read((char *)ptr, samples() * sizeof(T));
 	}
  
  
@@ -72,4 +75,4 @@ public:
 }
  
  
-#endif
 \ No newline at end of file
+#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(std::string wild_name){
+	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();
+
+		//load the first image and set all of the image_stack properties
+		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_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++){
+
+			//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_list[i]);
+
+
+			std::cout<<file_list[i]<<std::endl;
+		}
+
  
 	}
  
@@ -21,4 +95,4 @@ public:
  
 }
  
-#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
@@ -31,6 +31,7 @@ class filename{
 private:
 	void init(){
  
+		absolute = false;
  
 	}
  
@@ -41,6 +42,8 @@ protected:
 	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
@@ -73,15 +76,17 @@ protected:
 		#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(2);		//remove the drive information from the locator string
+				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
  
-		//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)
  
@@ -124,11 +129,14 @@ public:
 	std::string dir(){
 		std::stringstream ss;
  
-		//output the drive letter if in Windows
-		#ifdef _WIN32
-			ss<<drive<<":";
-		#endif
-		ss<<STIM_FILENAME_DIV;
+		//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++)
@@ -197,6 +205,7 @@ public:
 			 exit(1);
 		 }
  
+		 std::cout<<cCurrentPath<<std::endl;
 		 return stim::filename(std::string(cCurrentPath) + STIM_FILENAME_DIV);
 	}
  
@@ -231,13 +240,22 @@ public:
 		std::vector<std::string> result_path(begin, end);
  
 		//create a new path to be returned
-		stim::filename result;
+		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;
+	}
+
+