Skip to content
Snippets Groups Projects
Commit cad25c1c authored by Eric Wait's avatar Eric Wait
Browse files

Moved around helper functions

parent 920a240e
No related branches found
No related tags found
No related merge requests found
#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
......@@ -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
#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
......@@ -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
......@@ -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)
......
......@@ -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>
......
......@@ -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">
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment