diff --git a/stim/envi/binary.h b/stim/envi/binary.h
index 22dafec..5483a3d 100644
--- a/stim/envi/binary.h
+++ b/stim/envi/binary.h
@@ -81,7 +81,7 @@ protected:
 
 		//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;
+			std::cout<<"class STIM::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;
diff --git a/stim/envi/bsq.h b/stim/envi/bsq.h
index e442137..0e71748 100644
--- a/stim/envi/bsq.h
+++ b/stim/envi/bsq.h
@@ -776,49 +776,46 @@ public:
 		return true;
 	}
 
-	/// Saves only those pixels in a band corresponding to the mask value != 0
-	/// @param array is a pointer to the destination array used to store the data
-	/// @param i is the band index
-	/// @p is a pointer to the mask data
-	bool sift_band(T* values, unsigned long b, unsigned char* p){
+	/// Copies all spectra corresponding to nonzero values of a mask into a pre-allocated matrix of size (B x P)
+	///		where P is the number of masked pixels and B is the number of bands. The allocated memory can be accessed
+	///		using the following indexing: i = p*B + b
+	/// @param matrix is the destination for the pixel data
+	/// @param mask is the mask
+	bool sift(T* matrix, unsigned char* mask){
 		unsigned long long XY = X() * Y(); 					//Number of XY pixels
 		unsigned long long L = XY * sizeof(T); 				//size of XY plane (in bytes)
-		
-		unsigned long long vi = 0;							//create an index into the values array
-		
-		unsigned long long start, end;						//start and end indices of a block of masked pixels in the band
-		bool reading = false;
-		unsigned long long l, i;								//length of the masked region
-
-		for(unsigned long long xy = 0; xy < XY; xy++){		//for each pixel in the band
-			
-			if(reading){								//if we are currently iterating through a block of masked pixels
-				if(p[xy]) end++;						//if the current pixel is part of that block, increment the end index
-				else{									//otherwise, terminate the block
-					reading = false;													//stop reading
-					i = b * XY + start;
-					file.seekg( i * sizeof(T) + header);		//skip all of the unmasked pixels up to this point
-					l = (end - start);
-					file.read((char *)&values[vi], l * sizeof(T));		//write the values between start and end to the values array
-					vi += l;											//increment the pointer into the values array
-				}
+
+		//calculate the number of pixels in the mask
+		unsigned long long P = 0;
+		if(mask == NULL) P = XY;
+		else{
+			for(unsigned long long xy = 0; xy < XY; xy++){
+				if(mask[xy] != 0) P++;
 			}
-			else{										//if we are currently iterating through a block of empty pixels
-				if(p[xy]){								//if the next pixel is masked, start a new block for reading
-					reading = true;					
-					start = xy;					//set the start and end indices to the beginning of this new block
-					end = start + 1;
+		}
+		
+		T* band_image = (T*) malloc( XY * sizeof(T));		//allocate space for a single band
+
+		unsigned long long i;								//pixel index into the sifted array
+		for(unsigned long long b = 0; b < Z(); b++){		//for each band in the data set
+			band_index(band_image, b);						//retrieve an image of that band
+
+			i = 0;
+			for(unsigned long long xy = 0; xy < XY; xy++){
+				if(mask == NULL || mask[xy] != 0){				//if the pixel is valid
+					matrix[i*Z() + b] = band_image[xy];			//copy it to the appropriate point in the values[] array
+					i++;
 				}
 			}
 		}
-
+		
 		return true;
 	}
 
 	/// Saves only those spectra corresponding to mask value != 0 to pre-allocated memory
 	/// @param matrix is the destination for the sifted pixels
 	/// @param p is the mask file used for sifting
-	bool sift(T* matrix, unsigned char* p){
+	/*bool sift(T* matrix, unsigned char* p){
 
 		// open a band (XY plane)
 		unsigned long XY = X() * Y(); 					//Number of XY pixels
@@ -845,7 +842,7 @@ public:
 
 		free(bandvals);				//clean up temporary memory
 		return true;
-	}
+	}*/
 
 	/// Saves to disk only those spectra corresponding to mask values != 0
 	/// @param outfile is the name of the sifted ENVI file to be written to disk
diff --git a/stim/envi/envi.h b/stim/envi/envi.h
index 8303dec..b1f6459 100644
--- a/stim/envi/envi.h
+++ b/stim/envi/envi.h
@@ -465,7 +465,9 @@ public:
 		return false;
 	}
 
-	/// sift copies all spectra corresponding to nonzero values of a mask into a pre-allocated matrix
+	/// Copies all spectra corresponding to nonzero values of a mask into a pre-allocated matrix of size (P x B)
+	///		where P is the number of masked pixels and B is the number of bands. The allocated memory can be accessed
+	///		using the following indexing: i = b*P + p
 	/// @param matrix is the destination for the pixel data
 	/// @param p is the mask
 	bool sift(void* matrix, unsigned char* p){
@@ -478,11 +480,20 @@ public:
 			else
 				std::cout << "ERROR: unidentified data type" << std::endl;
 		}
+
+		if (header.interleave == envi_header::BIP){
+			std::cout<<"Memory sifting not supported for BIP files"<<std::endl;
+			exit(1);
+		}
+		if (header.interleave == envi_header::BIL){
+			std::cout<<"Memory sifting not supported for BIL files"<<std::endl;
+			exit(1);
+		}
 		return false;
 
 	}
 
-	/// sift-mask saves in an array only those spectra corresponding to nonzero values of the mask.
+	/// Saves in an array only those spectra corresponding to nonzero values of the mask.
 	/// @param outfile is the name of the sifted output file
 	/// @param p is the mask
 	bool sift(std::string outfile, unsigned char* p)
diff --git a/stim/envi/envi_header.h b/stim/envi/envi_header.h
index 6650557..3ca70e1 100644
--- a/stim/envi/envi_header.h
+++ b/stim/envi/envi_header.h
@@ -77,6 +77,9 @@ struct envi_header
 	}
 
 	std::string trim(std::string line){
+
+		if(line.length() == 0)
+			return line;
 		//trims whitespace from the beginning and end of line
 		unsigned int start_i, end_i;
 		for(start_i=0; start_i < line.length(); start_i++)
diff --git a/stim/image/image.h b/stim/image/image.h
index 594095e..e10e6b0 100644
--- a/stim/image/image.h
+++ b/stim/image/image.h
@@ -94,6 +94,24 @@ public:
 
 	}
 
+	T& operator()(unsigned x, unsigned y, unsigned z = 0, unsigned c = 0){
+		return img(x, y, z, c);
+	}
+
+	/// Set all elements in the image to a given scalar value
+
+	/// @param v is the value used to set all values in the image
+	image<T> operator=(T v){
+
+		unsigned int X = width() * height() * depth() * channels();
+
+		for(unsigned x = 0; x < X; x++)
+			img.data()[x] = v;
+
+		return *this;
+
+	}
+
 	/// Copy the given data to the specified channel
 
 	/// @param c is the channel number that the data will be copied to
@@ -134,6 +152,10 @@ public:
 		return img.height();
 	}
 
+	unsigned int depth(){
+		return img.depth();
+	}
+
 	T* data(){
 
 		return img.data();
diff --git a/stim/parser/filename.h b/stim/parser/filename.h
index 69e9ba0..d7f221a 100644
--- a/stim/parser/filename.h
+++ b/stim/parser/filename.h
@@ -15,6 +15,7 @@
 
 #include <string>
 #include <sstream>
+#include <iomanip>
 #include <vector>
 #include <stack>
 #include <algorithm>
@@ -290,6 +291,25 @@ public:
 		return result;
 	}
 
+	/// This function replaces a wildcard in the prefix with the specified string
+	stim::filename insert(std::string str){
+
+		stim::filename result = *this;				//initialize the result filename to the current filename
+		size_t loc = result.prefix.find('*');		//find a wild card in the string
+		if(loc == std::string::npos)						//if a wildcard isn't found
+			return result;							//return the original string
+
+		result.prefix.replace(loc, 1, str);			//replace the wildcard with the string
+		return result;								//return the result
+	}
+
+	stim::filename insert(unsigned i, unsigned int n = 2){
+
+		std::stringstream ss;
+		ss << std::setw(n) << std::setfill('0') << i;
+		return insert(ss.str());
+	}
+
 	bool is_relative(){
 		return !absolute;
 	}
--
libgit2 0.21.4