Moved around helper functions

src/c/Common/CHelpers.cpp

+#include "CHelpers.h"
+
+double* createCircleKernel(int rad, Vec<unsigned int>& kernelDims)
+{
+	kernelDims.x = rad%2==0 ? rad+1 : rad;
+	kernelDims.y = rad%2==0 ? rad+1 : rad;
+	kernelDims.z = rad%2==0 ? rad+1 : rad;
+
+	double* kernel = new double[kernelDims.product()];
+	memset(kernel,0,sizeof(double)*kernelDims.product());
+
+	Vec<unsigned int> mid;
+	mid.x = kernelDims.x/2+1;
+	mid.y = kernelDims.y/2+1;
+	mid.z = kernelDims.z/2+1;
+
+	Vec<unsigned int> cur(0,0,0);
+	for (cur.x=0; cur.x < kernelDims.x ; ++cur.x)
+	{
+		for (cur.y=0; cur.y < kernelDims.y ; ++cur.y)
+		{
+			for (cur.z=0; cur.z < kernelDims.z ; ++cur.z)
+			{
+				if (cur.EuclideanDistanceTo(mid)<=rad)
+					kernel[kernelDims.linearAddressAt(cur)] = 1;
+			}
+		}
+	}
+
+	return kernel;
+}
+
+
+int calcOtsuThreshold(const double* normHistogram, int numBins)
+{
+	//code modified from http://www.dandiggins.co.uk/arlib-9.html
+	double totalMean = 0.0f;
+	for (int i=0; i<numBins; ++i)
+		totalMean += i*normHistogram[i];
+
+	double class1Prob=0, class1Mean=0, temp1, curThresh;
+	double bestThresh = 0.0;
+	int bestIndex = 0;
+	for (int i=0; i<numBins; ++i)
+	{
+		class1Prob += normHistogram[i];
+		class1Mean += i * normHistogram[i];
+
+		temp1 = totalMean * class1Prob - class1Mean;
+		curThresh = (temp1*temp1) / (class1Prob*(1.0f-class1Prob));
+
+		if(curThresh>bestThresh)
+		{
+			bestThresh = curThresh;
+			bestIndex = i;
+		}
+	}
+
+	return bestIndex;
+}
\ No newline at end of file

src/c/Common/CHelpers.h

@@ -3,171 +3,7 @@
 #include "Vec.h"
 #include <memory.h>
 #include <complex>
-#define MAX_KERNAL_DIM (25)
 
-double* createCircleKernal(int rad, Vec<int>& kernalDims)
-{
-	kernalDims.x = rad%2==0 ? rad+1 : rad;
-	kernalDims.y = rad%2==0 ? rad+1 : rad;
-	kernalDims.z = rad%2==0 ? rad+1 : rad;
+double* createCircleKernel(int rad, Vec<unsigned int>& kernelDims);
 
-	double* kernal = new double[kernalDims.product()];
-	memset(kernal,0,sizeof(double)*kernalDims.product());
-
-	Vec<int> mid;
-	mid.x = kernalDims.x/2+1;
-	mid.y = kernalDims.y/2+1;
-	mid.z = kernalDims.z/2+1;
-
-	Vec<int> cur(0,0,0);
-	for (cur.x=0; cur.x < kernalDims.x ; ++cur.x)
-	{
-		for (cur.y=0; cur.y < kernalDims.y ; ++cur.y)
-		{
-			for (cur.z=0; cur.z < kernalDims.z ; ++cur.z)
-			{
-				if (cur.EuclideanDistanceTo(mid)<=rad)
-					kernal[kernalDims.linearAddressAt(cur)] = 1;
-			}
-		}
-	}
-
-	return kernal;
-}
-
-template<typename KernalType>
-Vec<unsigned int> createGaussianKernal(Vec<float> sigma, KernalType* kernal, int& iterations)
-{
-	Vec<unsigned int> kernalDims(1,1,1);
-	iterations = 1;
-
-	if (sigma.product()*27>MAX_KERNAL_DIM*MAX_KERNAL_DIM*MAX_KERNAL_DIM)
-	{
-		Vec<int> minIterations;
-		minIterations.x = (int)ceil(9.0f*SQR(sigma.x)/SQR(MAX_KERNAL_DIM));
-		minIterations.y = (int)ceil(9.0f*SQR(sigma.y)/SQR(MAX_KERNAL_DIM));
-		minIterations.z = (int)ceil(9.0f*SQR(sigma.z)/SQR(MAX_KERNAL_DIM));
-
-		iterations = minIterations.maxValue();
-		sigma = sigma/sqrt((float)iterations);
-	}
-
-	kernalDims.x = (unsigned int)(3*sigma.x);
-	kernalDims.y = (unsigned int)(3*sigma.y);
-	kernalDims.z = (unsigned int)(3*sigma.z);
-
-	kernalDims.x = kernalDims.x%2==0 ? kernalDims.x+1 : kernalDims.x;
-	kernalDims.y = kernalDims.y%2==0 ? kernalDims.y+1 : kernalDims.y;
-	kernalDims.z = kernalDims.z%2==0 ? kernalDims.z+1 : kernalDims.z;
-
-	Vec<unsigned int> mid;
-	mid.x = kernalDims.x/2;
-	mid.y = kernalDims.y/2;
-	mid.z = kernalDims.z/2;
-
-	Vec<unsigned int> cur(0,0,0);
-	Vec<float> gaus;
-	float total = 0.0;
-	for (cur.x=0; cur.x<kernalDims.x ; ++cur.x)
-	{
-		for (cur.y=0; cur.y<kernalDims.y ; ++cur.y)
-		{
-			for (cur.z=0; cur.z<kernalDims.z ; ++cur.z)
-			{
-				gaus.x = exp(-(int)(SQR(mid.x-cur.x)) / (2*SQR(sigma.x)));
-				gaus.y = exp(-(int)(SQR(mid.y-cur.y)) / (2*SQR(sigma.y)));
-				gaus.z = exp(-(int)(SQR(mid.z-cur.z)) / (2*SQR(sigma.z)));
-
-				total += kernal[kernalDims.linearAddressAt(cur)] = (float)gaus.product();
-			}
-		}
-	}
-
-	for (cur.x=0; cur.x < kernalDims.x ; ++cur.x)
-		for (cur.y=0; cur.y < kernalDims.y ; ++cur.y)
-			for (cur.z=0; cur.z < kernalDims.z ; ++cur.z)
-				kernal[kernalDims.linearAddressAt(cur)] /= total;
-
-	return kernalDims;
-}
-
-template<typename KernalType>
-Vec<unsigned int> createGaussianKernal(Vec<float> sigma, KernalType* kernal, Vec<int>& iterations)
-{
-	Vec<unsigned int> kernalDims(1,1,1);
-	iterations = Vec<int>(1,1,1);
-
-	if ((sigma.x+sigma.y+sigma.z)*3>MAX_KERNAL_DIM*MAX_KERNAL_DIM*MAX_KERNAL_DIM)
-	{
-		iterations.x = (int)ceil(9.0f*SQR(sigma.x)/SQR(MAX_KERNAL_DIM));
-		iterations.y = (int)ceil(9.0f*SQR(sigma.y)/SQR(MAX_KERNAL_DIM));
-		iterations.z = (int)ceil(9.0f*SQR(sigma.z)/SQR(MAX_KERNAL_DIM));
-
-		//TODO: Optimize iterations per dim
-		sigma.x = (float)(sigma.x/sqrt((float)iterations.x));
-		sigma.y = (float)(sigma.y/sqrt((float)iterations.y));
-		sigma.z = (float)(sigma.z/sqrt((float)iterations.z));
-	}
-
-	kernalDims.x = (unsigned int)(3*sigma.x);
-	kernalDims.y = (unsigned int)(3*sigma.y);
-	kernalDims.z = (unsigned int)(3*sigma.z);
-
-	kernalDims.x = kernalDims.x%2==0 ? kernalDims.x+1 : kernalDims.x;
-	kernalDims.y = kernalDims.y%2==0 ? kernalDims.y+1 : kernalDims.y;
-	kernalDims.z = kernalDims.z%2==0 ? kernalDims.z+1 : kernalDims.z;
-
-	Vec<unsigned int> mid;
-	mid.x = kernalDims.x/2;
-	mid.y = kernalDims.y/2;
-	mid.z = kernalDims.z/2;
-
-	float total = 0.0;
-	for (unsigned int x=0; x<kernalDims.x ; ++x)
-		total += kernal[x] =  exp(-(int)(SQR(mid.x-x)) / (2*SQR(sigma.x)));
-	for (unsigned int x=0; x<kernalDims.x ; ++x)
-		kernal[x] /= total;
-
-	total = 0.0;
-	for (unsigned int y=0; y<kernalDims.y ; ++y)
-		total += kernal[y+kernalDims.x] = exp(-(int)(SQR(mid.y-y)) / (2*SQR(sigma.y)));
-	for (unsigned int y=0; y < kernalDims.y ; ++y)
-		kernal[y+kernalDims.x] /= total;
-
-	total = 0.0;
-	for (unsigned int z=0; z<kernalDims.z ; ++z)
-		total += kernal[z+kernalDims.x+kernalDims.y] = exp(-(int)(SQR(mid.z-z)) / (2*SQR(sigma.z)));
-	for (unsigned int z=0; z < kernalDims.z ; ++z)
-		kernal[z+kernalDims.x+kernalDims.y] /= total;
-				
-
-	return kernalDims;
-}
-
-int calcOtsuThreshold(const double* normHistogram, int numBins)
-{
-	//code modified from http://www.dandiggins.co.uk/arlib-9.html
-	double totalMean = 0.0f;
-	for (int i=0; i<numBins; ++i)
-		totalMean += i*normHistogram[i];
-
-	double class1Prob=0, class1Mean=0, temp1, curThresh;
-	double bestThresh = 0.0;
-	int bestIndex = 0;
-	for (int i=0; i<numBins; ++i)
-	{
-		class1Prob += normHistogram[i];
-		class1Mean += i * normHistogram[i];
-
-		temp1 = totalMean * class1Prob - class1Mean;
-		curThresh = (temp1*temp1) / (class1Prob*(1.0f-class1Prob));
-
-		if(curThresh>bestThresh)
-		{
-			bestThresh = curThresh;
-			bestIndex = i;
-		}
-	}
-
-	return bestIndex;
-}
\ No newline at end of file
+int calcOtsuThreshold(const double* normHistogram, int numBins);
\ No newline at end of file

src/c/Common/CudaUtilities.cu

+#include "CudaUtilities.cuh"
+
+void calcBlockThread(const Vec<unsigned int>& dims, const cudaDeviceProp &prop, dim3 &blocks, dim3 &threads)
+{
+	if (dims.z==1)
+	{
+		if (dims.y==1)
+		{
+			if ((int)dims.x<prop.maxThreadsPerBlock)
+			{
+				threads.x = dims.x;
+				threads.y = 1;
+				threads.z = 1;
+
+				blocks.x = 1;
+				blocks.y = 1;
+				blocks.z = 1;
+			} 
+			else
+			{
+				threads.x = prop.maxThreadsPerBlock;
+				threads.y = 1;
+				threads.z = 1;
+
+				blocks.x = (int)ceil((float)dims.x/prop.maxThreadsPerBlock);
+				blocks.y = 1;
+				blocks.z = 1;
+			}
+		}
+		else
+		{
+			if ((int)(dims.x*dims.y)<prop.maxThreadsPerBlock)
+			{
+				threads.x = dims.x;
+				threads.y = dims.y;
+				threads.z = 1;
+
+				blocks.x = 1;
+				blocks.y = 1;
+				blocks.z = 1;
+			} 
+			else
+			{
+				int dim = (int)sqrt((double)prop.maxThreadsPerBlock);
+
+				threads.x = dim;
+				threads.y = dim;
+				threads.z = 1;
+
+				blocks.x = (int)ceil((float)dims.x/dim);
+				blocks.y = (int)ceil((float)dims.y/dim);
+				blocks.z = 1;
+			}
+		}
+	}
+	else
+	{
+		if((int)(dims.x*dims.y*dims.z)<prop.maxThreadsPerBlock)
+		{
+			threads.x = dims.x;
+			threads.y = dims.y;
+			threads.z = dims.z;
+
+			blocks.x = 1;
+			blocks.y = 1;
+			blocks.z = 1;
+		}
+		else
+		{
+			int dim = (int)pow((float)prop.maxThreadsPerBlock,1/3.0f);
+			float extra = (float)(prop.maxThreadsPerBlock-dim*dim*dim)/(dim*dim);
+
+			threads.x = dim + (int)extra;
+			threads.y = dim;
+			threads.z = dim;
+
+			blocks.x = (unsigned int)ceil((float)dims.x/threads.x);
+			blocks.y = (unsigned int)ceil((float)dims.y/threads.y);
+			blocks.z = (unsigned int)ceil((float)dims.z/threads.z);
+		}
+	}
+}
+
+template<typename KernelType>
+Vec<unsigned int> createGaussianKernel(Vec<float> sigma, float* kernel, int& iterations)
+{
+	Vec<unsigned int> kernelDims(1,1,1);
+	iterations = 1;
+
+	if (sigma.product()*27>MAX_KERNEL_DIM*MAX_KERNEL_DIM*MAX_KERNEL_DIM)
+	{
+		Vec<int> minIterations;
+		minIterations.x = (int)ceil(9.0f*SQR(sigma.x)/SQR(MAX_KERNEL_DIM));
+		minIterations.y = (int)ceil(9.0f*SQR(sigma.y)/SQR(MAX_KERNEL_DIM));
+		minIterations.z = (int)ceil(9.0f*SQR(sigma.z)/SQR(MAX_KERNEL_DIM));
+
+		iterations = minIterations.maxValue();
+		sigma = sigma/sqrt((float)iterations);
+	}
+
+	kernelDims.x = (unsigned int)(3*sigma.x);
+	kernelDims.y = (unsigned int)(3*sigma.y);
+	kernelDims.z = (unsigned int)(3*sigma.z);
+
+	kernelDims.x = kernelDims.x%2==0 ? kernelDims.x+1 : kernelDims.x;
+	kernelDims.y = kernelDims.y%2==0 ? kernelDims.y+1 : kernelDims.y;
+	kernelDims.z = kernelDims.z%2==0 ? kernelDims.z+1 : kernelDims.z;
+
+	Vec<unsigned int> mid;
+	mid.x = kernelDims.x/2;
+	mid.y = kernelDims.y/2;
+	mid.z = kernelDims.z/2;
+
+	Vec<unsigned int> cur(0,0,0);
+	Vec<float> gaus;
+	float total = 0.0;
+	for (cur.x=0; cur.x<kernelDims.x ; ++cur.x)
+	{
+		for (cur.y=0; cur.y<kernelDims.y ; ++cur.y)
+		{
+			for (cur.z=0; cur.z<kernelDims.z ; ++cur.z)
+			{
+				gaus.x = exp(-(int)(SQR(mid.x-cur.x)) / (2*SQR(sigma.x)));
+				gaus.y = exp(-(int)(SQR(mid.y-cur.y)) / (2*SQR(sigma.y)));
+				gaus.z = exp(-(int)(SQR(mid.z-cur.z)) / (2*SQR(sigma.z)));
+
+				total += kernel[kernelDims.linearAddressAt(cur)] = (float)gaus.product();
+			}
+		}
+	}
+
+	for (cur.x=0; cur.x < kernelDims.x ; ++cur.x)
+		for (cur.y=0; cur.y < kernelDims.y ; ++cur.y)
+			for (cur.z=0; cur.z < kernelDims.z ; ++cur.z)
+				kernel[kernelDims.linearAddressAt(cur)] /= total;
+
+	return kernelDims;
+}
+
+Vec<unsigned int> createGaussianKernel(Vec<float> sigma, float* kernel, Vec<int>& iterations)
+{
+	Vec<unsigned int> kernelDims(1,1,1);
+	iterations = Vec<int>(1,1,1);
+
+	if ((sigma.x+sigma.y+sigma.z)*3>MAX_KERNEL_DIM*MAX_KERNEL_DIM*MAX_KERNEL_DIM)
+	{
+		iterations.x = (int)ceil(9.0f*SQR(sigma.x)/SQR(MAX_KERNEL_DIM));
+		iterations.y = (int)ceil(9.0f*SQR(sigma.y)/SQR(MAX_KERNEL_DIM));
+		iterations.z = (int)ceil(9.0f*SQR(sigma.z)/SQR(MAX_KERNEL_DIM));
+
+		//TODO: Optimize iterations per dim
+		sigma.x = sigma.x/sqrt((float)iterations.x);
+		sigma.y = sigma.y/sqrt((float)iterations.y);
+		sigma.z = sigma.z/sqrt((float)iterations.z);
+	}
+
+	kernelDims.x = (unsigned int)(3*sigma.x);
+	kernelDims.y = (unsigned int)(3*sigma.y);
+	kernelDims.z = (unsigned int)(3*sigma.z);
+
+	kernelDims.x = kernelDims.x%2==0 ? kernelDims.x+1 : kernelDims.x;
+	kernelDims.y = kernelDims.y%2==0 ? kernelDims.y+1 : kernelDims.y;
+	kernelDims.z = kernelDims.z%2==0 ? kernelDims.z+1 : kernelDims.z;
+
+	Vec<unsigned int> mid;
+	mid.x = kernelDims.x/2;
+	mid.y = kernelDims.y/2;
+	mid.z = kernelDims.z/2;
+
+	float total = 0.0;
+	for (unsigned int x=0; x<kernelDims.x ; ++x)
+		total += kernel[x] =  exp(-(int)(SQR(mid.x-x)) / (2*SQR(sigma.x)));
+	for (unsigned int x=0; x<kernelDims.x ; ++x)
+		kernel[x] /= total;
+
+	total = 0.0;
+	for (unsigned int y=0; y<kernelDims.y ; ++y)
+		total += kernel[y+kernelDims.x] = exp(-(int)(SQR(mid.y-y)) / (2*SQR(sigma.y)));
+	for (unsigned int y=0; y < kernelDims.y ; ++y)
+		kernel[y+kernelDims.x] /= total;
+
+	total = 0.0;
+	for (unsigned int z=0; z<kernelDims.z ; ++z)
+		total += kernel[z+kernelDims.x+kernelDims.y] = exp(-(int)(SQR(mid.z-z)) / (2*SQR(sigma.z)));
+	for (unsigned int z=0; z < kernelDims.z ; ++z)
+		kernel[z+kernelDims.x+kernelDims.y] /= total;
+
+
+	return kernelDims;
+}
\ No newline at end of file

src/c/Common/CudaUtilities.cuh

@@ -68,86 +68,7 @@ inline void gpuAssert(cudaError_t code, char *file, int line, bool abort=true)
 	}
 }
 
-void calcBlockThread(const Vec<unsigned int>& dims, const cudaDeviceProp &prop, dim3 &blocks, dim3 &threads)
-{
-	if (dims.z==1)
-	{
-		if (dims.y==1)
-		{
-			if ((int)dims.x<prop.maxThreadsPerBlock)
-			{
-				threads.x = dims.x;
-				threads.y = 1;
-				threads.z = 1;
-
-				blocks.x = 1;
-				blocks.y = 1;
-				blocks.z = 1;
-			} 
-			else
-			{
-				threads.x = prop.maxThreadsPerBlock;
-				threads.y = 1;
-				threads.z = 1;
-
-				blocks.x = (int)ceil((float)dims.x/prop.maxThreadsPerBlock);
-				blocks.y = 1;
-				blocks.z = 1;
-			}
-		}
-		else
-		{
-			if ((int)(dims.x*dims.y)<prop.maxThreadsPerBlock)
-			{
-				threads.x = dims.x;
-				threads.y = dims.y;
-				threads.z = 1;
-
-				blocks.x = 1;
-				blocks.y = 1;
-				blocks.z = 1;
-			} 
-			else
-			{
-				int dim = (int)sqrt((double)prop.maxThreadsPerBlock);
-
-				threads.x = dim;
-				threads.y = dim;
-				threads.z = 1;
-
-				blocks.x = (int)ceil((float)dims.x/dim);
-				blocks.y = (int)ceil((float)dims.y/dim);
-				blocks.z = 1;
-			}
-		}
-	}
-	else
-	{
-		if((int)(dims.x*dims.y*dims.z)<prop.maxThreadsPerBlock)
-		{
-			threads.x = dims.x;
-			threads.y = dims.y;
-			threads.z = dims.z;
-
-			blocks.x = 1;
-			blocks.y = 1;
-			blocks.z = 1;
-		}
-		else
-		{
-			int dim = (int)pow((float)prop.maxThreadsPerBlock,1/3.0f);
-			float extra = (float)(prop.maxThreadsPerBlock-dim*dim*dim)/(dim*dim);
-
-			threads.x = dim + (int)extra;
-			threads.y = dim;
-			threads.z = dim;
-
-			blocks.x = (unsigned int)ceil((float)dims.x/threads.x);
-			blocks.y = (unsigned int)ceil((float)dims.y/threads.y);
-			blocks.z = (unsigned int)ceil((float)dims.z/threads.z);
-		}
-	}
-}
+void calcBlockThread(const Vec<unsigned int>& dims, const cudaDeviceProp &prop, dim3 &blocks, dim3 &threads);
 
 struct Lock 
 {
@@ -183,3 +104,7 @@ struct Lock
 #endif
 	}
 };
+
+Vec<unsigned int> createGaussianKernel(Vec<float> sigma, float* kernel, int& iterations);
+
+Vec<unsigned int> createGaussianKernel(Vec<float> sigma, float* kernel, Vec<int>& iterations);
\ No newline at end of file

src/c/Common/Defines.h

@@ -2,6 +2,7 @@
 
 #define NUM_BUFFERS (3)
 #define NUM_BINS (255)
+#define MAX_KERNEL_DIM (25)
 
 #define SQR(x) ((x)*(x))
 #define MAX(x,y) (x>y)?(x):(y)

src/c/CudaMex.vcxproj

@@ -19,6 +19,7 @@
     </ProjectConfiguration>
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="Common\CHelpers.cpp" />
     <ClCompile Include="CudaMex\AddConstant.cpp" />
     <ClCompile Include="CudaMex\AddImageWith.cpp" />
     <ClCompile Include="CudaMex\ApplyPolyTransformation.cpp" />
@@ -28,12 +29,16 @@
     <ClCompile Include="CudaMex\GaussianFilter.cpp" />
     <ClCompile Include="CudaMex\Histogram.cpp" />
     <ClCompile Include="CudaMex\ImagePow.cpp" />
-    <ClCompile Include="CudaMex\MaxFilter.cpp" />
+    <ClCompile Include="CudaMex\MaxFilterNeighborHood.cpp" />
+    <ClCompile Include="CudaMex\MaxFilterCircle.cpp" />
+    <ClCompile Include="CudaMex\MaxFilterKernal.cpp" />
     <ClCompile Include="CudaMex\MaximumIntensityProjection.cpp" />
     <ClCompile Include="CudaMex\MeanFilter.cpp" />
     <ClCompile Include="CudaMex\MedianFilter.cpp" />
     <ClCompile Include="CudaMex\MexCommand.cpp" />
-    <ClCompile Include="CudaMex\MinFilter.cpp" />
+    <ClCompile Include="CudaMex\MinFilterNeighborhood.cpp" />
+    <ClCompile Include="CudaMex\MinFilterCircle.cpp" />
+    <ClCompile Include="CudaMex\MinFilterKernal.cpp" />
     <ClCompile Include="CudaMex\MultiplyImage.cpp" />
     <ClCompile Include="CudaMex\MultiplyImageWith.cpp" />
     <ClCompile Include="CudaMex\NormalizedCovariance.cpp" />
@@ -46,6 +51,7 @@
     <ClCompile Include="CudaMex\Unmix.cpp" />
   </ItemGroup>
   <ItemGroup>
+    <CudaCompile Include="Common\CudaUtilities.cu" />
     <CudaCompile Include="CudaMex\Process.cu" />
   </ItemGroup>
   <ItemGroup>
@@ -56,6 +62,12 @@
     <ClInclude Include="Common\Vec.h" />
     <ClInclude Include="Common\VecFuncs.h" />
     <ClInclude Include="CudaMex\MexCommand.h" />
+    <ClInclude Include="Common\CudaKernels.cuh">
+      <FileType>Document</FileType>
+    </ClInclude>
+    <ClInclude Include="Common\CudaUtilities.cuh">
+      <FileType>Document</FileType>
+    </ClInclude>
     <None Include="CudaMex\CudaMex.def" />
   </ItemGroup>
   <ItemGroup>
@@ -194,7 +206,11 @@ move "$(OutDir)CudaMex.dll" "$(ProjectDir)CudaMex.mexw64"
 echo copy "$(ProjectDir)CudaMex.mexw64" "$(ProjectDir)..\MATLAB\."
 copy "$(ProjectDir)CudaMex.mexw64" "$(ProjectDir)..\MATLAB\."
 echo copy "$(CudaToolkitBinDir)\cudart*.dll" "$(ProjectDir)..\MATLAB\."
-copy "$(CudaToolkitBinDir)\cudart*.dll" "$(ProjectDir)..\MATLAB\."</Command>
+copy "$(CudaToolkitBinDir)\cudart*.dll" "$(ProjectDir)..\MATLAB\."
+echo copy "$(ProjectDir)CudaMex.mexw64" "$(ProjectDir)..\..\bin\."
+copy "$(ProjectDir)CudaMex.mexw64" "$(ProjectDir)..\..\bin\."
+echo copy "$(CudaToolkitBinDir)\cudart*.dll" "$(ProjectDir)..\..\bin\."
+copy "$(CudaToolkitBinDir)\cudart*.dll" "$(ProjectDir)..\..\bin\."</Command>
     </PostBuildEvent>
     <CudaLink>
       <AdditionalLibraryDirectories>$(CUDA_PATH)lib\x64</AdditionalLibraryDirectories>

src/c/CudaMex.vcxproj.filters

@@ -39,9 +39,6 @@
     <ClCompile Include="CudaMex\GaussianFilter.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="CudaMex\MaxFilter.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="CudaMex\MaximumIntensityProjection.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -51,9 +48,6 @@
     <ClCompile Include="CudaMex\MedianFilter.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="CudaMex\MinFilter.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="CudaMex\MultiplyImage.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -90,16 +84,46 @@
     <ClCompile Include="CudaMex\OtsuThesholdValue.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="CudaMex\MaxFilterKernal.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="CudaMex\MinFilterKernal.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="CudaMex\MaxFilterCircle.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="CudaMex\MinFilterCircle.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="CudaMex\MaxFilterNeighborHood.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="CudaMex\MinFilterNeighborhood.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Common\CHelpers.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <CudaCompile Include="CudaMex\Process.cu">
       <Filter>Source Files</Filter>
     </CudaCompile>
+    <CudaCompile Include="Common\CudaUtilities.cu">
+      <Filter>Source Files</Filter>
+    </CudaCompile>
   </ItemGroup>
   <ItemGroup>
     <None Include="CudaMex\CudaMex.def">
       <Filter>Resource Files</Filter>
     </None>
+    <None Include="Common\CudaKernels.cuh">
+      <Filter>Header Files</Filter>
+    </None>
+    <None Include="Common\CudaUtilities.cuh">
+      <Filter>Header Files</Filter>
+    </None>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="CudaMex\Process.h">