InputImageType::Pointer getEmpty(int s1,int s2, int s3)
{
InputImageType::Pointer p = InputImageType::New();
InputImageType::SizeType size;
InputImageType::IndexType index;
InputImageType::RegionType region;
size[0] = s1; size[1] = s2; size[2] = s3;
index.Fill(0);
region.SetSize(size);
region.SetIndex(index);
p->SetRegions(region);
p->Allocate();
return p;
}
void unmixMPIInternal(InputImageType::Pointer im [4],InputImageType::Pointer om[4], InputImageType::Pointer assignment[4])
{
printf("Performing unmixing ...\n");
InputImageType::SizeType size = im[0]->GetLargestPossibleRegion().GetSize();
IteratorType iterator[4];
IteratorType assigniter[4];
InputImageType::SizeType radius;
radius[0]=1;
radius[1]=1;
radius[2]=1;
InputImageType::SizeType imagesize = im[0]->GetLargestPossibleRegion().GetSize();
InputImageType::IndexType imageindex;
imageindex.Fill(0);
InputImageType::RegionType region;
region.SetSize(imagesize);
region.SetIndex(imageindex);
for(int counter=0; counter<4; counter++)
{
printf("\tPerforming median filtering on channel %d ...",counter+1);
om[counter]=im[counter];
assignment[counter]=InputImageType::New();
assignment[counter]->SetRegions(region);
assignment[counter]->Allocate();
assigniter[counter]=IteratorType(assignment[counter],assignment[counter]->GetLargestPossibleRegion());
assigniter[counter].GoToBegin();
iterator[counter]=IteratorType(om[counter],om[counter]->GetLargestPossibleRegion());
iterator[counter].GoToBegin();
printf(" Done %d.\n",counter+1);
}
//int total_voxels = size[0]*size[1]*size[2];
int num_processed = 0;
printf("\tComputing maximum among channels ... ");
for(;!iterator[0].IsAtEnd();)
{
num_processed++;
/*
if(num_processed % 100 ==0)
printf("Processed %0.2lf%% voxels\r",100.0/total_voxels*num_processed);
*/
// if(100.0/total_voxels*num_processed> 100)
// break;
double max = -1;
int maxpos = -1;
for(int co = 0; co < 4; co++)
{
unsigned char temp = iterator[co].Value();
if(max < temp)
{
max = temp;
maxpos = co;
}
}
for(int co = 0; co < 4; co++)
{
if(maxpos != co)
{
iterator[co].Set(0);
assigniter[co].Set(0);
}
else
{
assigniter[co].Set(255);
}
}
for(int co = 0; co<4; co++)
{
++iterator[co];
++assigniter[co];
}
}
printf(" Done.\n");
}
void unmix_median(InputImageType::Pointer im[],InputImageType::Pointer om[],int n)
{
printf("Unnmixing %d channels ...\n",n);
InputImageType::SizeType size = im[0]->GetLargestPossibleRegion().GetSize();
printf("I'm here\n");
MedianFilterType::Pointer filt[15];
IteratorType iterator[15];
//IteratorType assigniter[15];
InputImageType::SizeType radius;
radius[0]=1;
radius[1]=1;
radius[2]=1;
InputImageType::SizeType imagesize = im[0]->GetLargestPossibleRegion().GetSize();
InputImageType::IndexType imageindex;
imageindex.Fill(0);
InputImageType::RegionType region;
region.SetSize(imagesize);
region.SetIndex(imageindex);
double max_values[15];
for(int counter=0; counter<n; counter++)
{
printf("\tPerforming median filtering on channel %d ...",counter+1);
filt[counter]=MedianFilterType::New();
filt[counter]->SetRadius(radius);
filt[counter]->SetInput(im[counter]);
filt[counter]->Update();
om[counter]=filt[counter]->GetOutput();
iterator[counter]=IteratorType(om[counter],om[counter]->GetLargestPossibleRegion());
iterator[counter].GoToBegin();
max_values[counter]=-1;
printf(" Done %d.\n",counter+1);
for(;!iterator[counter].IsAtEnd();++iterator[counter])
{
if(max_values[counter]<iterator[counter].Value())
max_values[counter] = iterator[counter].Value();
}
// printf("Max%d = %lf\n",counter,max_values[counter]);
iterator[counter].GoToBegin();
}
//int total_voxels = size[0]*size[1]*size[2];
int num_processed = 0;
printf("\tComputing maximum among channels ... ");
for(;!iterator[0].IsAtEnd();)
{
num_processed++;
/*
if(num_processed % 100 ==0)
printf("Processed %0.2lf%% voxels\r",100.0/total_voxels*num_processed);
*/
// if(100.0/total_voxels*num_processed> 100)
// break;
double max = -1;
int maxpos = -1;
for(int co = 0; co < n; co++)
{
double temp = iterator[co].Value();///max_values[co];
if(max < temp)
{
max = temp;
maxpos = co;
}
}
for(int co = 0; co < n; co++)
{
if(maxpos != co)
{
iterator[co].Set(0);
}
}
for(int co = 0; co<n; co++)
{
++iterator[co];
}
}
printf(" Done.\n");
}
void get_tiles(InputImageType::RegionType inputr, int tilesizex, int tilesizey, int tilesizez, int borderx, int bordery, int borderz, std::vector<InputImageType::RegionType> &in1, std::vector<InputImageType::RegionType> &in2, std::vector<InputImageType::RegionType> &out1, std::vector<InputImageType::RegionType> &out2)
{
int xsize = inputr.GetSize()[0];
int ysize = inputr.GetSize()[1];
int zsize = inputr.GetSize()[2];
int kx = 0;int ky = 0;int kz = 0;
kx = xsize /(tilesizex-borderx);
ky = ysize /(tilesizey-bordery);
kz = zsize /(tilesizez-borderz);
int remx = xsize % (tilesizex-borderx);
int remy = ysize % (tilesizey-bordery);
int remz = zsize % (tilesizez-borderz);
if ( remx > 0 )
kx ++;
if ( remy > 0 )
ky ++;
if ( remz > 0 )
kz ++;
for(int xco = 0; xco < kx; xco++)
{
for(int yco = 0; yco < ky; yco++)
{
for(int zco = 0; zco < kz; zco++)
{
InputImageType::SizeType imsize = inputr.GetSize();
InputImageType::IndexType index;
InputImageType::SizeType size;
index.Fill(0);
size[0] = MIN((xco)*(tilesizex-borderx)+tilesizex-1,imsize[0]-1) - xco * (tilesizex-borderx) +1;
size[1] = MIN((yco)*(tilesizey-bordery)+tilesizey-1,imsize[1]-1) - yco * (tilesizey-bordery) +1;
size[2] = MIN((zco)*(tilesizez-borderz)+tilesizez-1,imsize[2]-1) - zco * (tilesizez-borderz) +1;
InputImageType::RegionType region;
region.SetIndex(index);
region.SetSize(size);
in2.push_back(region);
InputImageType::RegionType region1;
index[0] = xco *(tilesizex-borderx);
index[1] = yco *(tilesizey-bordery);
index[2] = zco *(tilesizez-borderz);
region1.SetIndex(index);
region1.SetSize(size);
in1.push_back(region1);
if(xco != 0)
{
size[0] = size[0] - borderx/2;
index[0] = borderx/2;
}
if(xco != kx-1)
{
size[0] = size[0] - borderx/2;
}
if(yco != 0)
{
size[1] = size[1] - bordery/2;
index[1] = bordery/2;
}
if(yco != ky-1)
{
size[1] = size[1] - bordery/2;
}
if(zco != 0)
{
size[2] = size[2] - borderz/2;
index[2] = borderz/2;
}
if(zco != kz-1)
{
size[2] = size[2] - borderz/2;
}
region.SetIndex(index);
region.SetSize(size);
out2.push_back(region);
if(xco!=0)
{
index[0] = xco *(tilesizex-borderx)+borderx/2;
}
if(yco!=0)
{
index[1] = yco *(tilesizey-bordery)+bordery/2;
}
if(zco!=0)
{
index[2] = zco *(tilesizez-borderz)+borderz/2;
}
region1.SetIndex(index);
region1.SetSize(size);
out1.push_back(region1);
}
}
}
}
vtkSmartPointer<vtkPolyData> getVTKPolyDataPrecise(LabelImageType::Pointer label)
{
LabelIteratorType liter = LabelIteratorType(label,label->GetLargestPossibleRegion());
liter.GoToBegin();
//find the maximum number of cells
unsigned short max1 = 0;
for(liter.GoToBegin();!liter.IsAtEnd();++liter)
max1 = MAX(max1,liter.Get());
//find all the cubes in which cells lie
cubecoord* carray = new cubecoord[max1+1];
for(int counter=0; counter<=max1; counter++)
{
carray[counter].sx=60000; carray[counter].sy=60000;carray[counter].sz=60000;
carray[counter].ex=0;carray[counter].ey=0;carray[counter].ez=0;
}
typedef itk::ImageRegionConstIteratorWithIndex<LabelImageType> ConstLabelIteratorWithIndex;
ConstLabelIteratorWithIndex cliter = ConstLabelIteratorWithIndex(label,label->GetLargestPossibleRegion());
InputImageType::IndexType index;
for(cliter.GoToBegin();!cliter.IsAtEnd();++cliter)
{
int cur = cliter.Get();
if(cur!=0)
{
index = cliter.GetIndex();
carray[cur].sx= MIN(index[0],carray[cur].sx);
carray[cur].sy= MIN(index[1],carray[cur].sy);
carray[cur].sz= MIN(index[2],carray[cur].sz);
carray[cur].ex= MAX(index[0],carray[cur].ex);
carray[cur].ey= MAX(index[1],carray[cur].ey);
carray[cur].ez= MAX(index[2],carray[cur].ez);
}
}
//find the largest image size we need
unsigned short wx=0,wy=0,wz=0;
for(int counter=1; counter<=max1; counter++)
{
wx = MAX(carray[counter].ex-carray[counter].sx+1,wx);
wy = MAX(carray[counter].ey-carray[counter].sy+1,wy);
wz = MAX(carray[counter].ez-carray[counter].sz+1,wz);
}
// accommodate padding
wx = wx+2;wy = wy +2; wz = wz+2;
printf("wx wy wz %u %u %u\n",wx,wy,wz);
// create a tiny image of maximum size
//appendfilter->UserManagedInputsOn();
//appendfilter->SetNumberOfInputs(max1);
vtkSmartPointer<vtkAppendPolyData> appendfilter = vtkSmartPointer<vtkAppendPolyData>::New();
/**************/
ExportFilterType::Pointer itkexporter = ExportFilterType::New();
vtkSmartPointer<vtkImageImport> vtkimporter = vtkSmartPointer<vtkImageImport>::New();
ConnectPipelines(itkexporter,(vtkImageImport *)vtkimporter);
vtkSmartPointer<vtkMarchingCubes> contourf = vtkSmartPointer<vtkMarchingCubes>::New();
contourf->SetInputData(vtkimporter->GetOutput());
contourf->SetValue(0,127);
contourf->ComputeNormalsOff();
contourf->ComputeScalarsOff();
contourf->ComputeGradientsOff();
vtkSmartPointer<vtkSmoothPolyDataFilter> smoothf = vtkSmartPointer<vtkSmoothPolyDataFilter>::New();
smoothf->SetInputData(contourf->GetOutput());
smoothf->SetRelaxationFactor(0.3);
smoothf->SetNumberOfIterations(20);
vtkSmartPointer<vtkTransform> transform = vtkSmartPointer<vtkTransform>::New();
transform->PostMultiply();
transform->Identity();
vtkSmartPointer<vtkTransformPolyDataFilter> tf = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
tf->SetTransform(transform);
tf->SetInputData(smoothf->GetOutput());
/******************/
InputImageType::Pointer t = getEmpty(wx,wy,wz);
for(int counter=1; counter<=max1; counter++)
{
//printf("Maximum tiny image size I need is [%d %d %d]\n",wx,wy,wz);
if(carray[counter].sx > 59999)
continue;
printf("Working..\n");
// scanf("%*d");
InputImageType::SizeType size;
InputImageType::RegionType region;
index.Fill(1);
region.SetIndex(index);
region.SetSize(size);
LabelImageType::SizeType lsize;
LabelImageType::IndexType lindex;
LabelImageType::RegionType lregion;
itkexporter->SetInput(t);
t->FillBuffer(0);
lsize[0] = carray[counter].ex-carray[counter].sx+1;
lsize[1] = carray[counter].ey-carray[counter].sy+1;
lsize[2] = carray[counter].ez-carray[counter].sz+1;
lindex[0] = carray[counter].sx;
lindex[1] = carray[counter].sy;
lindex[2] = carray[counter].sz;
lregion.SetIndex(lindex);
lregion.SetSize(lsize);
LabelIteratorType localiter = LabelIteratorType(label,lregion);
size = lsize;
region.SetSize(size);
IteratorType iter = IteratorType(t,region);
for(localiter.GoToBegin(),iter.GoToBegin();!localiter.IsAtEnd();++localiter,++iter)
{
if(localiter.Get()==counter)
{
iter.Set(255);
}
}
t->Modified();
vtkimporter->Modified();
transform->Identity();
transform->Translate(carray[counter].sx-1,carray[counter].sy-1,carray[counter].sz-1);
tf->SetTransform(transform);
tf->Update();
vtkSmartPointer<vtkPolyData> pol=vtkSmartPointer<vtkPolyData>::New();
pol->DeepCopy(tf->GetOutput());
// tf->GetOutput()->Print(std::cout);
appendfilter->AddInputData(pol);
//appendfilter->Update();
//appendfilter->SetInputByNumber(counter-1,tf->GetOutput());
// appendfilter->Update();
// appendfilter->GetOutput()->Print(std::cout);
//if(counter>500)
// break;
printf("Completed %d/%d\r",counter,max1);
// scanf("%*d");
}
appendfilter->Update();
vtkSmartPointer<vtkDecimatePro> decimate = vtkSmartPointer<vtkDecimatePro>::New();
decimate->SetInputData(appendfilter->GetOutput());
decimate->SetTargetReduction(0.1);
//decimate->SetNumberOfDivisions(32,32,32);
printf("Decimating the contours...");
decimate->Update();
printf("Done\n");
printf("Smoothing the contours after decimation...");
vtkSmartPointer<vtkSmoothPolyDataFilter> smoothfinal = vtkSmartPointer<vtkSmoothPolyDataFilter>::New();
smoothfinal->SetRelaxationFactor(0.2);
smoothfinal->SetInputData(decimate->GetOutput());
smoothfinal->SetNumberOfIterations(0);
smoothfinal->Update();
printf("Done\n");
delete [] carray;
vtkSmartPointer<vtkPolyData> out = smoothfinal->GetOutput();
return out;
}
InputImageType::Pointer Curvelet::RunOnInputImage(InputImageType::Pointer InputImage)
{
//InputImage = NewInputImage;
slices = InputImage->GetLargestPossibleRegion().GetSize()[2];
InputImageType::Pointer outputim = InputImageType::New();
outputim->SetRegions(InputImage->GetLargestPossibleRegion());
outputim->Allocate();
FloatImageType::Pointer cosim = FloatImageType::New();
cosim->SetRegions(InputImage->GetLargestPossibleRegion());
cosim->Allocate();
FloatImageType::Pointer sinim = FloatImageType::New();
sinim->SetRegions(InputImage->GetLargestPossibleRegion());
sinim->Allocate();
if(outputim->GetBufferPointer() == NULL || cosim->GetBufferPointer() == NULL || sinim->GetBufferPointer() == NULL)
{
printf("Couldnt' allocate memory - 3.. going to crash now\n");
}
int max_dim = tile_size;
int xsize = InputImage->GetLargestPossibleRegion().GetSize()[0];
int ysize = InputImage->GetLargestPossibleRegion().GetSize()[1];
int kx = 0;int ky = 0;
kx = xsize /(max_dim-this->border);
ky = ysize /(max_dim-this->border);
int remx = xsize % (max_dim-this->border);
int remy = ysize % (max_dim-this->border);
if ( remx > 0 )
kx ++;
if ( remy > 0 )
ky ++;
for(int xco = 0; xco < kx; xco++)
{
for(int yco = 0; yco < ky; yco++)
{
InputImageType::SizeType imsize = InputImage->GetLargestPossibleRegion().GetSize();
InputImageType::IndexType index;
InputImageType::SizeType size;
InputImageType::RegionType region;
index.Fill(0);
size[0] = MIN((xco)*(max_dim-this->border)+max_dim-1,imsize[0]-1) - xco * (max_dim-this->border) +1;
size[1] = MIN((yco)*(max_dim-this->border)+max_dim-1,imsize[1]-1) - yco * (max_dim-this->border) +1;
size[2] = imsize[2];
InputImageType::Pointer imtile = InputImageType::New();
region.SetIndex(index);
region.SetSize(size);
imtile->SetRegions(region);
imtile->Allocate();
if(imtile->GetBufferPointer()==NULL)
printf("Couldn't allocate memory - 4 .. going to crash now\n");
InputImageType::RegionType region1;
index[0] = xco *(max_dim-this->border);
index[1] = yco *(max_dim-this->border);
index[2] = 0;
region1.SetIndex(index);
region1.SetSize(size);
typedef itk::ImageRegionIterator<InputImageType> IteratorType;
IteratorType iter1(InputImage,region1);
IteratorType iter2(imtile,region);
//printf("xco = %d yco = %d :\n",xco,yco);
region1.Print(std::cout);
region.Print(std::cout);
iter1.GoToBegin();
iter2.GoToBegin();
for(;!iter1.IsAtEnd();++iter1,++iter2)
{
iter2.Set(iter1.Get());
}
InputImageType::Pointer outputtile = InputImageType::New();
outputtile->SetRegions(imtile->GetLargestPossibleRegion());
outputtile->Allocate();
FloatImageType::Pointer cosimtile = FloatImageType::New();
cosimtile->SetRegions(imtile->GetLargestPossibleRegion());
cosimtile->Allocate();
FloatImageType::Pointer sinimtile = FloatImageType::New();
sinimtile->SetRegions(imtile->GetLargestPossibleRegion());
sinimtile->Allocate();
if(outputtile->GetBufferPointer() == NULL || cosimtile->GetBufferPointer()==NULL || sinimtile->GetBufferPointer() == NULL )
{
printf("Couldn't allocate memory - 5 .. going to crash now ..\n");
}
{
#pragma omp parallel for shared(cosimtile,imtile,sinimtile,outputtile) num_threads(numt)
for(int counter = 0; counter < slices; counter++)
{
//printf("Counter = %d\n",counter);
Input2DImageType::Pointer im2d = getSlice(imtile,counter);
Input2DImageType::Pointer om2d;
Float2DImageType::Pointer cosim2d,sinim2d;
//call single slice 2-d curvelets function
getCurveletsForOneSlice(im2d,om2d,cosim2d,sinim2d);
copyslice<InputPixelType>(om2d,outputtile,counter);
copyslice<float>(cosim2d,cosimtile,counter);
copyslice<float>(sinim2d,sinimtile,counter);
}
}
//printf("copying the tile\n");
if(xco != 0)
{
size[0] = size[0] - border/2;
index[0] = border/2;
}
if(xco != kx-1)
{
size[0] = size[0] - border/2;
}
if(yco != 0)
{
size[1] = size[1] - border/2;
index[1] = border/2;
}
if(yco != ky-1)
{
size[1] = size[1] - border/2;
}
size[2] = slices;
index[2] = 0;
region.SetIndex(index);
region.SetSize(size);
if(xco!=0)
{
index[0] = xco *(max_dim-border)+border/2;
}
if(yco!=0)
{
index[1] = yco *(max_dim-border)+border/2;
}
index[2] = 0;
region1.SetSize(size);
region1.SetIndex(index);
iter1 = IteratorType(outputim,region1);
iter2 = IteratorType(outputtile,region);
typedef itk::ImageRegionIterator<FloatImageType> FIteratorType;
FIteratorType iter3(cosim,region1);
FIteratorType iter4(cosimtile,region);
FIteratorType iter5(sinim,region1);
FIteratorType iter6(sinimtile, region);
iter1.GoToBegin();iter2.GoToBegin();
iter3.GoToBegin();iter4.GoToBegin();
iter5.GoToBegin();iter6.GoToBegin();
for(;!iter1.IsAtEnd();++iter1,++iter2,++iter3,++iter4,++iter5,++iter6)
{
iter1.Set(iter2.Get());
iter3.Set(iter4.Get());
iter5.Set(iter6.Get());
}
//printf("Done with copying the tile to full image\n");
}
}
return outputim;
}
void unmix_threshold(InputImageType::Pointer im[],InputImageType::Pointer om[],int n,int GFP_channel,int AF_channel, int thresh)
{
printf("Unnmixing %d channels ...\n",n);
InputImageType::SizeType size = im[0]->GetLargestPossibleRegion().GetSize();
printf("I'm here\n");
MedianFilterType::Pointer filt[15];
IteratorType iterator[15];
//IteratorType assigniter[15];
InputImageType::SizeType radius;
radius[0]=1;
radius[1]=1;
radius[2]=1;
InputImageType::SizeType imagesize = im[0]->GetLargestPossibleRegion().GetSize();
InputImageType::IndexType imageindex;
imageindex.Fill(0);
InputImageType::RegionType region;
region.SetSize(imagesize);
region.SetIndex(imageindex);
double max_values[15];
for(int counter=0; counter<n; counter++)
{
printf("\tPerforming median filtering on channel %d ...",counter+1);
filt[counter]=MedianFilterType::New();
filt[counter]->SetRadius(radius);
filt[counter]->SetInput(im[counter]);
filt[counter]->Update();
om[counter]=filt[counter]->GetOutput();
iterator[counter]=IteratorType(om[counter],om[counter]->GetLargestPossibleRegion());
iterator[counter].GoToBegin();
max_values[counter]=-1;
printf(" Done %d.\n",counter+1);
for(;!iterator[counter].IsAtEnd();++iterator[counter])
{
if(max_values[counter]<iterator[counter].Value())
max_values[counter] = iterator[counter].Value();
}
// printf("Max%d = %lf\n",counter,max_values[counter]);
iterator[counter].GoToBegin();
}
printf("Binarizing the Autofluoroscence Channel\n");
ThresholdFilterType::Pointer tfilter = ThresholdFilterType::New();
tfilter->SetInput(om[AF_channel]);
tfilter->SetLowerThreshold(thresh);
tfilter->SetUpperThreshold(255);
tfilter->SetInsideValue(255);
tfilter->SetOutsideValue(0);
om[AF_channel] = tfilter->GetOutput();
tfilter->Update();
//int total_voxels = size[0]*size[1]*size[2];
int num_processed = 0;
//Removing Small components
om[AF_channel] = getLargeComponents(om[AF_channel],thresh);
printf("\tComputing foreground in AF channel ... ");
for(;!iterator[0].IsAtEnd();)
{
num_processed++;
unsigned char temp = iterator[2].Value();///max_values[co];
if(temp > 0)
{
iterator[GFP_channel].Set(0);
//iterator[0].Set(0);
}
for(int co = 0; co<n; co++)
{
++iterator[co];
}
}
printf(" Done.\n");
}
void IntrinsicFeatureCalculator::GetDistanceToSurfaceMeasures(vtkSmartPointer<vtkTable> table, std::vector< ftk::Object::Point > surfacePoints)
{
typedef itk::Image< IPixelT, 3 > InputImageType;
typedef itk::Image< LPixelT, 3 > OutputImageType;
typedef itk::DanielssonDistanceMapImageFilter< OutputImageType, OutputImageType > DanielssonFilterType;
typedef itk::RescaleIntensityImageFilter< OutputImageType, OutputImageType > RescalerType;
typedef itk::ImageFileReader< InputImageType > ReaderType;
typedef itk::ImageFileWriter< InputImageType > InputWriterType;
typedef itk::ImageFileWriter< OutputImageType > WriterType;
typedef itk::LineIterator< OutputImageType > LineIteratorType;
vtkSmartPointer<vtkDoubleArray> column = vtkSmartPointer<vtkDoubleArray>::New();
column->SetName( "Dist_To_Surface" );
column->SetNumberOfValues( table->GetNumberOfRows() );
table->AddColumn(column);
OutputImageType::Pointer im;
im = OutputImageType::New();
OutputImageType::PointType origin;
origin[0] = 0;
origin[1] = 0;
origin[2] = 0;
im->SetOrigin( origin );
OutputImageType::IndexType start;
start[0] = 0; // first index on X
start[1] = 0; // first index on Y
start[2] = 0; // first index on Z
OutputImageType::Pointer temp_image = labelImage->GetItkPtr< LPixelT >(0,0);
itk::Size<3> im_size = temp_image->GetBufferedRegion().GetSize();
im_size[2] = 1;
InputImageType::RegionType region;
region.SetSize( im_size );
region.SetIndex( start );
im->SetRegions( region );
im->Allocate();
im->FillBuffer(0);
im->Update();
//copy the input image into the ITK image
for(int p = 1; p < (int)surfacePoints.size(); ++p)
{
itk::Index<3> indx,indy;
indx[0] = surfacePoints[p-1].x;
indx[1] = surfacePoints[p-1].y;
indx[2] = 0;
indy[0] = surfacePoints[p].x;
indy[1] = surfacePoints[p].y;
indy[2] = 0;
LineIteratorType it( im, indx, indy );
//it.GoToBegin();
//while(!it.IsAtEnd())
for(it.GoToBegin(); !it.IsAtEnd(); ++it)
{
it.Set(255);
}
}
DanielssonFilterType::Pointer danielssonFilter = DanielssonFilterType::New();
WriterType::Pointer writer = WriterType::New();
danielssonFilter->SetInput( im );
writer->SetFileName( "DistanceMap.tif" );
danielssonFilter->InputIsBinaryOn();
danielssonFilter->Update();
OutputImageType::Pointer distMap = danielssonFilter->GetOutput();
writer->SetInput( distMap );
writer->Update();
for(int row=0; row<(int)table->GetNumberOfRows(); ++row)
{
OutputImageType::IndexType indx;
indx[0] = table->GetValue(row, 1).ToInt();
indx[1] = table->GetValue(row, 2).ToInt();
indx[2] = 0;
int dist = distMap->GetPixel(indx);
table->SetValueByName(row, "Dist_To_Surface", vtkVariant(dist));
}
}