FuzzyCMeans::FuzzyCMeans(QVector<ClusterPoint2D> &points, QVector<ClusterCentroid2D> &clusters, float fuzzy, imageType::Pointer myImage, int numCluster)
{
this->Eps = std::pow(10, -5);
this->isConverged=false;
this->Points = points;
this->Clusters = clusters;
this->myImageHeight = myImage->GetBufferedRegion().GetSize()[0];
this->myImageWidth = myImage->GetBufferedRegion().GetSize()[1];
this->myImage = myImage;
U= boost::numeric::ublas::matrix<double>(Points.size(),Clusters.size());
this->Fuzzyness = fuzzy;
double diff;
imageType::SizeType size;
size[0]=myImageWidth; // x axis
size[1]=myImageHeight; // y
imageType::RegionType region;
region.SetSize(size);
imageType::Pointer image = imageType::New();
image->SetRegions(region);
image->Allocate(); // immagine create
// Iterate through all points to create initial U matrix
for (int i = 0; i < Points.size()-1; i++)
{
ClusterPoint2D p = Points.at(i);
double sum = 0.0;
for (int j = 0; j < Clusters.size()-1; j++)
{
ClusterCentroid2D c = Clusters.at(j);
diff = std::sqrt(std::pow(CalculateEuclideanDistance(p, c), 2.0));
//U(i, j) = (diff == 0) ? Eps : diff;
if (diff==0){
U(i,j)=Eps;
}
else{
U(i,j)=diff;
}
sum += U(i, j);
}
}
this->RecalculateClusterMembershipValues();
}
// ------------------------------------------------------------------------
InitialTransformExtractor::TranslationType InitialTransformExtractor::ComputeTranslation(
const ImageType::Pointer &image,
const OptionsData &options)
{
// set the offsets
TranslationType translation;
translation.Fill(0);
translation[0] -= options.roiOffset[0];
translation[1] -= options.roiOffset[1];
translation[2] -= options.roiOffset[2];
ImageType::PointType origin = image->GetOrigin();
translation[0] -= origin[0];
translation[1] -= origin[1];
translation[2] -= origin[2];
return translation;
}
void TestDeepCopyUnsignedCharScalar()
{
itk::Index<2> corner = {{0,0}};
itk::Size<2> size = {{10,10}};
itk::ImageRegion<2> region(corner, size);
typedef itk::Image<unsigned char, 2> ImageType;
ImageType::Pointer imageIn = ImageType::New();
imageIn->SetRegions(region);
imageIn->Allocate();
ImageType::Pointer imageOut = ImageType::New();
ITKHelpers::DeepCopy(imageIn.GetPointer(), imageOut.GetPointer());
}
void TestBlurAllChannels()
{
{
typedef itk::VectorImage<float, 2> ImageType;
ImageType::Pointer image = ImageType::New();
ImageType::Pointer blurred = ImageType::New();
float sigma = 2.0f;
ITKHelpers::BlurAllChannels(image.GetPointer(), blurred.GetPointer(), sigma);
}
{
typedef itk::VectorImage<float, 2> ImageType;
ImageType::Pointer image = ImageType::New();
ImageType::Pointer blurred = ImageType::New();
float sigma = 2.0f;
ITKHelpers::BlurAllChannels(image.GetPointer(), blurred.GetPointer(), sigma);
}
}
// ------------------------------------------------------------------------
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 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;
}
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;
}
void setUp(void)
{
// Load Image Data
m_Image = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(GetTestDataFilePath("Pic3D.nrrd"))[0].GetPointer());
mitk::CastToItkImage(m_Image,m_ItkImage);
// Create a single mask with only one pixel within the regions
mitk::Image::Pointer mask1 = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(GetTestDataFilePath("Pic3D.nrrd"))[0].GetPointer());
mitk::CastToItkImage(mask1,m_ItkMask);
m_ItkMask->FillBuffer(0);
MaskType::IndexType index;
index[0]=88;index[1]=81;index[2]=13;
m_ItkMask->SetPixel(index, 1);
MITK_INFO << "Pixel Value: "<<m_ItkImage->GetPixel(index);
mitk::CastToMitkImage(m_ItkMask, m_Mask);
// Create a mask with a covered region
mitk::Image::Pointer lmask1 = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(GetTestDataFilePath("Pic3D.nrrd"))[0].GetPointer());
mitk::CastToItkImage(lmask1,m_ItkMask1);
m_ItkMask1->FillBuffer(0);
int range=2;
for (int x = 88-range;x < 88+range+1;++x)
{
for (int y=81-range;y<81+range+1;++y)
{
for (int z=13-range;z<13+range+1;++z)
{
index[0] = x;
index[1] = y;
index[2] = z;
//MITK_INFO << "Pixel: " <<m_ItkImage->GetPixel(index);
m_ItkMask1->SetPixel(index, 1);
}
}
}
mitk::CastToMitkImage(m_ItkMask1, m_Mask1);
m_GradientImage=GenerateGradientWithDimXImage<unsigned char>(5,5,5);
m_GradientMask = GenerateMaskImage<unsigned char>(5,5,5);
}
bool TestDeepCopyFloatScalar()
{
itk::Index<2> corner = {{0,0}};
itk::Size<2> size = {{10,10}};
itk::ImageRegion<2> region(corner, size);
typedef itk::Image<float, 2> ImageType;
ImageType::Pointer imageIn = ImageType::New();
imageIn->SetRegions(region);
imageIn->Allocate();
ImageType::Pointer imageOut = ImageType::New();
ITKHelpers::DeepCopy(imageIn.GetPointer(), imageOut.GetPointer());
return true;
}
bool TestRandomImage()
{
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();
image->FillBuffer(0);
ITKHelpers::RandomImage(image.GetPointer());
ITKHelpers::WriteImage(image.GetPointer(), "random.png");
return true;
}
void TestDrawRectangle()
{
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();
image->FillBuffer(0);
itk::Index<2> corner0 = {{10,10}};
itk::Index<2> corner1 = {{30,30}};
ITKHelpers::DrawRectangle(image.GetPointer(), 255,
corner0, corner1);
ITKHelpers::WriteImage(image.GetPointer(), "rectangle.png");
}
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;
}
// Run with: Data/trashcan.mha Data/trashcan_mask.mha 15 Data/trashcan.vtp Intensity filled.mha
int main(int argc, char *argv[])
{
// Verify arguments
if(argc != 6)
{
std::cerr << "Required arguments: image.mha imageMask.mha patch_half_width normals.vts output.mha" << std::endl;
std::cerr << "Input arguments: ";
for(int i = 1; i < argc; ++i)
{
std::cerr << argv[i] << " ";
}
return EXIT_FAILURE;
}
// Parse arguments
std::string imageFilename = argv[1];
std::string maskFilename = argv[2];
std::stringstream ssPatchRadius;
ssPatchRadius << argv[3];
unsigned int patch_half_width = 0;
ssPatchRadius >> patch_half_width;
std::string normalsFileName = argv[4];
std::string outputFilename = argv[5];
// Output arguments
std::cout << "Reading image: " << imageFilename << std::endl;
std::cout << "Reading mask: " << maskFilename << std::endl;
std::cout << "Patch half width: " << patch_half_width << std::endl;
std::cout << "Reading normals: " << normalsFileName << std::endl;
std::cout << "Output: " << outputFilename << std::endl;
vtkSmartPointer<vtkXMLStructuredGridReader> structuredGridReader = vtkSmartPointer<vtkXMLStructuredGridReader>::New();
structuredGridReader->SetFileName(normalsFileName.c_str());
structuredGridReader->Update();
typedef FloatVectorImageType ImageType;
typedef itk::ImageFileReader<ImageType> ImageReaderType;
ImageReaderType::Pointer imageReader = ImageReaderType::New();
imageReader->SetFileName(imageFilename);
imageReader->Update();
ImageType::Pointer image = ImageType::New();
ITKHelpers::DeepCopy(imageReader->GetOutput(), image.GetPointer());
Mask::Pointer mask = Mask::New();
mask->Read(maskFilename);
std::cout << "hole pixels: " << mask->CountHolePixels() << std::endl;
std::cout << "valid pixels: " << mask->CountValidPixels() << std::endl;
typedef ImagePatchPixelDescriptor<ImageType> ImagePatchPixelDescriptorType;
typedef FeatureVectorPixelDescriptor FeatureVectorPixelDescriptorType;
// Create the graph
typedef boost::grid_graph<2> VertexListGraphType;
boost::array<std::size_t, 2> graphSideLengths = { { imageReader->GetOutput()->GetLargestPossibleRegion().GetSize()[0],
imageReader->GetOutput()->GetLargestPossibleRegion().GetSize()[1] } };
VertexListGraphType graph(graphSideLengths);
typedef boost::graph_traits<VertexListGraphType>::vertex_descriptor VertexDescriptorType;
// Get the index map
typedef boost::property_map<VertexListGraphType, boost::vertex_index_t>::const_type IndexMapType;
IndexMapType indexMap(get(boost::vertex_index, graph));
// Create the priority map
typedef boost::vector_property_map<float, IndexMapType> PriorityMapType;
PriorityMapType priorityMap(num_vertices(graph), indexMap);
// Create the node fill status map. Each pixel is either filled (true) or not filled (false).
typedef boost::vector_property_map<bool, IndexMapType> FillStatusMapType;
FillStatusMapType fillStatusMap(num_vertices(graph), indexMap);
// Create the boundary status map. A node is on the current boundary if this property is true.
// This property helps the boundaryNodeQueue because we can mark here if a node has become no longer
// part of the boundary, so when the queue is popped we can check this property to see if it should
// actually be processed.
typedef boost::vector_property_map<bool, IndexMapType> BoundaryStatusMapType;
BoundaryStatusMapType boundaryStatusMap(num_vertices(graph), indexMap);
// Create the descriptor map. This is where the data for each pixel is stored.
typedef boost::vector_property_map<ImagePatchPixelDescriptorType, IndexMapType> ImagePatchDescriptorMapType;
ImagePatchDescriptorMapType imagePatchDescriptorMap(num_vertices(graph), indexMap);
// Create the descriptor map. This is where the data for each pixel is stored.
typedef boost::vector_property_map<FeatureVectorPixelDescriptorType, IndexMapType> FeatureVectorDescriptorMapType;
FeatureVectorDescriptorMapType featureVectorDescriptorMap(num_vertices(graph), indexMap);
// Create the patch inpainter. The inpainter needs to know the status of each pixel to determine if they should be inpainted.
typedef MaskedGridPatchInpainter<FillStatusMapType> InpainterType;
InpainterType patchInpainter(patch_half_width, fillStatusMap);
// Create the priority function
typedef PriorityRandom PriorityType;
PriorityType priorityFunction;
// Create the boundary node queue. The priority of each node is used to order the queue.
typedef boost::vector_property_map<std::size_t, IndexMapType> IndexInHeapMap;
IndexInHeapMap index_in_heap(indexMap);
// Create the priority compare functor
typedef std::less<float> PriorityCompareType;
PriorityCompareType lessThanFunctor;
typedef boost::d_ary_heap_indirect<VertexDescriptorType, 4, IndexInHeapMap, PriorityMapType, PriorityCompareType> BoundaryNodeQueueType;
BoundaryNodeQueueType boundaryNodeQueue(priorityMap, index_in_heap, lessThanFunctor);
// Create the descriptor visitors
typedef FeatureVectorPrecomputedStructuredGridNormalsDescriptorVisitor<VertexListGraphType, FeatureVectorDescriptorMapType> FeatureVectorPrecomputedStructuredGridNormalsDescriptorVisitorType;
FeatureVectorPrecomputedStructuredGridNormalsDescriptorVisitorType featureVectorPrecomputedStructuredGridNormalsDescriptorVisitor(featureVectorDescriptorMap, structuredGridReader->GetOutput());
typedef ImagePatchDescriptorVisitor<VertexListGraphType, ImageType, ImagePatchDescriptorMapType> ImagePatchDescriptorVisitorType;
ImagePatchDescriptorVisitorType imagePatchDescriptorVisitor(image, mask, imagePatchDescriptorMap, patch_half_width);
typedef CompositeDescriptorVisitor<VertexListGraphType> CompositeDescriptorVisitorType;
CompositeDescriptorVisitorType compositeDescriptorVisitor;
compositeDescriptorVisitor.AddVisitor(&imagePatchDescriptorVisitor);
compositeDescriptorVisitor.AddVisitor(&featureVectorPrecomputedStructuredGridNormalsDescriptorVisitor);
// Create the inpainting visitor
typedef InpaintingVisitor<VertexListGraphType, ImageType, BoundaryNodeQueueType, FillStatusMapType,
CompositeDescriptorVisitorType, PriorityType, PriorityMapType, BoundaryStatusMapType> InpaintingVisitorType;
InpaintingVisitorType inpaintingVisitor(image, mask, boundaryNodeQueue, fillStatusMap,
compositeDescriptorVisitor, priorityMap, &priorityFunction, patch_half_width, boundaryStatusMap);
InitializePriority(mask, boundaryNodeQueue, priorityMap, &priorityFunction, boundaryStatusMap);
// Initialize the boundary node queue from the user provided mask image.
InitializeFromMaskImage(mask, &inpaintingVisitor, graph, fillStatusMap);
std::cout << "PatchBasedInpaintingNonInteractive: There are " << boundaryNodeQueue.size()
<< " nodes in the boundaryNodeQueue" << std::endl;
// Create the nearest neighbor finder
// typedef LinearSearchKNNProperty<FeatureVectorDescriptorMapType, FeatureVectorAngleDifference> KNNSearchType;
// KNNSearchType linearSearchKNN(featureVectorDescriptorMap);
typedef LinearSearchCriteriaProperty<FeatureVectorDescriptorMapType, FeatureVectorAngleDifference> ThresholdSearchType;
//float maximumAngle = 0.34906585; // ~ 20 degrees
float maximumAngle = 0.15; // ~ 10 degrees
//float maximumAngle = 0.08; // ~ 5 degrees (this seems to be too strict)
ThresholdSearchType thresholdSearchType(featureVectorDescriptorMap, maximumAngle);
typedef LinearSearchBestProperty<ImagePatchDescriptorMapType, ImagePatchDifference<ImagePatchPixelDescriptorType> > BestSearchType;
BestSearchType linearSearchBest(imagePatchDescriptorMap);
TwoStepNearestNeighbor<ThresholdSearchType, BestSearchType> twoStepNearestNeighbor(thresholdSearchType, linearSearchBest);
// Perform the inpainting
std::cout << "Performing inpainting...: " << std::endl;
inpainting_loop(graph, inpaintingVisitor, boundaryStatusMap, boundaryNodeQueue, twoStepNearestNeighbor, patchInpainter);
HelpersOutput::WriteImage<ImageType>(image, outputFilename);
return EXIT_SUCCESS;
}
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;
}
void LabelsVolumeGenerator::postProcessTargetITK()
{
typedef unsigned char PixelType;
typedef Image<PixelType, 3> ImageType;
// create a new image from the target data
ImageType::Pointer input = ImageType::New();
ImageType::IndexType start;
start.Fill(0);
ImageType::SizeType size;
for (int i = 0; i < 3; ++i) size[i] = m_targetVolume->dimensions[i];
ImageType::RegionType region;
region.SetSize(size);
region.SetIndex(start);
input->SetRegions(region);
input->SetSpacing(m_targetVolume->spacing.data());
input->Allocate();
memcpy(input->GetBufferPointer(), m_targetVolume->data, m_bufferSize);
// create a grayscale dilation filter and a structuring element
typedef BinaryBallStructuringElement<PixelType, 3> StructureType;
typedef GrayscaleDilateImageFilter<ImageType, ImageType, StructureType> DilateFilterType;
DilateFilterType::Pointer filter = DilateFilterType::New();
StructureType structure;
structure.SetRadius(1);
filter->SetKernel(structure);
// set up progress reporting
if (m_progressReporter)
{
CStyleCommand::Pointer command = CStyleCommand::New();
command->SetClientData(m_progressReporter);
command->SetCallback(ProgressCallback);
filter->AddObserver(ProgressEvent(), command);
m_progressReporter->start("Post-Processing Label volume",
"Dilating label field...");
}
// hook up the filters and run
filter->SetInput(input);
filter->Update();
if (m_progressReporter)
m_progressReporter->finish();
// copy back into the target volume data
memcpy(m_targetVolume->data, filter->GetOutput()->GetBufferPointer(), m_bufferSize);
// threshold and gaussian blur to put a smooth version into the alpha channel
typedef BinaryThresholdImageFilter<ImageType, ImageType> ThresholderType;
// typedef DiscreteGaussianImageFilter<ImageType, ImageType> SmoothFilterType;
typedef SmoothingRecursiveGaussianImageFilter<ImageType, ImageType> SmoothFilterType;
ThresholderType::Pointer thresholder = ThresholderType::New();
thresholder->SetLowerThreshold(1);
thresholder->SetUpperThreshold(255);
thresholder->SetInsideValue(255);
thresholder->SetOutsideValue(0);
SmoothFilterType::Pointer smoother = SmoothFilterType::New();
// smoother->SetVariance(0.05); // in physical units
// smoother->SetMaximumKernelWidth(5);
smoother->SetSigma(0.2);
// set up progress reporting (again)
if (m_progressReporter)
{
CStyleCommand::Pointer command = CStyleCommand::New();
command->SetClientData(m_progressReporter);
command->SetCallback(ProgressCallback);
smoother->AddObserver(ProgressEvent(), command);
m_progressReporter->start("Post-Processing Label volume",
"Smoothing alpha mask...");
}
// hook up the filters and run
thresholder->SetInput(input);
smoother->SetInput(thresholder->GetOutput());
smoother->Update();
// copy back into the target volume data
memcpy(m_targetMask->data, smoother->GetOutput()->GetBufferPointer(), m_bufferSize);
if (m_progressReporter)
m_progressReporter->finish();
}
int main( int argc, char* argv[] )
{
std::string input_file;
std::string output_file;
float variance;
int patchRadius;
int searchRadius;
po::options_description desc("Allowed options");
desc.add_options()
("help", "produce help message")
("input,i", po::value<std::string>(&input_file), "input file")
("output,o", po::value<std::string>(&output_file), "output file")
("variance,v", po::value<float>(&variance)->default_value(10.0), "variance")
("patch-radius,p", po::value<int>(&patchRadius)->default_value(2), "patch radius")
("search-radius,s", po::value<int>(&searchRadius)->default_value(4), "search radius")
;
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
po::notify(vm);
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;
}
const unsigned int Dimension = 3;
//typedef float PixelType;
//typedef itk::Image< PixelType, Dimension > ImageType;
typedef itk::ImageFileReader<ImageType> ReaderType;
typedef itk::ImageFileWriter<ImageType> WriterType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(input_file);
reader->Update();
ImageType::Pointer image = reader->GetOutput();
ImageType::Pointer output_image = ImageType::New();
output_image->SetRegions(image->GetLargestPossibleRegion());
output_image->Allocate();
output_image->SetSpacing(image->GetSpacing());
//denoise(image, output_image);
denoise(
image->GetPixelContainer()->GetBufferPointer(),
output_image->GetPixelContainer()->GetBufferPointer(),
image->GetLargestPossibleRegion().GetSize()[0],
image->GetLargestPossibleRegion().GetSize()[1],
image->GetLargestPossibleRegion().GetSize()[2],
variance,
patchRadius,
searchRadius);
WriterType::Pointer writer = WriterType::New();
writer->SetFileName(output_file);
writer->SetInput(output_image);
try
{
writer->Update();
}
catch( itk::ExceptionObject & error )
{
std::cerr << "Error: " << error << std::endl;
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int main(int argc, char ** argv){
typedef itk::Image<float,3> ImageType;
typedef itk::ImageFileReader<ImageType> ReaderType;
typedef itk::ImageFileWriter<ImageType> WriterType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(argv[1]);
typedef itk::HessianRecursiveGaussianImageFilter<ImageType> HessianFilterType;
typedef HessianFilterType::OutputImageType HessianImageType;
typedef HessianImageType::PixelType HessianType;
HessianFilterType::Pointer hessianFilter = HessianFilterType::New();
hessianFilter->SetSigma(0.05);
hessianFilter->SetInput(reader->GetOutput());
hessianFilter->Update();
HessianImageType::Pointer hessianImage = hessianFilter->GetOutput();
hessianImage->DisconnectPipeline();
typedef itk::ImageRegionConstIteratorWithIndex<HessianImageType> IteratorType;
IteratorType hessianIterator(hessianImage,hessianImage->GetLargestPossibleRegion());
typedef HessianType::EigenValuesArrayType EigenvalueArrayType;
EigenvalueArrayType expectation;
expectation.Fill(0.0);
unsigned count=0;
ImageType::Pointer small = ImageType::New();
small->CopyInformation(reader->GetOutput());
small->SetRegions(reader->GetOutput()->GetLargestPossibleRegion());
small->Allocate();
small->FillBuffer(0.0);
ImageType::Pointer medium = ImageType::New();
medium->CopyInformation(reader->GetOutput());
medium->SetRegions(reader->GetOutput()->GetLargestPossibleRegion());
medium->Allocate();
medium->FillBuffer(0.0);
ImageType::Pointer large = ImageType::New();
large->CopyInformation(reader->GetOutput());
large->SetRegions(reader->GetOutput()->GetLargestPossibleRegion());
large->Allocate();
large->FillBuffer(0.0);
while(!hessianIterator.IsAtEnd()){
auto hessian = hessianIterator.Get();
EigenvalueArrayType eigenValues;
hessian.ComputeEigenValues(eigenValues);
std::sort(eigenValues.Begin(),eigenValues.End(),[](double & a, double &b){
return std::abs(a) > std::abs(b);
});
//std::cout << eigenValues[0] << "\t"<< eigenValues[1] << "\t" << eigenValues[2] <<std::endl;
if(eigenValues[0]<0){
expectation[0]+=eigenValues[0];
expectation[1]+=eigenValues[1];
expectation[2]+=eigenValues[2];
count++;
large->SetPixel(hessianIterator.GetIndex(),std::abs(eigenValues[0]));
medium->SetPixel(hessianIterator.GetIndex(),std::abs(eigenValues[1]));
small->SetPixel(hessianIterator.GetIndex(),std::abs(eigenValues[2]));
}
++hessianIterator;
}
expectation[0]=expectation[0]/count;
expectation[1]=expectation[1]/count;
expectation[2]=expectation[2]/count;
WriterType::Pointer smallWriter = WriterType::New();
smallWriter->SetInput(small);
smallWriter->SetFileName("small.mha");
smallWriter->Update();
WriterType::Pointer mediumWriter = WriterType::New();
mediumWriter->SetInput(medium);
mediumWriter->SetFileName("medium.mha");
mediumWriter->Update();
WriterType::Pointer largeWriter = WriterType::New();
largeWriter->SetInput(large);
largeWriter->SetFileName("large.mha");
largeWriter->Update();
std::cout << "Expectation: \t" << expectation<< std::endl;
}
void QmitkBasicImageProcessing::StartButtonClicked()
{
if(!m_SelectedImageNode->GetNode()) return;
this->BusyCursorOn();
mitk::Image::Pointer newImage;
try
{
newImage = dynamic_cast<mitk::Image*>(m_SelectedImageNode->GetNode()->GetData());
}
catch ( std::exception &e )
{
QString exceptionString = "An error occured during image loading:\n";
exceptionString.append( e.what() );
QMessageBox::warning( NULL, "Basic Image Processing", exceptionString , QMessageBox::Ok, QMessageBox::NoButton );
this->BusyCursorOff();
return;
}
// check if input image is valid, casting does not throw exception when casting from 'NULL-Object'
if ( (! newImage) || (newImage->IsInitialized() == false) )
{
this->BusyCursorOff();
QMessageBox::warning( NULL, "Basic Image Processing", "Input image is broken or not initialized. Returning.", QMessageBox::Ok, QMessageBox::NoButton );
return;
}
// check if operation is done on 4D a image time step
if(newImage->GetDimension() > 3)
{
mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput(newImage);
timeSelector->SetTimeNr( ((QmitkSliderNavigatorWidget*)m_Controls->sliceNavigatorTime)->GetPos() );
timeSelector->Update();
newImage = timeSelector->GetOutput();
}
// check if image or vector image
ImageType::Pointer itkImage = ImageType::New();
VectorImageType::Pointer itkVecImage = VectorImageType::New();
int isVectorImage = newImage->GetPixelType().GetNumberOfComponents();
if(isVectorImage > 1)
{
CastToItkImage( newImage, itkVecImage );
}
else
{
CastToItkImage( newImage, itkImage );
}
std::stringstream nameAddition("");
int param1 = m_Controls->sbParam1->value();
int param2 = m_Controls->sbParam2->value();
double dparam1 = m_Controls->dsbParam1->value();
double dparam2 = m_Controls->dsbParam2->value();
double dparam3 = m_Controls->dsbParam3->value();
try{
switch (m_SelectedAction)
{
case GAUSSIAN:
{
GaussianFilterType::Pointer gaussianFilter = GaussianFilterType::New();
gaussianFilter->SetInput( itkImage );
gaussianFilter->SetVariance( param1 );
gaussianFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(gaussianFilter->GetOutput())->Clone();
nameAddition << "_Gaussian_var_" << param1;
std::cout << "Gaussian filtering successful." << std::endl;
break;
}
case MEDIAN:
{
MedianFilterType::Pointer medianFilter = MedianFilterType::New();
MedianFilterType::InputSizeType size;
size.Fill(param1);
medianFilter->SetRadius( size );
medianFilter->SetInput(itkImage);
medianFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(medianFilter->GetOutput())->Clone();
nameAddition << "_Median_radius_" << param1;
std::cout << "Median Filtering successful." << std::endl;
break;
}
case TOTALVARIATION:
{
if(isVectorImage > 1)
{
VectorTotalVariationFilterType::Pointer TVFilter
= VectorTotalVariationFilterType::New();
TVFilter->SetInput( itkVecImage.GetPointer() );
TVFilter->SetNumberIterations(param1);
TVFilter->SetLambda(double(param2)/1000.);
TVFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(TVFilter->GetOutput())->Clone();
}
else
{
ImagePTypeToFloatPTypeCasterType::Pointer floatCaster = ImagePTypeToFloatPTypeCasterType::New();
floatCaster->SetInput( itkImage );
floatCaster->Update();
FloatImageType::Pointer fImage = floatCaster->GetOutput();
TotalVariationFilterType::Pointer TVFilter
= TotalVariationFilterType::New();
TVFilter->SetInput( fImage.GetPointer() );
TVFilter->SetNumberIterations(param1);
TVFilter->SetLambda(double(param2)/1000.);
TVFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(TVFilter->GetOutput())->Clone();
}
nameAddition << "_TV_Iter_" << param1 << "_L_" << param2;
std::cout << "Total Variation Filtering successful." << std::endl;
break;
}
case DILATION:
{
BallType binaryBall;
binaryBall.SetRadius( param1 );
binaryBall.CreateStructuringElement();
DilationFilterType::Pointer dilationFilter = DilationFilterType::New();
dilationFilter->SetInput( itkImage );
dilationFilter->SetKernel( binaryBall );
dilationFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(dilationFilter->GetOutput())->Clone();
nameAddition << "_Dilated_by_" << param1;
std::cout << "Dilation successful." << std::endl;
break;
}
case EROSION:
{
BallType binaryBall;
binaryBall.SetRadius( param1 );
binaryBall.CreateStructuringElement();
ErosionFilterType::Pointer erosionFilter = ErosionFilterType::New();
erosionFilter->SetInput( itkImage );
erosionFilter->SetKernel( binaryBall );
erosionFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(erosionFilter->GetOutput())->Clone();
nameAddition << "_Eroded_by_" << param1;
std::cout << "Erosion successful." << std::endl;
break;
}
case OPENING:
{
BallType binaryBall;
binaryBall.SetRadius( param1 );
binaryBall.CreateStructuringElement();
OpeningFilterType::Pointer openFilter = OpeningFilterType::New();
openFilter->SetInput( itkImage );
openFilter->SetKernel( binaryBall );
openFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(openFilter->GetOutput())->Clone();
nameAddition << "_Opened_by_" << param1;
std::cout << "Opening successful." << std::endl;
break;
}
case CLOSING:
{
BallType binaryBall;
binaryBall.SetRadius( param1 );
binaryBall.CreateStructuringElement();
ClosingFilterType::Pointer closeFilter = ClosingFilterType::New();
closeFilter->SetInput( itkImage );
closeFilter->SetKernel( binaryBall );
closeFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(closeFilter->GetOutput())->Clone();
nameAddition << "_Closed_by_" << param1;
std::cout << "Closing successful." << std::endl;
break;
}
case GRADIENT:
{
GradientFilterType::Pointer gradientFilter = GradientFilterType::New();
gradientFilter->SetInput( itkImage );
gradientFilter->SetSigma( param1 );
gradientFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(gradientFilter->GetOutput())->Clone();
nameAddition << "_Gradient_sigma_" << param1;
std::cout << "Gradient calculation successful." << std::endl;
break;
}
case LAPLACIAN:
{
// the laplace filter requires a float type image as input, we need to cast the itkImage
// to correct type
ImagePTypeToFloatPTypeCasterType::Pointer caster = ImagePTypeToFloatPTypeCasterType::New();
caster->SetInput( itkImage );
caster->Update();
FloatImageType::Pointer fImage = caster->GetOutput();
LaplacianFilterType::Pointer laplacianFilter = LaplacianFilterType::New();
laplacianFilter->SetInput( fImage );
laplacianFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(laplacianFilter->GetOutput())->Clone();
nameAddition << "_Second_Derivative";
std::cout << "Laplacian filtering successful." << std::endl;
break;
}
case SOBEL:
{
// the sobel filter requires a float type image as input, we need to cast the itkImage
// to correct type
ImagePTypeToFloatPTypeCasterType::Pointer caster = ImagePTypeToFloatPTypeCasterType::New();
caster->SetInput( itkImage );
caster->Update();
FloatImageType::Pointer fImage = caster->GetOutput();
SobelFilterType::Pointer sobelFilter = SobelFilterType::New();
sobelFilter->SetInput( fImage );
sobelFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(sobelFilter->GetOutput())->Clone();
nameAddition << "_Sobel";
std::cout << "Edge Detection successful." << std::endl;
break;
}
case THRESHOLD:
{
ThresholdFilterType::Pointer thFilter = ThresholdFilterType::New();
thFilter->SetLowerThreshold(param1 < param2 ? param1 : param2);
thFilter->SetUpperThreshold(param2 > param1 ? param2 : param1);
thFilter->SetInsideValue(1);
thFilter->SetOutsideValue(0);
thFilter->SetInput(itkImage);
thFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(thFilter->GetOutput())->Clone();
nameAddition << "_Threshold";
std::cout << "Thresholding successful." << std::endl;
break;
}
case INVERSION:
{
InversionFilterType::Pointer invFilter = InversionFilterType::New();
mitk::ScalarType min = newImage->GetScalarValueMin();
mitk::ScalarType max = newImage->GetScalarValueMax();
invFilter->SetMaximum( max + min );
invFilter->SetInput(itkImage);
invFilter->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(invFilter->GetOutput())->Clone();
nameAddition << "_Inverted";
std::cout << "Image inversion successful." << std::endl;
break;
}
case DOWNSAMPLING:
{
ResampleImageFilterType::Pointer downsampler = ResampleImageFilterType::New();
downsampler->SetInput( itkImage );
NearestInterpolatorType::Pointer interpolator = NearestInterpolatorType::New();
downsampler->SetInterpolator( interpolator );
downsampler->SetDefaultPixelValue( 0 );
ResampleImageFilterType::SpacingType spacing = itkImage->GetSpacing();
spacing *= (double) param1;
downsampler->SetOutputSpacing( spacing );
downsampler->SetOutputOrigin( itkImage->GetOrigin() );
downsampler->SetOutputDirection( itkImage->GetDirection() );
ResampleImageFilterType::SizeType size = itkImage->GetLargestPossibleRegion().GetSize();
for ( int i = 0; i < 3; ++i )
{
size[i] /= param1;
}
downsampler->SetSize( size );
downsampler->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(downsampler->GetOutput())->Clone();
nameAddition << "_Downsampled_by_" << param1;
std::cout << "Downsampling successful." << std::endl;
break;
}
case FLIPPING:
{
FlipImageFilterType::Pointer flipper = FlipImageFilterType::New();
flipper->SetInput( itkImage );
itk::FixedArray<bool, 3> flipAxes;
for(int i=0; i<3; ++i)
{
if(i == param1)
{
flipAxes[i] = true;
}
else
{
flipAxes[i] = false;
}
}
flipper->SetFlipAxes(flipAxes);
flipper->UpdateLargestPossibleRegion();
newImage = mitk::ImportItkImage(flipper->GetOutput())->Clone();
std::cout << "Image flipping successful." << std::endl;
break;
}
case RESAMPLING:
{
std::string selectedInterpolator;
ResampleImageFilterType::Pointer resampler = ResampleImageFilterType::New();
switch (m_SelectedInterpolation)
{
case LINEAR:
{
LinearInterpolatorType::Pointer interpolator = LinearInterpolatorType::New();
resampler->SetInterpolator(interpolator);
selectedInterpolator = "Linear";
break;
}
case NEAREST:
{
NearestInterpolatorType::Pointer interpolator = NearestInterpolatorType::New();
resampler->SetInterpolator(interpolator);
selectedInterpolator = "Nearest";
break;
}
default:
{
LinearInterpolatorType::Pointer interpolator = LinearInterpolatorType::New();
resampler->SetInterpolator(interpolator);
selectedInterpolator = "Linear";
break;
}
}
resampler->SetInput( itkImage );
resampler->SetOutputOrigin( itkImage->GetOrigin() );
ImageType::SizeType input_size = itkImage->GetLargestPossibleRegion().GetSize();
ImageType::SpacingType input_spacing = itkImage->GetSpacing();
ImageType::SizeType output_size;
ImageType::SpacingType output_spacing;
output_size[0] = input_size[0] * (input_spacing[0] / dparam1);
output_size[1] = input_size[1] * (input_spacing[1] / dparam2);
output_size[2] = input_size[2] * (input_spacing[2] / dparam3);
output_spacing [0] = dparam1;
output_spacing [1] = dparam2;
output_spacing [2] = dparam3;
resampler->SetSize( output_size );
resampler->SetOutputSpacing( output_spacing );
resampler->SetOutputDirection( itkImage->GetDirection() );
resampler->UpdateLargestPossibleRegion();
ImageType::Pointer resampledImage = resampler->GetOutput();
newImage = mitk::ImportItkImage( resampledImage );
nameAddition << "_Resampled_" << selectedInterpolator;
std::cout << "Resampling successful." << std::endl;
break;
}
case RESCALE:
{
FloatImageType::Pointer floatImage = FloatImageType::New();
CastToItkImage( newImage, floatImage );
itk::RescaleIntensityImageFilter<FloatImageType,FloatImageType>::Pointer filter = itk::RescaleIntensityImageFilter<FloatImageType,FloatImageType>::New();
filter->SetInput(0, floatImage);
filter->SetOutputMinimum(dparam1);
filter->SetOutputMaximum(dparam2);
filter->Update();
floatImage = filter->GetOutput();
newImage = mitk::Image::New();
newImage->InitializeByItk(floatImage.GetPointer());
newImage->SetVolume(floatImage->GetBufferPointer());
nameAddition << "_Rescaled";
std::cout << "Rescaling successful." << std::endl;
break;
}
default:
this->BusyCursorOff();
return;
}
}
catch (...)
{
this->BusyCursorOff();
QMessageBox::warning(NULL, "Warning", "Problem when applying filter operation. Check your input...");
return;
}
newImage->DisconnectPipeline();
// adjust level/window to new image
mitk::LevelWindow levelwindow;
levelwindow.SetAuto( newImage );
mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
levWinProp->SetLevelWindow( levelwindow );
// compose new image name
std::string name = m_SelectedImageNode->GetNode()->GetName();
if (name.find(".pic.gz") == name.size() -7 )
{
name = name.substr(0,name.size() -7);
}
name.append( nameAddition.str() );
// create final result MITK data storage node
mitk::DataNode::Pointer result = mitk::DataNode::New();
result->SetProperty( "levelwindow", levWinProp );
result->SetProperty( "name", mitk::StringProperty::New( name.c_str() ) );
result->SetData( newImage );
// for vector images, a different mapper is needed
if(isVectorImage > 1)
{
mitk::VectorImageMapper2D::Pointer mapper =
mitk::VectorImageMapper2D::New();
result->SetMapper(1,mapper);
}
// reset GUI to ease further processing
// this->ResetOneImageOpPanel();
// add new image to data storage and set as active to ease further processing
GetDefaultDataStorage()->Add( result, m_SelectedImageNode->GetNode() );
if ( m_Controls->cbHideOrig->isChecked() == true )
m_SelectedImageNode->GetNode()->SetProperty( "visible", mitk::BoolProperty::New(false) );
// TODO!! m_Controls->m_ImageSelector1->SetSelectedNode(result);
// show the results
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
this->BusyCursorOff();
}
int main(int argc, char *argv[])
{
/* % MINIMALPATH Recherche du chemin minimum de Haut vers le bas et de
% bas vers le haut tel que dÈcrit par Luc Vincent 1998
% [sR,sC,S] = MinimalPath(I,factx)
%
% I : Image d'entrÔøΩe dans laquelle on doit trouver le
% chemin minimal
% factx : Poids de linearite [1 10]
%
% Programme par : Ramnada Chav
% ModifiÈ le 16 novembre 2007 */
typedef itk::ImageDuplicator< ImageType > DuplicatorType3D;
typedef itk::InvertIntensityImageFilter <ImageType> InvertIntensityImageFilterType;
typedef itk::StatisticsImageFilter<ImageType> StatisticsImageFilterType;
ImageType::Pointer inverted_image = image;
// if (invert)
// {
// StatisticsImageFilterType::Pointer statisticsImageFilterInput = StatisticsImageFilterType::New();
// statisticsImageFilterInput->SetInput(image);
// statisticsImageFilterInput->Update();
// double maxIm = statisticsImageFilterInput->GetMaximum();
// InvertIntensityImageFilterType::Pointer invertIntensityFilter = InvertIntensityImageFilterType::New();
// invertIntensityFilter->SetInput(image);
// invertIntensityFilter->SetMaximum(maxIm);
// invertIntensityFilter->Update();
// inverted_image = invertIntensityFilter->GetOutput();
// }
ImageType::SizeType sizeImage = image->GetLargestPossibleRegion().GetSize();
int m = sizeImage[0]; // x to change because we are in AIL
int n = sizeImage[2]; // y
int p = sizeImage[1]; // z
// create image with high values J1
DuplicatorType3D::Pointer duplicator = DuplicatorType3D::New();
duplicator->SetInputImage(inverted_image);
duplicator->Update();
ImageType::Pointer J1 = duplicator->GetOutput();
typedef itk::ImageRegionIterator<ImageType> ImageIterator3D;
ImageIterator3D vItJ1( J1, J1->GetBufferedRegion() );
vItJ1.GoToBegin();
while ( !vItJ1.IsAtEnd() )
{
vItJ1.Set(100000000);
++vItJ1;
}
// create image with high values J2
DuplicatorType3D::Pointer duplicatorJ2 = DuplicatorType3D::New();
duplicatorJ2->SetInputImage(inverted_image);
duplicatorJ2->Update();
ImageType::Pointer J2 = duplicatorJ2->GetOutput();
ImageIterator3D vItJ2( J2, J2->GetBufferedRegion() );
vItJ2.GoToBegin();
while ( !vItJ2.IsAtEnd() )
{
vItJ2.Set(100000000);
++vItJ2;
}
DuplicatorType3D::Pointer duplicatorCPixel = DuplicatorType3D::New();
duplicatorCPixel->SetInputImage(inverted_image);
duplicatorCPixel->Update();
ImageType::Pointer cPixel = duplicatorCPixel->GetOutput();
ImageType::IndexType index;
// iterate on slice from slice 1 (start=0) to slice p-2. Basically, we avoid first and last slices.
// IMPORTANT: first slice of J1 and last slice of J2 must be set to 0...
for (int x=0; x<m; x++)
{
for (int y=0; y<n; y++)
{
index[0] = x; index[1] = 0; index[2] = y;
J1->SetPixel(index, 0.0);
}
}
for (int slice=1; slice<p; slice++)
{
// 1. extract pJ = the (slice-1)th slice of the image J1
Matrice pJ = Matrice(m,n);
for (int x=0; x<m; x++)
{
for (int y=0; y<n; y++)
{
index[0] = x; index[1] = slice-1; index[2] = y;
pJ(x,y) = J1->GetPixel(index);
}
}
// 2. extract cP = the (slice)th slice of the image cPixel
Matrice cP = Matrice(m,n);
for (int x=0; x<m; x++)
{
for (int y=0; y<n; y++)
{
index[0] = x; index[1] = slice; index[2] = y;
cP(x,y) = cPixel->GetPixel(index);
}
}
// 2'
Matrice cPm = Matrice(m,n);
if (homoInt)
{
for (int x=0; x<m; x++)
{
for (int y=0; y<n; y++)
{
index[0] = x; index[1] = slice-1; index[2] = y;
cP(x,y) = cPixel->GetPixel(index);
}
}
}
// 3. Create a matrix VI with 5 slices, that are exactly a repetition of cP without borders
// multiply all elements of all slices of VI except the middle one by factx
Matrice VI[5];
for (int i=0; i<5; i++)
{
// Create VI
Matrice cP_in = Matrice(m-1, n-1);
for (int x=0; x<m-2; x++)
{
for (int y=0; y<n-2; y++)
{
cP_in(x,y) = cP(x+1,y+1);
if (i!=2)
cP_in(x,y) *= factx;
}
}
VI[i] = cP_in;
}
// 3'.
Matrice VIm[5];
if (homoInt)
{
for (int i=0; i<5; i++)
{
// Create VIm
Matrice cPm_in = Matrice(m-1, n-1);
for (int x=0; x<m-2; x++)
{
for (int y=0; y<n-2; y++)
{
cPm_in(x,y) = cPm(x+1,y+1);
if (i!=2)
cPm_in(x,y) *= factx;
}
}
VIm[i] = cPm_in;
}
}
// 4. create a matrix of 5 slices, containing pJ(vectx-1,vecty),pJ(vectx,vecty-1),pJ(vectx,vecty),pJ(vectx,vecty+1),pJ(vectx+1,vecty) where vectx=2:m-1; and vecty=2:n-1;
Matrice Jq[5];
int s = 0;
Matrice pJ_temp = Matrice(m-1, n-1);
for (int x=0; x<m-2; x++)
{
for (int y=0; y<n-2; y++)
{
pJ_temp(x,y) = pJ(x+1,y+1);
}
}
Jq[2] = pJ_temp;
for (int k=-1; k<=1; k+=2)
{
for (int l=-1; l<=1; l+=2)
{
Matrice pJ_temp = Matrice(m-1, n-1);
for (int x=0; x<m-2; x++)
{
for (int y=0; y<n-2; y++)
{
pJ_temp(x,y) = pJ(x+k+1,y+l+1);
}
}
Jq[s] = pJ_temp;
s++;
if (s==2) s++; // we deal with middle slice before
}
}
// 4'. An alternative is to minimize the difference in intensity between slices.
if (homoInt)
{
Matrice VI_temp[5];
// compute the difference between VI and VIm
for (int i=0; i<5; i++)
VI_temp[i] = VI[i] - VIm[i];
// compute the minimum value for each element of the matrices
for (int i=0; i<5; i++)
{
for (int x=0; x<m-2; x++)
{
for (int y=0; y<n-2; y++)
{
if (VI_temp[i](x,y) > 0)
VI[i](x,y) = abs(VI_temp[i](x,y));///VIm[i](x,y);
else
VI[i](x,y) = abs(VI_temp[i](x,y));///VI[i](x,y);
}
}
}
}
// 5. sum Jq and Vi voxel by voxel to produce JV
Matrice JV[5];
for (int i=0; i<5; i++)
JV[i] = VI[i] + Jq[i];
// 6. replace each pixel of the (slice)th slice of J1 with the minimum value of the corresponding column in JV
for (int x=0; x<m-2; x++)
{
for (int y=0; y<n-2; y++)
{
double min_value = 1000000;
for (int i=0; i<5; i++)
{
if (JV[i](x,y) < min_value)
min_value = JV[i](x,y);
}
index[0] = x+1; index[1] = slice; index[2] = y+1;
J1->SetPixel(index, min_value);
}
}
}
// iterate on slice from slice n-1 to slice 1. Basically, we avoid first and last slices.
// IMPORTANT: first slice of J1 and last slice of J2 must be set to 0...
for (int x=0; x<m; x++)
{
for (int y=0; y<n; y++)
{
index[0] = x; index[1] = p-1; index[2] = y;
J2->SetPixel(index, 0.0);
}
}
for (int slice=p-2; slice>=0; slice--)
{
// 1. extract pJ = the (slice-1)th slice of the image J1
Matrice pJ = Matrice(m,n);
for (int x=0; x<m; x++)
{
for (int y=0; y<n; y++)
{
index[0] = x; index[1] = slice+1; index[2] = y;
pJ(x,y) = J2->GetPixel(index);
}
}
// 2. extract cP = the (slice)th slice of the image cPixel
Matrice cP = Matrice(m,n);
for (int x=0; x<m; x++)
{
for (int y=0; y<n; y++)
{
index[0] = x; index[1] = slice; index[2] = y;
cP(x,y) = cPixel->GetPixel(index);
}
}
// 2'
Matrice cPm = Matrice(m,n);
if (homoInt)
{
for (int x=0; x<m; x++)
{
for (int y=0; y<n; y++)
{
index[0] = x; index[1] = slice+1; index[2] = y;
cPm(x,y) = cPixel->GetPixel(index);
}
}
}
// 3. Create a matrix VI with 5 slices, that are exactly a repetition of cP without borders
// multiply all elements of all slices of VI except the middle one by factx
Matrice VI[5];
for (int i=0; i<5; i++)
{
// Create VI
Matrice cP_in = Matrice(m-1, n-1);
for (int x=0; x<m-2; x++)
{
for (int y=0; y<n-2; y++)
{
cP_in(x,y) = cP(x+1,y+1);
if (i!=2)
cP_in(x,y) *= factx;
}
}
VI[i] = cP_in;
}
// 3'.
Matrice VIm[5];
if (homoInt)
{
for (int i=0; i<5; i++)
{
// Create VI
Matrice cPm_in = Matrice(m-1, n-1);
for (int x=0; x<m-2; x++)
{
for (int y=0; y<n-2; y++)
{
cPm_in(x,y) = cPm(x+1,y+1);
if (i!=2)
cPm_in(x,y) *= factx;
}
}
VIm[i] = cPm_in;
}
}
// 4. create a matrix of 5 slices, containing pJ(vectx-1,vecty),pJ(vectx,vecty-1),pJ(vectx,vecty),pJ(vectx,vecty+1),pJ(vectx+1,vecty) where vectx=2:m-1; and vecty=2:n-1;
Matrice Jq[5];
int s = 0;
Matrice pJ_temp = Matrice(m-1, n-1);
for (int x=0; x<m-2; x++)
{
for (int y=0; y<n-2; y++)
{
pJ_temp(x,y) = pJ(x+1,y+1);
}
}
Jq[2] = pJ_temp;
for (int k=-1; k<=1; k+=2)
{
for (int l=-1; l<=1; l+=2)
{
Matrice pJ_temp = Matrice(m-1, n-1);
for (int x=0; x<m-2; x++)
{
for (int y=0; y<n-2; y++)
{
pJ_temp(x,y) = pJ(x+k+1,y+l+1);
}
}
Jq[s] = pJ_temp;
s++;
if (s==2) s++; // we deal with middle slice before
}
}
// 4'. An alternative is to minimize the difference in intensity between slices.
if (homoInt)
{
Matrice VI_temp[5];
// compute the difference between VI and VIm
for (int i=0; i<5; i++)
VI_temp[i] = VI[i] - VIm[i];
// compute the minimum value for each element of the matrices
for (int i=0; i<5; i++)
{
for (int x=0; x<m-2; x++)
{
for (int y=0; y<n-2; y++)
{
if (VI_temp[i](x,y) > 0)
VI[i](x,y) = abs(VI_temp[i](x,y));///VIm[i](x,y);
else
VI[i](x,y) = abs(VI_temp[i](x,y));///VI[i](x,y);
}
}
}
}
// 5. sum Jq and Vi voxel by voxel to produce JV
Matrice JV[5];
for (int i=0; i<5; i++)
JV[i] = VI[i] + Jq[i];
// 6. replace each pixel of the (slice)th slice of J1 with the minimum value of the corresponding column in JV
for (int x=0; x<m-2; x++)
{
for (int y=0; y<n-2; y++)
{
double min_value = 10000000;
for (int i=0; i<5; i++)
{
if (JV[i](x,y) < min_value)
min_value = JV[i](x,y);
}
index[0] = x+1; index[1] = slice; index[2] = y+1;
J2->SetPixel(index, min_value);
}
}
}
// add J1 and J2 to produce "S" which is actually J1 here.
ImageIterator3D vItS( J1, J1->GetBufferedRegion() );
ImageIterator3D vItJ2b( J2, J2->GetBufferedRegion() );
vItS.GoToBegin();
vItJ2b.GoToBegin();
while ( !vItS.IsAtEnd() )
{
vItS.Set(vItS.Get()+vItJ2b.Get());
++vItS;
++vItJ2b;
}
// Find the minimal value of S for each slice and create a binary image with all the coordinates
// TO DO: the minimal path shouldn't be a pixelar path. It should be a continuous spline that is minimum.
double val_temp;
vector<CVector3> list_index;
for (int slice=1; slice<p-1; slice++)
{
double min_value_S = 10000000;
ImageType::IndexType index_min;
for (int x=1; x<m-1; x++)
{
for (int y=1; y<n-1; y++)
{
index[0] = x; index[1] = slice; index[2] = y;
val_temp = J1->GetPixel(index);
if (val_temp < min_value_S)
{
min_value_S = val_temp;
index_min = index;
}
}
}
list_index.push_back(CVector3(index_min[0], index_min[1], index_min[2]));
}
//BSplineApproximation centerline_approximator = BSplineApproximation(&list_index);
//list_index = centerline_approximator.EvaluateBSplinePoints(list_index.size());
/*// create image with high values J1
ImageType::Pointer result_bin = J2;
ImageIterator3D vItresult( result_bin, result_bin->GetBufferedRegion() );
vItresult.GoToBegin();
while ( !vItresult.IsAtEnd() )
{
vItresult.Set(0.0);
++vItresult;
}
for (int i=0; i<list_index.size(); i++)
{
index[0] = list_index[i][0]; index[1] = list_index[i][1]; index[2] = list_index[i][2];
result_bin->SetPixel(index,1.0);
}
typedef itk::ImageFileWriter< ImageType > WriterTypeM;
WriterTypeM::Pointer writerMin = WriterTypeM::New();
itk::NiftiImageIO::Pointer ioV = itk::NiftiImageIO::New();
writerMin->SetImageIO(ioV);
writerMin->SetInput( J1 ); // result_bin
writerMin->SetFileName("minimalPath.nii.gz");
try {
writerMin->Update();
}
catch( itk::ExceptionObject & e )
{
cout << "Exception thrown ! " << endl;
cout << "An error ocurred during Writing Min" << endl;
cout << "Location = " << e.GetLocation() << endl;
cout << "Description = " << e.GetDescription() << endl;
}*/
centerline = list_index;
return J1; // return image with minimal path
}
void NrrdTensorImageReader
::GenerateData()
{
if ( m_FileName == "")
{
throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename 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;
}
}
try
{
MITK_INFO << "Trying to load dti as nifti ...";
std::string fname3 = "temp_dti.nii";
itksys::SystemTools::CopyAFile(m_FileName.c_str(), fname3.c_str());
typedef itk::Image<float,4> 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();
itksys::SystemTools::RemoveFile(fname3.c_str());
ImageType::Pointer img = reader->GetOutput();
itk::Size<4> size = img->GetLargestPossibleRegion().GetSize();
itk::ImageRegion< 3 > region;
region.SetSize(0,size[0]);
region.SetSize(1,size[1]);
region.SetSize(2,size[2]);
itk::Vector<double,3> spacing;
spacing[0] = img->GetSpacing()[0];
spacing[1] = img->GetSpacing()[1];
spacing[2] = img->GetSpacing()[2];
itk::Point<double,3> origin;
origin[0] = img->GetOrigin()[0];
origin[1] = img->GetOrigin()[1];
origin[2] = img->GetOrigin()[2];
itk::Matrix<double,3,3> direction;
direction[0][0] = img->GetDirection()[0][0];
direction[1][0] = img->GetDirection()[1][0];
direction[2][0] = img->GetDirection()[2][0];
direction[0][1] = img->GetDirection()[0][1];
direction[1][1] = img->GetDirection()[1][1];
direction[2][1] = img->GetDirection()[2][1];
direction[0][2] = img->GetDirection()[0][2];
direction[1][2] = img->GetDirection()[1][2];
direction[2][2] = img->GetDirection()[2][2];
typedef itk::Image<itk::DiffusionTensor3D<float>,3> VecImgType;
typedef VecImgType::PixelType FixPixType;
VecImgType::Pointer vecImg = VecImgType::New();
vecImg->SetSpacing( spacing );
vecImg->SetOrigin( origin );
vecImg->SetDirection( direction );
vecImg->SetRegions( region );
vecImg->Allocate();
itk::ImageRegionIterator<VecImgType> ot (vecImg, vecImg->GetLargestPossibleRegion() );
ot = ot.Begin();
while (!ot.IsAtEnd())
{
itk::DiffusionTensor3D<float> tensor;
ImageType::IndexType idx;
idx[0] = ot.GetIndex()[0]; idx[1] = ot.GetIndex()[1]; idx[2] = ot.GetIndex()[2];
if (size[3]==6)
{
for (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!");
FixPixType fixVec(tensor);
ot.Set(fixVec);
++ot;
}
this->GetOutput()->InitializeByItk(vecImg.GetPointer());
this->GetOutput()->SetVolume(vecImg->GetBufferPointer());
}
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(this->m_FileName);
reader->Update();
ImageType::Pointer img = reader->GetOutput();
typedef itk::Image<itk::DiffusionTensor3D<float>,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->SetRegions( img->GetLargestPossibleRegion());
vecImg->Allocate();
itk::ImageRegionIterator<VecImgType> ot (vecImg, vecImg->GetLargestPossibleRegion() );
ot = ot.Begin();
itk::ImageRegionIterator<ImageType> it (img, img->GetLargestPossibleRegion() );
it = it.Begin();
typedef ImageType::PixelType VarPixType;
typedef VecImgType::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)
{
itk::DiffusionTensor3D<float> 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();
itk::DiffusionTensor3D<float> 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(this->m_FileName);
reader->Update();
ImageType::Pointer img = reader->GetOutput();
itk::Size<4> size = img->GetLargestPossibleRegion().GetSize();
MITK_INFO << size;
while (!ot.IsAtEnd())
{
itk::DiffusionTensor3D<float> tensor;
ImageType::IndexType idx;
idx[0] = ot.GetIndex()[0]; idx[1] = ot.GetIndex()[1]; idx[2] = ot.GetIndex()[2];
if (size[3]==6)
{
for (int te=0; te<size[3]; te++)
{
idx[3] = te;
tensor.SetElement(te, img->GetPixel(idx));
}
// idx[3] = 0;
// tensor.SetElement(0, img->GetPixel(idx));
// idx[3] = 1;
// tensor.SetElement(1, img->GetPixel(idx));
// idx[3] = 3;
// tensor.SetElement(2, img->GetPixel(idx));
// idx[3] = 2;
// tensor.SetElement(3, img->GetPixel(idx));
// idx[3] = 4;
// tensor.SetElement(4, img->GetPixel(idx));
// idx[3] = 5;
// tensor.SetElement(5, 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!");
}
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 DTI 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;
}
virtual ReadResult readImage(const std::string& file, const osgDB::ReaderWriter::Options* options) const
{
std::string ext = osgDB::getLowerCaseFileExtension(file);
if (!acceptsExtension(ext)) return ReadResult::FILE_NOT_HANDLED;
std::string fileName = osgDB::findDataFile( file, options );
if (fileName.empty()) return ReadResult::FILE_NOT_FOUND;
notice()<<"Reading DICOM file "<<fileName<<std::endl;
typedef unsigned short PixelType;
const unsigned int Dimension = 3;
typedef itk::Image< PixelType, Dimension > ImageType;
typedef itk::ImageFileReader< ImageType > ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName( fileName.c_str() );
typedef itk::GDCMImageIO ImageIOType;
ImageIOType::Pointer gdcmImageIO = ImageIOType::New();
reader->SetImageIO( gdcmImageIO );
try
{
reader->Update();
}
catch (itk::ExceptionObject & e)
{
std::cerr << "exception in file reader " << std::endl;
std::cerr << e.GetDescription() << std::endl;
std::cerr << e.GetLocation() << std::endl;
return ReadResult::ERROR_IN_READING_FILE;
}
ImageType::Pointer inputImage = reader->GetOutput();
ImageType::RegionType region = inputImage->GetBufferedRegion();
ImageType::SizeType size = region.GetSize();
ImageType::IndexType start = region.GetIndex();
//inputImage->GetSpacing();
//inputImage->GetOrigin();
unsigned int width = size[0];
unsigned int height = size[1];
unsigned int depth = size[2];
osg::RefMatrix* matrix = new osg::RefMatrix;
notice()<<"width = "<<width<<" height = "<<height<<" depth = "<<depth<<std::endl;
for(unsigned int i=0; i<Dimension; ++i)
{
(*matrix)(i,i) = inputImage->GetSpacing()[i];
(*matrix)(3,i) = inputImage->GetOrigin()[i];
}
osg::Image* image = new osg::Image;
image->allocateImage(width, height, depth, GL_LUMINANCE, GL_UNSIGNED_BYTE, 1);
unsigned char* data = image->data();
typedef itk::ImageRegionConstIterator< ImageType > IteratorType;
IteratorType it(inputImage, region);
it.GoToBegin();
while (!it.IsAtEnd())
{
*data = it.Get();
++data;
++it;
}
image->setUserData(matrix);
matrix->preMult(osg::Matrix::scale(double(image->s()), double(image->t()), double(image->r())));
return image;
}
int main(int argc, char *argv[])
{
//check that the user specified the right number of command line arguments
if(argc < 3)
{
cerr << argv[0] << " <input file> <output file>" << endl;
cerr << argv[0] << " <raw input file> <sizeX> <sizeY> <sizeZ> <output file>"
<< endl;
return EXIT_FAILURE;
}
//check if the input image is .raw
bool rawInput = false;
string inputFileName = argv[1];
const char *outputFileName;
//double space[3]={1,1,1};
if(inputFileName.rfind(".raw") != string::npos)
{
//if so, the user is also required to pass in image dimensions
if(argc < 6)
{
cerr << "Usage: <raw input file> <sizeX> <sizeY> <sizeZ> <output file>" << endl;
return EXIT_FAILURE;
}
rawInput = true;
sizeX = atoi(argv[2]);
sizeY = atoi(argv[3]);
sizeZ = atoi(argv[4]);
outputFileName = argv[5];
}
else
{
outputFileName = argv[2];
}
FILE *infile = 0;
FILE *outfile;
int i,j,k;
int ii, jj, kk;
DATATYPEOUT *volout;
long idx;
int sizeExpand = 0;
DATATYPEOUT blockMax;
int timesDilate;
int border;
unsigned short *GraphcutResults;
cout << "Volume Processing..." << endl;
//make sure we can write to the output file
if((outfile=fopen(outputFileName, "wb")) == NULL)
{
cerr << "Output file open error!" << endl;
return EXIT_FAILURE;
}
typedef float PixelType;
const unsigned int Dimension = 3;
typedef itk::Image< PixelType, Dimension > ImageType;
ImageType::Pointer inputImage;
if(rawInput)
{
if((infile=fopen(inputFileName.c_str(), "rb"))==NULL)
{
cout << "Input file open error!" << endl;
return EXIT_FAILURE;
}
volin = (DATATYPEIN*)malloc(sizeX*sizeY*(sizeZ+sizeExpand*2)*sizeof(DATATYPEIN));
if (fread(volin, sizeof(DATATYPEIN), sizeX*sizeY*sizeZ, infile) < (unsigned int)(sizeX*sizeY*sizeZ))
{
cerr << "File size is not the same as volume size" << endl;
return EXIT_FAILURE;
}
inputImage = ImageType::New();
ImageType::PointType origin;
origin[0] = 0.;
origin[1] = 0.;
origin[2] = 0.;
inputImage->SetOrigin( origin );
ImageType::IndexType start;
start[0] = 0;
start[1] = 0;
start[2] = 0;
ImageType::SizeType size;
size[0] = sizeX;
size[1] = sizeY;
size[2] = sizeZ;
ImageType::RegionType region;
region.SetSize( size );
region.SetIndex( start );
inputImage->SetRegions( region );
inputImage->Allocate();
inputImage->FillBuffer(0);
inputImage->Update();
typedef itk::ImageRegionIteratorWithIndex< ImageType > IteratorType;
IteratorType iterator1(inputImage,inputImage->GetRequestedRegion());
int lng = sizeX*sizeY*sizeZ;
for(int i=0; i<lng; i++)
{
iterator1.Set((float)volin[i]);
++iterator1;
}
} // end if(rawInput)
else
{
typedef itk::ImageFileReader< ImageType > ReaderType;
ReaderType::Pointer reader = ReaderType::New();
inputImage = reader->GetOutput();
reader->SetFileName( inputFileName.c_str() );
try
{
reader->Update();
}
catch( itk::ExceptionObject & err )
{
cerr << "ExceptionObject caught!" << endl;
cerr << err << endl;
return EXIT_FAILURE;
}
} // end of itk image read
// ---------------Linear Mapping --------------------//
typedef itk::RescaleIntensityImageFilter<
ImageType, ImageType> RescaleFilterType;
RescaleFilterType::Pointer rescaleFilter = RescaleFilterType::New();
rescaleFilter->SetInput(inputImage);
rescaleFilter->SetOutputMinimum( 0 );
rescaleFilter->SetOutputMaximum( 255 );
try
{
rescaleFilter->Update();
}
catch( itk::ExceptionObject & err )
{
cerr << "ExceptionObject caught!" << endl;
cerr << err << endl;
return EXIT_FAILURE;
}
inputImage = rescaleFilter->GetOutput();
cout << "The Linear Mapping is done\n";
# if Curvature_Anistropic_Diffusion
{
cout << "The Curvature Diffusion is doing\n";
typedef itk::CurvatureAnisotropicDiffusionImageFilter<
ImageType, ImageType > MCD_FilterType;
MCD_FilterType::Pointer MCDFilter = MCD_FilterType::New();
//Initialnization, using the paper's optimal parameters
const unsigned int numberOfIterations = 5;
const double timeStep = 0.0425;
const double conductance = 3;
MCDFilter->SetNumberOfIterations(numberOfIterations);
MCDFilter->SetTimeStep( timeStep );
MCDFilter->SetConductanceParameter( conductance );
MCDFilter->SetInput(inputImage);
try
{
MCDFilter->Update();
}
catch( itk::ExceptionObject & err )
{
cerr << "ExceptionObject caught!" << endl;
cerr << err << endl;
return EXIT_FAILURE;
}
inputImage=MCDFilter->GetOutput();
cout << "The Curvature Diffusion is done\n";
}
#endif
ImageType::RegionType region = inputImage->GetBufferedRegion();
ImageType::SizeType size = region.GetSize();
cout << "input image size: " << size << endl;
sizeX = size[0];
sizeY = size[1];
sizeZ = size[2];
itk::ImageRegionIterator< ImageType >
itr( inputImage, inputImage->GetBufferedRegion() );
itr.GoToBegin();
idx = 0;
volin = (DATATYPEIN*)malloc(sizeX*sizeY*(sizeZ+sizeExpand*2)*sizeof(DATATYPEIN));
while( ! itr.IsAtEnd() )
{
volin[idx] = itr.Get();
++itr;
++idx;
}
//allocate memory for the output image
volout = (DATATYPEOUT*)malloc(sizeX*sizeY*(sizeZ+sizeExpand*2)*sizeof(DATATYPEOUT));
// one pre-processing scheme
GraphcutResults = (unsigned short*)malloc(sizeX*sizeY*(sizeZ+sizeExpand*2)*sizeof(unsigned short));
Neuron_Binarization_3D(volin,GraphcutResults,sizeX,sizeY,sizeZ,0,1);
for (k=0; k<(sizeZ+sizeExpand*2); k++)
for (j=0; j<sizeY; j++)
for (i=0; i<sizeX; i++) {
volout[k *sizeX*sizeY + j *sizeX + i] = 0;
} //initial to zeros
std::cout << "Do you think we need the distance transform to make the centerline of image become bright with higher intensity?";
char tmpAnswer = 'n';
//tmpAnswer = getchar();
if (tmpAnswer =='Y' || tmpAnswer =='y')
{
unsigned char *GraphcutResultsTmp;
GraphcutResultsTmp = (unsigned char*)malloc(sizeX*sizeY*(sizeZ+sizeExpand*2)*sizeof(unsigned char));
for (k=0; k<(sizeZ+sizeExpand*2); k++)
for (j=0; j<sizeY; j++)
for (i=0; i<sizeX; i++)
{
GraphcutResultsTmp[k *sizeX*sizeY + j *sizeX + i] = (unsigned char) GraphcutResults[k *sizeX*sizeY + j *sizeX + i];
} //initial to zeros
distTransform(GraphcutResultsTmp,sizeX,sizeY,sizeZ);
for (k=0; k<sizeZ; k++)
{
// threshold first
for (j=0; j<sizeY; j++)
{
for (i=0; i<sizeX; i++)
{
idx = k *sizeX*sizeY + j *sizeX + i;
volin[idx] = GraphcutResultsTmp [idx];
} // end for
} // end for
} // end for
free(GraphcutResultsTmp);
GraphcutResultsTmp=NULL;
} // end if
else {
for (k=0; k<sizeZ; k++)
{
// threshold first
for (j=0; j<sizeY; j++)
{
for (i=0; i<sizeX; i++)
{
idx = k *sizeX*sizeY + j *sizeX + i;
if (GraphcutResults [idx] == 0)
{
volin[idx] = 0;
}
}
}
}
} // end else
free(GraphcutResults);
GraphcutResults=NULL;
// the secpnd Pre-Processing method, corresponding to the old version MDL
/*
double threshold;
// by xiao liang, using 3 sigma theory to estimate threshold;
double meanValue =0.0, VarianceValue = 0.0;
// threshold first
for (k=0; k<sizeZ; k++)
{
for (j=0; j<sizeY; j++)
{
for (i=0; i<sizeX; i++)
{
idx = k *sizeX*sizeY + j *sizeX + i;
meanValue += volin[idx];
}
}
}
meanValue = meanValue/(double)(sizeX*sizeY*sizeZ);
// threshold first
for (k=0; k<sizeZ; k++)
{
for (j=0; j<sizeY; j++)
{
for (i=0; i<sizeX; i++)
{
idx = k *sizeX*sizeY + j *sizeX + i;
VarianceValue += (volin[idx]-meanValue)*(volin[idx]-meanValue);
}
}
}
VarianceValue = VarianceValue/(double)(sizeX*sizeY*sizeZ);
VarianceValue = sqrt(VarianceValue);
double m_threshold=OtsuThreshold (sizeX,sizeY,sizeZ);
if (m_threshold > 7 || m_threshold < 0)
{
threshold =(meanValue-VarianceValue/30);
}
else
{
threshold = m_threshold;
}
//threshold =7;
cout << "OTSU optimal threshold " << threshold << endl;
for (k=0; k<(sizeZ+sizeExpand*2); k++)
for (j=0; j<sizeY; j++)
for (i=0; i<sizeX; i++) {
volout[k *sizeX*sizeY + j *sizeX + i] = 0;
} //initial to zeros
for (k=0; k<sizeZ; k++)
{
// threshold first
for (j=0; j<sizeY; j++)
{
for (i=0; i<sizeX; i++)
{
idx = k *sizeX*sizeY + j *sizeX + i;
if (volin[idx] < threshold)
{
volin[idx] = 0;
}
}
}
}
*/
// Method 2: Dilation of the object
timesDilate = 1;
border = 3;
while (timesDilate >0 )
{
for (k=border; k<sizeZ-border; k++)
{
for (j=border; j<sizeY-border; j++)
{
for (i=border; i<sizeX-border; i++)
{
blockMax = volin[k *sizeX*sizeY + j *sizeX + i];
for (kk=-1; kk<=1; kk++)
{
for (jj=-1; jj<=1; jj++)
{
for (ii=-1; ii<=1; ii++)
{
if(volin[(k+kk)*sizeX*sizeY + (j+jj)*sizeX + (i+ii)] > blockMax)
{
blockMax = volin[(k+kk)*sizeX*sizeY + (j+jj)*sizeX + (i+ii)];
}
}
}
}
// Keep the peak of the original intensity
if (blockMax == volin[k *sizeX*sizeY + j *sizeX + i] && blockMax != 0)
{
blockMax = blockMax + 1;
//if (blockMax > 255) blockMax = 255;
}
volout[k *sizeX*sizeY + j *sizeX + i] = blockMax;
}
}
}
// copy volout back to volin for the next dilation
for (k=0; k<sizeZ; k++)
{
for (j=0; j<sizeY; j++)
{
for (i=0; i<sizeX; i++)
{
volin[k *sizeX*sizeY + j *sizeX + i] = volout[k *sizeX*sizeY + j *sizeX + i];
}
}
}
timesDilate--;
}
//----- Image write
/*
typedef itk::ImageRegionIteratorWithIndex< ImageType > IteratorType;
IteratorType iterator1(inputImage,inputImage->GetRequestedRegion());
int lng = sizeX*sizeY*sizeZ;
for(int i=0; i<lng; i++)
{
iterator1.Set((float)volin[i]);
++iterator1;
}
*/
//write the output image and free memory
fwrite(volout, sizeX*sizeY*sizeZ, sizeof(DATATYPEOUT), outfile);
FILE *mhdfile;
if((mhdfile=fopen("volume_Processed.mhd","w"))==NULL)
{
cerr << "output file open error!" << endl;
return -1;
}
fprintf (mhdfile,"ObjectType = Image\n");
fprintf (mhdfile,"NDims = 3\n");
fprintf (mhdfile,"BinaryData = True\n");
fprintf (mhdfile,"BinaryDataByteOrderMSB = False\n");
fprintf (mhdfile,"CompressedData = False\n");
fprintf (mhdfile,"TransformMatrix = 1 0 0 0 1 0 0 0 1\n");
fprintf (mhdfile,"Offset = 0 0 0\n");
fprintf (mhdfile,"CenterOfRotation = 0 0 0\n");
fprintf (mhdfile,"AnatomicalOrientation = RAI\n");
fprintf (mhdfile,"ElementSpacing = 1 1 1\n");
fprintf (mhdfile,"DimSize = %d %d %d\n",sizeX,sizeY,sizeZ);
fprintf (mhdfile,"ElementType = MET_UCHAR\n");
fprintf (mhdfile,"ElementDataFile = volume_Processed.raw\n");
fclose(mhdfile);
if (rawInput)
fclose(infile);
fclose(outfile);
free(volin); // by xiao
free(volout); // by xiao
volin=NULL;
volout=NULL;
//cout << "Done" << endl;
return 0;
}
void MakeDices(const char * montagefileName, const char * seedfileName, int diceWidth,
double alfa, double beta, int timethreshold, double curvatureScaling, double rmsThres, int holeSize, int minObjSize)
{
typedef SomaExtractor::ProbImageType ImageType;
typedef SomaExtractor::OutputImageType OutputImageType;
typedef itk::RegionOfInterestImageFilter< ImageType, ImageType> RegionOfInterestFilter;
SomaExtractor *Somas = new SomaExtractor();
std::cout<< "ReadMontage..."<<std::endl;
ImageType::Pointer image = Somas->SetInputImage(montagefileName);
int SZ = image->GetLargestPossibleRegion().GetSize()[2];
std::vector< itk::Index<3> > seedVector;
Somas->ReadSeedpoints( seedfileName, seedVector, 0);
std::cout<< "Seed points size:"<< seedVector.size()<<std::endl;
#pragma omp parallel for
for(int i = 0; i < seedVector.size(); i++)
{
SomaExtractor *somaExtractor = new SomaExtractor();
ImageType::IndexType start;
start[0] = seedVector[i][0] - diceWidth / 2;
start[1] = seedVector[i][1] - diceWidth / 2;
start[2] = 0;
ImageType::SizeType size;
size[0] = diceWidth;
size[1] = diceWidth;
size[2] = SZ;
ImageType::RegionType desiredRegion;
desiredRegion.SetSize(size);
desiredRegion.SetIndex(start);
RegionOfInterestFilter::Pointer regionFilter = RegionOfInterestFilter::New();
regionFilter->SetInput(image);
regionFilter->SetRegionOfInterest(desiredRegion);
regionFilter->Update();
ImageType::Pointer diceImage = regionFilter->GetOutput();
std::ostringstream oss1;
oss1<< "Dice_"<< i<<".tif";
std::string str1 = oss1.str();
somaExtractor->writeImage(str1.c_str(), diceImage);
std::vector< itk::Index<3> > seedsForDice;
itk::Index<3> seedIndex = seedVector[i];
seedIndex[0] = diceWidth / 2;
seedIndex[1] = diceWidth / 2;
seedsForDice.push_back(seedIndex);
float Origion[3] = {0,0,0};
diceImage->SetOrigin(Origion);
//SomaExtractor::SegmentedImageType::Pointer segImage= somaExtractor->SegmentSoma(diceImage, seedsForDice, alfa,
// beta, timethreshold, curvatureScaling, rmsThres, holeSize, minObjSize);
//double threshold = 0;
// //ImageType::Pointer segImage = Somas->EnhanceContrast(diceImage, seedIndex[2], alfa, beta, threshold);
//
//#pragma omp critical
// std::cout<< "segment "<< i<<"\t"<<seedsForDice.size()<<std::endl;
// std::ostringstream oss;
// oss<< "Dice_Segment_"<< i<<".tif";
// std::string str = oss.str();
// somaExtractor->writeImage(str.c_str(), segImage);
delete somaExtractor;
}
delete Somas;
}
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;
}
// Run with: Data/trashcan.mha Data/trashcan_mask.mha 15 filled.mha
int main(int argc, char *argv[])
{
// Verify arguments
if(argc != 6)
{
std::cerr << "Required arguments: image.mha imageMask.mha patchHalfWidth neighborhoodRadius output.mha" << std::endl;
std::cerr << "Input arguments: ";
for(int i = 1; i < argc; ++i)
{
std::cerr << argv[i] << " ";
}
return EXIT_FAILURE;
}
// Parse arguments
std::string imageFileName = argv[1];
std::string maskFileName = argv[2];
std::stringstream ssPatchRadius;
ssPatchRadius << argv[3];
unsigned int patchHalfWidth = 0;
ssPatchRadius >> patchHalfWidth;
// The percent of the image size to use as the neighborhood (0 - 1)
std::stringstream ssNeighborhoodPercent;
ssNeighborhoodPercent << argv[4];
float neighborhoodPercent = 0;
ssNeighborhoodPercent >> neighborhoodPercent;
std::string outputFileName = argv[5];
// Output arguments
std::cout << "Reading image: " << imageFileName << std::endl;
std::cout << "Reading mask: " << maskFileName << std::endl;
std::cout << "Patch half width: " << patchHalfWidth << std::endl;
std::cout << "Neighborhood percent: " << neighborhoodPercent << std::endl;
std::cout << "Output: " << outputFileName << std::endl;
typedef itk::Image<itk::CovariantVector<int, 3>, 2> ImageType;
typedef itk::ImageFileReader<ImageType> ImageReaderType;
ImageReaderType::Pointer imageReader = ImageReaderType::New();
imageReader->SetFileName(imageFileName);
imageReader->Update();
ImageType::Pointer image = ImageType::New();
ITKHelpers::DeepCopy(imageReader->GetOutput(), image.GetPointer());
Mask::Pointer mask = Mask::New();
mask->Read(maskFileName);
std::cout << "hole pixels: " << mask->CountHolePixels() << std::endl;
std::cout << "valid pixels: " << mask->CountValidPixels() << std::endl;
typedef ImagePatchPixelDescriptor<ImageType> ImagePatchPixelDescriptorType;
// Create the graph
typedef boost::grid_graph<2> VertexListGraphType;
boost::array<std::size_t, 2> graphSideLengths = { { imageReader->GetOutput()->GetLargestPossibleRegion().GetSize()[0],
imageReader->GetOutput()->GetLargestPossibleRegion().GetSize()[1] } };
// VertexListGraphType graph(graphSideLengths);
std::shared_ptr<VertexListGraphType> graph(new VertexListGraphType(graphSideLengths));
typedef boost::graph_traits<VertexListGraphType>::vertex_descriptor VertexDescriptorType;
//ImagePatchDescriptorMapType smallImagePatchDescriptorMap(num_vertices(graph), indexMap);
// Create the patch inpainter. The inpainter needs to know the status of each pixel to determine if they should be inpainted.
typedef PatchInpainter<ImageType> ImageInpainterType;
std::shared_ptr<ImageInpainterType> imagePatchInpainter(new
ImageInpainterType(patchHalfWidth, image, mask));
// Create the priority function
typedef PriorityRandom PriorityType;
std::shared_ptr<PriorityType> priorityFunction(new PriorityType);
// typedef PriorityCriminisi<ImageType> PriorityType;
// std::shared_ptr<PriorityType> priorityFunction(new PriorityType(image, mask, patchHalfWidth));
typedef IndirectPriorityQueue<VertexListGraphType> BoundaryNodeQueueType;
std::shared_ptr<BoundaryNodeQueueType> boundaryNodeQueue(new BoundaryNodeQueueType(*graph));
// Create the descriptor map. This is where the data for each pixel is stored.
typedef boost::vector_property_map<ImagePatchPixelDescriptorType, BoundaryNodeQueueType::IndexMapType> ImagePatchDescriptorMapType;
// ImagePatchDescriptorMapType imagePatchDescriptorMap(num_vertices(graph), indexMap);
std::shared_ptr<ImagePatchDescriptorMapType> imagePatchDescriptorMap(new
ImagePatchDescriptorMapType(num_vertices(*graph), *(boundaryNodeQueue->GetIndexMap())));
// Create the descriptor visitor
typedef ImagePatchDescriptorVisitor<VertexListGraphType, ImageType, ImagePatchDescriptorMapType>
ImagePatchDescriptorVisitorType;
// ImagePatchDescriptorVisitorType imagePatchDescriptorVisitor(image, mask, imagePatchDescriptorMap, patchHalfWidth);
std::shared_ptr<ImagePatchDescriptorVisitorType> imagePatchDescriptorVisitor(new
ImagePatchDescriptorVisitorType(image.GetPointer(), mask,
imagePatchDescriptorMap, patchHalfWidth));
/* ImagePatchDescriptorVisitor(TImage* const in_image, Mask* const in_mask,
std::shared_ptr<TDescriptorMap> in_descriptorMap,
const unsigned int in_half_width) : */
typedef ImagePatchDifference<ImagePatchPixelDescriptorType, SumAbsolutePixelDifference<ImageType::PixelType> >
ImagePatchDifferenceType;
// typedef CompositeDescriptorVisitor<VertexListGraphType> CompositeDescriptorVisitorType;
// CompositeDescriptorVisitorType compositeDescriptorVisitor;
// compositeDescriptorVisitor.AddVisitor(imagePatchDescriptorVisitor);
// Create the descriptor visitor
// typedef CompositeAcceptanceVisitor<VertexListGraphType> CompositeAcceptanceVisitorType;
// CompositeAcceptanceVisitorType compositeAcceptanceVisitor;
typedef DefaultAcceptanceVisitor<VertexListGraphType> AcceptanceVisitorType;
std::shared_ptr<AcceptanceVisitorType> acceptanceVisitor(new AcceptanceVisitorType);
// typedef AlwaysAccept<VertexListGraphType> AcceptanceVisitorType;
// AcceptanceVisitorType acceptanceVisitor;
// If the hole is less than 15% of the patch, always accept the initial best match
// HoleSizeAcceptanceVisitor<VertexListGraphType> holeSizeAcceptanceVisitor(mask, patchHalfWidth, .15);
// compositeAcceptanceVisitor.AddOverrideVisitor(&holeSizeAcceptanceVisitor);
// AllQuadrantHistogramCompareAcceptanceVisitor<VertexListGraphType, ImageType>
// allQuadrantHistogramCompareAcceptanceVisitor(image, mask, patchHalfWidth, 8.0f); // Crazy low
// compositeAcceptanceVisitor.AddRequiredPassVisitor(&allQuadrantHistogramCompareAcceptanceVisitor);
// template <typename TGraph, typename TBoundaryNodeQueue,
// typename TDescriptorVisitor, typename TAcceptanceVisitor, typename TPriority>
typedef InpaintingVisitor<VertexListGraphType, BoundaryNodeQueueType,
ImagePatchDescriptorVisitorType, AcceptanceVisitorType, PriorityType>
InpaintingVisitorType;
std::shared_ptr<InpaintingVisitorType> inpaintingVisitor(new InpaintingVisitorType(mask, boundaryNodeQueue,
imagePatchDescriptorVisitor, acceptanceVisitor,
priorityFunction, patchHalfWidth, "InpaintingVisitor"));
// typedef InpaintingVisitor<VertexListGraphType, BoundaryNodeQueueType,
// ImagePatchDescriptorVisitorType, AcceptanceVisitorType, PriorityType>
// InpaintingVisitorType;
// std::shared_ptr<InpaintingVisitorType> inpaintingVisitor(new InpaintingVisitorType(mask, boundaryNodeQueue,
// imagePatchDescriptorVisitor, acceptanceVisitor,
// priorityFunction, patchHalfWidth, "InpaintingVisitor"));
// typedef DebugVisitor<VertexListGraphType, ImageType, BoundaryStatusMapType, BoundaryNodeQueueType> DebugVisitorType;
// DebugVisitorType debugVisitor(image, mask, patchHalfWidth, boundaryStatusMap, boundaryNodeQueue);
LoggerVisitor<VertexListGraphType> loggerVisitor("log.txt");
InitializePriority(mask, boundaryNodeQueue.get(), priorityFunction.get());
// Initialize the boundary node queue from the user provided mask image.
InitializeFromMaskImage<InpaintingVisitorType, VertexDescriptorType>(mask, inpaintingVisitor.get());
// For debugging we use LinearSearchBestProperty instead of DefaultSearchBest because it can output the difference value.
typedef LinearSearchBestProperty<ImagePatchDescriptorMapType,
ImagePatchDifferenceType > BestSearchType;
std::shared_ptr<BestSearchType> linearSearchBest(new BestSearchType(*imagePatchDescriptorMap));
typedef NeighborhoodSearch<VertexDescriptorType, ImagePatchDescriptorMapType> NeighborhoodSearchType;
NeighborhoodSearchType neighborhoodSearch(image->GetLargestPossibleRegion(), image->GetLargestPossibleRegion().GetSize()[0] * neighborhoodPercent, *imagePatchDescriptorMap);
InpaintingAlgorithmWithLocalSearch<VertexListGraphType, InpaintingVisitorType,
BoundaryNodeQueueType, NeighborhoodSearchType,
ImageInpainterType, BestSearchType>(graph, inpaintingVisitor, boundaryNodeQueue,
linearSearchBest, imagePatchInpainter, neighborhoodSearch);
// If the output filename is a png file, then use the RGBImage writer so that it is first
// casted to unsigned char. Otherwise, write the file directly.
if(Helpers::GetFileExtension(outputFileName) == "png")
{
ITKHelpers::WriteRGBImage(image.GetPointer(), outputFileName);
}
else
{
ITKHelpers::WriteImage(image.GetPointer(), outputFileName);
}
return EXIT_SUCCESS;
}
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;
}
void TestComputeMaskedImage1DHistogram()
{
// // Single channel
// {
// typedef itk::Image<unsigned char, 2> ImageType;
// ImageType::Pointer image = ImageType::New();
// ImageType::IndexType corner = {{0,0}};
// ImageType::SizeType size = {{100,100}};
// ImageType::RegionType region(corner, size);
// image->SetRegions(region);
// image->Allocate();
// itk::ImageRegionIterator<ImageType> imageIterator(image,region);
// while(!imageIterator.IsAtEnd())
// {
// if(imageIterator.GetIndex()[0] < 70)
// {
// imageIterator.Set(255);
// }
// else
// {
// imageIterator.Set(0);
// }
// ++imageIterator;
// }
// ImageType::PixelType rangeMin = 0;
// ImageType::PixelType rangeMax = 255;
// unsigned int numberOfBins = 10;
// typedef int BinValueType;
// typedef Histogram<BinValueType>::HistogramType HistogramType;
// HistogramType histogram = Histogram<BinValueType>::ComputeImageHistogram1D(image.GetPointer(),
// image->GetLargestPossibleRegion(),
// numberOfBins, rangeMin, rangeMax);
// Histogram<BinValueType>::OutputHistogram(histogram);
// std::cout << std::endl;
// }
// Multi channel VectorImage
{
typedef itk::VectorImage<unsigned char, 2> ImageType;
ImageType::Pointer image = ImageType::New();
ImageType::IndexType corner = {{0,0}};
ImageType::SizeType size = {{100,100}};
ImageType::RegionType region(corner, size);
image->SetRegions(region);
image->SetNumberOfComponentsPerPixel(3);
image->Allocate();
Mask::Pointer mask = Mask::New();
mask->SetRegions(region);
mask->Allocate();
itk::ImageRegionIterator<ImageType> imageIterator(image,region);
while(!imageIterator.IsAtEnd())
{
ImageType::PixelType pixel(image->GetNumberOfComponentsPerPixel());
if(imageIterator.GetIndex()[0] < 70)
{
for(unsigned int i = 0; i < pixel.GetSize(); ++i)
{
pixel[i] = 255;
}
}
else
{
for(unsigned int i = 0; i < pixel.GetSize(); ++i)
{
pixel[i] = 0;
}
}
imageIterator.Set(pixel);
++imageIterator;
}
// TypeTraits<ImageType::PixelType>::ComponentType rangeMin = 0;
// TypeTraits<ImageType::PixelType>::ComponentType rangeMax = 255;
ImageType::PixelType rangeMins;
rangeMins.SetSize(image->GetNumberOfComponentsPerPixel());
rangeMins.Fill(0);
ImageType::PixelType rangeMaxs;
rangeMaxs.SetSize(image->GetNumberOfComponentsPerPixel());
rangeMaxs.Fill(255);
unsigned int numberOfBinsPerComponent = 10;
typedef int BinValueType;
itk::ImageRegion<2> imageRegion = image->GetLargestPossibleRegion();
itk::ImageRegion<2> maskRegion = image->GetLargestPossibleRegion();
typedef MaskedHistogramGenerator<BinValueType> HistogramGeneratorType;
typedef HistogramGeneratorType::HistogramType HistogramType;
bool allowOutside = false;
HistogramType histogram =
HistogramGeneratorType::ComputeMaskedImage1DHistogram(image.GetPointer(), imageRegion,
mask.GetPointer(), maskRegion,
numberOfBinsPerComponent, rangeMins, rangeMaxs,
allowOutside, HoleMaskPixelTypeEnum::VALID);
histogram.Print();
std::cout << std::endl;
}
// // Multi channel Image<CovariantVector>
// {
// typedef itk::Image<itk::CovariantVector<unsigned char, 3>, 2> ImageType;
// ImageType::Pointer image = ImageType::New();
// ImageType::IndexType corner = {{0,0}};
// ImageType::SizeType size = {{100,100}};
// ImageType::RegionType region(corner, size);
// image->SetRegions(region);
// image->Allocate();
// itk::ImageRegionIterator<ImageType> imageIterator(image,region);
// while(!imageIterator.IsAtEnd())
// {
// ImageType::PixelType pixel(image->GetNumberOfComponentsPerPixel());
// if(imageIterator.GetIndex()[0] < 70)
// {
// for(unsigned int i = 0; i < pixel.GetNumberOfComponents(); ++i)
// {
// pixel[i] = 255;
// }
// }
// else
// {
// for(unsigned int i = 0; i < pixel.GetNumberOfComponents(); ++i)
// {
// pixel[i] = 0;
// }
// }
// imageIterator.Set(pixel);
// ++imageIterator;
// }
// TypeTraits<ImageType::PixelType>::ComponentType rangeMin = 0;
// TypeTraits<ImageType::PixelType>::ComponentType rangeMax = 255;
// unsigned int numberOfBinsPerComponent = 10;
// typedef int BinValueType;
// Histogram<BinValueType>::HistogramType histogram = Histogram<BinValueType>::ComputeImageHistogram1D(image.GetPointer(),
// image->GetLargestPossibleRegion(),
// numberOfBinsPerComponent, rangeMin, rangeMax);
// Histogram<BinValueType>::OutputHistogram(histogram);
// std::cout << std::endl;
// }
}
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, char ** argv)
{
OptionsData options;
readXMLValues(argv[2], options);
exit(1);
// parse the dicom directory
gdcm::Directory dir;
dir.Load(argv[1], true);
gdcm::Directory::FilenamesType filenames = dir.GetFilenames();
gdcm::Tag seriesDescription = gdcm::Tag(0x0008,0x103e);
gdcm::Tag seriesNumber = gdcm::Tag(0x0020,0x0011);
gdcm::Tag instanceNumber = gdcm::Tag(0x0020,0x0013);
gdcm::Tag sliceThickness = gdcm::Tag(0x0018,0x0050);
gdcm::Tag triggerTime = gdcm::Tag(0x0018,0x1060);
gdcm::Tag numberOfImages = gdcm::Tag(0x0018,0x1090);
gdcm::Tag slicePosition = gdcm::Tag(0x0019,0x1015);
gdcm::Tag imagePosition = gdcm::Tag(0x0020,0x0032);
gdcm::Tag imageOrientation = gdcm::Tag(0x0020,0x0037);
gdcm::Tag sliceLocation = gdcm::Tag(0x0020,0x1041);
gdcm::Tag rows = gdcm::Tag(0x0028,0x0010);
gdcm::Tag cols = gdcm::Tag(0x0028,0x0011);
gdcm::Tag pixelSpacing = gdcm::Tag(0x0028,0x0030);
gdcm::Scanner scanner;
scanner.AddTag(seriesDescription);
scanner.AddTag(seriesNumber);
scanner.AddTag(instanceNumber);
scanner.AddTag(sliceThickness);
scanner.AddTag(triggerTime);
scanner.AddTag(numberOfImages);
scanner.AddTag(slicePosition);
scanner.AddTag(imagePosition);
scanner.AddTag(imageOrientation);
scanner.AddTag(sliceLocation);
scanner.AddTag(rows);
scanner.AddTag(cols);
scanner.AddTag(pixelSpacing);
scanner.Scan(filenames);
gdcm::Scanner::MappingType mapping = scanner.GetMappings();
// extract all the images that are Short axis and are the first instance
gdcm::Directory::FilenamesType targetFilenames;
for(unsigned int i = 0; i < filenames.size(); i++)
{
const char * fname = filenames[i].c_str();
if(mapping.count(fname) == 0) continue;
// extract the image information
std::string descriptionStr = mapping[fname][seriesDescription];
std::string instanceNumberStr = mapping[fname][instanceNumber];
QString description = QString::fromStdString(descriptionStr);
unsigned int instanceNumber = QString::fromStdString(instanceNumberStr).toInt();
// check that the description is a short axis one and is instance 1
if(instanceNumber == 1 && description.contains("sa", Qt::CaseInsensitive))
{
targetFilenames.push_back(filenames[i]);
}
}
// sort the images based on their slice position
/*
gdcm::Sorter sorter;
sorter.SetSortFunction(position_sort);
sorter.StableSort(targetFilenames);
gdcm::Directory::FilenamesType sorted = sorter.GetFilenames();
for(unsigned int i = 0; i < sorted.size(); i++)
{
const char * fname = sorted[i].c_str();
std::string position = mapping[fname][imagePosition];
std::cout << position << std::endl;
std::cout << mapping[fname][sliceLocation] << std::endl;
}
*/
std::cout << targetFilenames.size() << std::endl;
// find the slice with the smallest slice position
double smallest = 1000000.0;
int smallestIndex;
for(unsigned int i = 0; i < targetFilenames.size(); i++)
{
const char * fname = targetFilenames[i].c_str();
std::string slicePosition = mapping[fname][sliceLocation];
double pos = QString::fromStdString(slicePosition).toDouble();
std::cout << pos << std::endl;
if(pos < smallest)
{
smallest = pos;
smallestIndex = i;
}
}
// load the image
typedef itk::Image<unsigned short, 3> ImageType;
typedef itk::ImageFileReader<ImageType> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(targetFilenames[smallestIndex]);
reader->SetImageIO(itk::GDCMImageIO::New());
reader->Update();
// flip the x and y axis
typedef itk::PermuteAxesImageFilter<ImageType> FlipperType;
FlipperType::Pointer flipper = FlipperType::New();
itk::FixedArray<unsigned int, 3> order;
order[0] = 1;
order[1] = 0;
order[2] = 2;
flipper->SetOrder(order);
flipper->SetInput(reader->GetOutput());
flipper->Update();
ImageType::Pointer referenceImage = flipper->GetOutput();
ImageType::DirectionType direction = referenceImage->GetDirection();
direction.SetIdentity();
referenceImage->SetDirection(direction);
ImageType::PointType origin = referenceImage->GetOrigin();
origin.Fill(20.0);
referenceImage->SetOrigin(origin);
ImageType::SpacingType spacing;
spacing.Fill(1.0);
referenceImage->SetSpacing(spacing);
flipper->GetOutput()->Print(std::cout);
typedef itk::ImageFileWriter<ImageType> WriterType;
WriterType::Pointer writer = WriterType::New();
writer->SetInput(referenceImage);
writer->SetImageIO(itk::NrrdImageIO::New());
writer->SetFileName("test.nrrd");
writer->Update();
std::cout << targetFilenames[smallestIndex] << std::endl;
return 0;
}