Merge branch 'master' of git.stim.ee.uh.edu:codebase/stimlib into Graph

Pavel Govyadinov
2 parents 0df6a853 d24662d2
Showing 8 changed files with 530 additions and 53 deletions Show diff stats
matlab/images2ENVI.m
stim/biomodels/cellset.h
stim/cuda/sharedmem.cuh
stim/image/image.h
stim/math/filters/conv2.h
stim/math/filters/gauss2.h
stim/math/filters/sepconv2.h
stim/parser/filename.h
+function images2ENVI( image_struct, filename )
+%HSIWRITE : This function generates a hyperspectral binary image and header
+% based on multi-dimention image
+%
+%
+% This function accepts a srutcture which contains several channels.
+% It creates a 'bsq' interleaved image and a ENVI header filer correspoing
+% to the information of the image
+
+fields = fieldnames(image_struct);
+
+% check all images to have the same size
+for i = 1 : size (fields, 1)
+    for j = 1 : size (fields, 1)
+        if size(image_struct.(fields{i}))~= size(image_struct.(fields{i}))
+            fprintf ('Dimension of input images do not Match !');
+            exit;
+        end
+    end
+end
+
+
+
+
+
+% Extracting the needed information
+base_image = image_struct.(fields{1});
+
+rows = size(base_image, 1);
+columns = size(base_image, 2);
+bands = size(fields,1);
+multiDimImage = base_image';                                                % Matlab stores column major, transposing make it row major to be saved on memory
+
+% Create multi-dimentional image
+for j = 1 : size(fields,1)
+    multiDimImage(:,:,j) = (image_struct.(fields{j})');                     % Matlab stores column major, transposing make it row major to be saved on memory
+end
+
+% create the binary image
+HSImage = reshape (multiDimImage, [rows*columns*bands, 1]);
+if (~isfloat(HSImage))
+    HSImage_float = single(HSImage);                                         % casting to float
+end
+multibandwrite(HSImage_float,filename,'bsq');
+
+
+% create the header file
+info.samples = columns;
+info.lines = rows;
+info.bands = bands;
+info.header_offset = 0;
+info.file_type = 'ENVI Standard';
+info.data_type = 4;
+info.interleave = 'bsq';
+
+
+
+
+fid = fopen(strcat(filename, '.hdr'),'w');                                  % open a file to write the header file
+fprintf(fid,'%s\n','ENVI');                                                 % first line of the header file showing it is an ENVI file
+
+info_fields=fieldnames(info);
+for i = 1:length(info_fields)
+    parameter = info_fields{i};                                             % get the parameter of each line
+    value = info.(info_fields{i});                                          % get the corresponding value of the parameter
+    parameter(strfind(parameter,'_')) = ' ';                                % change '_' to ' '
+    line=[parameter,' = ',num2str(value)];                                  % create the line of the hdr file
+    fprintf(fid,'%s\n',line);                                               % write it to the hdr file
+end
+
+fclose(fid);                                                                % clode the header file
+
+end
+
@@ -167,6 +167,26 @@ public:
 		cells.push_back(newcell);						//push the new memory entry into the cell array
 	}
+void save(std::string filename){
+
+		
+		size_t ncells = cells.size();	// get the number of cells
+		std::ofstream file(filename);	//open a file to store the cell's coordinates
+		if (file.is_open()) {
+		
+			file << "x y z radius\n";	//write the file header
+			for (size_t c=0; c < ncells; c++){   //for each cell
+				if (cells[c][ip[3]] != NULL)	//check if for the current cell, radius has been assigned
+					file << cells[c][ip[0]]  << delim << cells[c][ip[1]] << delim << cells[c][ip[2]] << delim << cells[c][ip[3]] << '\n' ;
+				else							//check if for the current cell, radius has not been assigned, set radius to zero
+					file << cells[c][ip[0]]  << delim << cells[c][ip[1]] << delim << cells[c][ip[2]] << delim << 0 << '\n' ;
+			}
+			
+		}
+			file.close();
+
+	}
+	
 };		//end class cellset
 };		//end namespace stim
@@ -48,7 +48,11 @@ namespace stim{
 		/// Threaded copying of 2D data on a CUDA device
 		/// @param dest is a linear destination array of size nx * ny
+		/// @param nx is the size of the region to be copied along the X dimension
+		/// @param ny is the size of the region to be copied along the Y dimension
 		/// @param src is a 2D image stored as a linear array with a pitch of X
+		/// @param x is the x position in the source image where the copy is started
+		/// @param y is the y position in the source image where the copy is started
 		/// @param X is the number of bytes in a row of src
 		/// @param tid is a 1D id for the current thread
 		/// @param nt is the number of threads in the block
 #ifndef STIM_IMAGE_H
 #define STIM_IMAGE_H
-#include <opencv2/core/core.hpp>
-#include <opencv2/highgui/highgui.hpp>
+#ifdef USING_OPENCV
+	#include <opencv2/core/core.hpp>
+	#include <opencv2/highgui/highgui.hpp>
+#endif
 #include <vector>
 #include <iostream>
 #include <limits>
 #include <typeinfo>
+#include <fstream>
 namespace stim{
 /// This static class provides the STIM interface for loading, saving, and storing 2D images.
@@ -17,13 +20,12 @@ namespace stim{
 template <class T>
 class image{
-	//cimg_library::CImg<T> img;
-	T* img;										//pointer to the image data (assumes RGB for loading/saving)
+	T* img;										//pointer to the image data (interleaved RGB for color)
 	size_t R[3];
-	size_t X() const { return R[1]; }
-	size_t Y() const { return R[2]; }
-	size_t C() const { return R[0]; }
+	inline size_t X() const { return R[1]; }
+	inline size_t Y() const { return R[2]; }
+	inline size_t C() const { return R[0]; }
 	void init(){								//initializes all variables, assumes no memory is allocated
 		memset(R, 0, sizeof(size_t) * 3);		//set the resolution and number of channels to zero
@@ -52,22 +54,12 @@ class image{
 	size_t bytes(){ return size() * sizeof(T); }
-	size_t idx(size_t x, size_t y, size_t c = 0){
-		return y * C() * X() + x * C() + c;
+	inline size_t idx(size_t x, size_t y, size_t c = 0) const {
+		return y * R[0] * R[1] + x * R[0] + c;
 	}
-
+#ifdef USING_OPENCV
 	int cv_type(){
-		// The following is C++ 11 code, but causes problems on some compilers (ex. nvcc). Below is my best approximation to a solution
-
-		//if(std::is_same<T, unsigned char>::value)	return CV_MAKETYPE(CV_8U, (int)C());
-		//if(std::is_same<T, char>::value)			return CV_MAKETYPE(CV_8S, (int)C());
-		//if(std::is_same<T, unsigned short>::value)	return CV_MAKETYPE(CV_16U, (int)C());
-		//if(std::is_same<T, short>::value)			return CV_MAKETYPE(CV_16S, (int)C());
-		//if(std::is_same<T, int>::value)				return CV_MAKETYPE(CV_32S, (int)C());
-		//if(std::is_same<T, float>::value)			return CV_MAKETYPE(CV_32F, (int)C());
-		//if(std::is_same<T, double>::value)			return CV_MAKETYPE(CV_64F, (int)C());
-
 		if(typeid(T) == typeid(unsigned char))		return CV_MAKETYPE(CV_8U, (int)C());
 		if(typeid(T) == typeid(char))				return CV_MAKETYPE(CV_8S, (int)C());
 		if(typeid(T) == typeid(unsigned short))		return CV_MAKETYPE(CV_16U, (int)C());
@@ -79,18 +71,9 @@ class image{
 		std::cout<<"ERROR in stim::image::cv_type - no valid data type found"<<std::endl;
 		exit(1);
 	}
-
+#endif
 	/// Returns the value for "white" based on the dynamic range (assumes white is 1.0 for floating point images)
 	T white(){
-		// The following is C++ 11 code, but causes problems on some compilers (ex. nvcc). Below is my best approximation to a solution
-
-		//if(std::is_same<T, unsigned char>::value)		return UCHAR_MAX;
-		//if(std::is_same<T, unsigned short>::value)		return SHRT_MAX;
-		//if(std::is_same<T, unsigned>::value)			return UINT_MAX;
-		//if(std::is_same<T, unsigned long>::value)		return ULONG_MAX;
-		//if(std::is_same<T, unsigned long long>::value)	return ULLONG_MAX;
-		//if(std::is_same<T, float>::value)				return 1.0f;
-		//if(std::is_same<T, double>::value)				return 1.0;
 		if(typeid(T) == typeid(unsigned char))		return UCHAR_MAX;
 		if(typeid(T) == typeid(unsigned short))		return SHRT_MAX;
@@ -142,6 +125,11 @@ public:
 		free(img);
 	}
+	///Resize an image
+	void resize(size_t x, size_t y, size_t c = 1) {
+		allocate(x, y, c);
+	}
+
 	stim::image<T>& operator=(const stim::image<T>& I){
 		init();
 		if(&I == this)									//handle self-assignment
@@ -151,9 +139,88 @@ public:
 		return *this;
 	}
+	//save a Netpbm file
+	void load_netpbm(std::string filename) {
+		std::ifstream infile(filename, std::ios::in | std::ios::binary);		//open an output file
+		if (!infile) {
+			std::cout << "Error opening input file in image::load_netpbm()" << std::endl;
+			exit(1);
+		}
+		if (sizeof(T) != 1) {
+			std::cout << "Error in image::load_netpbm() - data type must be 8-bit integer." << std::endl;
+			exit(1);
+		}
+
+		size_t nc;													//allocate space for the number of channels
+		char format[2];												//allocate space to hold the image format tag
+		infile.read(format, 2);										//read the image format tag
+		infile.seekg(1, std::ios::cur);								//skip the newline character
+
+		if (format[0] != 'P') {
+			std::cout << "Error in image::load_netpbm() - file format tag is invalid: " << format[0] << format[1] << std::endl;
+			exit(1);
+		}
+		if (format[1] == '5') nc = 1;								//get the number of channels from the format flag
+		else if (format[1] == '6') nc = 3;
+		else {
+			std::cout << "Error in image::load_netpbm() - file format tag is invalid: " << format[0] << format[1] << std::endl;
+			exit(1);
+		}
+
+		unsigned char c;								//stores a character
+		while (infile.peek() == '#') {					//if the next character indicates the start of a comment
+			while (true) {
+				c = infile.get();
+				if (c == 0x0A) break;
+			}
+		}
+
+		std::string sw;									//create a string to store the width of the image
+		while(true){
+			c = infile.get();							//get a single character
+			if (c == ' ') break;						//exit if we've encountered a space
+			sw.push_back(c);							//push the character on to the string
+		}
+		size_t w = atoi(sw.c_str());					//convert the string into an integer
+
+		std::string sh;
+		while (true) {
+			c = infile.get();
+			if (c == 0x0A) break;
+			sh.push_back(c);
+		}
+
+		while (true) {									//skip the maximum value
+			c = infile.get();
+			if (c == 0x0A) break;
+		}
+		size_t h = atoi(sh.c_str());					//convert the string into an integer
+
+		allocate(w, h, nc);								//allocate space for the image
+		infile.read((char*)img, size());						//copy the binary data from the file to the image
+		infile.close();
+	}
+	
+
+#ifdef USING_OPENCV
+	void from_opencv(unsigned char* buffer, size_t width, size_t height) {
+		allocate(width, height, 3);
+		T value;
+		size_t i;
+		for (size_t c = 0; c < C(); c++) {								//copy directly
+			for (size_t y = 0; y < Y(); y++) {
+				for (size_t x = 0; x < X(); x++) {
+					i = y * X() * C() + x * C() + (2 - c);
+					value = buffer[i];
+					img[idx(x, y, c)] = value;
+				}
+			}
+		}
+	}
+#endif
 	/// Load an image from a file
 	void load(std::string filename){
-
+#ifdef USING_OPENCV
 		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;
@@ -168,25 +235,42 @@ public:
 			memcpy(img, cv_ptr, bytes());
 		if(C() == 3)														//if this is a 3-color image, OpenCV uses BGR interleaving
 			from_opencv(cv_ptr, X(), Y());
+#else
+		load_netpbm(filename);
+#endif
 	}
-	void from_opencv(unsigned char* buffer, size_t width, size_t height){
-		allocate(width, height, 3);
-		T value;
-		size_t i;
-		for(size_t c = 0; c < C(); c++){								//copy directly
-			for(size_t y = 0; y < Y(); y++){
-				for(size_t x = 0; x < X(); x++){
-					i = y * X() * C() + x * C() + (2-c);
-					value = buffer[i];
-					img[idx(x, y, c)] = value;
-				}
-			}
+
+
+	//save a Netpbm file
+	void save_netpbm(std::string filename) {
+		std::ofstream outfile(filename, std::ios::out | std::ios::binary);		//open an output file
+		if(!outfile) {
+			std::cout << "Error generating output file in image::save_netpbm()" << std::endl;
+			exit(1);
+		}
+		if (sizeof(T) != 1) {
+			std::cout << "Error in image::save_netpbm() - data type must be 8-bit integer." << std::endl;
+			exit(1);
 		}
+		std::string format;
+		if (channels() == 1) outfile << "P5" << (char)0x0A;			//output P5 if the file is grayscale
+		else if (channels() == 3) outfile << "P6" << (char)0x0A;		//output P6 if the file is color
+		else {
+			std::cout << "Error in image::save_netpbm() - data must be grayscale or RGB." << std::endl;
+			exit(1);
+		}
+		size_t w = width();
+		size_t h = height();
+		outfile << w << " " << h << (char)0x0A;			//save the width and height
+		outfile << "255" << (char)0x0A;								//output the maximum value
+		outfile.write((const char*)img, size());			//write the binary data
+		outfile.close();
 	}
 	//save a file
 	void save(std::string filename){
+#ifdef USING_OPENCV
 		//OpenCV uses an interleaved format, so convert first and then output
 		T* buffer = (T*) malloc(bytes());
@@ -197,6 +281,9 @@ public:
 		cv::Mat cvImage((int)Y(), (int)X(), cv_type(), buffer);
 		cv::imwrite(filename, cvImage);
 		free(buffer);
+#else
+		save_netpbm(filename);
+#endif
 	}
 	void set_interleaved(T* buffer, size_t width, size_t height, size_t channels){
@@ -256,20 +343,36 @@ public:
 		}
 	}
-
-	image<T> channel(size_t c){
-
-		//create a new image
-		image<T> r(X(), Y(), 1);
-
+	/// Return an image representing a specified channel
+	/// @param c is the channel to be returned
+	image<T> channel(size_t c) const {		
+		image<T> r(X(), Y(), 1);				//create a new image
 		for(size_t x = 0; x < X(); x++){
 			for(size_t y = 0; y < Y(); y++){
 				r.img[r.idx(x, y, 0)] = img[idx(x, y, c)];
 			}
 		}
+		return r;
+	}
+
+	/// Returns an std::vector containing each channel as a separate image
+	std::vector<image<T>> split() const {
+		std::vector<image<T>> r;			//create an image array
+		r.resize(C());						//create images for each channel
+		for (size_t c = 0; c < C(); c++) {	//for each channel
+			r[c] = channel(c);				//copy the channel image to the array
+		}
 		return r;
+	}
+	/// Merge a series of single-channel images into a multi-channel image
+	void merge(std::vector<image<T>>& list) {
+		size_t x = list[0].width();				//calculate the size of the image
+		size_t y = list[0].height();
+		allocate(x, y, list.size());			//re-allocate the image
+		for (size_t c = 0; c < list.size(); c++)		//for each channel
+			set_channel(list[c].channel(0).data(), c);	//insert the channel into the output image
 	}
 	T& operator()(size_t x, size_t y, size_t c = 0){
@@ -300,20 +403,20 @@ public:
 		size_t x, y;
 		for(y = 0; y < Y(); y++){
 			for(x = 0; x < X(); x++){
-				img[idx(x, y, c)] = buffer[c];
+				img[idx(x, y, c)] = buffer[y * X() + x];
 			}
 		}
 	}
-	size_t channels(){
+	size_t channels() const{
 		return C();
 	}
-	size_t width(){
+	size_t width() const{
 		return X();
 	}
-	size_t height(){
+	size_t height() const{
 		return Y();
 	}
@@ -423,6 +526,14 @@ public:
 		exit(1);
 	}
+	/// Casting operator, casts every value in an image to a different data type V
+	template<typename V>
+	operator image<V>() {
+		image<V> r(X(), Y(), C());					//create a new image
+		std::copy(img, img + size(), r.data());		//copy and cast the data
+		return r;									//return the new image
+	}
+
 };
 };		//end namespace stim
+#ifndef STIM_CUDA_CONV2_H
+#define STIM_CUDA_CONV2_H
+//#define __CUDACC__
+
+#ifdef __CUDACC__
+#include <stim/cuda/cudatools.h>
+#include <stim/cuda/sharedmem.cuh>
+#endif
+
+namespace stim {
+#ifdef __CUDACC__
+	//Kernel function that performs the 2D convolution.
+	template<typename T, typename K = T>
+	__global__ void kernel_conv2(T* out, T* in, K* kernel, size_t sx, size_t sy, size_t kx, size_t ky) {
+		extern __shared__ T s[];								//declare a shared memory array
+		size_t xi = blockIdx.x * blockDim.x + threadIdx.x;	//threads correspond to indices into the output image
+		size_t yi = blockIdx.y * blockDim.y + threadIdx.y;
+		size_t tid = threadIdx.y * blockDim.x + threadIdx.x;
+		size_t nt = blockDim.x * blockDim.y;
+
+		size_t cx = blockIdx.x * blockDim.x;					//find the upper left corner of the input region
+		size_t cy = blockIdx.y * blockDim.y;
+
+		size_t X = sx - kx + 1;								//calculate the size of the output image
+		size_t Y = sy - ky + 1;
+
+		if (cx >= X || cy >= Y) return;						//return if the entire block is outside the image
+		size_t smx = min(blockDim.x + kx - 1, sx - cx);			//size of the shared copy of the input image
+		size_t smy = min(blockDim.y + ky - 1, sy - cy);			//	min function is used to deal with boundary blocks
+		stim::cuda::threadedMemcpy2D<T>(s, smx, smy, in, cx, cy, sx, sy, tid, nt);	//copy the input region to shared memory
+		__syncthreads();
+
+		if (xi >= X || yi >= Y) return;						//returns if the thread is outside of the output image
+		
+		//loop through the kernel
+		size_t kxi, kyi;
+		K v = 0;
+		for (kyi = 0; kyi < ky; kyi++) {
+			for (kxi = 0; kxi < kx; kxi++) {
+				v += s[(threadIdx.y + kyi) * smx + threadIdx.x + kxi] * kernel[kyi * kx + kxi];
+				//v += in[(yi + kyi) * sx + xi + kxi] * kernel[kyi * kx + kxi];
+			}
+		}
+		out[yi * X + xi] = (T)v;								//write the result to global memory
+
+	}
+
+	//Performs a convolution of a 2D image using the GPU. All pointers are assumed to be to memory on the current device.
+	//@param out is a pointer to the output image
+	//@param in is a pointer to the input image
+	//@param sx is the size of the input image along X
+	//@param sy is the size of the input image along Y
+	//@param kx is the size of the kernel along X
+	//@param ky is the size of the kernel along Y
+	template<typename T, typename K = T>
+	void gpu_conv2(T* out, T* in, K* kernel, size_t sx, size_t sy, size_t kx, size_t ky) {
+		cudaDeviceProp p;
+		HANDLE_ERROR(cudaGetDeviceProperties(&p, 0));
+		size_t tmax = p.maxThreadsPerBlock;
+		dim3 nt(sqrt(tmax), sqrt(tmax));					//calculate the block dimensions
+		size_t X = sx - kx + 1;								//calculate the size of the output image
+		size_t Y = sy - ky + 1;
+		dim3 nb(X / nt.x + 1, Y / nt.y + 1);							//calculate the grid dimensions
+		size_t sm = (nt.x + kx - 1) * (nt.y + ky - 1) * sizeof(T);		//shared memory bytes required to store block data
+		if (sm > p.sharedMemPerBlock) {
+			std::cout << "Error in stim::gpu_conv2() - insufficient shared memory for this kernel." << std::endl;
+			exit(1);
+		}
+		kernel_conv2 <<<nb, nt, sm>>> (out, in, kernel, sx, sy, kx, ky);	//launch the kernel
+	}
+#endif
+	//Performs a convolution of a 2D image. Only valid pixels based on the kernel are returned.
+	//	As a result, the output image will be smaller than the input image by (kx-1, ky-1)
+	//@param out is a pointer to the output image
+	//@param in is a pointer to the input image
+	//@param sx is the size of the input image along X
+	//@param sy is the size of the input image along Y
+	//@param kx is the size of the kernel along X
+	//@param ky is the size of the kernel along Y
+	template<typename T, typename K = T>
+	void cpu_conv2(T* out, T* in, K* kernel, size_t sx, size_t sy, size_t kx, size_t ky) {
+		size_t X = sx - kx + 1;					//x size of the output image
+		size_t Y = sy - ky + 1;					//y size of the output image
+
+#ifdef __CUDACC__
+		//allocate memory and copy everything to the GPU
+		T* gpu_in;
+		HANDLE_ERROR(cudaMalloc(&gpu_in, sx * sy * sizeof(T)));
+		HANDLE_ERROR(cudaMemcpy(gpu_in, in, sx * sy * sizeof(T), cudaMemcpyHostToDevice));
+		K* gpu_kernel;
+		HANDLE_ERROR(cudaMalloc(&gpu_kernel, kx * ky * sizeof(K)));
+		HANDLE_ERROR(cudaMemcpy(gpu_kernel, kernel, kx * ky * sizeof(K), cudaMemcpyHostToDevice));
+		T* gpu_out;
+		HANDLE_ERROR(cudaMalloc(&gpu_out, X * Y * sizeof(T)));
+		gpu_conv2(gpu_out, gpu_in, gpu_kernel, sx, sy, kx, ky);								//execute the GPU kernel
+		HANDLE_ERROR(cudaMemcpy(out, gpu_out, X * Y * sizeof(T), cudaMemcpyDeviceToHost));	//copy the result to the host
+		HANDLE_ERROR(cudaFree(gpu_in));
+		HANDLE_ERROR(cudaFree(gpu_kernel));
+		HANDLE_ERROR(cudaFree(gpu_out));
+#else
+		K v;												//register stores the integral of the current pixel value
+		size_t yi, xi, kyi, kxi, yi_kyi_sx;
+		for (yi = 0; yi < Y; yi++) {					//for each pixel in the output image
+			for (xi = 0; xi < X; xi++) {
+				v = 0;
+				for (kyi = 0; kyi < ky; kyi++) {		//for each pixel in the kernel
+					yi_kyi_sx = (yi + kyi) * sx;
+					for (kxi = 0; kxi < kx; kxi++) {
+						v += in[yi_kyi_sx + xi + kxi] * kernel[kyi * kx + kxi];
+					}
+				}
+				out[yi * X + xi] = v;						//save the result to the output array
+			}
+		}
+		
+#endif
+	}
+
+
+}
+
+
+#endif
 \ No newline at end of file
+#ifndef STIM_CUDA_GAUSS2_H
+#define STIM_CUDA_GAUSS2_H
+
+#include <stim/image/image.h>
+#include <stim/math/filters/sepconv2.h>
+#include <stim/math/constants.h>
+
+namespace stim {
+
+	template<typename T>
+	T gauss1d(T x, T mu, T std) {
+		return ((T)1 / (T)sqrt(stim::TAU * std * std) * exp(-(x - mu)*(x - mu) / (2 * std*std)));
+	}
+	///Perform a 2D gaussian convolution on an input image.
+	///@param in is a pointer to the input image
+	///@param stdx is the standard deviation (in pixels) along the x axis
+	///@param stdy is the standard deviation (in pixels) along the y axis
+	///@param nstds specifies the number of standard deviations of the Gaussian that will be kept in the kernel
+	template<typename T, typename K = T>
+	stim::image<T> cpu_gauss2(const stim::image<T>& in, K stdx, K stdy, size_t nstds = 3) {
+		size_t kx = stdx * nstds * 2;					//calculate the kernel sizes
+		size_t ky = stdy * nstds * 2;
+		size_t X = in.width() - kx + 1;					//calculate the size of the output image
+		size_t Y = in.height() - ky + 1;
+		stim::image<T> r(X, Y, in.channels());		//create an output image
+
+		K* gx = (K*)malloc(kx * sizeof(K));			//allocate space for the gaussian kernels
+		K* gy = (K*)malloc(ky * sizeof(K));
+		K mux = (K)kx / (K)2;						//calculate the mean of the gaussian (center of the kernel)
+		K muy = (K)ky / (K)2;
+		for (size_t xi = 0; xi < kx; xi++)			//evaluate the kernels
+			gx[xi] = gauss1d((K)xi, mux, stdx);
+		for (size_t yi = 0; yi < ky; yi++)
+			gy[yi] = gauss1d((K)yi, muy, stdy);
+
+		std::vector<stim::image<T>> IN = in.split();	//split the input image into channels
+		std::vector<stim::image<T>> R = r.split();		//split the output image into channels
+		for (size_t c = 0; c < in.channels(); c++)		//for each channel
+			cpu_sepconv2(R[c].data(), IN[c].data(), gx, gy, IN[c].width(), IN[c].height(), kx, ky);
+
+		r.merge(R);										//merge the blurred channels into the final image
+		return r;
+	}
+}
+
+
+#endif
 \ No newline at end of file
+#ifndef STIM_CUDA_SEPCONV2_H
+#define STIM_CUDA_SEPCONV2_H
+#include <stim/math/filters/conv2.h>
+#ifdef __CUDACC__
+#include <stim/cuda/cudatools.h>
+#include <stim/cuda/sharedmem.cuh>
+#endif
+
+namespace stim {
+#ifdef __CUDACC__
+	//Performs a convolution of a 2D image using the GPU. All pointers are assumed to be to memory on the current device.
+	//@param out is a pointer to the output image
+	//@param in is a pointer to the input image
+	//@param sx is the size of the input image along X
+	//@param sy is the size of the input image along Y
+	//@param kx is the size of the kernel along X
+	//@param ky is the size of the kernel along Y
+	template<typename T, typename K = T>
+	void gpu_sepconv2(T* out, T* in, K* k0, K* k1, size_t sx, size_t sy, size_t kx, size_t ky) {
+		cudaDeviceProp p;
+		HANDLE_ERROR(cudaGetDeviceProperties(&p, 0));
+		size_t tmax = p.maxThreadsPerBlock;
+		dim3 nt(sqrt(tmax), sqrt(tmax));						//calculate the block dimensions
+		size_t X = sx - kx + 1;									//calculate the x size of the output image
+		T* temp;												//declare a temporary variable to store the intermediate image
+		HANDLE_ERROR(cudaMalloc(&temp, X * sy * sizeof(T)));	//allocate memory for the intermediate image
+
+		dim3 nb(X / nt.x + 1, sy / nt.y + 1);							//calculate the grid dimensions
+		size_t sm = (nt.x + kx - 1) * nt.y * sizeof(T);					//shared memory bytes required to store block data
+		if (sm > p.sharedMemPerBlock) {
+			std::cout << "Error in stim::gpu_conv2() - insufficient shared memory for this kernel." << std::endl;
+			exit(1);
+		}
+		kernel_conv2 <<<nb, nt, sm>>> (temp, in, k0, sx, sy, kx, 1);	//launch the kernel to compute the intermediate image
+
+		size_t Y = sy - ky + 1;									//calculate the y size of the output image
+		nb.y = Y / nt.y + 1;									//update the grid dimensions to reflect the Y-axis size of the output image
+		sm = nt.x * (nt.y + ky - 1) * sizeof(T);				//calculate the amount of shared memory needed for the second pass
+		if (sm > p.sharedMemPerBlock) {
+			std::cout << "Error in stim::gpu_conv2() - insufficient shared memory for this kernel." << std::endl;
+			exit(1);
+		}
+		kernel_conv2 <<<nb, nt, sm>>> (out, temp, k1, X, sy, 1, ky);	//launch the kernel to compute the final image
+		HANDLE_ERROR(cudaFree(temp));							//free memory allocated for the intermediate image
+	}
+#endif
+	//Performs a separable convolution of a 2D image. Only valid pixels based on the kernel are returned.
+	//	As a result, the output image will be smaller than the input image by (kx-1, ky-1)
+	//@param out is a pointer to the output image
+	//@param in is a pointer to the input image
+	//@param k0 is the x-axis convolution filter
+	//@param k1 is the y-axis convolution filter
+	//@param sx is the size of the input image along X
+	//@param sy is the size of the input image along Y
+	//@param kx is the size of the kernel along X
+	//@param ky is the size of the kernel along Y
+	template<typename T, typename K = T>
+	void cpu_sepconv2(T* out, T* in, K* k0, K* k1, size_t sx, size_t sy, size_t kx, size_t ky) {
+		size_t X = sx - kx + 1;					//x size of the output image
+		size_t Y = sy - ky + 1;
+#ifdef __CUDACC__
+		//allocate memory and copy everything to the GPU
+		T* gpu_in;
+		HANDLE_ERROR(cudaMalloc(&gpu_in, sx * sy * sizeof(T)));
+		HANDLE_ERROR(cudaMemcpy(gpu_in, in, sx * sy * sizeof(T), cudaMemcpyHostToDevice));
+		K* gpu_k0;
+		HANDLE_ERROR(cudaMalloc(&gpu_k0, kx * sizeof(K)));
+		HANDLE_ERROR(cudaMemcpy(gpu_k0, k0, kx * sizeof(K), cudaMemcpyHostToDevice));
+		K* gpu_k1;
+		HANDLE_ERROR(cudaMalloc(&gpu_k1, ky * sizeof(K)));
+		HANDLE_ERROR(cudaMemcpy(gpu_k1, k1, ky * sizeof(K), cudaMemcpyHostToDevice));
+		T* gpu_out;
+		HANDLE_ERROR(cudaMalloc(&gpu_out, X * Y * sizeof(T)));
+		gpu_sepconv2(gpu_out, gpu_in, gpu_k0, gpu_k1, sx, sy, kx, ky);								//execute the GPU kernel
+		HANDLE_ERROR(cudaMemcpy(out, gpu_out, X * Y * sizeof(T), cudaMemcpyDeviceToHost));	//copy the result to the host
+		HANDLE_ERROR(cudaFree(gpu_in));
+		HANDLE_ERROR(cudaFree(gpu_k0));
+		HANDLE_ERROR(cudaFree(gpu_k1));
+		HANDLE_ERROR(cudaFree(gpu_out));
+#else
+		T* temp = (T*)malloc(X * sy * sizeof(T));		//allocate space for the intermediate image
+		cpu_conv2(temp, in, k0, sx, sy, kx, 1);			//evaluate the intermediate image
+		cpu_conv2(out, temp, k1, X, sy, 1, ky);			//evaluate the final image
+		free(temp);										//free the memory for the intermediate image
+#endif
+	}
+}
+
+#endif
 \ No newline at end of file
@@ -302,6 +302,15 @@ public:
 		return insert(ss.str());
 	}
+	///This method returns true if any characters in the filename contain '*' or '?'
+	bool wildcards() {
+		if (_prefix.find('*') != std::string::npos) return true;
+		if (_prefix.find('?') != std::string::npos) return true;
+		if (_extension.find('*') != std::string::npos) return true;
+		if (_extension.find('?') != std::string::npos) return true;
+		return false;
+	}
+
 	/// Returns a list of files using the current filename as a template.
 	/// For example: