Work in progress to get Mex working

src/MATLAB/sandbox.m

+im = tiffReader('DAPI Olig2-514 GFAP-488 Dcx-647 Laminin-Cy3 Bcatenin-568 20x1 TopLeft');
\ No newline at end of file

src/MATLAB/tiffReader.m

+function im = tiffReader(datasetName,dirName,nameConvention,cPos,tPos,zPos)
+global DatasetName OrgDir
+
+DatasetName = datasetName;
+im = [];
+
+if (~exist('dirName','var'))
+    fprintf('Select Image Dir...');
+    dirName = uigetdir();
+    disp(dirName);
+end
+
+if (~exist('nameConvention','var'))
+    nameConvention = '_c%d_t%04d_z%04d%s';
+    cPos = 1;
+    tPos = 2;
+    zPos = 3;
+end
+
+OrgDir = dirName;
+
+dList = dir(fullfile(dirName,'*.tif*'));
+
+mxC = 0;
+mxT = 0;
+mxZ = 0;
+
+for i=1:length(dList)
+    vals = textscan(dList(i).name,[datasetName nameConvention]);
+    
+    if (isempty(vals) || isempty(vals{1}) || isempty(vals{2}) || isempty(vals{3}))
+        continue;
+    end
+    
+    c = vals{cPos};
+    t = vals{tPos};
+    z = vals{zPos};
+    im(:,:,z,t,c) = imread(fullfile(dirName,dList(i).name));
+    
+    if (c>mxC)
+        mxC = c;
+    end
+    if (t>mxT)
+        mxT = t;
+    end
+    if (z>mxZ)
+        mxZ = z;
+    end
+end

src/c/Common/CudaImageBuffer.cuh

@@ -395,7 +395,7 @@ public:
 	template<typename FactorType>
 	void multiplyImage(FactorType factor)
 	{
-		cudaMultiplyImage<<<blocks,threads>>>(getCurrentBuffer(),getNextBuffer(),imageDims,factor,minValue,maxValue,isColumnMajor);
+		cudaMultiplyImage<<<blocks,threads>>>(getCurrentBuffer(),getNextBuffer(),imageDims,factor,minPixel,maxPixel,isColumnMajor);
 		incrementBufferNumber();
 	}
 

src/c/Common/CudaKernals.cuh

@@ -55,8 +55,8 @@ __global__ void cudaMeanFilter(ImagePixelType* imageIn, ImagePixelType* imageOut
 	}
 }
 
-template<typename ImagePixelType, typename FactorType>
-__global__ void cudaMultiplyImage(ImagePixelType* imageIn, ImagePixelType* imageOut, Vec<unsigned int> hostImageDims, FactorType factor,
+template<typename ImagePixelType>
+__global__ void cudaMultiplyImage(ImagePixelType* imageIn, ImagePixelType* imageOut, Vec<unsigned int> hostImageDims, double factor,
 	ImagePixelType minValue, ImagePixelType maxValue, bool isColumnMajor=false)
 {
 	DeviceVec<unsigned int> imageDims = hostImageDims;
@@ -68,7 +68,7 @@ __global__ void cudaMultiplyImage(ImagePixelType* imageIn, ImagePixelType* image
 	if (coordinate<imageDims)
 	{
 		imageOut[imageDims.linearAddressAt(coordinate,isColumnMajor)] = 
-			min(maxValue,max(minValue, factor*imageIn[imageDims.linearAddressAt(coordinate,isColumnMajor)]));
+			min((double)maxValue,max((double)minValue, factor*imageIn[imageDims.linearAddressAt(coordinate,isColumnMajor)]));
 	}
 }
 
@@ -111,8 +111,8 @@ __global__ void cudaMultiplyTwoImages(ImagePixelType1* imageIn1, ImagePixelType2
 	}
 }
 
- template<typename ImagePixelType, typename FactorType>
- __global__ void cudaAddFactor(ImagePixelType* imageIn1, ImagePixelType* imageOut, Vec<unsigned int> hostImageDims, FactorType factor,
+ template<typename ImagePixelType>
+ __global__ void cudaAddFactor(ImagePixelType* imageIn1, ImagePixelType* imageOut, Vec<unsigned int> hostImageDims, double factor,
 	 ImagePixelType minValue, ImagePixelType maxValue, bool isColumnMajor=false)
 {
 	DeviceVec<unsigned int> imageDims = hostImageDims;
@@ -123,8 +123,8 @@ __global__ void cudaMultiplyTwoImages(ImagePixelType1* imageIn1, ImagePixelType2
 
 	if (coordinate<imageDims)
 	{
-		FactorType outValue = imageIn1[imageDims.linearAddressAt(coordinate,isColumnMajor)] + factor;
-		imageOut[imageDims.linearAddressAt(coordinate,isColumnMajor)] = min(maxValue,max(minValue,outValue));
+		double outValue = imageIn1[imageDims.linearAddressAt(coordinate,isColumnMajor)] + factor;
+		imageOut[imageDims.linearAddressAt(coordinate,isColumnMajor)] = min((double)maxValue,max((double)minValue,outValue));
 	}
 }
 
@@ -599,9 +599,9 @@ __global__ void cudaFindMinMax(ImagePixelType* arrayIn, double* minArrayOut, dou
 	}
 }
 
-template<typename ImagePixelType, typename ThresholdType>
+template<typename ImagePixelType>
 __global__ void cudaPolyTransferFuncImage(ImagePixelType* imageIn, ImagePixelType* imageOut, Vec<unsigned int> hostImageDims,
-	ThresholdType a, ThresholdType b, ThresholdType c, ImagePixelType minPixelValue, ImagePixelType maxPixelValue, bool isColumnMajor=false)
+	double a, double b, double c, ImagePixelType minPixelValue, ImagePixelType maxPixelValue, bool isColumnMajor=false)
 {
 	DeviceVec<unsigned int> imageDims = hostImageDims;
 	DeviceVec<unsigned int> coordinate;
@@ -618,7 +618,7 @@ __global__ void cudaPolyTransferFuncImage(ImagePixelType* imageIn, ImagePixelTyp
 		if (multiplier>1)
 			multiplier = 1;
 
-		ImagePixelType newPixelVal = min(maxPixelValue,max(minPixelValue, multiplier*maxPixelValue));
+		ImagePixelType newPixelVal = min((double)maxPixelValue,max((double)minPixelValue, multiplier*maxPixelValue));
 
 		imageOut[imageDims.linearAddressAt(coordinate,isColumnMajor)] = newPixelVal;
 	}

src/c/CudaImageProccessing.sln

 
-Microsoft Visual Studio Solution File, Format Version 11.00
-# Visual Studio 2010
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CudaImageProccessing", "CudaImageProccessing.vcxproj", "{385B5E1B-A569-4527-A8F4-C8A8B7D03531}"
-EndProject
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2012
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CudaMex", "CudaMex.vcxproj", "{DF033EF0-D4AC-41CD-900B-5BFE8099BED4}"
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CudaLibTester", "CudaLibTester.vcxproj", "{6B92E36C-E848-4592-AD0C-A8951E6F92CA}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Win32 = Debug|Win32
 		Debug|x64 = Debug|x64
-		Release|Win32 = Release|Win32
 		Release|x64 = Release|x64
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{385B5E1B-A569-4527-A8F4-C8A8B7D03531}.Debug|Win32.ActiveCfg = Debug|Win32
-		{385B5E1B-A569-4527-A8F4-C8A8B7D03531}.Debug|Win32.Build.0 = Debug|Win32
-		{385B5E1B-A569-4527-A8F4-C8A8B7D03531}.Debug|x64.ActiveCfg = Debug|x64
-		{385B5E1B-A569-4527-A8F4-C8A8B7D03531}.Debug|x64.Build.0 = Debug|x64
-		{385B5E1B-A569-4527-A8F4-C8A8B7D03531}.Release|Win32.ActiveCfg = Release|Win32
-		{385B5E1B-A569-4527-A8F4-C8A8B7D03531}.Release|Win32.Build.0 = Release|Win32
-		{385B5E1B-A569-4527-A8F4-C8A8B7D03531}.Release|x64.ActiveCfg = Release|x64
-		{DF033EF0-D4AC-41CD-900B-5BFE8099BED4}.Debug|Win32.ActiveCfg = Debug|Win32
-		{DF033EF0-D4AC-41CD-900B-5BFE8099BED4}.Debug|Win32.Build.0 = Debug|Win32
-		{DF033EF0-D4AC-41CD-900B-5BFE8099BED4}.Debug|x64.ActiveCfg = Debug|Win32
-		{DF033EF0-D4AC-41CD-900B-5BFE8099BED4}.Release|Win32.ActiveCfg = Release|Win32
-		{DF033EF0-D4AC-41CD-900B-5BFE8099BED4}.Release|Win32.Build.0 = Release|Win32
+		{DF033EF0-D4AC-41CD-900B-5BFE8099BED4}.Debug|x64.ActiveCfg = Debug|x64
+		{DF033EF0-D4AC-41CD-900B-5BFE8099BED4}.Debug|x64.Build.0 = Debug|x64
 		{DF033EF0-D4AC-41CD-900B-5BFE8099BED4}.Release|x64.ActiveCfg = Release|x64
-		{6B92E36C-E848-4592-AD0C-A8951E6F92CA}.Debug|Win32.ActiveCfg = Debug|Win32
-		{6B92E36C-E848-4592-AD0C-A8951E6F92CA}.Debug|Win32.Build.0 = Debug|Win32
 		{6B92E36C-E848-4592-AD0C-A8951E6F92CA}.Debug|x64.ActiveCfg = Debug|x64
 		{6B92E36C-E848-4592-AD0C-A8951E6F92CA}.Debug|x64.Build.0 = Debug|x64
-		{6B92E36C-E848-4592-AD0C-A8951E6F92CA}.Release|Win32.ActiveCfg = Release|Win32
-		{6B92E36C-E848-4592-AD0C-A8951E6F92CA}.Release|Win32.Build.0 = Release|Win32
 		{6B92E36C-E848-4592-AD0C-A8951E6F92CA}.Release|x64.ActiveCfg = Release|x64
 		{6B92E36C-E848-4592-AD0C-A8951E6F92CA}.Release|x64.Build.0 = Release|x64
 	EndGlobalSection

src/c/CudaMex.cpp

-#include "mex.h"
-#include <string>
-
-void mexFunction(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
-{
-	if (nrhs<1 || !mxIsChar(prhs[0])) mexErrMsgTxt("Usage:\n");
-
-	char* command = mxArrayToString(prhs[0]);
-
-	if (_strcmpi("load image",command)==0)
-	{
-		if (nrhs!=0 || nlhs!=1) mexErrMsgTxt("no right hand arguments or more than one left hand argument!\n");
-		mxGetImagData(prhs[0]);
-
-	}else if (_strcmpi("",command)==0)
-	{
-
-	}
-}
\ No newline at end of file

src/c/CudaMex.vcxproj

@@ -18,6 +18,43 @@
       <Platform>x64</Platform>
     </ProjectConfiguration>
   </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="CudaMex\AddConstant.cpp" />
+    <ClCompile Include="CudaMex\AddImageWith.cpp" />
+    <ClCompile Include="CudaMex\ApplyPolyTransformation.cpp" />
+    <ClCompile Include="CudaMex\CalculateMinMax.cpp" />
+    <ClCompile Include="CudaMex\ContrastEnhancement.cpp" />
+    <ClCompile Include="CudaMex\CudaMex.cpp" />
+    <ClCompile Include="CudaMex\GaussianFilter.cpp" />
+    <ClCompile Include="CudaMex\ImagePow.cpp" />
+    <ClCompile Include="CudaMex\MaxFilter.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\MultiplyImage.cpp" />
+    <ClCompile Include="CudaMex\MultiplyImageWith.cpp" />
+    <ClCompile Include="CudaMex\ReduceImage.cpp" />
+    <ClCompile Include="CudaMex\SumArray.cpp" />
+    <ClCompile Include="CudaMex\ThresholdFilter.cpp" />
+    <ClCompile Include="CudaMex\Unmix.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <CudaCompile Include="CudaMex\Process.cu" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="Common\CudaImageBuffer.cuh">
+      <FileType>Document</FileType>
+    </ClInclude>
+    <ClInclude Include="Common\Vec.h" />
+    <ClInclude Include="Common\VecFuncs.h" />
+    <ClInclude Include="CudaMex\MexCommand.h" />
+    <None Include="CudaMex\CudaMex.def" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="CudaMex\Process.h" />
+  </ItemGroup>
   <PropertyGroup Label="Globals">
     <ProjectGuid>{DF033EF0-D4AC-41CD-900B-5BFE8099BED4}</ProjectGuid>
     <RootNamespace>CudaMex</RootNamespace>
@@ -63,12 +100,12 @@
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <IncludePath>$(CUDA_PATH)include;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include;</IncludePath>
+    <IncludePath>$(CUDA_PATH)\include;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include;</IncludePath>
     <OutDir>$(SolutionDir)Output\$(ProjectName)\$(Configuration)_$(PlatformName)\</OutDir>
     <IntDir>$(SolutionDir)Intermediate\$(ProjectName)\$(Configuration)_$(PlatformName)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <IncludePath>$(CUDA_PATH)include;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include;</IncludePath>
+    <IncludePath>$(CUDA_PATH)\include;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSdkDir)include;$(FrameworkSDKDir)\include;</IncludePath>
     <OutDir>$(SolutionDir)Output\$(ProjectName)\$(Configuration)_$(PlatformName)\</OutDir>
     <IntDir>$(SolutionDir)Intermediate\$(ProjectName)\$(Configuration)_$(PlatformName)\</IntDir>
   </PropertyGroup>
@@ -85,20 +122,21 @@
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>$(MATLAB_DIR)\extern\include;$(SolutionDir)Common;</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(MATLAB_DIR)\extern\include;$(SolutionDir)CudaMex;$(SolutionDir)Common;</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalLibraryDirectories>$(MATLAB_DIR)\extern\lib\win64\microsoft;$(CUDA_PATH)lib\x64\;</AdditionalLibraryDirectories>
+      <AdditionalLibraryDirectories>$(MATLAB_DIR)\extern\lib\win64\microsoft;$(CudaToolkitLibDir)</AdditionalLibraryDirectories>
       <AdditionalDependencies>cudart.lib;libmx.lib;libmex.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <ModuleDefinitionFile>$(SolutionDir)CudaMex\CudaMex.def</ModuleDefinitionFile>
     </Link>
     <PostBuildEvent>
-      <Command>echo copy" $(OutDir)CudaMex.dll" "$(ProjectDir)"
-copy "$(OutDir)CudaMex.dll" "$(ProjectDir)"
+      <Command>echo copy" $(CudaToolkitBinDir)\cudart*.dll" "$(ProjectDir)"
+copy "$(CudaToolkitBinDir)\cudart*.dll" "$(ProjectDir)"
 echo copy "$(OutDir)CudaMex.pdb" "$(ProjectDir)"
 copy "$(OutDir)CudaMex.pdb" "$(ProjectDir)"
-echo move "$(ProjectDir)CudaMex.dll" "$(ProjectDir)CudaMex.mexw64"
-move "$(ProjectDir)CudaMex.dll" "$(ProjectDir)CudaMex.mexw64"
+echo move "$(OutDir)CudaMex.dll" "$(ProjectDir)CudaMex.mexw64"
+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\."
@@ -107,6 +145,9 @@ copy "$(CudaToolkitBinDir)\cudart*.dll" "$(ProjectDir)..\MATLAB\."</Command>
     <CudaLink>
       <AdditionalLibraryDirectories>$(CUDA_PATH)lib\x64</AdditionalLibraryDirectories>
     </CudaLink>
+    <CudaCompile>
+      <CodeGeneration>compute_20,sm_20;compute_30,sm_30;compute_35,sm_35;</CodeGeneration>
+    </CudaCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <ClCompile>
@@ -127,22 +168,23 @@ copy "$(CudaToolkitBinDir)\cudart*.dll" "$(ProjectDir)..\MATLAB\."</Command>
       <Optimization>MaxSpeed</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <AdditionalIncludeDirectories>$(MATLAB_DIR)\extern\include;$(SolutionDir)Common;</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(MATLAB_DIR)\extern\include;$(SolutionDir)CudaMex;$(SolutionDir)Common;</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
-      <AdditionalLibraryDirectories>$(MATLAB_DIR)\extern\lib\win64\microsoft;$(CUDA_PATH)lib\x64\;</AdditionalLibraryDirectories>
+      <AdditionalLibraryDirectories>$(MATLAB_DIR)\extern\lib\win64\microsoft;$(CudaToolkitLibDir)</AdditionalLibraryDirectories>
       <AdditionalDependencies>cudart.lib;libmx.lib;libmex.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <ModuleDefinitionFile>$(SolutionDir)CudaMex\CudaMex.def</ModuleDefinitionFile>
     </Link>
     <PostBuildEvent>
-      <Command>echo copy" $(OutDir)CudaMex.dll" "$(ProjectDir)"
-copy "$(OutDir)CudaMex.dll" "$(ProjectDir)"
+      <Command>echo copy" $(CudaToolkitBinDir)\cudart*.dll" "$(ProjectDir)"
+copy "$(CudaToolkitBinDir)\cudart*.dll" "$(ProjectDir)"
 echo copy "$(OutDir)CudaMex.pdb" "$(ProjectDir)"
 copy "$(OutDir)CudaMex.pdb" "$(ProjectDir)"
-echo move "$(ProjectDir)CudaMex.dll" "$(ProjectDir)CudaMex.mexw64"
-move "$(ProjectDir)CudaMex.dll" "$(ProjectDir)CudaMex.mexw64"
+echo move "$(OutDir)CudaMex.dll" "$(ProjectDir)CudaMex.mexw64"
+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\."
@@ -151,25 +193,10 @@ copy "$(CudaToolkitBinDir)\cudart*.dll" "$(ProjectDir)..\MATLAB\."</Command>
     <CudaLink>
       <AdditionalLibraryDirectories>$(CUDA_PATH)lib\x64</AdditionalLibraryDirectories>
     </CudaLink>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClInclude Include="Common\CHelpers.h" />
-    <ClInclude Include="Common\CudaImageBuffer.h" />
-    <ClInclude Include="Common\CudaKernals.h" />
-    <ClInclude Include="Common\CudaUtilities.h" />
-    <ClInclude Include="Common\Defines.h" />
-    <ClInclude Include="Common\Vec.h" />
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="CudaMex.def" />
-    <CudaCompile Include="CudaWrapper.cu">
-      <FileType>Document</FileType>
+    <CudaCompile>
+      <CodeGeneration>compute_20,sm_20;compute_30,sm_30;compute_35,sm_35;</CodeGeneration>
     </CudaCompile>
-    <None Include="CudaWrapper.h" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="CudaMex.cpp" />
-  </ItemGroup>
+  </ItemDefinitionGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
     <Import Project="$(VCTargetsPath)\BuildCustomizations\CUDA 5.5.targets" />

src/c/CudaMex.vcxproj.filters

@@ -15,41 +15,92 @@
     </Filter>
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="Common\CHelpers.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Common\CudaImageBuffer.h">
+    <ClCompile Include="CudaMex\CudaMex.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="CudaMex\MexCommand.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="CudaMex\AddConstant.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="CudaMex\AddImageWith.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="CudaMex\ApplyPolyTransformation.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="CudaMex\CalculateMinMax.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="CudaMex\ContrastEnhancement.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <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>
+    <ClCompile Include="CudaMex\MeanFilter.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <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>
+    <ClCompile Include="CudaMex\MultiplyImageWith.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="CudaMex\ImagePow.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="CudaMex\SumArray.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="CudaMex\ReduceImage.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="CudaMex\ThresholdFilter.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="CudaMex\Unmix.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <CudaCompile Include="CudaMex\Process.cu">
+      <Filter>Source Files</Filter>
+    </CudaCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="CudaMex\CudaMex.def">
+      <Filter>Resource Files</Filter>
+    </None>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="CudaMex\Process.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="Common\CudaKernals.h">
+    <ClInclude Include="Common\CudaImageBuffer.cuh">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="Common\CudaUtilities.h">
+    <ClInclude Include="Common\Vec.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="Common\Defines.h">
+    <ClInclude Include="Common\VecFuncs.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="Common\Vec.h">
+    <ClInclude Include="CudaMex\MexCommand.h">
       <Filter>Header Files</Filter>
     </ClInclude>
   </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="CudaMex.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="CudaMex.def">
-      <Filter>Resource Files</Filter>
-    </None>
-    <None Include="CudaWrapper.h">
-      <Filter>Header Files</Filter>
-    </None>
-  </ItemGroup>
-  <ItemGroup>
-    <CudaCompile Include="CudaWrapper.cu">
-      <Filter>Source Files</Filter>
-    </CudaCompile>
-  </ItemGroup>
 </Project>
\ No newline at end of file

src/c/CudaMex/AddConstant.cpp

+#include "MexCommand.h"
+#include "Process.h"
+
+void AddConstant::execute(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+	Vec<unsigned int> imageDims;
+	MexImagePixelType* imageIn, * imageOut;
+	setupImagePointers(prhs[0],&imageIn,&imageDims,&plhs[0],&imageOut);
+
+	double additive = mxGetScalar(prhs[1]);
+
+	addConstant(imageIn,imageOut,imageDims,additive);
+}
+
+std::string AddConstant::check(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+	if (nrhs!=2)
+		return "Incorrect number of inputs!";
+
+	if (nlhs!=1)
+		return "Requires one output!";
+
+	if (!mxIsUint8(prhs[0]))
+		return "Image has to be formated as a uint8!";
+
+	int numDims = mxGetNumberOfDimensions(prhs[0]);
+	if (numDims>3 || numDims<2)
+		return "Image can only be either 2D or 3D!";
+
+	if (!mxIsDouble(prhs[1]))
+		return "Additive needs to be a single double!";
+
+	return "";
+}
+
+std::string AddConstant::printUsage()
+{
+	return "imageOut = CudaMex('AddConstant',imageIn,additive)";
+}
\ No newline at end of file

src/c/CudaMex/AddImageWith.cpp

+#include "MexCommand.h"
+#include "Process.h"
+
+void AddImageWith::execute( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[] )
+{
+	Vec<unsigned int> imageDims1;
+	MexImagePixelType* imageIn1, * imageOut;
+	setupImagePointers(prhs[0],&imageIn1,&imageDims1,&plhs[0],&imageOut);
+	Vec<unsigned int> imageDims2;
+	MexImagePixelType* imageIn2;
+	setupImagePointers(prhs[1],&imageIn2,&imageDims2);
+
+	double factor = mxGetScalar(prhs[2]);
+	addImageWith(imageIn1,imageIn2,imageOut,imageDims1,factor);
+}
+
+std::string AddImageWith::check( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[] )
+{
+	if (nrhs!=3)
+		return "Incorrect number of inputs!";
+
+	if (nlhs!=1)
+		return "Requires one output!";
+
+	if (!mxIsUint8(prhs[0]) || !mxIsUint8(prhs[1]))
+		return "Images has to be formated as a uint8!";
+
+	int numDims = mxGetNumberOfDimensions(prhs[0]);
+	if (numDims>3 || numDims<2)
+		return "Image can only be either 2D or 3D!";
+
+	numDims = mxGetNumberOfDimensions(prhs[1]);
+	if (numDims>3 || numDims<2)
+		return "Image can only be either 2D or 3D!";
+
+	if (!mxIsDouble(prhs[2]))
+		return "Factor needs to be a double!";
+
+	return "";
+}
+
+std::string AddImageWith::printUsage()
+{
+	return "imageOut = CudaMex('AddImageWith',imageIn1,imageIn2,factor)";
+}
\ No newline at end of file

src/c/CudaMex/ApplyPolyTransformation.cpp

+#include "MexCommand.h"
+#include "Process.h"
+
+
+void ApplyPolyTransformation::execute( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[] )
+{
+	Vec<unsigned int> imageDims;
+	MexImagePixelType* imageIn, * imageOut;
+	setupImagePointers(prhs[0],&imageIn,&imageDims,&plhs[0],&imageOut);
+
+	double a = mxGetScalar(prhs[1]);
+	double b = mxGetScalar(prhs[2]);
+	double c = mxGetScalar(prhs[3]);
+
+	applyPolyTransformation(imageIn,imageOut,imageDims,a,b,c,
+		std::numeric_limits<MexImagePixelType>::min(),std::numeric_limits<MexImagePixelType>::max());
+}
+
+
+std::string ApplyPolyTransformation::check( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[] )
+{
+	if (nrhs!=4)
+		return "Incorrect number of inputs!";
+
+	if (nlhs!=1)
+		return "Requires one output!";
+
+	if (!mxIsUint8(prhs[0]))
+		return "Image has to be formated as a uint8!";
+
+	int numDims = mxGetNumberOfDimensions(prhs[0]);
+	if (numDims>3 || numDims<2)
+		return "Image can only be either 2D or 3D!";
+
+	if (!mxIsDouble(prhs[1]) || !mxIsDouble(prhs[2]) || !mxIsDouble(prhs[3]))
+		return "a,b,c all have to be doubles!";
+
+	return "";
+}
+
+std::string ApplyPolyTransformation::printUsage()
+{
+	return "imageOut = CudaMex('ApplyPolyTransformation',imageIn,a,b,c)";
+}
\ No newline at end of file

src/c/CudaMex/CalculateMinMax.cpp

+#include "MexCommand.h"
+#include "Process.h"
+
+void CalculateMinMax::execute( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[] )
+{
+	Vec<unsigned int> imageDims;
+	MexImagePixelType* imageIn;
+	setupImagePointers(prhs[0],&imageIn,&imageDims);
+
+	MexImagePixelType mn, mx;
+
+	calculateMinMax(imageIn,imageDims,mn,mx);
+
+	plhs[0] = mxCreateDoubleScalar((double)mn);
+	plhs[1] = mxCreateDoubleScalar((double)mx);
+}
+
+std::string CalculateMinMax::check( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[] )
+{
+	if (nrhs!=1)
+		return "Incorrect number of inputs!";
+
+	if (nlhs!=2)
+		return "Requires two outputs!";
+
+	if (!mxIsUint8(prhs[0]))
+		return "Image has to be formated as a uint8!";
+
+	int numDims = mxGetNumberOfDimensions(prhs[0]);
+	if (numDims>3 || numDims<2)
+		return "Image can only be either 2D or 3D!";
+
+	return "";
+}
+
+std::string CalculateMinMax::printUsage()
+{
+	return "[min max] = CudaMex('CalculateMinMax',imageIn)";
+}
\ No newline at end of file

src/c/CudaMex/ContrastEnhancement.cpp

+#include "MexCommand.h"
+#include "Process.h"
+
+void ContrastEnhancement::execute( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[] )
+{
+	Vec<unsigned int> imageDims;
+	MexImagePixelType* imageIn, * imageOut;
+	setupImagePointers(prhs[0],&imageIn,&imageDims,&plhs[0],&imageOut);
+
+	double* sigmasD = (double*)mxGetData(prhs[1]);
+	double* neighborhoodD = (double*)mxGetData(prhs[2]);
+
+	Vec<float> sigmas((float)sigmasD[0],(float)sigmasD[1],(float)sigmasD[2]);
+	Vec<unsigned int> neighborhood((int)neighborhoodD[0],(int)neighborhoodD[1],(int)neighborhoodD[2]);
+	
+	contrastEnhancement(imageIn,imageOut,imageDims,sigmas,neighborhood);
+}
+
+std::string ContrastEnhancement::check( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[] )
+{
+	if (nrhs!=3)
+		return "Incorrect number of inputs!";
+
+	if (nlhs!=1)
+		return "Requires one output!";
+
+	if (!mxIsUint8(prhs[0]))
+		return "Image has to be formated as a uint8!";
+
+	int numDims = mxGetNumberOfDimensions(prhs[0]);
+	if (numDims>3 || numDims<2)
+		return "Image can only be either 2D or 3D!";
+
+	numDims = mxGetNumberOfDimensions(prhs[1]);
+	if (numDims!=3 || !mxIsDouble(prhs[1]))
+		return "Sigmas has to be an array of three doubles!";
+
+	numDims = mxGetNumberOfDimensions(prhs[2]);
+	if (numDims!=3 || !mxIsDouble(prhs[2]))
+		return "Median neighborhood has to be an array of three doubles!";
+
+	return "";
+}
+
+std::string ContrastEnhancement::printUsage()
+{
+	return "imageOut = CudaMex('ContrastEnhancement',imageIn,[sigmaX,sigmaY,sigmaZ],[MedianNeighborhoodX,MedianNeighborhoodY,MedianNeighborhoodZ])";
+}
\ No newline at end of file

src/c/CudaMex/CudaMex.cpp

+#include "mex.h"
+#include <string>
+#include "Vec.h"
+#include "Process.h"
+#include "MexCommand.h"
+
+extern "C" 
+{
+	void mexCleanUp()
+	{
+		MexCommand::cleanUp();
+	}
+};
+
+void mexFunction(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
+{
+	if (MexCommand::needsInit())
+	{
+		mexAtExit(mexCleanUp);
+		MexCommand::init();
+	}
+
+	//TODO: print the actual error reason after the list
+	if (nrhs==0)
+		mexErrMsgTxt(MexCommand::printUsageList().c_str());
+
+	if (!mxIsChar(prhs[0]))
+		mexErrMsgTxt(MexCommand::printUsageList().c_str());
+
+	char cmd[255];
+	mxGetString(prhs[0],cmd,255);
+
+	MexCommand* thisCommand = MexCommand::getCommand(cmd);
+	if (thisCommand==NULL)
+		mexErrMsgTxt(MexCommand::printUsageList().c_str());
+
+	std::string errMsg = thisCommand->check(nlhs,plhs,nrhs-1,prhs+1);
+	if (errMsg.length()!=0)
+	{
+		mexPrintf("%s\n",thisCommand->printUsage().c_str());
+		mexErrMsgTxt(errMsg.c_str());
+	}
+
+	try
+	{
+		thisCommand->execute(nlhs,plhs,nrhs-1,prhs+1);
+	}
+	catch (std::string err)
+	{
+		mexErrMsgTxt(err.c_str());
+	}
+}
\ No newline at end of file

src/c/CudaMex/GaussianFilter.cpp

+#include "MexCommand.h"
+#include "Process.h"
+
+void GaussianFilter::execute( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[] )
+{
+	Vec<unsigned int> imageDims;
+	MexImagePixelType* imageIn, * imageOut;
+	setupImagePointers(prhs[0],&imageIn,&imageDims,&plhs[0],&imageOut);
+
+	double* sigmasD = (double*)mxGetData(prhs[1]);
+
+	Vec<float> sigmas(sigmasD[0],sigmasD[1],sigmasD[2]);
+	gaussianFilter(imageIn,imageOut,imageDims,sigmas);
+}
+
+std::string GaussianFilter::check( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[] )
+{
+	if (nrhs!=2)
+		return "Incorrect number of inputs!";
+
+	if (nlhs!=1)
+		return "Requires one output!";
+
+	if (!mxIsUint8(prhs[0]))
+		return "Image has to be formated as a uint8!";
+
+	int numDims = mxGetNumberOfDimensions(prhs[0]);
+	if (numDims>3 || numDims<2)
+		return "Image can only be either 2D or 3D!";
+
+	numDims = mxGetNumberOfDimensions(prhs[1]);
+	if (numDims!=3 || !mxIsDouble(prhs[1]))
+		return "Sigmas must be an array of three doubles!";
+
+	return "";
+}
+
+std::string GaussianFilter::printUsage()
+{
+	return "imageOut = CudaMex('GaussianFilter',imageIn,[sigmaX,sigmaY,sigmaZ])";
+}
\ No newline at end of file

src/c/CudaMex/ImagePow.cpp

+#include "MexCommand.h"
+#include "Process.h"
+
+void ImagePow::execute( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[] )
+{
+	Vec<unsigned int> imageDims;
+	MexImagePixelType* imageIn, * imageOut;
+	setupImagePointers(prhs[0],&imageIn,&imageDims,&plhs[0],&imageOut);
+
+	double p = mxGetScalar(prhs[1]);
+	imagePow(imageIn,imageOut,imageDims,(int)p);
+}
+
+std::string ImagePow::check( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[] )
+{
+	if (nrhs!=2)
+		return "Incorrect number of inputs!";
+
+	if (nlhs!=1)
+		return "Requires one output!";
+
+	if (!mxIsUint8(prhs[0]))
+		return "Image has to be formated as a uint8!";
+
+	int numDims = mxGetNumberOfDimensions(prhs[0]);
+	if (numDims>3 || numDims<2)
+		return "Image can only be either 2D or 3D!";
+
+	if (!mxIsDouble(prhs[1]))
+		return "Power has to be a single double!";
+
+	return "";
+}
+
+std::string ImagePow::printUsage()
+{
+	return "imageOut = CudaMex('ImagePow',imageIn,power)";
+}
\ No newline at end of file

src/c/CudaMex/MaxFilter.cpp

+#include "MexCommand.h"
+#include "Process.h"
+
+void MaxFilter::execute( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[] )
+{
+	Vec<unsigned int> imageDims;
+	MexImagePixelType* imageIn, * imageOut;
+	setupImagePointers(prhs[0],&imageIn,&imageDims,&plhs[0],&imageOut);
+
+	double* nbh = (double*)mxGetData(prhs[1]);
+
+	Vec<unsigned int> neighborhood((unsigned int)nbh[0],(unsigned int)nbh[1],(unsigned int)nbh[2]);
+	maxFilter(imageIn,imageOut,imageDims,neighborhood);
+}
+
+std::string MaxFilter::check( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[] )
+{
+	if (nrhs!=2)
+		return "Incorrect number of inputs!";
+
+	if (nlhs!=1)
+		return "Requires one output!";
+
+	if (!mxIsUint8(prhs[0]))
+		return "Image has to be formated as a uint8!";
+
+	int numDims = mxGetNumberOfDimensions(prhs[0]);
+	if (numDims>3 || numDims<2)
+		return "Image can only be either 2D or 3D!";
+
+	if (!mxIsDouble(prhs[1]))
+		return "Neighborhood needs to be an array of three doubles!";
+
+	numDims = mxGetNumberOfDimensions(prhs[1]);
+	if (numDims!=3)
+		return "Neighborhood needs to be an array of three doubles!";
+
+	return "";
+}
+
+std::string MaxFilter::printUsage()
+{
+	return "imageOut = CudaMex('MaxFilter',imageIn,[neighborhoodX,neighborhoodY,neighborhoodZ])";
+}
\ No newline at end of file

src/c/CudaMex/MaximumIntensityProjection.cpp

+#include "MexCommand.h"
+#include "Process.h"
+
+void MaximumIntensityProjection::execute( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[] )
+{
+	Vec<unsigned int> imageDims;
+	MexImagePixelType* imageIn, * imageOut;
+	setupImagePointers(prhs[0],&imageIn,&imageDims);
+// TODO
+// 	if (argOut!=NULL && imageOut!=NULL)
+// 	{
+// 		*argOut = mxCreateNumericArray(numDims,DIMS,mxUINT8_CLASS,mxREAL);
+// 		*imageOut = (MexImagePixelType*)mxGetData(*argOut);
+// 	}
+
+	maximumIntensityProjection(imageIn,imageOut,imageDims);
+}
+
+std::string MaximumIntensityProjection::check( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[] )
+{
+
+}
+
+std::string MaximumIntensityProjection::printUsage()
+{
+
+}
\ No newline at end of file

src/c/CudaMex/MeanFilter.cpp

+#include "MexCommand.h"
+#include "Process.h"
+
+void MeanFilter::execute( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[] )
+{
+
+}
+
+std::string MeanFilter::check( int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[] )
+{
+
+}
+
+std::string MeanFilter::printUsage()
+{
+
+}
\ No newline at end of file