diff --git a/stim/envi/bil.h b/stim/envi/bil.h
index f576d4b..b1a6ed1 100644
--- a/stim/envi/bil.h
+++ b/stim/envi/bil.h
@@ -200,6 +200,11 @@ public:
 	/// @param p is a pointer to pre-allocated memory at least B * sizeof(T) in size.
 	/// @param x is the x-coordinate (dimension 1) of the spectrum.
 	/// @param y is the y-coordinate (dimension 2) of the spectrum.
+	bool spectrum(T* p, size_t n, bool PROGRESS = false){
+		size_t y = n / X();
+		size_t x = n - y * X();
+		return binary<T>::read_line_1(p, x, y, PROGRESS);
+	}
 	bool spectrum(T * p, unsigned long long x, unsigned long long y, bool PROGRESS = false){
 		return binary<T>::read_line_1(p, x, y, PROGRESS);
 	}
diff --git a/stim/envi/binary.h b/stim/envi/binary.h
index 7b5a730..3385d00 100644
--- a/stim/envi/binary.h
+++ b/stim/envi/binary.h
@@ -200,11 +200,30 @@ public:
 	/// @param p is a pointer to pre-allocated memory equal to the line size R[2]
 	/// @param x is the x coordinate
 	/// @param y is the y coordinate
-	bool read_line_2( T * p, unsigned long long x, unsigned long long y, bool PROGRESS = false){
+	void read_line_2( T* p, size_t n, bool PROGRESS = false){
 		unsigned long long i;
 
 		if(PROGRESS) progress = 0;
 
+		if ( n > R[0] * R[1]){							//make sure the sample and line number is right
+			std::cout<<"ERROR: sample or line out of range in "<<__FILE__<<" (line "<<__LINE__<<")"<<std::endl;
+			exit(1);
+		}
+
+		file.seekg(n * sizeof(T), std::ios::beg);           //point to the certain sample and line
+		for (i = 0; i < R[2]; i++){							//for each band
+			file.read((char *)(p + i), sizeof(T));
+			file.seekg((R[1] * R[0] - 1) * sizeof(T), std::ios::cur);    //go to the next band
+			if(PROGRESS) progress = (double)i / (double)R[2] * 100;
+		}
+		if(PROGRESS) progress = 100;
+	}
+	void read_line_2( T * p, unsigned long long x, unsigned long long y, bool PROGRESS = false){
+		read_line_2(p, y * R[0] + x, PROGRESS);
+		/*unsigned long long i;
+
+		if(PROGRESS) progress = 0;
+
 		if ( x >= R[0] || y >= R[1]){							//make sure the sample and line number is right
 			std::cout<<"ERROR: sample or line out of range"<<std::endl;
 			return false;
@@ -219,7 +238,7 @@ public:
 		}
 		if(PROGRESS) progress = 100;
 
-		return true;
+		return true;*/
 	}
 
 	///Reads a line X (fastest dimension) for a given YZ value
@@ -230,7 +249,7 @@ public:
 	bool read_line_0(T * p, unsigned long long y, unsigned long long z, bool PROGRESS = false){
 		//test to make sure the specified value is within range
 		if( y >= R[1] || z >= R[2] ){
-			std::cout<<"ERROR: sample or line out of range"<<std::endl;
+			std::cout<<"ERROR: sample ("<<y<<", "<<z<<") out of range in "<<__FILE__<<" (line "<<__LINE__<<")"<<std::endl;
 			return false;
 		}
 
@@ -249,7 +268,7 @@ public:
 		if(PROGRESS) progress = 0;
 		//test to make sure the specified value is within range
 		if( x >= R[0] || z >= R[2] ){
-			std::cout<<"ERROR: sample or line out of range"<<std::endl;
+			std::cout<<"ERROR: sample or line out of range in "<<__FILE__<<" (line "<<__LINE__<<")"<<std::endl;
 			return false;
 		}
 
@@ -270,7 +289,7 @@ public:
 	bool read_plane_0(T* p, unsigned long long n, bool PROGRESS = false){
 		if(PROGRESS) progress = 0;
 		if (n >= R[0]){										//make sure the number is within the possible range
-			std::cout<<"ERROR read_plane_0: page out of range"<<std::endl;
+			std::cout<<"ERROR: sample or line out of range in "<<__FILE__<<" (line "<<__LINE__<<")"<<std::endl;
 			return false;
 		}
 		unsigned long long jump = (R[0] - 1) * sizeof(T);		//number of bytes to skip between samples
diff --git a/stim/envi/bip.h b/stim/envi/bip.h
index 5e4061d..639a251 100644
--- a/stim/envi/bip.h
+++ b/stim/envi/bip.h
@@ -143,6 +143,11 @@ public:
 	bool spectrum(T * p, unsigned long long x, unsigned long long y, bool PROGRESS = false){
 		return read_line_0(p, x, y, PROGRESS);				//read a line in the binary YZ plane (dimension order for BIP is ZXY)
 	}
+	bool spectrum(T* p, size_t n, bool PROGRESS = false){
+		size_t y = n / X();
+		size_t x = n - y * X();
+		return read_line_0(p, x, y, PROGRESS);				//read a line in the binary YZ plane (dimension order for BIP is ZXY)
+	}
 
 	/// Retrieves a band of x values from a given xz plane.
 
diff --git a/stim/envi/bsq.h b/stim/envi/bsq.h
index b383727..afdaf96 100644
--- a/stim/envi/bsq.h
+++ b/stim/envi/bsq.h
@@ -146,9 +146,13 @@ public:
 	/// @param p is a pointer to pre-allocated memory at least B * sizeof(T) in size.
 	/// @param x is the x-coordinate (dimension 1) of the spectrum.
 	/// @param y is the y-coordinate (dimension 2) of the spectrum.
-	bool spectrum(T * p, unsigned long long x, unsigned long long y, bool PROGRESS = false){
-		return read_line_2(p, x, y, PROGRESS);
+	void spectrum(T* p, size_t n, bool PROGRESS){
+		read_line_2(p, n, PROGRESS);
 	}
+	void spectrum(T * p, unsigned long long x, unsigned long long y, bool PROGRESS = false){
+		read_line_2(p, x, y, PROGRESS);
+	}
+
 
 	/// Retrieve a single pixel and stores it in pre-allocated memory.
 
diff --git a/stim/envi/envi.h b/stim/envi/envi.h
index 2c27acc..a8dc5ac 100644
--- a/stim/envi/envi.h
+++ b/stim/envi/envi.h
@@ -21,10 +21,56 @@ class envi{
 	void* file;		//void pointer to the relevant file reader (bip, bsq, or bil - with appropriate data type)
 	std::string fname;					//file name used for repeated opening and closing
 
+	//allocate sufficient space for a spectrum based on the data type and number of bands
+	void* alloc_array(size_t len){
+		switch(header.data_type){
+		case envi_header::int8:
+			return malloc(len);
+		case envi_header::int16:
+		case envi_header::uint16:
+			return malloc(2 * len);
+		case envi_header::int32:
+		case envi_header::uint32:
+		case envi_header::float32:
+			return malloc(4 * len);
+		case envi_header::int64:
+		case envi_header::uint64:
+		case envi_header::float64:
+		case envi_header::complex32:
+			return malloc(8 * len);
+		case envi_header::complex64:
+			return malloc(16 * len);
+		default:
+			std::cout<<"ERROR stim::envi data type not recognized for spectral allocation"<<std::endl;
+			exit(1);
+		}
+	}
+
+	//cast a value to DEST type from SRC type
+	template<typename DST, typename SRC>
+	inline void cast(DST* dst, SRC* src){
+		(*dst) = (DST)(*src);
+	}
+
+	//cast an array from type SRC to type DEST
+	template<typename DST, typename SRC>
+	inline void cast(DST* dst, SRC* src, size_t len){
+		for(size_t i = 0; i < len; i++)
+			cast(&dst[i], &src[i]);
+	}
+
 public:
 
 	envi_header header;
 
+	void* malloc_spectrum(){
+		return alloc_array(header.bands);
+	}
+
+	void* malloc_band(){
+		return alloc_array(header.samples * header.lines);
+	}
+
 	/// Returns the size of the data type in bytes
 	unsigned int type_size(){
 		if(header.data_type == envi_header::float32) return 4;
@@ -1060,7 +1106,7 @@ public:
 	/// @param ptr is a pointer to pre-allocated memory of size B*sizeof(T)
 	/// @param x is the x-coordinate of the spectrum
 	/// @param y is the y-coordinate of the spectrum
-	bool spectrum(void* ptr, unsigned long long x, unsigned long long y, bool PROGRESS = false){
+	/*bool spectrum(void* ptr, unsigned long long x, unsigned long long y, bool PROGRESS = false){
 
 		if(header.interleave == envi_header::BSQ){		//if the infile is bsq file
 			if(header.data_type ==envi_header::float32)
@@ -1093,6 +1139,114 @@ public:
 			}
 		}
 		return false;
+	}*/
+
+	// Retrieve a spectrum at the specified 1D location
+
+	/// @param ptr is a pointer to pre-allocated memory of size B*sizeof(T)
+	/// @param x is the 1D coordinate of the spectrum
+	template<typename T>
+	void spectrum(T* ptr, size_t n, bool PROGRESS = false){
+
+		void* temp = alloc_array(header.bands);		//allocate space for the output array
+
+		if(header.interleave == envi_header::BSQ){		//if the infile is bsq file
+			if(header.data_type ==envi_header::float32){
+				((bsq<float>*)file)->spectrum((float*)temp, n, PROGRESS);
+				cast<T, float>(ptr, (float*)temp, header.bands);
+			}
+			else if (header.data_type == envi_header::float64){
+				((bsq<double>*)file)->spectrum((double*)temp, n, PROGRESS);
+				cast<T, double>(ptr, (double*)temp, header.bands);
+			}
+			else{
+				std::cout << "ERROR: unidentified data type" << std::endl;
+				exit(1);
+			}
+		}
+		else if (header.interleave == envi_header::BIL){
+			if (header.data_type == envi_header::float32){
+				((bil<float>*)file)->spectrum((float*)temp, n, PROGRESS);
+				cast<T, float>(ptr, (float*)temp, header.bands);
+			}
+			else if (header.data_type == envi_header::float64){
+				((bil<double>*)file)->spectrum((double*)temp, n, PROGRESS);
+				cast<T, double>(ptr, (double*)temp, header.bands);
+			}
+			else{
+				std::cout << "ERROR: unidentified data type" << std::endl;
+				exit(1);
+			}
+		}
+		else if (header.interleave == envi_header::BIP){
+			if (header.data_type == envi_header::float32){
+				((bip<float>*)file)->spectrum((float*)temp, n, PROGRESS);
+				cast<T, float>(ptr, (float*)temp, header.bands);
+			}
+			else if (header.data_type == envi_header::float64){
+				((bip<double>*)file)->spectrum((double*)temp, n, PROGRESS);
+				cast<T, double>(ptr, (double*)temp, header.bands);
+			}
+			else{
+				std::cout << "ERROR: unidentified data type" << std::endl;
+				exit(1);
+			}
+		}
+	}
+
+	/// Retrieve a spectrum from the specified (x, y) location
+
+	/// @param ptr is a pointer to pre-allocated memory of size B*sizeof(T)
+	/// @param x is the x-coordinate of the spectrum
+	/// @param y is the y-coordinate of the spectrum
+	template<typename T>
+	void spectrum(T* ptr, unsigned long long x, unsigned long long y, bool PROGRESS = false){
+
+		spectrum<T>(ptr, y * header.samples + x, PROGRESS = false);
+		/*void* temp = alloc_array<T>(header.bands);		//allocate space for the output array
+
+		if(header.interleave == envi_header::BSQ){		//if the infile is bsq file
+			if(header.data_type ==envi_header::float32){
+				((bsq<float>*)file)->spectrum((float*)temp, x, y, PROGRESS);
+				cast<T, float>(ptr, temp, header.bands);
+			}
+			else if (header.data_type == envi_header::float64){
+				((bsq<double>*)file)->spectrum((double*)temp, x, y, PROGRESS);
+				cast<T, double>(ptr, temp, header.bands);
+			}
+			else{
+				std::cout << "ERROR: unidentified data type" << std::endl;
+				exit(1);
+			}
+		}
+		else if (header.interleave == envi_header::BIL){
+			if (header.data_type == envi_header::float32){
+				((bil<float>*)file)->spectrum((float*)temp, x, y, PROGRESS);
+				cast<T, float>(ptr, temp, header.bands);
+			}
+			else if (header.data_type == envi_header::float64){
+				((bil<double>*)file)->spectrum((double*)temp, x, y, PROGRESS);
+				cast<T, double>(ptr, temp, header.bands);
+			}
+			else{
+				std::cout << "ERROR: unidentified data type" << std::endl;
+				exit(1);
+			}
+		}
+		else if (header.interleave == envi_header::BIP){
+			if (header.data_type == envi_header::float32){
+				((bip<float>*)file)->spectrum((float*)temp, x, y, PROGRESS);
+				cast<T, float>(ptr, temp, header.bands);
+			}
+			else if (header.data_type == envi_header::float64){
+				((bip<double>*)file)->spectrum((double*)temp, x, y, PROGRESS);
+				cast<T, double>(ptr, temp, header.bands);
+			}
+			else{
+				std::cout << "ERROR: unidentified data type" << std::endl;
+				exit(1);
+			}
+		}*/
 	}
 
 	/// Retrieve a single band (based on index) and stores it in pre-allocated memory.
diff --git a/stim/image/image.h b/stim/image/image.h
index 9eca082..a18f179 100644
--- a/stim/image/image.h
+++ b/stim/image/image.h
@@ -33,8 +33,7 @@ class image{
 
 	void unalloc(){								//frees any resources associated with the image
 		if(img)	free(img);						//if memory has been allocated, free it
-		img=NULL;
-		
+		img=NULL;		
 	}
 
 
@@ -92,7 +91,9 @@ class image{
 public:
 
 	/// Default constructor - creates an empty image object
-	image(){ init(); }							//initialize all variables to zero, don't allocate any memory
+	image(){
+		init();						//initialize all variables to zero, don't allocate any memory
+	}							
 
 	/// Constructor with a filename - loads the specified file
 	image(std::string filename){				//constructor initialize the image with an image file
@@ -114,7 +115,7 @@ public:
 	}
 
 	/// Copy constructor - duplicates an image object
-	image(const stim::image<T>& I){
+	image(const stim::image<T> &I){
 		init();
 		allocate(I.X(), I.Y(), I.C());
 		memcpy(img, I.img, bytes());
@@ -125,7 +126,7 @@ public:
 		free(img);
 	}
 
-	stim::image<T> operator=(const stim::image<T>& I){
+	stim::image<T>& operator=(const stim::image<T>& I){
 		if(&I == this)									//handle self-assignment
 			return *this;
 		allocate(I.X(), I.Y(), I.C());
@@ -138,7 +139,7 @@ public:
 
 		cv::Mat cvImage = cv::imread(filename, CV_LOAD_IMAGE_UNCHANGED);	//use OpenCV to open the image file
 		if(!cvImage.data){
-			std::cout<<"ERROR stim::image::load() - unable to find image "<<filename<<std::endl;
+			std::cout<<"ERROR stim::image::load() - unable to find image "<<filename<<" ["<<__FILE__<<" (line "<<__LINE__<<")]"<<std::endl;
 			exit(1);
 		}
 		allocate(cvImage.cols, cvImage.rows, cvImage.channels());			//allocate space for the image
diff --git a/stim/parser/table.h b/stim/parser/table.h
new file mode 100644
index 0000000..d43b663
--- /dev/null
+++ b/stim/parser/table.h
@@ -0,0 +1,106 @@
+#ifndef STIM_CSV_H
+#define STIM_CSV_H
+
+#include <vector>
+#include <sstream>
+#include <fstream>
+
+namespace stim{
+
+	class table{
+
+		std::vector< std::vector< std::string > > TABLE;
+
+		size_t x;											//current x and y positions for adding elements to the table
+		size_t y;
+
+		void init(){
+			x = y = 0;
+			TABLE.resize(1);								//create a single row
+			TABLE[0].clear();								//make sure that the row is empty
+		}
+	public:
+
+		table(){
+			init();
+		}
+
+		void new_column(){
+			x = 0;											//reset to the first position of the column
+			y++;											//increment the current row position
+			TABLE.push_back( std::vector<std::string>() );	//push an empty row
+		}
+
+		template<typename T>
+		T operator<<(T i){
+			std::stringstream ss;
+			ss<<i;
+			TABLE[y].push_back(ss.str());
+			x++;
+			return i;
+		}
+
+		std::string str(){
+			std::stringstream ss;
+			for(size_t yi = 0; yi < TABLE.size(); yi++){
+				for(size_t xi = 0; xi < TABLE[yi].size(); xi++){
+					if(xi != 0) ss<<", ";
+					ss<<TABLE[yi][xi];
+				}
+				ss<<std::endl;
+			}
+			return ss.str();
+		}
+
+		void save_ascii(std::string filename, char col_delim = ',', char row_delim = '\n'){
+			ofstream outfile(filename);
+			for(size_t yi = 0; yi < TABLE.size(); yi++){
+				if(yi != 0 && TABLE[yi].size() > 0) outfile<<row_delim;
+				for(size_t xi = 0; xi < TABLE[yi].size(); xi++){
+					if(xi != 0) outfile<<col_delim;
+					outfile<<TABLE[yi][xi];
+				}
+			}
+		}
+
+		void read_ascii(std::string filename, char col_delim = ',', char row_delim = '\n'){
+			ifstream infile(filename);						//open an ascii file for reading
+			TABLE.clear();									//empty out the table
+
+			std::string line;
+			while(!infile.eof()){
+				std::getline(infile, line, row_delim);		//read a line from the file using the row delimiter
+				size_t pos = 0;
+				std::string token;
+				std::vector< std::string > row;
+				while ((pos = line.find(col_delim)) != std::string::npos) {
+					token = line.substr(0, pos);
+					row.push_back(token);
+					line.erase(0, pos + 1);
+				}
+				token = line.substr(0, std::string::npos);		//read the last column
+				row.push_back(token);							//push it into the table
+				TABLE.push_back(row);		//add an empty vector to the table
+			}
+		}
+
+		/// Returns a vector representation of the table by casting to the specified template
+		template<typename T>
+		std::vector< std::vector<T> > get_vector(){
+			std::vector< std::vector<T> > result;
+			result.resize(TABLE.size());							//initialize the first dimension of the returned table
+			for(size_t i = 0; i < TABLE.size(); i++){				//for each row
+				result[i].resize(TABLE[i].size());					//initialize the number of columns in this row
+				for(size_t j = 0; j < TABLE[i].size(); j++){			//for each column
+					std::stringstream ss(TABLE[i][j]);
+					ss >> result[i][j];
+				}
+			}
+			return result;											//return the casted table
+		}
+
+	};
+};
+
+
+#endif
\ No newline at end of file
--
libgit2 0.21.4