Input2DImageType::Pointer Curvelet::getSlice(InputImageType::Pointer im, int slice)
{
Input2DImageType::Pointer out = Input2DImageType::New();
Input2DImageType::SizeType size;
size[0] = im->GetLargestPossibleRegion().GetSize()[0];
size[1] = im->GetLargestPossibleRegion().GetSize()[1];
Input2DImageType::IndexType index;
index.Fill(0);
Input2DImageType::RegionType region;
region.SetSize(size);
region.SetIndex(index);
out->SetRegions(region);
out->Allocate();
if(out->GetBufferPointer()==NULL)
printf("Could not allocate memory -1 ... I'm going to crash any moment now.. \n");
memcpy(out->GetBufferPointer(),im->GetBufferPointer()+slice*size[0]*size[1],size[0]*size[1]*sizeof(unsigned char));
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;
}