BoundingBoxType::Pointer SBImageUtils::GetBoundingBox(ImageType::Pointer image)
{
ConstIteratorType constIterator(image, image->GetLargestPossibleRegion());
IteratorType iterator(image, image->GetLargestPossibleRegion());
PointSetType::Pointer pointSet = PointSetType::New();
PointsContainerPointer points = pointSet->GetPoints();
int pointCounter=0;
for (iterator.GoToBegin(), constIterator.GoToBegin(); !iterator.IsAtEnd(); ++iterator, ++constIterator) {
if(constIterator.Value() == 0)
{
ImageType::IndexType index = constIterator.GetIndex();
PointType point;
point[0] = index[0];
point[1] = index[1];
points->InsertElement(pointCounter, point);
pointCounter++;
}
}
BoundingBoxType::Pointer boundingBox = BoundingBoxType::New();
boundingBox->SetPoints(points);
boundingBox->ComputeBoundingBox();
return boundingBox;
}
void Form::on_btnOpen_clicked()
{
QString fileName = QFileDialog::getOpenFileName(this, "Open File", ".", "Image Files (*.jpg *.jpeg *.bmp *.png)");
std::cout << "Got filename: " << fileName.toStdString() << std::endl;
if(fileName.toStdString().empty())
{
std::cout << "Filename was empty." << std::endl;
return;
}
/*
typedef itk::RGBPixel<unsigned char> RGBPixelType;
typedef itk::Image<RGBPixelType> RGBImageType;
typedef itk::ImageFileReader<RGBImageType> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(fileName.toStdString());
reader->Update();
RGBImageType::Pointer itkimage = reader->GetOutput();
*/
//typedef itk::VectorImage<unsigned char, 2> ImageType;
typedef itk::VectorImage<char, 2> ImageType;
typedef itk::ImageFileReader<ImageType> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(fileName.toStdString());
reader->Update();
ImageType::Pointer itkimage = reader->GetOutput();
QImage image(itkimage->GetLargestPossibleRegion().GetSize()[0], itkimage->GetLargestPossibleRegion().GetSize()[1], QImage::Format_RGB32);
itk::ImageRegionIterator<ImageType> imageIterator(itkimage, itkimage->GetLargestPossibleRegion());
QColor black(0,0,0);
while(!imageIterator.IsAtEnd())
{
ImageType::PixelType pixel = imageIterator.Get();
//QRgb qtPixel(pixel[0], pixel[1], pixel[2]);
//image.setPixel(imageIterator.GetIndex()[0], imageIterator.GetIndex()[1], QColor(pixel[0], pixel[1], pixel[2]).rgb());
image.setPixel(imageIterator.GetIndex()[0], imageIterator.GetIndex()[1], black.rgb());
++imageIterator;
}
//QPixmap image;
//image.loadFromData(itkimage->GetBufferPointer());
QGraphicsScene* scene = new QGraphicsScene();
//scene->addPixmap(image);
scene->addPixmap(QPixmap::fromImage(image));
this->graphicsView->setScene(scene);
}
// ------------------------------------------------------------------------
void buildOutput(const SeriesTransform::List &series, ImageType::Pointer &outputImage,
ImageType::Pointer &outputLabel, const unsigned int & timestep)
{
// get the output parameters
unsigned int slices = series.size();
unsigned int timeSteps = series.front().images.size();
ImageType::Pointer ref = series.front().images.front();
ImageType::SpacingType spacing = ref->GetSpacing();
spacing[2] = series.front().sliceThickness;
ImageType::DirectionType direction = ref->GetDirection();
ImageType::PointType origin = ref->GetOrigin();
ImageType::RegionType region = ref->GetLargestPossibleRegion();
region.SetSize(2,slices);
// create the outputs
outputImage->SetSpacing(spacing);
outputImage->SetDirection(direction);
outputImage->SetOrigin(origin);
outputImage->SetRegions(region);
outputImage->Allocate();
outputLabel->SetSpacing(spacing);
outputLabel->SetDirection(direction);
outputLabel->SetOrigin(origin);
outputLabel->SetRegions(region);
outputLabel->Allocate();
itk::ImageRegionIterator<ImageType> outLIt(outputLabel, outputLabel->GetLargestPossibleRegion());
itk::ImageRegionIterator<ImageType> outImIt(outputImage, outputImage->GetLargestPossibleRegion());
// loop through the slices
for(unsigned int i = 0; i < slices; i++)
{
ImageType::Pointer im = series[i].images[timestep];
ImageType::Pointer label = series[i].labelImages[timestep];
itk::ImageRegionConstIterator<ImageType> imIt(im, im->GetLargestPossibleRegion());
itk::ImageRegionConstIterator<ImageType> lIt(label, label->GetLargestPossibleRegion());
while(!imIt.IsAtEnd())
{
outLIt.Set(lIt.Get());
outImIt.Set(imIt.Get());
++imIt; ++lIt;
++outLIt; ++outImIt;
}
}
}
void Vector()
{
std::cout << "Vector()" << std::endl;
std::vector<float> vec(patchRadius*patchRadius);
ImageType::Pointer image = ImageType::New();
CreateImage(image);
itk::Index<2> center = {{imageSize/2, imageSize/2}};
itk::ImageRegion<2> centerRegion = GetRegionInRadiusAroundPixel(center, patchRadius);
std::vector<float> centerDescriptor = MakeDescriptor(centerRegion, image);
std::vector<std::vector<float> > allDescriptors;
{
itk::ImageRegionIterator<ImageType> imageIterator(image, image->GetLargestPossibleRegion());
while(!imageIterator.IsAtEnd())
{
itk::ImageRegion<2> region = GetRegionInRadiusAroundPixel(imageIterator.GetIndex(), patchRadius);
if(image->GetLargestPossibleRegion().IsInside(region))
{
allDescriptors.push_back(MakeDescriptor(region, image));
}
++imageIterator;
}
}
std::cout << "There are " << allDescriptors.size() << " descriptors." << std::endl;
std::cout << "There are " << allDescriptors[0].size() << " elements per descriptor." << std::endl;
itk::TimeProbe clock1;
clock1.Start();
float totalDifference = 0.0f;
for(unsigned int outerLoop = 0; outerLoop < numberOfOuterLoops; ++outerLoop)
{
for(unsigned int i = 0; i < allDescriptors.size(); ++i)
{
totalDifference += Difference(centerDescriptor, allDescriptors[i]);
}
}
clock1.Stop();
std::cout << "Total time: " << clock1.GetTotal() << std::endl;
std::cout << "Total difference: " << totalDifference << std::endl;
}
void setup_snapshot_image(string basename, ImageType::Pointer model)
{
ImageType::SpacingType spacing = model->GetSpacing();
spacing[0] /= constants::SnapshotImageZoom;
spacing[1] /= constants::SnapshotImageZoom;
spacing[2] /= constants::SnapshotImageZoom;
g_snapshot_image = ImageType::New();
g_snapshot_image->SetSpacing( spacing );
g_snapshot_image->SetOrigin( model->GetOrigin() );
ImageType::RegionType const& region = model->GetLargestPossibleRegion();
ImageType::RegionType::SizeType size = region.GetSize();
// size is in pixels
ImageType::SizeType doubled_size(size);
doubled_size[0] *= constants::SnapshotImageZoom;
doubled_size[1] *= constants::SnapshotImageZoom;
doubled_size[2] *= constants::SnapshotImageZoom;
g_snapshot_image->SetRegions( doubled_size );
g_snapshot_image->Allocate();
s_snapshot_basename = basename;
}
int main(int, char* [] )
{
typedef itk::Image<unsigned char, 2> ImageType;
ImageType::Pointer image = ImageType::New();
CreateImage(image.GetPointer());
const unsigned int numberOfIterations = 1e5;
// Create a list of the indices in the image
itk::ImageRegionConstIteratorWithIndex<ImageType> imageIterator(image, image->GetLargestPossibleRegion());
std::vector<itk::Index<2> > indices;
while(!imageIterator.IsAtEnd())
{
indices.push_back(imageIterator.GetIndex());
++imageIterator;
}
unsigned int total = 0; // To make sure the loop isn't optimized away
for(unsigned int i = 0; i < numberOfIterations; ++i)
{
// total += Iterator(image.GetPointer()); // 1.4s
total += GetPixel(image.GetPointer(), indices); // 5.9s
}
std::cout << "total " << total << std::endl; // To make sure the loop isn't optimized away
return 0;
}
/*
* random a voxel. define plane through this voxel. reslice at the plane. compare the pixel vaues of the voxel
* in the volume with the pixel value in the resliced image.
* there are some indice shifting problems which causes the test to fail for oblique planes. seems like the chosen
* worldcoordinate is not corrresponding to the index in the 2D image. and so the pixel values are not the same as
* expected.
*/
static void PixelvalueBasedTest()
{
/* setup itk image */
typedef itk::Image<unsigned short, 3> ImageType;
typedef itk::ImageRegionConstIterator< ImageType > ImageIterator;
ImageType::Pointer image = ImageType::New();
ImageType::IndexType start;
start[0] = start[1] = start[2] = 0;
ImageType::SizeType size;
size[0] = size[1] = size[2] = 32;
ImageType::RegionType imgRegion;
imgRegion.SetSize(size);
imgRegion.SetIndex(start);
image->SetRegions(imgRegion);
image->SetSpacing(1.0);
image->Allocate();
ImageIterator imageIterator( image, image->GetLargestPossibleRegion() );
imageIterator.GoToBegin();
unsigned short pixelValue = 0;
//fill the image with distinct values
while ( !imageIterator.IsAtEnd() )
{
image->SetPixel(imageIterator.GetIndex(), pixelValue);
++imageIterator;
++pixelValue;
}
/* end setup itk image */
mitk::Image::Pointer imageInMitk;
CastToMitkImage(image, imageInMitk);
/*mitk::ImageWriter::Pointer writer = mitk::ImageWriter::New();
writer->SetInput(imageInMitk);
std::string file = "C:\\Users\\schroedt\\Desktop\\cube.nrrd";
writer->SetFileName(file);
writer->Update();*/
PixelvalueBasedTestByPlane(imageInMitk, mitk::PlaneGeometry::Frontal);
PixelvalueBasedTestByPlane(imageInMitk, mitk::PlaneGeometry::Sagittal);
PixelvalueBasedTestByPlane(imageInMitk, mitk::PlaneGeometry::Axial);
}
int main(int argc, char *argv[])
{
// Verify arguments
if(argc < 6)
{
std::cerr << "Required: outputFilename sizeX sizeY components value" << std::endl;
return EXIT_FAILURE;
}
// Parse arguments
std::string outputFilename = argv[1];
std::stringstream ss;
ss << argv[2] << " " << argv[3] << " " << argv[4];
itk::Size<2> size = {{0,0}};
unsigned int components = 0;
float value = 0.0f;
ss >> size[0] >> size[1] >> components >> value;
// Output arguments
std::cout << "outputFilename " << outputFilename << std::endl;
std::cout << "size " << size << std::endl;
std::cout << "value " << value << std::endl;
ImageType::Pointer image = ImageType::New();
itk::Index<2> index = {{0,0}};
itk::ImageRegion<2> region(index, size);
image->SetRegions(region);
image->SetNumberOfComponentsPerPixel(components);
image->Allocate();
typename itk::ImageRegionIterator<ImageType> imageIterator(image, image->GetLargestPossibleRegion());
ImageType::PixelType pixel;
pixel.SetSize(components);
pixel.Fill(value);
while(!imageIterator.IsAtEnd())
{
imageIterator.Set(pixel);
++imageIterator;
}
// Write the result
typedef itk::ImageFileWriter<ImageType> WriterType;
WriterType::Pointer writer = WriterType::New();
writer->SetFileName(outputFilename);
writer->SetInput(image);
writer->Update();
return EXIT_SUCCESS;
}
// ------------------------------------------------------------------------
void createOutput(const ImageType::Pointer &input, ImageType::Pointer &output)
{
output->SetDirection(input->GetDirection());
output->SetSpacing(input->GetSpacing());
output->SetRegions(input->GetLargestPossibleRegion());
output->SetOrigin(input->GetOrigin());
output->Allocate();
output->FillBuffer(0);
}
void ITKImage()
{
std::cout << "ITKImage()" << std::endl;
ImageType::Pointer image = ImageType::New();
CreateImage(image);
itk::Index<2> center = {{imageSize/2, imageSize/2}};
itk::ImageRegion<2> centerRegion = GetRegionInRadiusAroundPixel(center, patchRadius);
std::vector<itk::ImageRegion<2> > allRegions;
{
itk::ImageRegionIterator<ImageType> imageIterator(image, image->GetLargestPossibleRegion());
while(!imageIterator.IsAtEnd())
{
itk::ImageRegion<2> region = GetRegionInRadiusAroundPixel(imageIterator.GetIndex(), patchRadius);
if(image->GetLargestPossibleRegion().IsInside(region))
{
allRegions.push_back(region);
}
++imageIterator;
}
}
itk::TimeProbe clock1;
clock1.Start();
float totalDifference = 0.0f;
for(unsigned int outerLoop = 0; outerLoop < numberOfOuterLoops; ++outerLoop)
{
for(size_t regionId = 0; regionId < allRegions.size(); ++regionId)
{
totalDifference += Difference(allRegions[regionId], centerRegion, image);
}
}
clock1.Stop();
std::cout << "Total time: " << clock1.GetTotal() << std::endl;
std::cout << "Total difference: " << totalDifference << std::endl;
}
// ------------------------------------------------------------------------
void buildShortAxisVolume(const SeriesTransform::Map &transforms,
const unsigned int seriesNumber, ImageType::Pointer &saVolume)
{
// get the short axis transforms
SeriesTransform::Map::const_iterator mapIt = transforms.begin();
std::vector<SeriesTransform> saSlices;
while(mapIt != transforms.end())
{
if(mapIt->second.series == seriesNumber)
{
unsigned int sliceNum = mapIt->second.slice;
if(saSlices.size() < (sliceNum+1))
saSlices.resize(sliceNum+1);
saSlices[sliceNum] = mapIt->second;
}
++mapIt;
}
// get the dimensions of the output image
ImageType::Pointer reference = saSlices[0].images[0];
unsigned int x,y,z;
x = reference->GetLargestPossibleRegion().GetSize()[0];
y = reference->GetLargestPossibleRegion().GetSize()[1];
z = saSlices.size();
ImageType::RegionType region;
ImageType::SizeType size;
ImageType::IndexType index;
size[0] = x;
size[1] = y;
size[2] = z;
index.Fill(0);
region.SetSize(size);
region.SetIndex(index);
// get the other parts
ImageType::SpacingType spacing = reference->GetSpacing();
spacing[2] = saSlices[0].sliceThickness;
ImageType::DirectionType direction = reference->GetDirection();
ImageType::PointType origin = reference->GetOrigin();
saVolume->SetOrigin(origin);
saVolume->SetDirection(direction);
saVolume->SetSpacing(spacing);
saVolume->SetRegions(region);
saVolume->Allocate();
saVolume->FillBuffer(0);
}
int main(int argc, char* *argv)
{
GetPot cl(argc, argv);
if( cl.size() == 1 || cl.search(2, "--help", "-h") )
{
std::cout << "Not enough arguments" << std::endl;
return -1;
}
const string image_n = cl.follow("NoFile", 1, "-i");
typedef itk::Image<float, 3> ImageType;
typedef itk::ImageFileReader<ImageType> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(image_n.c_str());
reader-> Update();
ImageType::Pointer image = reader->GetOutput();
typedef itk::ImageRegionIterator<ImageType> ImageIterator;
ImageIterator it(image, image->GetLargestPossibleRegion());
for (it.GoToBegin(); !it.IsAtEnd(); ++it)
{
if (it.Get() < -5 )
{
it.Set(1.0);
std::cout << it.GetIndex() << std::endl;
}
else if (it.Get() > 5 )
{
it.Set(1.0);
std::cout << it.GetIndex() << std::endl;
}
else
{
it.Set(0.0);
}
}
typedef itk::ImageFileWriter<ImageType> WriterType;
WriterType::Pointer writer = WriterType::New();
writer->SetFileName("Trace_mask.nii.gz");
writer->SetInput(image);
writer->Update();
return 0;
}
ComposeImageFilter::ImageType::IndexType ComposeImageFilter::ComputeImageIndex(long int N, ImageType::Pointer image)
{
ImageType::IndexType index;
ImageType::SizeType size = image->GetLargestPossibleRegion().GetSize();
std::div_t div_1, div_2;
long int temp1=size[0]*size[1];
div_1 = div(N,temp1);
index[2]=div_1.quot;
long int temp2=size[0];
div_2 = div(div_1.rem, temp2);
index[1]=div_2.quot;
index[0]=div_2.rem;
return index;
}
//get number of slices
int CTImageTreeItem::getNumberOfSlices() const {
ImageType::Pointer itkImage = peekITKImage();
if (itkImage.IsNotNull()) {
ImageType::RegionType imageRegion = itkImage->GetLargestPossibleRegion();
return static_cast<uint>(imageRegion.GetSize(2));
} else {
int num = m_fnList.size();
if (num > 1)
return num;
else {
std::string t;
itk::ExposeMetaData( m_dict, getNumberOfFramesTag(), t );
std::istringstream buffer(t);
buffer >> num;
return num;
}
}
}
bool VolumeProcess:: RunFillingZeroOnBouandary(int Bx,int By,int Bz)
{
ImageType::Pointer tempImg = ImageType::New();
tempImg->SetRegions( m_outputImage->GetLargestPossibleRegion() );
tempImg->Allocate();
tempImg->FillBuffer(0);
ImageType::RegionType fullRegion = m_outputImage->GetBufferedRegion();
int numColumns = fullRegion.GetSize(0);
int numRows = fullRegion.GetSize(1);
int numStacks = fullRegion.GetSize(2);
int i, j,k;
itk::ImageRegionIteratorWithIndex< ImageType > itr( m_outputImage, fullRegion );
for(itr.GoToBegin(); !itr.IsAtEnd(); ++itr)
{
ImageType::IndexType index = itr.GetIndex();
ImageType::PixelType pix = m_outputImage->GetPixel(index);
i = index[0];
j = index[1];
k = index[2];
if (i < Bx || i > numColumns -Bx || j < By || j > numRows-By ||k <Bz ||k > numStacks-Bz )
tempImg->SetPixel(itr.GetIndex(), 0);
else
tempImg->SetPixel(itr.GetIndex(), pix);
}
//Copy temp img back to image
itk::ImageRegionIterator< ImageType > itr1( tempImg, tempImg->GetLargestPossibleRegion());
itk::ImageRegionIterator< ImageType > itr2( m_outputImage, m_outputImage->GetLargestPossibleRegion());
for(itr1.GoToBegin(), itr2.GoToBegin() ; !itr1.IsAtEnd(); ++itr1, ++itr2)
{
itr2.Set( itr1.Get() );
}
if(debug)
std::cerr << "RunFillingZero Done" << std::endl;
return true;
}
std::vector<cleaver::AbstractScalarField*>
NRRDTools::loadNRRDFiles(std::vector<std::string> files,
double sigma) {
std::vector<cleaver::AbstractScalarField*> fields;
size_t num = 0;
for (auto file : files) {
// read file using ITK
if (file.find(".nrrd") != std::string::npos) {
itk::NrrdImageIOFactory::RegisterOneFactory();
} else if (file.find(".mha") != std::string::npos) {
itk::MetaImageIOFactory::RegisterOneFactory();
}
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(file);
reader->Update();
//do some blurring
GaussianBlurType::Pointer blur = GaussianBlurType::New();
blur->SetInput(reader->GetOutput());
blur->SetVariance(sigma * sigma);
blur->Update();
ImageType::Pointer img = blur->GetOutput();
//convert the image to a cleaver "abstract field"
auto region = img->GetLargestPossibleRegion();
auto numPixel = region.GetNumberOfPixels();
float *data = new float[numPixel];
auto x = region.GetSize()[0], y = region.GetSize()[1], z = region.GetSize()[2];
fields.push_back(new cleaver::FloatField(data, x, y, z));
auto beg = file.find_last_of("/") + 1;
auto name = file.substr(beg, file.size() - beg);
fields[num]->setName(name);
itk::ImageRegionConstIterator<ImageType> imageIterator(img, region);
size_t pixel = 0;
while (!imageIterator.IsAtEnd()) {
// Get the value of the current pixel
float val = static_cast<float>(imageIterator.Get());
((cleaver::FloatField*)fields[num])->data()[pixel++] = val;
++imageIterator;
}
((cleaver::FloatField*)fields[num])->setScale(cleaver::vec3(1., 1., 1.));
num++;
}
return fields;
}
void TestUpsample()
{
typedef itk::Image<unsigned char, 2> ImageType;
ImageType::Pointer image = ImageType::New();
itk::Index<2> corner = {{0,0}};
itk::Size<2> size = {{100,100}};
itk::ImageRegion<2> region(corner, size);
image->SetRegions(region);
image->Allocate();
ImageType::Pointer upsampled = ImageType::New();
ITKHelpers::Upsample(image.GetPointer(), 2, upsampled.GetPointer());
std::cout << "TestUpsample() output size: "
<< upsampled->GetLargestPossibleRegion().GetSize() << std::endl;
}
// ------------------------------------------------------------------------
void getImageBounds(const ImageType::Pointer &image, BoundsType &bounds)
{
// get the image size
ImageType::SizeType size = image->GetLargestPossibleRegion().GetSize();
typedef ImageType::IndexType IndexType;
IndexType ind1, ind2, ind3, ind4;
ind1.Fill(0); ind2.Fill(0); ind3.Fill(0); ind4.Fill(0);
ind2[0] = size[0]-1;
ind3[1] = size[1]-1;
ind4[0] = size[0]-1;
ind4[1] = size[1]-1;
image->TransformIndexToPhysicalPoint(ind1, bounds.corners[0]);
image->TransformIndexToPhysicalPoint(ind2, bounds.corners[1]);
image->TransformIndexToPhysicalPoint(ind3, bounds.corners[2]);
image->TransformIndexToPhysicalPoint(ind4, bounds.corners[3]);
}
int main (int argc, char *argv[])
{
const unsigned int ImageDimension = 2;
GetPot cl (argc, const_cast<char**>(argv));
if( cl.size() == 1 || cl.search (2,"--help","-h") )
{
std::cout << "Not Enough Arguments" << std::endl;
std::cout << "Generate the Gradient Table" << std::endl;
std::cout << "Usage: return -1" << std::endl;
}
const string image_n = cl.follow("NoFile",1, "-i");
const string out_n = cl.follow("NoFile",1, "-o");
typedef itk::DiffusionTensor3D<float> DiffusionTensorType;
typedef itk::Image<DiffusionTensorType, 3> ImageType;
typedef itk::ImageFileReader<ImageType> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(image_n);
reader->Update();
ImageType::Pointer image = reader->GetOutput();
typedef itk::ImageRegionIterator<ImageType> TensorIterator;
TensorIterator itImg(image, image->GetLargestPossibleRegion());
std::ofstream file;
file.open(out_n);
for(itImg.GoToBegin(); !itImg.IsAtEnd(); ++itImg)
{
file << itImg.Get() << std::endl;
}
file.close();
return 0;
}
// ------------------------------------------------------------------------
void OpenCVValve::ConvertImage(const ImageType::Pointer &input, MatPtr &mat)
{
// cast the image to uchar
typedef itk::Image<unsigned char, 2> OutputImageType;
typedef itk::RescaleIntensityImageFilter<ImageType, OutputImageType> CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetOutputMaximum(255);
caster->SetOutputMinimum(0);
caster->SetInput(input);
caster->Update();
OutputImageType::Pointer output = caster->GetOutput();
typedef itk::ImageFileWriter<OutputImageType> WriterType;
WriterType::Pointer writer = WriterType::New();
writer->SetImageIO(itk::PNGImageIO::New());
writer->SetInput(output);
writer->SetFileName("test.png");
writer->Update();
ImageType::SizeType size = input->GetLargestPossibleRegion().GetSize();
unsigned int rows = size[1];
unsigned int cols = size[0];
mat = new MatType(rows,cols, CV_8UC1);
itk::ImageRegionConstIterator<OutputImageType> it(output, output->GetLargestPossibleRegion());
it.GoToBegin();
while(!it.IsAtEnd())
{
OutputImageType::IndexType index = it.GetIndex();
unsigned char val = it.Get();
mat->at<unsigned char>(cv::Point(index[0], index[1])) = val;
++it;
}
}
// ------------------------------------------------------------------------
void createLabelImage(const SeriesTransform &series,
const ImageType::Pointer &reference,
const LevelSetType::Pointer &levelSet,
const std::vector<int> &roiOffset,
ImageType::Pointer &label,
unsigned int instance)
{
// initialise the label image
createOutput(series.images[instance], label);
// create the level set interpolator
typedef itk::LinearInterpolateImageFunction<LevelSetType> InterpolatorType;
InterpolatorType::Pointer interpolator = InterpolatorType::New();
interpolator->SetInputImage(levelSet);
// iterate through the output
itk::ImageRegionIterator<ImageType> it(label, label->GetLargestPossibleRegion());
it.GoToBegin();
while(!it.IsAtEnd())
{
ImageType::IndexType index = it.GetIndex();
ImageType::PointType p1, p2;
// get the point in the level set space
label->TransformIndexToPhysicalPoint(index, p1);
transformPointToPatient(reference, series, roiOffset, p1, p2);
// interpolate the level set value
if(interpolator->IsInsideBuffer(p2))
{
float val = interpolator->Evaluate(p2);
if(val >= 0) it.Set(1);
}
++it;
}
}
void TestHistogramOfGradients()
{
typedef itk::Image<float, 2> ImageType;
ImageType::Pointer image = ImageType::New();
itk::Index<2> corner = {{0,0}};
itk::Size<2> size = {{100,100}};
itk::ImageRegion<2> region(corner, size);
image->SetRegions(region);
image->Allocate();
std::vector<float> histogram =
ITKHelpers::HistogramOfGradients(image.GetPointer(),
image->GetLargestPossibleRegion(), 10);
for(unsigned int i = 0; i < histogram.size(); ++i)
{
std::cout << histogram[i] << " ";
}
std::cout << std::endl;
}
int main(int argc, char *argv[])
{
if(argc < 3)
{
std::cerr << "Required: inputFilename outputFilename" << std::endl;
return EXIT_FAILURE;
}
std::string inputFilename = argv[1];
std::string outputFilename = argv[2];
typedef itk::ImageFileReader<ImageType> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(inputFilename.c_str());
reader->Update();
ImageType::Pointer output = ImageType::New();
output->SetNumberOfComponentsPerPixel(reader->GetOutput()->GetNumberOfComponentsPerPixel());
output->SetRegions(reader->GetOutput()->GetLargestPossibleRegion());
output->Allocate();
itk::ImageRegionIterator<ImageType> outputIterator(output, output->GetLargestPossibleRegion());
while(!outputIterator.IsAtEnd())
{
outputIterator.Set(reader->GetOutput()->GetPixel(outputIterator.GetIndex()));
++outputIterator;
}
typedef itk::ImageFileWriter<ImageType> WriterType;
WriterType::Pointer writer = WriterType::New();
writer->SetFileName(outputFilename);
writer->SetInput(output);
writer->Update();
return EXIT_SUCCESS;
}
bool TestComputeGradientsInRegion()
{
itk::Index<2> imageCorner = {{0,0}};
itk::Size<2> imageSize = {{100,100}};
itk::ImageRegion<2> imageRegion(imageCorner, imageSize);
typedef itk::Image<unsigned char, 2> ImageType;
ImageType::Pointer image = ImageType::New();
image->SetRegions(imageRegion);
image->Allocate();
itk::ImageRegionIterator<ImageType> imageIterator(image, image->GetLargestPossibleRegion());
while(!imageIterator.IsAtEnd())
{
imageIterator.Set(rand() % 255);
++imageIterator;
}
ITKHelpers::WriteImage(image.GetPointer(), "Image.mha");
itk::Index<2> regionCorner = {{50,50}};
itk::Size<2> regionSize = {{10,10}};
itk::ImageRegion<2> region(regionCorner, regionSize);
typedef itk::Image<itk::CovariantVector<float, 2>, 2> GradientImageType;
GradientImageType::Pointer gradientImage = GradientImageType::New();
std::cout << "Computing gradients..." << std::endl;
ITKHelpers::ComputeGradientsInRegion(image.GetPointer(), region, gradientImage.GetPointer());
std::cout << "Writing..." << std::endl;
ITKHelpers::WriteImage(gradientImage.GetPointer(), "GradientImage.mha");
return true;
}
ImageType::Pointer SBImageUtils::ResizeImage(ImageType::Pointer input, uint width, uint height)
{
ResampleImageFilterType::Pointer resample = ResampleImageFilterType::New();
ImageType::SizeType outputSize;
outputSize.Fill(width);
ImageType::SizeType inputSize = input->GetLargestPossibleRegion().GetSize();
ImageType::SpacingType outputSpacing;
outputSpacing[0] = input->GetSpacing()[0] * (static_cast<double>(inputSize[0]) / static_cast<double>(outputSize[0]));
outputSpacing[1] = input->GetSpacing()[1] * (static_cast<double>(inputSize[1]) / static_cast<double>(outputSize[1]));
//default will be white
resample->SetDefaultPixelValue(0xFFFF);
resample->SetInput(input);
resample->SetSize(outputSize);
resample->SetOutputSpacing(outputSpacing);
resample->SetTransform(TransformType::New());
resample->UpdateLargestPossibleRegion();
return resample->GetOutput();
}
void NrrdQBallImageReader
::GenerateData()
{
if ( m_FileName == "")
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename of the vessel tree to be read is empty!");
}
else
{
try
{
const std::string& locale = "C";
const std::string& currLocale = setlocale( LC_ALL, NULL );
if ( locale.compare(currLocale)!=0 )
{
try
{
setlocale(LC_ALL, locale.c_str());
}
catch(...)
{
MITK_INFO << "Could not set locale " << locale;
}
}
typedef itk::VectorImage<float,3> ImageType;
itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
typedef itk::ImageFileReader<ImageType> FileReaderType;
FileReaderType::Pointer reader = FileReaderType::New();
reader->SetImageIO(io);
reader->SetFileName(this->m_FileName);
reader->Update();
ImageType::Pointer img = reader->GetOutput();
typedef itk::Image<itk::Vector<float,QBALL_ODFSIZE>,3> VecImgType;
VecImgType::Pointer vecImg = VecImgType::New();
vecImg->SetSpacing( img->GetSpacing() ); // Set the image spacing
vecImg->SetOrigin( img->GetOrigin() ); // Set the image origin
vecImg->SetDirection( img->GetDirection() ); // Set the image direction
vecImg->SetLargestPossibleRegion( img->GetLargestPossibleRegion());
vecImg->SetBufferedRegion( img->GetLargestPossibleRegion() );
vecImg->Allocate();
itk::ImageRegionIterator<VecImgType> ot (vecImg, vecImg->GetLargestPossibleRegion() );
ot = ot.Begin();
itk::ImageRegionIterator<ImageType> it (img, img->GetLargestPossibleRegion() );
typedef ImageType::PixelType VarPixType;
typedef VecImgType::PixelType FixPixType;
for (it = it.Begin(); !it.IsAtEnd(); ++it)
{
VarPixType vec = it.Get();
FixPixType fixVec(vec.GetDataPointer());
ot.Set(fixVec);
++ot;
}
this->GetOutput()->InitializeByItk(vecImg.GetPointer());
this->GetOutput()->SetVolume(vecImg->GetBufferPointer());
try
{
setlocale(LC_ALL, currLocale.c_str());
}
catch(...)
{
MITK_INFO << "Could not reset locale " << currLocale;
}
}
catch(std::exception& e)
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
}
catch(...)
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested vessel tree file!");
}
}
}
int main(int argc, char* *argv)
{
GetPot cl(argc, argv);
if( cl.size() == 1 || cl.search(2, "--help", "-h") )
{
std::cout << "Not enough arguments" << std::endl;
return -1;
}
const string image_n = cl.follow("NoFile", 1, "-i");
const string maskImage_n = cl.follow("NoFile", 1, "-m");
typedef itk::Image<float, 3> ImageType;
typedef itk::ImageFileReader<ImageType> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(maskImage_n.c_str());
reader-> Update();
ImageType::Pointer maskimage = reader->GetOutput();
typedef itk::ImageRegionIterator<ImageType> ImageIterator;
ImageIterator it(maskimage, maskimage->GetLargestPossibleRegion());
typedef itk::DiffusionTensor3D<float> DiffusionTensorType;
typedef itk::Image<DiffusionTensorType, 3> TensorImageType;
typedef itk::ImageFileReader<TensorImageType> TensorImageReaderType;
TensorImageReaderType::Pointer tensorReader = TensorImageReaderType::New();
tensorReader->SetFileName(image_n.c_str());
tensorReader->Update();
TensorImageType::Pointer tensorImage = tensorReader->GetOutput();
typedef itk::ImageRegionIterator<TensorImageType> TensorIterator;
TensorIterator itT(tensorImage, tensorImage->GetLargestPossibleRegion());
typedef DiffusionTensorType::EigenValuesArrayType EigenArrayType;
ImageType::Pointer Eig1 = ImageType::New();
ImageType::Pointer Eig2 = ImageType::New();
ImageType::Pointer Eig3 = ImageType::New();
CopyImage cpImage;
cpImage.CopyScalarImage(maskimage, Eig1);
cpImage.CopyScalarImage(maskimage, Eig2);
cpImage.CopyScalarImage(maskimage, Eig3);
TensorImageType::Pointer tensorProb = TensorImageType::New();
cpImage.CopyTensorImage(tensorImage, tensorProb);
DiffusionTensorType D_Identity;
vnl_matrix<float> ZeroD_mat; ZeroD_mat.set_size(3,3);
ZeroD_mat.set_identity();
TensorUtilities utils;
D_Identity = utils.ConvertMat2DT(ZeroD_mat);
//tensorProb->FillBuffer(D_Identity);
for (it.GoToBegin(), itT.GoToBegin(); !it.IsAtEnd(), !itT.IsAtEnd(); ++it, ++itT)
{
if (it.Get() != 0)
{
EigenArrayType eig;
DiffusionTensorType D = itT.Get();
D.ComputeEigenValues(eig);
if ( (eig[0] < 0) || (eig[1] < 0 ) || (eig[2] < 0) || eig[0] > 5 || (eig[1] > 5) || (eig[2] > 5))
{
tensorProb->SetPixel(itT.GetIndex(), D);
std::cout << eig << std::endl;
}
}
}
typedef itk::ImageFileWriter<TensorImageType> TensorImageWriter;
TensorImageWriter::Pointer tensorWriter = TensorImageWriter::New();
tensorWriter->SetFileName("TensorImage_Prob.nii.gz");
tensorWriter->SetInput(tensorProb);
tensorWriter->Update();
return 0;
}
std::vector<itk::SmartPointer<BaseData> > NrrdTensorImageReader::Read()
{
std::vector<itk::SmartPointer<mitk::BaseData> > result;
std::string location = GetInputLocation();
if ( location == "")
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename is empty!");
}
else
{
try
{
mitk::LocaleSwitch localeSwitch("C");
try
{
std::string fname3 = mitk::IOUtil::GetTempPath()+"/temp_dti.nii.gz";
int c = 0;
while( itksys::SystemTools::FileExists(fname3) )
{
fname3 = mitk::IOUtil::GetTempPath()+"/temp_dti_" + boost::lexical_cast<std::string>(c) + ".nii.gz";
++c;
}
itksys::SystemTools::CopyAFile(location.c_str(), fname3.c_str());
typedef itk::VectorImage<float,3> ImageType;
itk::NiftiImageIO::Pointer io = itk::NiftiImageIO::New();
typedef itk::ImageFileReader<ImageType> FileReaderType;
FileReaderType::Pointer reader = FileReaderType::New();
reader->SetImageIO(io);
reader->SetFileName(fname3);
reader->Update();
ImageType::Pointer img = reader->GetOutput();
TensorImage::ItkTensorImageType::Pointer vecImg = TensorImage::ItkTensorImageType::New();
vecImg->SetSpacing( img->GetSpacing() ); // Set the image spacing
vecImg->SetOrigin( img->GetOrigin() ); // Set the image origin
vecImg->SetDirection( img->GetDirection() ); // Set the image direction
vecImg->SetRegions( img->GetLargestPossibleRegion());
vecImg->Allocate();
itk::ImageRegionIterator<TensorImage::ItkTensorImageType> ot (vecImg, vecImg->GetLargestPossibleRegion() );
ot.GoToBegin();
itk::ImageRegionIterator<ImageType> it (img, img->GetLargestPossibleRegion() );
it.GoToBegin();
typedef ImageType::PixelType VarPixType;
typedef TensorImage::PixelType FixPixType;
int numComponents = img->GetNumberOfComponentsPerPixel();
if (numComponents==6)
{
MITK_INFO << "Trying to load dti as 6-comp nifti ...";
while (!it.IsAtEnd())
{
VarPixType vec = it.Get();
FixPixType fixVec(vec.GetDataPointer());
TensorImage::PixelType tensor;
tensor.SetElement(0, vec.GetElement(0));
tensor.SetElement(1, vec.GetElement(1));
tensor.SetElement(2, vec.GetElement(2));
tensor.SetElement(3, vec.GetElement(3));
tensor.SetElement(4, vec.GetElement(4));
tensor.SetElement(5, vec.GetElement(5));
fixVec = tensor;
ot.Set(fixVec);
++ot;
++it;
}
}
else if(numComponents==9)
{
MITK_INFO << "Trying to load dti as 9-comp nifti ...";
while (!it.IsAtEnd())
{
VarPixType vec = it.Get();
TensorImage::PixelType tensor;
tensor.SetElement(0, vec.GetElement(0));
tensor.SetElement(1, vec.GetElement(1));
tensor.SetElement(2, vec.GetElement(2));
tensor.SetElement(3, vec.GetElement(4));
tensor.SetElement(4, vec.GetElement(5));
tensor.SetElement(5, vec.GetElement(8));
FixPixType fixVec(tensor);
ot.Set(fixVec);
++ot;
++it;
}
}
else if (numComponents==1)
{
MITK_INFO << "Trying to load dti as 4D nifti ...";
typedef itk::Image<float,4> ImageType;
typedef itk::ImageFileReader<ImageType> FileReaderType;
FileReaderType::Pointer reader = FileReaderType::New();
reader->SetImageIO(io);
reader->SetFileName(fname3);
reader->Update();
ImageType::Pointer img = reader->GetOutput();
itk::Size<4> size = img->GetLargestPossibleRegion().GetSize();
while (!ot.IsAtEnd())
{
TensorImage::PixelType tensor;
ImageType::IndexType idx;
idx[0] = ot.GetIndex()[0]; idx[1] = ot.GetIndex()[1]; idx[2] = ot.GetIndex()[2];
if (size[3]==6)
{
for (unsigned int te=0; te<size[3]; te++)
{
idx[3] = te;
tensor.SetElement(te, img->GetPixel(idx));
}
}
else if (size[3]==9)
{
idx[3] = 0;
tensor.SetElement(0, img->GetPixel(idx));
idx[3] = 1;
tensor.SetElement(1, img->GetPixel(idx));
idx[3] = 2;
tensor.SetElement(2, img->GetPixel(idx));
idx[3] = 4;
tensor.SetElement(3, img->GetPixel(idx));
idx[3] = 5;
tensor.SetElement(4, img->GetPixel(idx));
idx[3] = 8;
tensor.SetElement(5, img->GetPixel(idx));
}
else
throw itk::ImageFileReaderException(__FILE__, __LINE__, "Unknown number of components for DTI file. Should be 6 or 9!");
FixPixType fixVec(tensor);
ot.Set(fixVec);
++ot;
}
}
OutputType::Pointer resultImage = OutputType::New();
resultImage->InitializeByItk( vecImg.GetPointer() );
resultImage->SetVolume( vecImg->GetBufferPointer() );
result.push_back( resultImage.GetPointer() );
}
catch(...)
{
MITK_INFO << "Trying to load dti as nrrd ...";
typedef itk::VectorImage<float,3> ImageType;
itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
typedef itk::ImageFileReader<ImageType> FileReaderType;
FileReaderType::Pointer reader = FileReaderType::New();
reader->SetImageIO(io);
reader->SetFileName(location);
reader->Update();
ImageType::Pointer img = reader->GetOutput();
TensorImage::ItkTensorImageType::Pointer vecImg = TensorImage::ItkTensorImageType::New();
vecImg->SetSpacing( img->GetSpacing() ); // Set the image spacing
vecImg->SetOrigin( img->GetOrigin() ); // Set the image origin
vecImg->SetDirection( img->GetDirection() ); // Set the image direction
vecImg->SetRegions( img->GetLargestPossibleRegion());
vecImg->Allocate();
itk::ImageRegionIterator<TensorImage::ItkTensorImageType> ot (vecImg, vecImg->GetLargestPossibleRegion() );
ot.GoToBegin();
itk::ImageRegionIterator<ImageType> it (img, img->GetLargestPossibleRegion() );
it.GoToBegin();
typedef ImageType::PixelType VarPixType;
typedef TensorImage::PixelType FixPixType;
int numComponents = img->GetNumberOfComponentsPerPixel();
itk::MetaDataDictionary imgMetaDictionary = img->GetMetaDataDictionary();
std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
std::string metaString;
bool readFrame = false;
double xx, xy, xz, yx, yy, yz, zx, zy, zz;
MeasurementFrameType measFrame;
measFrame.SetIdentity();
MeasurementFrameType measFrameTransp;
measFrameTransp.SetIdentity();
for (; itKey != imgMetaKeys.end(); itKey ++)
{
itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
if (itKey->find("measurement frame") != std::string::npos)
{
sscanf(metaString.c_str(), " ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) \n", &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz);
if (xx>10e-10 || xy>10e-10 || xz>10e-10 ||
yx>10e-10 || yy>10e-10 || yz>10e-10 ||
zx>10e-10 || zy>10e-10 || zz>10e-10 )
{
readFrame = true;
measFrame(0,0) = xx;
measFrame(0,1) = xy;
measFrame(0,2) = xz;
measFrame(1,0) = yx;
measFrame(1,1) = yy;
measFrame(1,2) = yz;
measFrame(2,0) = zx;
measFrame(2,1) = zy;
measFrame(2,2) = zz;
measFrameTransp = measFrame.GetTranspose();
}
}
}
if (numComponents==6)
{
while (!it.IsAtEnd())
{
// T'=RTR'
VarPixType vec = it.Get();
FixPixType fixVec(vec.GetDataPointer());
if(readFrame)
{
TensorImage::PixelType tensor;
tensor.SetElement(0, vec.GetElement(0));
tensor.SetElement(1, vec.GetElement(1));
tensor.SetElement(2, vec.GetElement(2));
tensor.SetElement(3, vec.GetElement(3));
tensor.SetElement(4, vec.GetElement(4));
tensor.SetElement(5, vec.GetElement(5));
tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame));
tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp));
fixVec = tensor;
}
ot.Set(fixVec);
++ot;
++it;
}
}
else if(numComponents==9)
{
while (!it.IsAtEnd())
{
VarPixType vec = it.Get();
TensorImage::PixelType tensor;
tensor.SetElement(0, vec.GetElement(0));
tensor.SetElement(1, vec.GetElement(1));
tensor.SetElement(2, vec.GetElement(2));
tensor.SetElement(3, vec.GetElement(4));
tensor.SetElement(4, vec.GetElement(5));
tensor.SetElement(5, vec.GetElement(8));
if(readFrame)
{
tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame));
tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp));
}
FixPixType fixVec(tensor);
ot.Set(fixVec);
++ot;
++it;
}
}
else if (numComponents==1)
{
typedef itk::Image<float,4> ImageType;
itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
typedef itk::ImageFileReader<ImageType> FileReaderType;
FileReaderType::Pointer reader = FileReaderType::New();
reader->SetImageIO(io);
reader->SetFileName(location);
reader->Update();
ImageType::Pointer img = reader->GetOutput();
itk::Size<4> size = img->GetLargestPossibleRegion().GetSize();
while (!ot.IsAtEnd())
{
TensorImage::PixelType tensor;
ImageType::IndexType idx;
idx[0] = ot.GetIndex()[0]; idx[1] = ot.GetIndex()[1]; idx[2] = ot.GetIndex()[2];
if (size[3]==6)
{
for (unsigned int te=0; te<size[3]; te++)
{
idx[3] = te;
tensor.SetElement(te, img->GetPixel(idx));
}
}
else if (size[3]==9)
{
idx[3] = 0;
tensor.SetElement(0, img->GetPixel(idx));
idx[3] = 1;
tensor.SetElement(1, img->GetPixel(idx));
idx[3] = 2;
tensor.SetElement(2, img->GetPixel(idx));
idx[3] = 4;
tensor.SetElement(3, img->GetPixel(idx));
idx[3] = 5;
tensor.SetElement(4, img->GetPixel(idx));
idx[3] = 8;
tensor.SetElement(5, img->GetPixel(idx));
}
else
throw itk::ImageFileReaderException(__FILE__, __LINE__, "Unknown number of komponents for DTI file. Should be 6 or 9!");
if(readFrame)
{
tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame));
tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp));
}
FixPixType fixVec(tensor);
ot.Set(fixVec);
++ot;
}
}
else
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, "Image has wrong number of pixel components!");
}
OutputType::Pointer resultImage = OutputType::New();
resultImage->InitializeByItk( vecImg.GetPointer() );
resultImage->SetVolume( vecImg->GetBufferPointer() );
result.push_back( resultImage.GetPointer() );
}
}
catch(std::exception& e)
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
}
catch(...)
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested DTI file!");
}
}
return result;
}
int main(int argc, char ** argv)
{
std::string folderName = argv[1];
std::string filter = argv[2];
typedef utils::Directory Directory;
Directory::FilenamesType filenames = Directory::GetFiles(folderName, ".nrrd");
Directory::FilenamesType goodFilenames;
filterFilenames(filenames, filter, goodFilenames);
// load the images
std::vector<ImageType::Pointer> imageList;
for(unsigned int i = 0; i < goodFilenames.size(); i++)
{
std::cout << goodFilenames[i] << std::endl;
typedef itk::ImageFileReader<ImageType> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(goodFilenames[i]);
reader->SetImageIO(itk::NrrdImageIO::New());
reader->Update();
imageList.push_back(reader->GetOutput());
}
std::sort(imageList.begin(), imageList.end(), imageSort);
ImageType::Pointer outputImage = ImageType::New();
ImageType::RegionType outputRegion;
ImageType::SizeType outputSize = imageList.front()->GetLargestPossibleRegion().GetSize();
outputSize[2] = imageList.size();
ImageType::IndexType outputIndex;
outputIndex.Fill(0);
outputRegion.SetSize(outputSize);
outputRegion.SetIndex(outputIndex);
// compute the spacing
double meanSpacing = 0.0;
for(unsigned int i = 1; i < imageList.size(); i++)
{
ImageType::Pointer im1 = imageList[i-1];
ImageType::Pointer im2 = imageList[i];
meanSpacing += (im1->GetOrigin()-im2->GetOrigin()).GetNorm();
}
meanSpacing /= (double) (imageList.size()-1);
ImageType::SpacingType spacing = imageList.front()->GetSpacing();
spacing[2] = meanSpacing;
outputImage->SetRegions(outputRegion);
outputImage->SetSpacing(spacing);
outputImage->SetOrigin(imageList.front()->GetOrigin());
outputImage->SetDirection(imageList.front()->GetDirection());
outputImage->Allocate();
itk::ImageRegionIterator<ImageType> outIt(outputImage, outputImage->GetLargestPossibleRegion());
outIt.GoToBegin();
while(!outIt.IsAtEnd())
{
ImageType::IndexType index = outIt.GetIndex();
ImageType::IndexType testIndex = index;
testIndex[2] = 0;
outIt.Set(imageList[index[2]]->GetPixel(testIndex));
++outIt;
}
std::string stackFilename = folderName + "/stack.nrrd";
typedef itk::ImageFileWriter<ImageType> WriterType;
WriterType::Pointer writer = WriterType::New();
writer->SetInput(outputImage);
writer->SetFileName(stackFilename);
writer->SetImageIO(itk::NrrdImageIO::New());
writer->Update();
return 0;
}
int
main(int argc, char* argv[])
{
boost::filesystem::path inputFile;
boost::filesystem::path outputFile;
Algorithm algorithm;
std::string algorithmName;
po::options_description desc("Allowed options");
desc.add_options()
("help", "produce help message")
("input,i", po::value<boost::filesystem::path>(&inputFile), "input file")
("algorithm,a", po::value<std::string>(&algorithmName)->default_value("itk-implementation"), "itk-implementation")
("output,o", po::value<boost::filesystem::path>(&outputFile), "output mask file")
;
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
po::notify(vm);
algorithm = getAlgorithmFromString(algorithmName);
if (vm.count("help")) {
std::cout << desc << "\n";
return 1;
}
if (vm.count("input") == 0) {
std::cout << "Missing input filename\n" << desc << "\n";
return 1;
}
if (vm.count("output") == 0) {
std::cout << "Missing output filename\n" << desc << "\n";
return 1;
}
typedef itk::ImageFileReader<ImageType> ImageReaderType;
BOOST_LOG_TRIVIAL(info) << "Loading inputs ...";
ImageReaderType::Pointer imageReader = ImageReaderType::New();
imageReader->SetFileName(inputFile.string());
imageReader->Update();
ImageType::Pointer image = imageReader->GetOutput();
LabeledImageType::Pointer outputImage;
switch (algorithm) {
case Algorithm::ItkImplementation: {
BOOST_LOG_TRIVIAL(info) << "Running ITK version of watershed transformation ...";
WatershedFilterType::Pointer filter = WatershedFilterType::New();
filter->SetInput(image);
filter->MarkWatershedLineOff();
boost::timer::cpu_timer computationTimer;
computationTimer.start();
filter->Update();
BOOST_LOG_TRIVIAL(info) << "Computation time: " << computationTimer.format(9, "%w");
outputImage = filter->GetOutput();
}
break;
default:
BOOST_LOG_TRIVIAL(info) << "Allocating output ...";
outputImage = LabeledImageType::New();
outputImage->SetRegions(image->GetLargestPossibleRegion());
outputImage->Allocate();
outputImage->SetSpacing(image->GetSpacing());
BOOST_LOG_TRIVIAL(info) << "Running CUDA version of watershed transformation (topographical distance)...";
boost::timer::cpu_timer computationTimer;
computationTimer.start();
watershedTransformation2(
cugip::const_view(*(image.GetPointer())),
cugip::view(*(outputImage.GetPointer())),
Options()
);
BOOST_LOG_TRIVIAL(info) << "Computation time: " << computationTimer.format(9, "%w");
//BOOST_LOG_TRIVIAL(error) << "Unknown algorithm";
}
BOOST_LOG_TRIVIAL(info) << "Saving output `" << outputFile << "` ...";
WriterType::Pointer writer = WriterType::New();
writer->SetFileName(outputFile.string());
writer->SetInput(outputImage);
try {
writer->Update();
} catch (itk::ExceptionObject & error) {
std::cerr << "Error: " << error << std::endl;
return EXIT_FAILURE;
}
return 0;
}
