diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkConnectomicsNetworkWriter.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkConnectomicsNetworkWriter.cpp
index c8bf4a3b1d..f4913056d2 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkConnectomicsNetworkWriter.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkConnectomicsNetworkWriter.cpp
@@ -1,136 +1,143 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkConnectomicsNetworkWriter.h"
#include "mitkConnectomicsNetworkDefinitions.h"
#include <tinyxml.h>
#include "itksys/SystemTools.hxx"
#include "mitkDiffusionIOMimeTypes.h"
mitk::ConnectomicsNetworkWriter::ConnectomicsNetworkWriter()
: AbstractFileWriter(mitk::ConnectomicsNetwork::GetStaticNameOfClass(), CustomMimeType( mitk::DiffusionIOMimeTypes::CONNECTOMICS_MIMETYPE_NAME() ), mitk::DiffusionIOMimeTypes::CONNECTOMICS_MIMETYPE_DESCRIPTION() )
{
RegisterService();
}
mitk::ConnectomicsNetworkWriter::ConnectomicsNetworkWriter(const mitk::ConnectomicsNetworkWriter& other)
: AbstractFileWriter(other)
{
}
mitk::ConnectomicsNetworkWriter::~ConnectomicsNetworkWriter()
{}
mitk::ConnectomicsNetworkWriter* mitk::ConnectomicsNetworkWriter::Clone() const
{
return new ConnectomicsNetworkWriter(*this);
}
void mitk::ConnectomicsNetworkWriter::Write()
{
MITK_INFO << "Writing connectomics network";
InputType::ConstPointer input = dynamic_cast<const InputType*>(this->GetInput());
if (input.IsNull() )
{
MITK_ERROR <<"Sorry, input to ConnectomicsNetworkWriter is NULL!";
return;
}
if ( this->GetOutputLocation().empty() )
{
MITK_ERROR << "Sorry, filename has not been set!" ;
return ;
}
std::string ext = itksys::SystemTools::GetFilenameLastExtension(this->GetOutputLocation());
ext = itksys::SystemTools::LowerCase(ext);
+ // default extension is .cnf
+ if(ext == "")
+ {
+ ext = ".cnf";
+ this->SetOutputLocation(this->GetOutputLocation() + ext);
+ }
+
if (ext == ".cnf")
{
// Get geometry of the network
mitk::BaseGeometry* geometry = input->GetGeometry();
// Create XML document
TiXmlDocument documentXML;
{ // begin document
TiXmlDeclaration* declXML = new TiXmlDeclaration( "1.0", "", "" ); // TODO what to write here? encoding? etc....
documentXML.LinkEndChild( declXML );
TiXmlElement* mainXML = new TiXmlElement(mitk::ConnectomicsNetworkDefinitions::XML_CONNECTOMICS_FILE);
mainXML->SetAttribute(mitk::ConnectomicsNetworkDefinitions::XML_FILE_VERSION, mitk::ConnectomicsNetworkDefinitions::VERSION_STRING);
documentXML.LinkEndChild(mainXML);
TiXmlElement* geometryXML = new TiXmlElement(mitk::ConnectomicsNetworkDefinitions::XML_GEOMETRY);
{ // begin geometry
geometryXML->SetDoubleAttribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_XX, geometry->GetMatrixColumn(0)[0]);
geometryXML->SetDoubleAttribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_XY, geometry->GetMatrixColumn(0)[1]);
geometryXML->SetDoubleAttribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_XZ, geometry->GetMatrixColumn(0)[2]);
geometryXML->SetDoubleAttribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_YX, geometry->GetMatrixColumn(1)[0]);
geometryXML->SetDoubleAttribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_YY, geometry->GetMatrixColumn(1)[1]);
geometryXML->SetDoubleAttribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_YZ, geometry->GetMatrixColumn(1)[2]);
geometryXML->SetDoubleAttribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_ZX, geometry->GetMatrixColumn(2)[0]);
geometryXML->SetDoubleAttribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_ZY, geometry->GetMatrixColumn(2)[1]);
geometryXML->SetDoubleAttribute(mitk::ConnectomicsNetworkDefinitions::XML_MATRIX_ZZ, geometry->GetMatrixColumn(2)[2]);
geometryXML->SetDoubleAttribute(mitk::ConnectomicsNetworkDefinitions::XML_ORIGIN_X, geometry->GetOrigin()[0]);
geometryXML->SetDoubleAttribute(mitk::ConnectomicsNetworkDefinitions::XML_ORIGIN_Y, geometry->GetOrigin()[1]);
geometryXML->SetDoubleAttribute(mitk::ConnectomicsNetworkDefinitions::XML_ORIGIN_Z, geometry->GetOrigin()[2]);
geometryXML->SetDoubleAttribute(mitk::ConnectomicsNetworkDefinitions::XML_SPACING_X, geometry->GetSpacing()[0]);
geometryXML->SetDoubleAttribute(mitk::ConnectomicsNetworkDefinitions::XML_SPACING_Y, geometry->GetSpacing()[1]);
geometryXML->SetDoubleAttribute(mitk::ConnectomicsNetworkDefinitions::XML_SPACING_Z, geometry->GetSpacing()[2]);
} // end geometry
mainXML->LinkEndChild(geometryXML);
TiXmlElement* verticesXML = new TiXmlElement(mitk::ConnectomicsNetworkDefinitions::XML_VERTICES);
{ // begin vertices section
VertexVectorType vertexVector = dynamic_cast<const InputType*>(this->GetInput())->GetVectorOfAllNodes();
for( unsigned int index = 0; index < vertexVector.size(); index++ )
{
// not localized as of yet TODO
TiXmlElement* vertexXML = new TiXmlElement(mitk::ConnectomicsNetworkDefinitions::XML_VERTEX );
vertexXML->SetAttribute( mitk::ConnectomicsNetworkDefinitions::XML_VERTEX_ID , vertexVector[ index ].id );
vertexXML->SetAttribute( mitk::ConnectomicsNetworkDefinitions::XML_VERTEX_LABEL , vertexVector[ index ].label );
vertexXML->SetDoubleAttribute( mitk::ConnectomicsNetworkDefinitions::XML_VERTEX_X , vertexVector[ index ].coordinates[0] );
vertexXML->SetDoubleAttribute( mitk::ConnectomicsNetworkDefinitions::XML_VERTEX_Y , vertexVector[ index ].coordinates[1] );
vertexXML->SetDoubleAttribute( mitk::ConnectomicsNetworkDefinitions::XML_VERTEX_Z , vertexVector[ index ].coordinates[2] );
verticesXML->LinkEndChild(vertexXML);
}
} // end vertices section
mainXML->LinkEndChild(verticesXML);
TiXmlElement* edgesXML = new TiXmlElement(mitk::ConnectomicsNetworkDefinitions::XML_EDGES);
{ // begin edges section
EdgeVectorType edgeVector = dynamic_cast<const InputType*>(this->GetInput())->GetVectorOfAllEdges();
for(unsigned int index = 0; index < edgeVector.size(); index++ )
{
TiXmlElement* edgeXML = new TiXmlElement(mitk::ConnectomicsNetworkDefinitions::XML_EDGE );
edgeXML->SetAttribute( mitk::ConnectomicsNetworkDefinitions::XML_EDGE_ID , index );
edgeXML->SetAttribute( mitk::ConnectomicsNetworkDefinitions::XML_EDGE_SOURCE_ID , edgeVector[ index ].second.sourceId );
edgeXML->SetAttribute( mitk::ConnectomicsNetworkDefinitions::XML_EDGE_TARGET_ID , edgeVector[ index ].second.targetId );
edgeXML->SetAttribute( mitk::ConnectomicsNetworkDefinitions::XML_EDGE_WEIGHT_ID , edgeVector[ index ].second.weight );
edgesXML->LinkEndChild(edgeXML);
}
} // end edges section
mainXML->LinkEndChild(edgesXML);
} // end document
documentXML.SaveFile( this->GetOutputLocation().c_str() );
MITK_INFO << "Connectomics network written";
}
}
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXWriter.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXWriter.cpp
index 8be7fc3d96..643219e16d 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXWriter.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXWriter.cpp
@@ -1,126 +1,133 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkFiberBundleXWriter.h"
#include <vtkSmartPointer.h>
#include <vtkCleanPolyData.h>
#include <itksys/SystemTools.hxx>
#include <mitkTrackvis.h>
#include <itkSize.h>
#include <mitkAbstractFileWriter.h>
#include <mitkCustomMimeType.h>
#include "mitkDiffusionIOMimeTypes.h"
mitk::FiberBundleXWriter::FiberBundleXWriter()
: mitk::AbstractFileWriter(mitk::FiberBundleX::GetStaticNameOfClass(), CustomMimeType( mitk::DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE_NAME() ), mitk::DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE_DESCRIPTION())
{
RegisterService();
}
mitk::FiberBundleXWriter::FiberBundleXWriter(const mitk::FiberBundleXWriter & other)
:mitk::AbstractFileWriter(other)
{}
mitk::FiberBundleXWriter::~FiberBundleXWriter()
{}
mitk::FiberBundleXWriter * mitk::FiberBundleXWriter::Clone() const
{
return new mitk::FiberBundleXWriter(*this);
}
void mitk::FiberBundleXWriter::Write()
{
std::ostream* out;
std::ofstream outStream;
if( this->GetOutputStream() )
{
out = this->GetOutputStream();
}else{
outStream.open( this->GetOutputLocation().c_str() );
out = &outStream;
}
if ( !out->good() )
{
mitkThrow() << "Stream not good.";
}
try
{
const std::string& locale = "C";
const std::string& currLocale = setlocale( LC_ALL, NULL );
setlocale(LC_ALL, locale.c_str());
std::locale previousLocale(out->getloc());
std::locale I("C");
out->imbue(I);
std::string filename = this->GetOutputLocation().c_str();
mitk::FiberBundleX::ConstPointer input = dynamic_cast<const mitk::FiberBundleX*>(this->GetInput());
std::string ext = itksys::SystemTools::GetFilenameLastExtension(this->GetOutputLocation().c_str());
+ // default extension is .fib
+ if(ext == "")
+ {
+ ext = ".fib";
+ this->SetOutputLocation(this->GetOutputLocation() + ext);
+ }
+
if (ext==".fib" || ext==".vtk")
{
MITK_INFO << "Writing fiber bundle as binary VTK";
vtkSmartPointer<vtkPolyDataWriter> writer = vtkSmartPointer<vtkPolyDataWriter>::New();
writer->SetInputData(input->GetFiberPolyData());
writer->SetFileName(this->GetOutputLocation().c_str());
writer->SetFileTypeToBinary();
writer->Write();
}
else if (ext==".afib")
{
itksys::SystemTools::ReplaceString(filename,".afib",".fib");
MITK_INFO << "Writing fiber bundle as ascii VTK";
vtkSmartPointer<vtkPolyDataWriter> writer = vtkSmartPointer<vtkPolyDataWriter>::New();
writer->SetInputData(input->GetFiberPolyData());
writer->SetFileName(this->GetOutputLocation().c_str());
writer->SetFileTypeToASCII();
writer->Write();
}
else if (ext==".avtk")
{
itksys::SystemTools::ReplaceString(filename,".avtk",".vtk");
MITK_INFO << "Writing fiber bundle as ascii VTK";
vtkSmartPointer<vtkPolyDataWriter> writer = vtkSmartPointer<vtkPolyDataWriter>::New();
writer->SetInputData(input->GetFiberPolyData());
writer->SetFileName(this->GetOutputLocation().c_str());
writer->SetFileTypeToASCII();
writer->Write();
}
else if (ext==".trk")
{
MITK_INFO << "Writing fiber bundle as TRK";
TrackVisFiberReader trk;
trk.create(filename, input.GetPointer());
trk.writeHdr();
trk.append(input.GetPointer());
}
setlocale(LC_ALL, currLocale.c_str());
MITK_INFO << "Fiber bundle written";
}
catch(...)
{
throw;
}
}
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.cpp
index a3cda09826..d9f7f745ba 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkNrrdDiffusionImageWriter.cpp
@@ -1,318 +1,326 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef __mitkNrrdDiffusionImageWriter__cpp
#define __mitkNrrdDiffusionImageWriter__cpp
#include "mitkNrrdDiffusionImageWriter.h"
#include "itkMetaDataDictionary.h"
#include "itkMetaDataObject.h"
#include "itkNrrdImageIO.h"
#include "itkNiftiImageIO.h"
#include "itkImageFileWriter.h"
#include "itksys/SystemTools.hxx"
#include "mitkDiffusionIOMimeTypes.h"
#include <iostream>
#include <fstream>
mitk::NrrdDiffusionImageWriter::NrrdDiffusionImageWriter()
: AbstractFileWriter(mitk::DiffusionImage<short>::GetStaticNameOfClass(), CustomMimeType( mitk::DiffusionIOMimeTypes::DWI_MIMETYPE_NAME() ), mitk::DiffusionIOMimeTypes::DWI_MIMETYPE_DESCRIPTION())
{
RegisterService();
}
mitk::NrrdDiffusionImageWriter::NrrdDiffusionImageWriter(const mitk::NrrdDiffusionImageWriter& other)
: AbstractFileWriter(other)
{
}
mitk::NrrdDiffusionImageWriter::~NrrdDiffusionImageWriter()
{}
void mitk::NrrdDiffusionImageWriter::Write()
{
InputType::ConstPointer input = dynamic_cast<const InputType*>(this->GetInput());
if (input.IsNull())
{
MITK_ERROR <<"Sorry, input to NrrdDiffusionImageWriter is NULL!";
return;
}
if ( this->GetOutputLocation().empty() )
{
MITK_ERROR << "Sorry, filename has not been set!";
return ;
}
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;
}
}
char keybuffer[512];
char valbuffer[512];
//itk::MetaDataDictionary dic = input->GetImage()->GetMetaDataDictionary();
vnl_matrix_fixed<double,3,3> measurementFrame = input->GetMeasurementFrame();
if (measurementFrame(0,0) || measurementFrame(0,1) || measurementFrame(0,2) ||
measurementFrame(1,0) || measurementFrame(1,1) || measurementFrame(1,2) ||
measurementFrame(2,0) || measurementFrame(2,1) || measurementFrame(2,2))
{
sprintf( valbuffer, " (%lf,%lf,%lf) (%lf,%lf,%lf) (%lf,%lf,%lf)", measurementFrame(0,0), measurementFrame(0,1), measurementFrame(0,2), measurementFrame(1,0), measurementFrame(1,1), measurementFrame(1,2), measurementFrame(2,0), measurementFrame(2,1), measurementFrame(2,2));
itk::EncapsulateMetaData<std::string>(input->GetVectorImage()->GetMetaDataDictionary(),std::string("measurement frame"),std::string(valbuffer));
}
sprintf( valbuffer, "DWMRI");
itk::EncapsulateMetaData<std::string>(input->GetVectorImage()->GetMetaDataDictionary(),std::string("modality"),std::string(valbuffer));
if(input->GetDirections()->Size())
{
sprintf( valbuffer, "%1f", input->GetReferenceBValue() );
itk::EncapsulateMetaData<std::string>(input->GetVectorImage()->GetMetaDataDictionary(),std::string("DWMRI_b-value"),std::string(valbuffer));
}
for(unsigned int i=0; i<input->GetDirections()->Size(); i++)
{
sprintf( keybuffer, "DWMRI_gradient_%04d", i );
/*if(itk::ExposeMetaData<std::string>(input->GetMetaDataDictionary(),
std::string(keybuffer),tmp))
continue;*/
sprintf( valbuffer, "%1f %1f %1f", input->GetDirections()->ElementAt(i).get(0),
input->GetDirections()->ElementAt(i).get(1), input->GetDirections()->ElementAt(i).get(2));
itk::EncapsulateMetaData<std::string>(input->GetVectorImage()->GetMetaDataDictionary(),std::string(keybuffer),std::string(valbuffer));
}
typedef itk::VectorImage<short,3> ImageType;
std::string ext = itksys::SystemTools::GetFilenameLastExtension(this->GetOutputLocation());
ext = itksys::SystemTools::LowerCase(ext);
+
+ // default extension is .dwi
+ if( ext == "")
+ {
+ ext = ".dwi";
+ this->SetOutputLocation(this->GetOutputLocation() + ext);
+ }
+
if (ext == ".hdwi" || ext == ".dwi")
{
itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
//io->SetNrrdVectorType( nrrdKindList );
io->SetFileType( itk::ImageIOBase::Binary );
io->UseCompressionOn();
typedef itk::ImageFileWriter<ImageType> WriterType;
WriterType::Pointer nrrdWriter = WriterType::New();
nrrdWriter->UseInputMetaDataDictionaryOn();
nrrdWriter->SetInput( input->GetVectorImage() );
nrrdWriter->SetImageIO(io);
nrrdWriter->SetFileName(this->GetOutputLocation());
nrrdWriter->UseCompressionOn();
nrrdWriter->SetImageIO(io);
try
{
nrrdWriter->Update();
}
catch (itk::ExceptionObject e)
{
std::cout << e << std::endl;
throw;
}
}
else if (ext == ".fsl" || ext == ".fslgz")
{
MITK_INFO << "Writing Nifti-Image for FSL";
ImageType::Pointer vecimg = input->GetVectorImage();
typedef itk::Image<short,4> ImageType4D;
ImageType4D::Pointer img4 = ImageType4D::New();
ImageType::SpacingType spacing = vecimg->GetSpacing();
ImageType4D::SpacingType spacing4;
for(int i=0; i<3; i++)
spacing4[i] = spacing[i];
spacing4[3] = 1;
img4->SetSpacing( spacing4 ); // Set the image spacing
ImageType::PointType origin = vecimg->GetOrigin();
ImageType4D::PointType origin4;
for(int i=0; i<3; i++)
origin4[i] = origin[i];
origin4[3] = 0;
img4->SetOrigin( origin4 ); // Set the image origin
ImageType::DirectionType direction = vecimg->GetDirection();
ImageType4D::DirectionType direction4;
for(int i=0; i<3; i++)
for(int j=0; j<3; j++)
direction4[i][j] = direction[i][j];
for(int i=0; i<4; i++)
direction4[i][3] = 0;
for(int i=0; i<4; i++)
direction4[3][i] = 0;
direction4[3][3] = 1;
img4->SetDirection( direction4 ); // Set the image direction
ImageType::RegionType region = vecimg->GetLargestPossibleRegion();
ImageType4D::RegionType region4;
ImageType::RegionType::SizeType size = region.GetSize();
ImageType4D::RegionType::SizeType size4;
for(int i=0; i<3; i++)
size4[i] = size[i];
size4[3] = vecimg->GetVectorLength();
ImageType::RegionType::IndexType index = region.GetIndex();
ImageType4D::RegionType::IndexType index4;
for(int i=0; i<3; i++)
index4[i] = index[i];
index4[3] = 0;
region4.SetSize(size4);
region4.SetIndex(index4);
img4->SetRegions( region4 );
img4->Allocate();
itk::ImageRegionIterator<ImageType> it (vecimg, vecimg->GetLargestPossibleRegion() );
typedef ImageType::PixelType VecPixType;
for (it.GoToBegin(); !it.IsAtEnd(); ++it)
{
VecPixType vec = it.Get();
ImageType::IndexType currentIndex = it.GetIndex();
for(unsigned int ind=0; ind<vec.Size(); ind++)
{
for(int i=0; i<3; i++)
index4[i] = currentIndex[i];
index4[3] = ind;
img4->SetPixel(index4, vec[ind]);
}
}
// create copy of file with correct ending for mitk
std::string fname3 = this->GetOutputLocation();
std::string::iterator itend = fname3.end();
if (ext == ".fsl")
fname3.replace( itend-3, itend, "nii");
else
fname3.replace( itend-5, itend, "nii.gz");
itk::NiftiImageIO::Pointer io4 = itk::NiftiImageIO::New();
typedef itk::VectorImage<short,3> ImageType;
typedef itk::ImageFileWriter<ImageType4D> WriterType4;
WriterType4::Pointer nrrdWriter4 = WriterType4::New();
nrrdWriter4->UseInputMetaDataDictionaryOn();
nrrdWriter4->SetInput( img4 );
nrrdWriter4->SetFileName(fname3);
nrrdWriter4->UseCompressionOn();
nrrdWriter4->SetImageIO(io4);
try
{
nrrdWriter4->Update();
}
catch (itk::ExceptionObject e)
{
std::cout << e << std::endl;
throw;
}
itksys::SystemTools::CopyAFile(fname3.c_str(), this->GetOutputLocation().c_str());
if(input->GetDirections()->Size())
{
std::ofstream myfile;
std::string fname = this->GetOutputLocation();
fname += ".bvals";
myfile.open (fname.c_str());
for(unsigned int i=0; i<input->GetDirections()->Size(); i++)
{
double twonorm = input->GetDirections()->ElementAt(i).two_norm();
myfile << input->GetReferenceBValue()*twonorm*twonorm << " ";
}
myfile.close();
std::ofstream myfile2;
std::string fname2 = this->GetOutputLocation();
fname2 += ".bvecs";
myfile2.open (fname2.c_str());
for(int j=0; j<3; j++)
{
for(unsigned int i=0; i<input->GetDirections()->Size(); i++)
{
//need to modify the length
mitk::DiffusionImage<short>::GradientDirectionContainerType::Pointer grads = input->GetDirections();
mitk::DiffusionImage<short>::GradientDirectionType direction = grads->ElementAt(i);
direction.normalize();
myfile2 << direction.get(j) << " ";
//myfile2 << input->GetDirections()->ElementAt(i).get(j) << " ";
}
myfile2 << std::endl;
}
std::ofstream myfile3;
std::string fname4 = this->GetOutputLocation();
fname4 += ".ttk";
myfile3.open (fname4.c_str());
for(unsigned int i=0; i<input->GetDirections()->Size(); i++)
{
for(int j=0; j<3; j++)
{
myfile3 << input->GetDirections()->ElementAt(i).get(j) << " ";
}
myfile3 << std::endl;
}
}
}
try
{
setlocale(LC_ALL, currLocale.c_str());
}
catch(...)
{
MITK_INFO << "Could not reset locale " << currLocale;
}
}
mitk::NrrdDiffusionImageWriter* mitk::NrrdDiffusionImageWriter::Clone() const
{
return new NrrdDiffusionImageWriter(*this);
}
mitk::IFileWriter::ConfidenceLevel mitk::NrrdDiffusionImageWriter::GetConfidenceLevel() const
{
InputType::ConstPointer input = dynamic_cast<const InputType*>(this->GetInput());
if (input.IsNull() )
{
return Unsupported;
}
else
{
return Supported;
}
}
#endif //__mitkNrrdDiffusionImageWriter__cpp
diff --git a/Modules/DiffusionImaging/MiniApps/FiberDirectionExtraction.cpp b/Modules/DiffusionImaging/MiniApps/FiberDirectionExtraction.cpp
index d08b515956..b80b1e1b1c 100755
--- a/Modules/DiffusionImaging/MiniApps/FiberDirectionExtraction.cpp
+++ b/Modules/DiffusionImaging/MiniApps/FiberDirectionExtraction.cpp
@@ -1,182 +1,177 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "MiniAppManager.h"
#include <mitkBaseDataIOFactory.h>
#include <mitkBaseData.h>
#include <mitkImageCast.h>
#include <mitkImageToItk.h>
#include <metaCommand.h>
#include "ctkCommandLineParser.h"
#include <usAny.h>
#include <itkImageFileWriter.h>
#include <mitkIOUtil.h>
#include <boost/lexical_cast.hpp>
#include <itkEvaluateDirectionImagesFilter.h>
#include <itkTractsToVectorImageFilter.h>
#include <mitkCoreObjectFactory.h>
#define _USE_MATH_DEFINES
#include <math.h>
int FiberDirectionExtraction(int argc, char* argv[])
{
MITK_INFO << "FiberDirectionExtraction";
ctkCommandLineParser parser;
parser.setTitle("Fiber Direction Extraction");
parser.setCategory("Fiber Tracking and Processing Methods");
parser.setDescription("");
parser.setContributor("MBI");
parser.setArgumentPrefix("--", "-");
parser.addArgument("input", "i", ctkCommandLineParser::InputFile, "Input:", "input tractogram (.fib/.trk)", us::Any(), false);
parser.addArgument("out", "o", ctkCommandLineParser::OutputDirectory, "Output:", "output root", us::Any(), false);
parser.addArgument("mask", "m", ctkCommandLineParser::InputFile, "Mask:", "mask image");
parser.addArgument("athresh", "a", ctkCommandLineParser::Float, "Angular threshold:", "angular threshold in degrees. closer fiber directions are regarded as one direction and clustered together.", 25, true);
parser.addArgument("peakthresh", "t", ctkCommandLineParser::Float, "Peak size threshold:", "peak size threshold relative to largest peak in voxel", 0.2, true);
parser.addArgument("verbose", "v", ctkCommandLineParser::Bool, "Verbose:", "output optional and intermediate calculation results");
parser.addArgument("numdirs", "d", ctkCommandLineParser::Int, "Max. num. directions:", "maximum number of fibers per voxel", 3, true);
parser.addArgument("normalize", "n", ctkCommandLineParser::Bool, "Normalize:", "normalize vectors");
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
string fibFile = us::any_cast<string>(parsedArgs["input"]);
string maskImage("");
if (parsedArgs.count("mask"))
maskImage = us::any_cast<string>(parsedArgs["mask"]);
float peakThreshold = 0.2;
if (parsedArgs.count("peakthresh"))
peakThreshold = us::any_cast<float>(parsedArgs["peakthresh"]);
float angularThreshold = 25;
if (parsedArgs.count("athresh"))
angularThreshold = us::any_cast<float>(parsedArgs["athresh"]);
string outRoot = us::any_cast<string>(parsedArgs["out"]);
bool verbose = false;
if (parsedArgs.count("verbose"))
verbose = us::any_cast<bool>(parsedArgs["verbose"]);
int maxNumDirs = 3;
if (parsedArgs.count("numdirs"))
maxNumDirs = us::any_cast<int>(parsedArgs["numdirs"]);
bool normalize = false;
if (parsedArgs.count("normalize"))
normalize = us::any_cast<bool>(parsedArgs["normalize"]);
try
{
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
typedef itk::Image< itk::Vector< float, 3>, 3 > ItkDirectionImage3DType;
typedef itk::VectorContainer< unsigned int, ItkDirectionImage3DType::Pointer > ItkDirectionImageContainerType;
// load fiber bundle
mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
// load/create mask image
ItkUcharImgType::Pointer itkMaskImage = NULL;
if (maskImage.compare("")!=0)
{
MITK_INFO << "Using mask image";
itkMaskImage = ItkUcharImgType::New();
mitk::Image::Pointer mitkMaskImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(maskImage)->GetData());
mitk::CastToItkImage<ItkUcharImgType>(mitkMaskImage, itkMaskImage);
}
// extract directions from fiber bundle
itk::TractsToVectorImageFilter<float>::Pointer fOdfFilter = itk::TractsToVectorImageFilter<float>::New();
fOdfFilter->SetFiberBundle(inputTractogram);
fOdfFilter->SetMaskImage(itkMaskImage);
fOdfFilter->SetAngularThreshold(cos(angularThreshold*M_PI/180));
fOdfFilter->SetNormalizeVectors(normalize);
fOdfFilter->SetUseWorkingCopy(false);
fOdfFilter->SetSizeThreshold(peakThreshold);
fOdfFilter->SetMaxNumDirections(maxNumDirs);
fOdfFilter->Update();
ItkDirectionImageContainerType::Pointer directionImageContainer = fOdfFilter->GetDirectionImageContainer();
// write direction images
for (unsigned int i=0; i<directionImageContainer->Size(); i++)
{
itk::TractsToVectorImageFilter<float>::ItkDirectionImageType::Pointer itkImg = directionImageContainer->GetElement(i);
typedef itk::ImageFileWriter< itk::TractsToVectorImageFilter<float>::ItkDirectionImageType > WriterType;
WriterType::Pointer writer = WriterType::New();
string outfilename = outRoot;
outfilename.append("_DIRECTION_");
outfilename.append(boost::lexical_cast<string>(i));
outfilename.append(".nrrd");
writer->SetFileName(outfilename.c_str());
writer->SetInput(itkImg);
writer->Update();
}
if (verbose)
{
// write vector field
mitk::FiberBundleX::Pointer directions = fOdfFilter->GetOutputFiberBundle();
- mitk::CoreObjectFactory::FileWriterList fileWriters = mitk::CoreObjectFactory::GetInstance()->GetFileWriters();
- for (mitk::CoreObjectFactory::FileWriterList::iterator it = fileWriters.begin() ; it != fileWriters.end() ; ++it)
- {
- if ( (*it)->CanWriteBaseDataType(directions.GetPointer()) ) {
- string outfilename = outRoot;
- outfilename.append("_VECTOR_FIELD.fib");
- (*it)->SetFileName( outfilename.c_str() );
- (*it)->DoWrite( directions.GetPointer() );
- }
- }
+
+ string outfilename = outRoot;
+ outfilename.append("_VECTOR_FIELD.fib");
+
+ mitk::IOUtil::SaveBaseData(directions.GetPointer(), outfilename );
// write num direction image
{
ItkUcharImgType::Pointer numDirImage = fOdfFilter->GetNumDirectionsImage();
typedef itk::ImageFileWriter< ItkUcharImgType > WriterType;
WriterType::Pointer writer = WriterType::New();
string outfilename = outRoot;
outfilename.append("_NUM_DIRECTIONS.nrrd");
writer->SetFileName(outfilename.c_str());
writer->SetInput(numDirImage);
writer->Update();
}
}
}
catch (itk::ExceptionObject e)
{
MITK_INFO << e;
return EXIT_FAILURE;
}
catch (std::exception e)
{
MITK_INFO << e.what();
return EXIT_FAILURE;
}
catch (...)
{
MITK_INFO << "ERROR!?!";
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
RegisterDiffusionMiniApp(FiberDirectionExtraction);
diff --git a/Modules/DiffusionImaging/MiniApps/FiberProcessing.cpp b/Modules/DiffusionImaging/MiniApps/FiberProcessing.cpp
index baa94f89af..a0534029f5 100644
--- a/Modules/DiffusionImaging/MiniApps/FiberProcessing.cpp
+++ b/Modules/DiffusionImaging/MiniApps/FiberProcessing.cpp
@@ -1,223 +1,218 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "MiniAppManager.h"
#include <vector>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <string>
#include <itkImageFileWriter.h>
#include <itkMetaDataObject.h>
#include <itkVectorImage.h>
#include <mitkBaseDataIOFactory.h>
#include <mitkBaseData.h>
#include <mitkFiberBundleX.h>
#include "ctkCommandLineParser.h"
#include <boost/lexical_cast.hpp>
#include <mitkCoreObjectFactory.h>
+#include <mitkIOUtil.h>
mitk::FiberBundleX::Pointer LoadFib(std::string filename)
{
const std::string s1="", s2="";
std::vector<mitk::BaseData::Pointer> fibInfile = mitk::BaseDataIO::LoadBaseDataFromFile( filename, s1, s2, false );
if( fibInfile.empty() )
MITK_INFO << "File " << filename << " could not be read!";
mitk::BaseData::Pointer baseData = fibInfile.at(0);
return dynamic_cast<mitk::FiberBundleX*>(baseData.GetPointer());
}
int FiberProcessing(int argc, char* argv[])
{
MITK_INFO << "FiberProcessing";
ctkCommandLineParser parser;
parser.setTitle("Fiber Processing");
parser.setCategory("Fiber Tracking and Processing Methods");
parser.setDescription("");
parser.setContributor("MBI");
parser.setArgumentPrefix("--", "-");
parser.addArgument("input", "i", ctkCommandLineParser::InputFile, "Input:", "input fiber bundle (.fib)", us::Any(), false);
parser.addArgument("outFile", "o", ctkCommandLineParser::OutputFile, "Output:", "output fiber bundle (.fib)", us::Any(), false);
parser.addArgument("resample", "r", ctkCommandLineParser::Float, "Linear resampling:", "Linearly resample fiber with the given point distance (in mm)");
parser.addArgument("smooth", "s", ctkCommandLineParser::Float, "Spline resampling:", "Resample fiber using splines with the given point distance (in mm)");
parser.addArgument("compress", "c", ctkCommandLineParser::Float, "Compress:", "Compress fiber using the given error threshold (in mm)");
parser.addArgument("minLength", "l", ctkCommandLineParser::Float, "Minimum length:", "Minimum fiber length (in mm)");
parser.addArgument("maxLength", "m", ctkCommandLineParser::Float, "Maximum length:", "Maximum fiber length (in mm)");
parser.addArgument("minCurv", "a", ctkCommandLineParser::Float, "Minimum curvature radius:", "Minimum curvature radius (in mm)");
parser.addArgument("mirror", "p", ctkCommandLineParser::Int, "Invert coordinates:", "Invert fiber coordinates XYZ (e.g. 010 to invert y-coordinate of each fiber point)");
parser.addArgument("rotate-x", "rx", ctkCommandLineParser::Float, "Rotate x-axis:", "Rotate around x-axis (if copy is given the copy is rotated, in deg)");
parser.addArgument("rotate-y", "ry", ctkCommandLineParser::Float, "Rotate y-axis:", "Rotate around y-axis (if copy is given the copy is rotated, in deg)");
parser.addArgument("rotate-z", "rz", ctkCommandLineParser::Float, "Rotate z-axis:", "Rotate around z-axis (if copy is given the copy is rotated, in deg)");
parser.addArgument("scale-x", "sx", ctkCommandLineParser::Float, "Scale x-axis:", "Scale in direction of x-axis (if copy is given the copy is scaled)");
parser.addArgument("scale-y", "sy", ctkCommandLineParser::Float, "Scale y-axis:", "Scale in direction of y-axis (if copy is given the copy is scaled)");
parser.addArgument("scale-z", "sz", ctkCommandLineParser::Float, "Scale z-axis", "Scale in direction of z-axis (if copy is given the copy is scaled)");
parser.addArgument("translate-x", "tx", ctkCommandLineParser::Float, "Translate x-axis:", "Translate in direction of x-axis (if copy is given the copy is translated, in mm)");
parser.addArgument("translate-y", "ty", ctkCommandLineParser::Float, "Translate y-axis:", "Translate in direction of y-axis (if copy is given the copy is translated, in mm)");
parser.addArgument("translate-z", "tz", ctkCommandLineParser::Float, "Translate z-axis:", "Translate in direction of z-axis (if copy is given the copy is translated, in mm)");
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
float pointDist = -1;
if (parsedArgs.count("resample"))
pointDist = us::any_cast<float>(parsedArgs["resample"]);
float smoothDist = -1;
if (parsedArgs.count("smooth"))
smoothDist = us::any_cast<float>(parsedArgs["smooth"]);
float compress = -1;
if (parsedArgs.count("compress"))
compress = us::any_cast<float>(parsedArgs["compress"]);
float minFiberLength = -1;
if (parsedArgs.count("minLength"))
minFiberLength = us::any_cast<float>(parsedArgs["minLength"]);
float maxFiberLength = -1;
if (parsedArgs.count("maxLength"))
maxFiberLength = us::any_cast<float>(parsedArgs["maxLength"]);
float curvThres = -1;
if (parsedArgs.count("minCurv"))
curvThres = us::any_cast<float>(parsedArgs["minCurv"]);
int axis = 0;
if (parsedArgs.count("mirror"))
axis = us::any_cast<int>(parsedArgs["mirror"]);
float rotateX = 0;
if (parsedArgs.count("rotate-x"))
rotateX = us::any_cast<float>(parsedArgs["rotate-x"]);
float rotateY = 0;
if (parsedArgs.count("rotate-y"))
rotateY = us::any_cast<float>(parsedArgs["rotate-y"]);
float rotateZ = 0;
if (parsedArgs.count("rotate-z"))
rotateZ = us::any_cast<float>(parsedArgs["rotate-z"]);
float scaleX = 0;
if (parsedArgs.count("scale-x"))
scaleX = us::any_cast<float>(parsedArgs["scale-x"]);
float scaleY = 0;
if (parsedArgs.count("scale-y"))
scaleY = us::any_cast<float>(parsedArgs["scale-y"]);
float scaleZ = 0;
if (parsedArgs.count("scale-z"))
scaleZ = us::any_cast<float>(parsedArgs["scale-z"]);
float translateX = 0;
if (parsedArgs.count("translate-x"))
translateX = us::any_cast<float>(parsedArgs["translate-x"]);
float translateY = 0;
if (parsedArgs.count("translate-y"))
translateY = us::any_cast<float>(parsedArgs["translate-y"]);
float translateZ = 0;
if (parsedArgs.count("translate-z"))
translateZ = us::any_cast<float>(parsedArgs["translate-z"]);
string inFileName = us::any_cast<string>(parsedArgs["input"]);
string outFileName = us::any_cast<string>(parsedArgs["outFile"]);
try
{
mitk::FiberBundleX::Pointer fib = LoadFib(inFileName);
if (minFiberLength>0)
fib->RemoveShortFibers(minFiberLength);
if (maxFiberLength>0)
fib->RemoveLongFibers(maxFiberLength);
if (curvThres>0)
fib->ApplyCurvatureThreshold(curvThres, false);
if (pointDist>0)
fib->ResampleLinear(pointDist);
if (smoothDist>0)
fib->ResampleSpline(smoothDist);
if (compress>0)
fib->Compress(compress);
if (axis/100==1)
fib->MirrorFibers(0);
if ((axis%100)/10==1)
fib->MirrorFibers(1);
if (axis%10==1)
fib->MirrorFibers(2);
if (rotateX > 0 || rotateY > 0 || rotateZ > 0){
MITK_INFO << "Rotate " << rotateX << " " << rotateY << " " << rotateZ;
fib->RotateAroundAxis(rotateX, rotateY, rotateZ);
}
if (translateX > 0 || translateY > 0 || translateZ > 0){
fib->TranslateFibers(translateX, translateY, translateZ);
}
if (scaleX > 0 || scaleY > 0 || scaleZ > 0)
fib->ScaleFibers(scaleX, scaleY, scaleZ);
- mitk::CoreObjectFactory::FileWriterList fileWriters = mitk::CoreObjectFactory::GetInstance()->GetFileWriters();
- for (mitk::CoreObjectFactory::FileWriterList::iterator it = fileWriters.begin() ; it != fileWriters.end() ; ++it)
- {
- if ( (*it)->CanWriteBaseDataType(fib.GetPointer()) ) {
- (*it)->SetFileName( outFileName.c_str() );
- (*it)->DoWrite( fib.GetPointer() );
- }
- }
+ mitk::IOUtil::SaveBaseData(fib.GetPointer(), outFileName );
+
}
catch (itk::ExceptionObject e)
{
MITK_INFO << e;
return EXIT_FAILURE;
}
catch (std::exception e)
{
MITK_INFO << e.what();
return EXIT_FAILURE;
}
catch (...)
{
MITK_INFO << "ERROR!?!";
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
RegisterDiffusionMiniApp(FiberProcessing);
diff --git a/Modules/DiffusionImaging/MiniApps/GibbsTracking.cpp b/Modules/DiffusionImaging/MiniApps/GibbsTracking.cpp
index 7bd0f14b97..e5a222818c 100755
--- a/Modules/DiffusionImaging/MiniApps/GibbsTracking.cpp
+++ b/Modules/DiffusionImaging/MiniApps/GibbsTracking.cpp
@@ -1,252 +1,245 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "MiniAppManager.h"
#include <mitkImageCast.h>
#include <mitkQBallImage.h>
#include <mitkTensorImage.h>
#include <mitkBaseDataIOFactory.h>
#include <mitkFiberBundleX.h>
#include <itkGibbsTrackingFilter.h>
#include <itkDiffusionTensor3D.h>
#include <itkShCoefficientImageImporter.h>
#include <mitkImageToItk.h>
#include <mitkIOUtil.h>
#include "ctkCommandLineParser.h"
#include <boost/algorithm/string.hpp>
#include <itkFlipImageFilter.h>
#include <mitkCoreObjectFactory.h>
template<int shOrder>
typename itk::ShCoefficientImageImporter< float, shOrder >::QballImageType::Pointer TemplatedConvertShCoeffs(mitk::Image* mitkImg, int toolkit, bool noFlip = false)
{
typedef itk::ShCoefficientImageImporter< float, shOrder > FilterType;
typedef mitk::ImageToItk< itk::Image< float, 4 > > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(mitkImg);
caster->Update();
itk::Image< float, 4 >::Pointer itkImage = caster->GetOutput();
typename FilterType::Pointer filter = FilterType::New();
if (noFlip)
{
filter->SetInputImage(itkImage);
}
else
{
MITK_INFO << "Flipping image";
itk::FixedArray<bool, 4> flipAxes;
flipAxes[0] = true;
flipAxes[1] = true;
flipAxes[2] = false;
flipAxes[3] = false;
itk::FlipImageFilter< itk::Image< float, 4 > >::Pointer flipper = itk::FlipImageFilter< itk::Image< float, 4 > >::New();
flipper->SetInput(itkImage);
flipper->SetFlipAxes(flipAxes);
flipper->Update();
itk::Image< float, 4 >::Pointer flipped = flipper->GetOutput();
itk::Matrix< double,4,4 > m = itkImage->GetDirection(); m[0][0] *= -1; m[1][1] *= -1;
flipped->SetDirection(m);
itk::Point< float, 4 > o = itkImage->GetOrigin();
o[0] -= (flipped->GetLargestPossibleRegion().GetSize(0)-1);
o[1] -= (flipped->GetLargestPossibleRegion().GetSize(1)-1);
flipped->SetOrigin(o);
filter->SetInputImage(flipped);
}
switch (toolkit)
{
case 0:
filter->SetToolkit(FilterType::FSL);
break;
case 1:
filter->SetToolkit(FilterType::MRTRIX);
break;
default:
filter->SetToolkit(FilterType::FSL);
}
filter->GenerateData();
return filter->GetQballImage();
}
int GibbsTracking(int argc, char* argv[])
{
MITK_INFO << "GibbsTracking";
ctkCommandLineParser parser;
parser.setTitle("Gibbs Tracking");
parser.setCategory("Fiber Tracking and Processing Methods");
parser.setDescription("");
parser.setContributor("MBI");
parser.setArgumentPrefix("--", "-");
parser.addArgument("input", "i", ctkCommandLineParser::InputFile, "Input:", "input image (tensor, Q-ball or FSL/MRTrix SH-coefficient image)", us::Any(), false);
parser.addArgument("parameters", "p", ctkCommandLineParser::InputFile, "Parameters:", "parameter file (.gtp)", us::Any(), false);
parser.addArgument("mask", "m", ctkCommandLineParser::InputFile, "Mask:", "binary mask image");
parser.addArgument("shConvention", "s", ctkCommandLineParser::String, "SH coefficient:", "sh coefficient convention (FSL, MRtrix)", string("FSL"), true);
parser.addArgument("outFile", "o", ctkCommandLineParser::OutputFile, "Output:", "output fiber bundle (.fib)", us::Any(), false);
parser.addArgument("noFlip", "f", ctkCommandLineParser::Bool, "No flip:", "do not flip input image to match MITK coordinate convention");
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
string inFileName = us::any_cast<string>(parsedArgs["input"]);
string paramFileName = us::any_cast<string>(parsedArgs["parameters"]);
string outFileName = us::any_cast<string>(parsedArgs["outFile"]);
bool noFlip = false;
if (parsedArgs.count("noFlip"))
noFlip = us::any_cast<bool>(parsedArgs["noFlip"]);
try
{
// instantiate gibbs tracker
typedef itk::Vector<float, QBALL_ODFSIZE> OdfVectorType;
typedef itk::Image<OdfVectorType,3> ItkQballImageType;
typedef itk::GibbsTrackingFilter<ItkQballImageType> GibbsTrackingFilterType;
GibbsTrackingFilterType::Pointer gibbsTracker = GibbsTrackingFilterType::New();
// load input image
const std::string s1="", s2="";
std::vector<mitk::BaseData::Pointer> infile = mitk::BaseDataIO::LoadBaseDataFromFile( inFileName, s1, s2, false );
mitk::Image::Pointer mitkImage = dynamic_cast<mitk::Image*>(infile.at(0).GetPointer());
// try to cast to qball image
if( boost::algorithm::ends_with(inFileName, ".qbi") )
{
MITK_INFO << "Loading qball image ...";
mitk::QBallImage::Pointer mitkQballImage = dynamic_cast<mitk::QBallImage*>(infile.at(0).GetPointer());
ItkQballImageType::Pointer itk_qbi = ItkQballImageType::New();
mitk::CastToItkImage(mitkQballImage, itk_qbi);
gibbsTracker->SetQBallImage(itk_qbi.GetPointer());
}
else if( boost::algorithm::ends_with(inFileName, ".dti") )
{
MITK_INFO << "Loading tensor image ...";
typedef itk::Image< itk::DiffusionTensor3D<float>, 3 > ItkTensorImage;
mitk::TensorImage::Pointer mitkTensorImage = dynamic_cast<mitk::TensorImage*>(infile.at(0).GetPointer());
ItkTensorImage::Pointer itk_dti = ItkTensorImage::New();
mitk::CastToItkImage(mitkTensorImage, itk_dti);
gibbsTracker->SetTensorImage(itk_dti);
}
else if ( boost::algorithm::ends_with(inFileName, ".nii") )
{
MITK_INFO << "Loading sh-coefficient image ...";
int nrCoeffs = mitkImage->GetLargestPossibleRegion().GetSize()[3];
int c=3, d=2-2*nrCoeffs;
double D = c*c-4*d;
int shOrder;
if (D>0)
{
shOrder = (-c+sqrt(D))/2.0;
if (shOrder<0)
shOrder = (-c-sqrt(D))/2.0;
}
else if (D==0)
shOrder = -c/2.0;
MITK_INFO << "using SH-order " << shOrder;
int toolkitConvention = 0;
if (parsedArgs.count("shConvention"))
{
string convention = us::any_cast<string>(parsedArgs["shConvention"]).c_str();
if ( boost::algorithm::equals(convention, "MRtrix") )
{
toolkitConvention = 1;
MITK_INFO << "Using MRtrix style sh-coefficient convention";
}
else
MITK_INFO << "Using FSL style sh-coefficient convention";
}
else
MITK_INFO << "Using FSL style sh-coefficient convention";
switch (shOrder)
{
case 4:
gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<4>(mitkImage, toolkitConvention, noFlip));
break;
case 6:
gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<6>(mitkImage, toolkitConvention, noFlip));
break;
case 8:
gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<8>(mitkImage, toolkitConvention, noFlip));
break;
case 10:
gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<10>(mitkImage, toolkitConvention, noFlip));
break;
case 12:
gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<12>(mitkImage, toolkitConvention, noFlip));
break;
default:
MITK_INFO << "SH-order " << shOrder << " not supported";
}
}
else
return EXIT_FAILURE;
// global tracking
if (parsedArgs.count("mask"))
{
typedef itk::Image<float,3> MaskImgType;
mitk::Image::Pointer mitkMaskImage = mitk::IOUtil::LoadImage(us::any_cast<string>(parsedArgs["mask"]));
MaskImgType::Pointer itk_mask = MaskImgType::New();
mitk::CastToItkImage(mitkMaskImage, itk_mask);
gibbsTracker->SetMaskImage(itk_mask);
}
gibbsTracker->SetDuplicateImage(false);
gibbsTracker->SetLoadParameterFile( paramFileName );
// gibbsTracker->SetLutPath( "" );
gibbsTracker->Update();
mitk::FiberBundleX::Pointer mitkFiberBundle = mitk::FiberBundleX::New(gibbsTracker->GetFiberBundle());
mitkFiberBundle->SetReferenceGeometry(mitkImage->GetGeometry());
- mitk::CoreObjectFactory::FileWriterList fileWriters = mitk::CoreObjectFactory::GetInstance()->GetFileWriters();
- for (mitk::CoreObjectFactory::FileWriterList::iterator it = fileWriters.begin() ; it != fileWriters.end() ; ++it)
- {
- if ( (*it)->CanWriteBaseDataType(mitkFiberBundle.GetPointer()) ) {
- (*it)->SetFileName( outFileName.c_str() );
- (*it)->DoWrite( mitkFiberBundle.GetPointer() );
- }
- }
+ mitk::IOUtil::SaveBaseData(mitkFiberBundle.GetPointer(), outFileName );
}
catch (itk::ExceptionObject e)
{
MITK_INFO << e;
return EXIT_FAILURE;
}
catch (std::exception e)
{
MITK_INFO << e.what();
return EXIT_FAILURE;
}
catch (...)
{
MITK_INFO << "ERROR!?!";
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
RegisterDiffusionMiniApp(GibbsTracking);
diff --git a/Modules/DiffusionImaging/MiniApps/LocalDirectionalFiberPlausibility.cpp b/Modules/DiffusionImaging/MiniApps/LocalDirectionalFiberPlausibility.cpp
index 2ec21daa9d..ff292b4feb 100755
--- a/Modules/DiffusionImaging/MiniApps/LocalDirectionalFiberPlausibility.cpp
+++ b/Modules/DiffusionImaging/MiniApps/LocalDirectionalFiberPlausibility.cpp
@@ -1,309 +1,304 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "MiniAppManager.h"
#include <mitkBaseDataIOFactory.h>
#include <mitkBaseData.h>
#include <mitkImageCast.h>
#include <mitkImageToItk.h>
#include <itkEvaluateDirectionImagesFilter.h>
#include <metaCommand.h>
#include "ctkCommandLineParser.h"
#include <itkTractsToVectorImageFilter.h>
#include <usAny.h>
#include <itkImageFileWriter.h>
#include <mitkIOUtil.h>
#include <boost/lexical_cast.hpp>
#include <iostream>
#include <fstream>
#include <itksys/SystemTools.hxx>
#include <mitkCoreObjectFactory.h>
#define _USE_MATH_DEFINES
#include <math.h>
int LocalDirectionalFiberPlausibility(int argc, char* argv[])
{
MITK_INFO << "LocalDirectionalFiberPlausibility";
ctkCommandLineParser parser;
parser.setTitle("Local Directional Fiber Plausibility");
parser.setCategory("Fiber Tracking and Processing Methods");
parser.setDescription("");
parser.setContributor("MBI");
parser.setArgumentPrefix("--", "-");
parser.addArgument("input", "i", ctkCommandLineParser::InputFile, "Input:", "input tractogram (.fib, vtk ascii file format)", us::Any(), false);
parser.addArgument("reference", "r", ctkCommandLineParser::StringList, "Reference images:", "reference direction images", us::Any(), false);
parser.addArgument("out", "o", ctkCommandLineParser::OutputDirectory, "Output:", "output root", us::Any(), false);
parser.addArgument("mask", "m", ctkCommandLineParser::StringList, "Masks:", "mask images");
parser.addArgument("athresh", "a", ctkCommandLineParser::Float, "Angular threshold:", "angular threshold in degrees. closer fiber directions are regarded as one direction and clustered together.", 25, true);
parser.addArgument("verbose", "v", ctkCommandLineParser::Bool, "Verbose:", "output optional and intermediate calculation results");
parser.addArgument("ignore", "n", ctkCommandLineParser::Bool, "Ignore:", "don't increase error for missing or too many directions");
parser.addArgument("fileID", "id", ctkCommandLineParser::String, "ID:", "optional ID field");
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
ctkCommandLineParser::StringContainerType referenceImages = us::any_cast<ctkCommandLineParser::StringContainerType>(parsedArgs["reference"]);
ctkCommandLineParser::StringContainerType maskImages;
if (parsedArgs.count("mask"))
maskImages = us::any_cast<ctkCommandLineParser::StringContainerType>(parsedArgs["mask"]);
string fibFile = us::any_cast<string>(parsedArgs["input"]);
float angularThreshold = 25;
if (parsedArgs.count("athresh"))
angularThreshold = us::any_cast<float>(parsedArgs["athresh"]);
string outRoot = us::any_cast<string>(parsedArgs["out"]);
bool verbose = false;
if (parsedArgs.count("verbose"))
verbose = us::any_cast<bool>(parsedArgs["verbose"]);
bool ignore = false;
if (parsedArgs.count("ignore"))
ignore = us::any_cast<bool>(parsedArgs["ignore"]);
string fileID = "";
if (parsedArgs.count("fileID"))
fileID = us::any_cast<string>(parsedArgs["fileID"]);
try
{
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
typedef itk::Image< itk::Vector< float, 3>, 3 > ItkDirectionImage3DType;
typedef itk::VectorContainer< unsigned int, ItkDirectionImage3DType::Pointer > ItkDirectionImageContainerType;
typedef itk::EvaluateDirectionImagesFilter< float > EvaluationFilterType;
// load fiber bundle
mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
// load reference directions
ItkDirectionImageContainerType::Pointer referenceImageContainer = ItkDirectionImageContainerType::New();
for (unsigned int i=0; i<referenceImages.size(); i++)
{
try
{
mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(referenceImages.at(i))->GetData());
typedef mitk::ImageToItk< ItkDirectionImage3DType > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(img);
caster->Update();
ItkDirectionImage3DType::Pointer itkImg = caster->GetOutput();
referenceImageContainer->InsertElement(referenceImageContainer->Size(),itkImg);
}
catch(...){ MITK_INFO << "could not load: " << referenceImages.at(i); }
}
ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
ItkDirectionImage3DType::Pointer dirImg = referenceImageContainer->GetElement(0);
itkMaskImage->SetSpacing( dirImg->GetSpacing() );
itkMaskImage->SetOrigin( dirImg->GetOrigin() );
itkMaskImage->SetDirection( dirImg->GetDirection() );
itkMaskImage->SetLargestPossibleRegion( dirImg->GetLargestPossibleRegion() );
itkMaskImage->SetBufferedRegion( dirImg->GetLargestPossibleRegion() );
itkMaskImage->SetRequestedRegion( dirImg->GetLargestPossibleRegion() );
itkMaskImage->Allocate();
itkMaskImage->FillBuffer(1);
// extract directions from fiber bundle
itk::TractsToVectorImageFilter<float>::Pointer fOdfFilter = itk::TractsToVectorImageFilter<float>::New();
fOdfFilter->SetFiberBundle(inputTractogram);
fOdfFilter->SetMaskImage(itkMaskImage);
fOdfFilter->SetAngularThreshold(cos(angularThreshold*M_PI/180));
fOdfFilter->SetNormalizeVectors(true);
fOdfFilter->SetUseWorkingCopy(false);
fOdfFilter->Update();
ItkDirectionImageContainerType::Pointer directionImageContainer = fOdfFilter->GetDirectionImageContainer();
if (verbose)
{
// write vector field
mitk::FiberBundleX::Pointer directions = fOdfFilter->GetOutputFiberBundle();
- mitk::CoreObjectFactory::FileWriterList fileWriters = mitk::CoreObjectFactory::GetInstance()->GetFileWriters();
- for (mitk::CoreObjectFactory::FileWriterList::iterator it = fileWriters.begin() ; it != fileWriters.end() ; ++it)
- {
- if ( (*it)->CanWriteBaseDataType(directions.GetPointer()) ) {
- string outfilename = outRoot;
- outfilename.append("_VECTOR_FIELD.fib");
- (*it)->SetFileName( outfilename.c_str() );
- (*it)->DoWrite( directions.GetPointer() );
- }
- }
+
+ string outfilename = outRoot;
+ outfilename.append("_VECTOR_FIELD.fib");
+
+ mitk::IOUtil::SaveBaseData(directions.GetPointer(), outfilename );
// write direction images
for (unsigned int i=0; i<directionImageContainer->Size(); i++)
{
itk::TractsToVectorImageFilter<float>::ItkDirectionImageType::Pointer itkImg = directionImageContainer->GetElement(i);
typedef itk::ImageFileWriter< itk::TractsToVectorImageFilter<float>::ItkDirectionImageType > WriterType;
WriterType::Pointer writer = WriterType::New();
string outfilename = outRoot;
outfilename.append("_DIRECTION_");
outfilename.append(boost::lexical_cast<string>(i));
outfilename.append(".nrrd");
writer->SetFileName(outfilename.c_str());
writer->SetInput(itkImg);
writer->Update();
}
// write num direction image
{
ItkUcharImgType::Pointer numDirImage = fOdfFilter->GetNumDirectionsImage();
typedef itk::ImageFileWriter< ItkUcharImgType > WriterType;
WriterType::Pointer writer = WriterType::New();
string outfilename = outRoot;
outfilename.append("_NUM_DIRECTIONS.nrrd");
writer->SetFileName(outfilename.c_str());
writer->SetInput(numDirImage);
writer->Update();
}
}
string logFile = outRoot;
logFile.append("_ANGULAR_ERROR.csv");
ofstream file;
file.open (logFile.c_str());
if (maskImages.size()>0)
{
for (unsigned int i=0; i<maskImages.size(); i++)
{
mitk::Image::Pointer mitkMaskImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(maskImages.at(i))->GetData());
mitk::CastToItkImage(mitkMaskImage, itkMaskImage);
// evaluate directions
EvaluationFilterType::Pointer evaluationFilter = EvaluationFilterType::New();
evaluationFilter->SetImageSet(directionImageContainer);
evaluationFilter->SetReferenceImageSet(referenceImageContainer);
evaluationFilter->SetMaskImage(itkMaskImage);
evaluationFilter->SetIgnoreMissingDirections(ignore);
evaluationFilter->Update();
if (verbose)
{
EvaluationFilterType::OutputImageType::Pointer angularErrorImage = evaluationFilter->GetOutput(0);
typedef itk::ImageFileWriter< EvaluationFilterType::OutputImageType > WriterType;
WriterType::Pointer writer = WriterType::New();
string outfilename = outRoot;
outfilename.append("_ERROR_IMAGE.nrrd");
writer->SetFileName(outfilename.c_str());
writer->SetInput(angularErrorImage);
writer->Update();
}
string maskFileName = itksys::SystemTools::GetFilenameWithoutExtension(maskImages.at(i));
unsigned found = maskFileName.find_last_of("_");
string sens = itksys::SystemTools::GetFilenameWithoutLastExtension(fibFile);
if (!fileID.empty())
sens = fileID;
sens.append(",");
sens.append(maskFileName.substr(found+1));
sens.append(",");
sens.append(boost::lexical_cast<string>(evaluationFilter->GetMeanAngularError()));
sens.append(",");
sens.append(boost::lexical_cast<string>(evaluationFilter->GetMedianAngularError()));
sens.append(",");
sens.append(boost::lexical_cast<string>(evaluationFilter->GetMaxAngularError()));
sens.append(",");
sens.append(boost::lexical_cast<string>(evaluationFilter->GetMinAngularError()));
sens.append(",");
sens.append(boost::lexical_cast<string>(std::sqrt(evaluationFilter->GetVarAngularError())));
sens.append(";\n");
file << sens;
}
}
else
{
// evaluate directions
EvaluationFilterType::Pointer evaluationFilter = EvaluationFilterType::New();
evaluationFilter->SetImageSet(directionImageContainer);
evaluationFilter->SetReferenceImageSet(referenceImageContainer);
evaluationFilter->SetMaskImage(itkMaskImage);
evaluationFilter->SetIgnoreMissingDirections(ignore);
evaluationFilter->Update();
if (verbose)
{
EvaluationFilterType::OutputImageType::Pointer angularErrorImage = evaluationFilter->GetOutput(0);
typedef itk::ImageFileWriter< EvaluationFilterType::OutputImageType > WriterType;
WriterType::Pointer writer = WriterType::New();
string outfilename = outRoot;
outfilename.append("_ERROR_IMAGE.nrrd");
writer->SetFileName(outfilename.c_str());
writer->SetInput(angularErrorImage);
writer->Update();
}
string sens = itksys::SystemTools::GetFilenameWithoutLastExtension(fibFile);
if (!fileID.empty())
sens = fileID;
sens.append(",");
sens.append(boost::lexical_cast<string>(evaluationFilter->GetMeanAngularError()));
sens.append(",");
sens.append(boost::lexical_cast<string>(evaluationFilter->GetMedianAngularError()));
sens.append(",");
sens.append(boost::lexical_cast<string>(evaluationFilter->GetMaxAngularError()));
sens.append(",");
sens.append(boost::lexical_cast<string>(evaluationFilter->GetMinAngularError()));
sens.append(",");
sens.append(boost::lexical_cast<string>(std::sqrt(evaluationFilter->GetVarAngularError())));
sens.append(";\n");
file << sens;
}
file.close();
}
catch (itk::ExceptionObject e)
{
MITK_INFO << e;
return EXIT_FAILURE;
}
catch (std::exception e)
{
MITK_INFO << e.what();
return EXIT_FAILURE;
}
catch (...)
{
MITK_INFO << "ERROR!?!";
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
RegisterDiffusionMiniApp(LocalDirectionalFiberPlausibility);
diff --git a/Modules/DiffusionImaging/MiniApps/NetworkCreation.cpp b/Modules/DiffusionImaging/MiniApps/NetworkCreation.cpp
index 45eda8cf9f..c3349de199 100644
--- a/Modules/DiffusionImaging/MiniApps/NetworkCreation.cpp
+++ b/Modules/DiffusionImaging/MiniApps/NetworkCreation.cpp
@@ -1,143 +1,136 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "MiniAppManager.h"
// std includes
#include <string>
// CTK includes
#include "ctkCommandLineParser.h"
// MITK includes
#include <mitkBaseDataIOFactory.h>
#include "mitkConnectomicsNetworkCreator.h"
#include <mitkCoreObjectFactory.h>
+#include <mitkIOUtil.h>
int NetworkCreation(int argc, char* argv[])
{
ctkCommandLineParser parser;
parser.setArgumentPrefix("--", "-");
parser.addArgument("fiberImage", "f", ctkCommandLineParser::InputFile, "Input image", "input fiber image (.fib)", us::Any(), false);
parser.addArgument("parcellation", "p", ctkCommandLineParser::InputFile, "Parcellation image", "parcellation image", us::Any(), false);
parser.addArgument("outputNetwork", "o", ctkCommandLineParser::String, "Output network", "where to save the output (.cnf)", us::Any(), false);
parser.addArgument("radius", "r", ctkCommandLineParser::Int, "Radius", "Search radius in mm", 15, true);
parser.addArgument("noCenterOfMass", "com", ctkCommandLineParser::Bool, "No center of mass", "Do not use center of mass for node positions");
parser.setCategory("Connectomics");
parser.setTitle("Network Creation");
parser.setDescription("");
parser.setContributor("MBI");
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
//default values
int searchRadius( 15 );
bool noCenterOfMass( false );
// parse command line arguments
std::string fiberFilename = us::any_cast<std::string>(parsedArgs["fiberImage"]);
std::string parcellationFilename = us::any_cast<std::string>(parsedArgs["parcellation"]);
std::string outputFilename = us::any_cast<std::string>(parsedArgs["outputNetwork"]);
if (parsedArgs.count("radius"))
searchRadius = us::any_cast<int>(parsedArgs["radius"]);
if (parsedArgs.count("noCenterOfMass"))
noCenterOfMass = us::any_cast<bool>(parsedArgs["noCenterOfMass"]);
try
{
const std::string s1="", s2="";
// load fiber image
std::vector<mitk::BaseData::Pointer> fiberInfile =
mitk::BaseDataIO::LoadBaseDataFromFile( fiberFilename, s1, s2, false );
if( fiberInfile.empty() )
{
std::string errorMessage = "Fiber Image at " + fiberFilename + " could not be read. Aborting.";
MITK_ERROR << errorMessage;
return EXIT_FAILURE;
}
mitk::BaseData* fiberBaseData = fiberInfile.at(0);
mitk::FiberBundleX* fiberBundle = dynamic_cast<mitk::FiberBundleX*>( fiberBaseData );
// load parcellation
std::vector<mitk::BaseData::Pointer> parcellationInFile =
mitk::BaseDataIO::LoadBaseDataFromFile( parcellationFilename, s1, s2, false );
if( parcellationInFile.empty() )
{
std::string errorMessage = "Parcellation at " + parcellationFilename + " could not be read. Aborting.";
MITK_ERROR << errorMessage;
return EXIT_FAILURE;
}
mitk::BaseData* parcellationBaseData = parcellationInFile.at(0);
mitk::Image* parcellationImage = dynamic_cast<mitk::Image*>( parcellationBaseData );
// do creation
mitk::ConnectomicsNetworkCreator::Pointer connectomicsNetworkCreator = mitk::ConnectomicsNetworkCreator::New();
connectomicsNetworkCreator->SetSegmentation( parcellationImage );
connectomicsNetworkCreator->SetFiberBundle( fiberBundle );
if( !noCenterOfMass )
{
connectomicsNetworkCreator->CalculateCenterOfMass();
}
connectomicsNetworkCreator->SetEndPointSearchRadius( searchRadius );
connectomicsNetworkCreator->CreateNetworkFromFibersAndSegmentation();
mitk::ConnectomicsNetwork::Pointer network = connectomicsNetworkCreator->GetNetwork();
MITK_INFO << "searching writer";
- mitk::CoreObjectFactory::FileWriterList fileWriters = mitk::CoreObjectFactory::GetInstance()->GetFileWriters();
- for (mitk::CoreObjectFactory::FileWriterList::iterator it = fileWriters.begin() ; it != fileWriters.end() ; ++it)
- {
- if ( (*it)->CanWriteBaseDataType(network.GetPointer()) )
- {
- MITK_INFO << "writing";
- (*it)->SetFileName( outputFilename.c_str() );
- (*it)->DoWrite( network.GetPointer() );
- }
- }
+
+ mitk::IOUtil::SaveBaseData(network.GetPointer(), outputFilename );
return EXIT_SUCCESS;
}
catch (itk::ExceptionObject e)
{
MITK_INFO << e;
return EXIT_FAILURE;
}
catch (std::exception e)
{
MITK_INFO << e.what();
return EXIT_FAILURE;
}
catch (...)
{
MITK_INFO << "ERROR!?!";
return EXIT_FAILURE;
}
MITK_INFO << "DONE";
return EXIT_SUCCESS;
}
RegisterDiffusionMiniApp(NetworkCreation);
diff --git a/Modules/DiffusionImaging/MiniApps/StreamlineTracking.cpp b/Modules/DiffusionImaging/MiniApps/StreamlineTracking.cpp
index 286274fd54..bdd10f38b0 100755
--- a/Modules/DiffusionImaging/MiniApps/StreamlineTracking.cpp
+++ b/Modules/DiffusionImaging/MiniApps/StreamlineTracking.cpp
@@ -1,186 +1,180 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "MiniAppManager.h"
#include <mitkImageCast.h>
#include <mitkTensorImage.h>
#include <mitkIOUtil.h>
#include <mitkBaseDataIOFactory.h>
#include <mitkFiberBundleX.h>
#include <itkStreamlineTrackingFilter.h>
#include <itkDiffusionTensor3D.h>
#include "ctkCommandLineParser.h"
#include <mitkCoreObjectFactory.h>
int StreamlineTracking(int argc, char* argv[])
{
MITK_INFO << "StreamlineTracking";
ctkCommandLineParser parser;
parser.setArgumentPrefix("--", "-");
parser.addArgument("input", "i", ctkCommandLineParser::StringList, "Input image", "input tensor image (.dti)", us::Any(), false);
parser.addArgument("seed", "si", ctkCommandLineParser::InputFile, "Seed image", "binary seed image", us::Any(), true);
parser.addArgument("mask", "mi", ctkCommandLineParser::InputFile, "Mask", "binary mask image", us::Any(), true);
parser.addArgument("faImage", "fai", ctkCommandLineParser::InputFile, "FA image", "FA image", us::Any(), true);
parser.addArgument("minFA", "fa", ctkCommandLineParser::Float, "Min. FA threshold", "minimum fractional anisotropy threshold", 0.15, true);
parser.addArgument("minCurv", "c", ctkCommandLineParser::Float, "Min. curvature radius", "minimum curvature radius in mm (default = 0.5*minimum-spacing)");
parser.addArgument("stepSize", "s", ctkCommandLineParser::Float, "Step size", "step size in mm (default = 0.1*minimum-spacing)");
parser.addArgument("tendf", "f", ctkCommandLineParser::Float, "Weight f", "Weighting factor between first eigenvector (f=1 equals FACT tracking) and input vector dependent direction (f=0).", 1.0, true);
parser.addArgument("tendg", "g", ctkCommandLineParser::Float, "Weight g", "Weighting factor between input vector (g=0) and tensor deflection (g=1 equals TEND tracking)", 0.0, true);
parser.addArgument("numSeeds", "n", ctkCommandLineParser::Int, "Seeds per voxel", "Number of seeds per voxel.", 1, true);
parser.addArgument("minLength", "l", ctkCommandLineParser::Float, "Min. fiber length", "minimum fiber length in mm", 20, true);
parser.addArgument("interpolate", "ip", ctkCommandLineParser::Bool, "Interpolate", "Use linear interpolation", false, true);
parser.addArgument("outFile", "o", ctkCommandLineParser::String, "Output file", "output fiber bundle (.fib)", us::Any(), false);
parser.setCategory("Fiber Tracking and Processing Methods");
parser.setTitle("Streamline Tracking");
parser.setDescription("");
parser.setContributor("MBI");
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
ctkCommandLineParser::StringContainerType inputImages = us::any_cast<ctkCommandLineParser::StringContainerType>(parsedArgs["input"]);
string dtiFileName;
string outFileName = us::any_cast<string>(parsedArgs["outFile"]);
float minFA = 0.15;
float minCurv = -1;
float stepSize = -1;
float tendf = 1;
float tendg = 0;
float minLength = 20;
int numSeeds = 1;
bool interpolate = false;
if (parsedArgs.count("minCurv"))
minCurv = us::any_cast<float>(parsedArgs["minCurv"]);
if (parsedArgs.count("minFA"))
minFA = us::any_cast<float>(parsedArgs["minFA"]);
if (parsedArgs.count("stepSize"))
stepSize = us::any_cast<float>(parsedArgs["stepSize"]);
if (parsedArgs.count("tendf"))
tendf = us::any_cast<float>(parsedArgs["tendf"]);
if (parsedArgs.count("tendg"))
tendg = us::any_cast<float>(parsedArgs["tendg"]);
if (parsedArgs.count("minLength"))
minLength = us::any_cast<float>(parsedArgs["minLength"]);
if (parsedArgs.count("numSeeds"))
numSeeds = us::any_cast<int>(parsedArgs["numSeeds"]);
if (parsedArgs.count("interpolate"))
interpolate = us::any_cast<bool>(parsedArgs["interpolate"]);
try
{
typedef itk::StreamlineTrackingFilter< float > FilterType;
FilterType::Pointer filter = FilterType::New();
mitk::Image::Pointer mitkImage = NULL;
MITK_INFO << "Loading tensor images ...";
typedef itk::Image< itk::DiffusionTensor3D<float>, 3 > ItkTensorImage;
dtiFileName = inputImages.at(0);
for (unsigned int i=0; i<inputImages.size(); i++)
{
try
{
mitkImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(inputImages.at(i))->GetData());
mitk::TensorImage::Pointer img = dynamic_cast<mitk::TensorImage*>(mitk::IOUtil::LoadDataNode(inputImages.at(i))->GetData());
ItkTensorImage::Pointer itk_dti = ItkTensorImage::New();
mitk::CastToItkImage(img, itk_dti);
filter->SetInput(i, itk_dti);
}
catch(...){ MITK_INFO << "could not load: " << inputImages.at(i); }
}
MITK_INFO << "Loading seed image ...";
typedef itk::Image< unsigned char, 3 > ItkUCharImageType;
mitk::Image::Pointer mitkSeedImage = NULL;
if (parsedArgs.count("seed"))
mitkSeedImage = mitk::IOUtil::LoadImage(us::any_cast<string>(parsedArgs["seed"]));
MITK_INFO << "Loading mask image ...";
mitk::Image::Pointer mitkMaskImage = NULL;
if (parsedArgs.count("mask"))
mitkMaskImage = mitk::IOUtil::LoadImage(us::any_cast<string>(parsedArgs["mask"]));
// instantiate tracker
filter->SetSeedsPerVoxel(numSeeds);
filter->SetFaThreshold(minFA);
filter->SetMinCurvatureRadius(minCurv);
filter->SetStepSize(stepSize);
filter->SetF(tendf);
filter->SetG(tendg);
filter->SetInterpolate(interpolate);
filter->SetMinTractLength(minLength);
if (mitkSeedImage.IsNotNull())
{
ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
mitk::CastToItkImage(mitkSeedImage, mask);
filter->SetSeedImage(mask);
}
if (mitkMaskImage.IsNotNull())
{
ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
mitk::CastToItkImage(mitkMaskImage, mask);
filter->SetMaskImage(mask);
}
filter->Update();
vtkSmartPointer<vtkPolyData> fiberBundle = filter->GetFiberPolyData();
if ( fiberBundle->GetNumberOfLines()==0 )
{
MITK_INFO << "No fibers reconstructed. Check parametrization.";
return EXIT_FAILURE;
}
mitk::FiberBundleX::Pointer fib = mitk::FiberBundleX::New(fiberBundle);
fib->SetReferenceGeometry(mitkImage->GetGeometry());
- mitk::CoreObjectFactory::FileWriterList fileWriters = mitk::CoreObjectFactory::GetInstance()->GetFileWriters();
- for (mitk::CoreObjectFactory::FileWriterList::iterator it = fileWriters.begin() ; it != fileWriters.end() ; ++it)
- {
- if ( (*it)->CanWriteBaseDataType(fib.GetPointer()) ) {
- (*it)->SetFileName( outFileName.c_str() );
- (*it)->DoWrite( fib.GetPointer() );
- }
- }
+ mitk::IOUtil::SaveBaseData(fib.GetPointer(), outFileName );
+
}
catch (itk::ExceptionObject e)
{
MITK_INFO << e;
return EXIT_FAILURE;
}
catch (std::exception e)
{
MITK_INFO << e.what();
return EXIT_FAILURE;
}
catch (...)
{
MITK_INFO << "ERROR!?!";
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
RegisterDiffusionMiniApp(StreamlineTracking);
diff --git a/Modules/DiffusionImaging/MiniApps/TractometerMetrics.cpp b/Modules/DiffusionImaging/MiniApps/TractometerMetrics.cpp
index befa4c8f9a..3bc7636c97 100755
--- a/Modules/DiffusionImaging/MiniApps/TractometerMetrics.cpp
+++ b/Modules/DiffusionImaging/MiniApps/TractometerMetrics.cpp
@@ -1,424 +1,418 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "MiniAppManager.h"
#include <mitkBaseDataIOFactory.h>
#include <mitkBaseData.h>
#include <mitkImageCast.h>
#include <mitkImageToItk.h>
#include <itkEvaluateDirectionImagesFilter.h>
#include <metaCommand.h>
#include "ctkCommandLineParser.h"
#include <itkTractsToVectorImageFilter.h>
#include <usAny.h>
#include <itkImageFileWriter.h>
#include <mitkIOUtil.h>
#include <boost/lexical_cast.hpp>
#include <iostream>
#include <fstream>
#include <itksys/SystemTools.hxx>
#include <mitkCoreObjectFactory.h>
#define _USE_MATH_DEFINES
#include <math.h>
int TractometerMetrics(int argc, char* argv[])
{
MITK_INFO << "TractometerMetrics";
ctkCommandLineParser parser;
parser.setTitle("Tractometer Metrics");
parser.setCategory("Fiber Tracking and Processing Methods");
parser.setDescription("");
parser.setContributor("MBI");
parser.setArgumentPrefix("--", "-");
parser.addArgument("input", "i", ctkCommandLineParser::InputFile, "Input:", "input tractogram (.fib, vtk ascii file format)", us::Any(), false);
parser.addArgument("out", "o", ctkCommandLineParser::OutputDirectory, "Output:", "output root", us::Any(), false);
parser.addArgument("labels", "l", ctkCommandLineParser::StringList, "Label pairs:", "label pairs", false);
parser.addArgument("labelimage", "li", ctkCommandLineParser::String, "Label image:", "label image", false);
parser.addArgument("verbose", "v", ctkCommandLineParser::Bool, "Verbose:", "output valid, invalid and no connections as fiber bundles");
parser.addArgument("fileID", "id", ctkCommandLineParser::String, "ID:", "optional ID field");
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
ctkCommandLineParser::StringContainerType labelpairs = us::any_cast<ctkCommandLineParser::StringContainerType>(parsedArgs["labels"]);
string fibFile = us::any_cast<string>(parsedArgs["input"]);
string labelImageFile = us::any_cast<string>(parsedArgs["labelimage"]);
string outRoot = us::any_cast<string>(parsedArgs["out"]);
string fileID = "";
if (parsedArgs.count("fileID"))
fileID = us::any_cast<string>(parsedArgs["fileID"]);
bool verbose = false;
if (parsedArgs.count("verbose"))
verbose = us::any_cast<bool>(parsedArgs["verbose"]);
try
{
typedef itk::Image<short, 3> ItkShortImgType;
typedef itk::Image<unsigned char, 3> ItkUcharImgType;
// load fiber bundle
mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(labelImageFile)->GetData());
typedef mitk::ImageToItk< ItkShortImgType > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(img);
caster->Update();
ItkShortImgType::Pointer labelImage = caster->GetOutput();
string path = itksys::SystemTools::GetFilenamePath(labelImageFile);
std::vector< bool > detected;
std::vector< std::pair< int, int > > labelsvector;
std::vector< ItkUcharImgType::Pointer > bundleMasks;
std::vector< ItkUcharImgType::Pointer > bundleMasksCoverage;
short max = 0;
for (unsigned int i=0; i<labelpairs.size()-1; i+=2)
{
std::pair< short, short > l;
l.first = boost::lexical_cast<short>(labelpairs.at(i));
l.second = boost::lexical_cast<short>(labelpairs.at(i+1));
MITK_INFO << labelpairs.at(i);
MITK_INFO << labelpairs.at(i+1);
if (l.first>max)
max=l.first;
if (l.second>max)
max=l.second;
labelsvector.push_back(l);
detected.push_back(false);
{
mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(path+"/Bundle"+boost::lexical_cast<string>(labelsvector.size())+"_MASK.nrrd")->GetData());
typedef mitk::ImageToItk< ItkUcharImgType > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(img);
caster->Update();
ItkUcharImgType::Pointer bundle = caster->GetOutput();
bundleMasks.push_back(bundle);
}
{
mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(path+"/Bundle"+boost::lexical_cast<string>(labelsvector.size())+"_MASK_COVERAGE.nrrd")->GetData());
typedef mitk::ImageToItk< ItkUcharImgType > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(img);
caster->Update();
ItkUcharImgType::Pointer bundle = caster->GetOutput();
bundleMasksCoverage.push_back(bundle);
}
}
vnl_matrix< unsigned char > matrix; matrix.set_size(max, max); matrix.fill(0);
vtkSmartPointer<vtkPolyData> polyData = inputTractogram->GetFiberPolyData();
int validConnections = 0;
int noConnection = 0;
int validBundles = 0;
int invalidBundles = 0;
int invalidConnections = 0;
ItkUcharImgType::Pointer coverage = ItkUcharImgType::New();
coverage->SetSpacing(labelImage->GetSpacing());
coverage->SetOrigin(labelImage->GetOrigin());
coverage->SetDirection(labelImage->GetDirection());
coverage->SetLargestPossibleRegion(labelImage->GetLargestPossibleRegion());
coverage->SetBufferedRegion( labelImage->GetLargestPossibleRegion() );
coverage->SetRequestedRegion( labelImage->GetLargestPossibleRegion() );
coverage->Allocate();
coverage->FillBuffer(0);
vtkSmartPointer<vtkPoints> noConnPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> noConnCells = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> invalidPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> invalidCells = vtkSmartPointer<vtkCellArray>::New();
vtkSmartPointer<vtkPoints> validPoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> validCells = vtkSmartPointer<vtkCellArray>::New();
boost::progress_display disp(inputTractogram->GetNumFibers());
for (int i=0; i<inputTractogram->GetNumFibers(); i++)
{
++disp;
vtkCell* cell = polyData->GetCell(i);
int numPoints = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
if (numPoints>1)
{
double* start = points->GetPoint(0);
itk::Point<float, 3> itkStart;
itkStart[0] = start[0]; itkStart[1] = start[1]; itkStart[2] = start[2];
itk::Index<3> idxStart;
labelImage->TransformPhysicalPointToIndex(itkStart, idxStart);
double* end = points->GetPoint(numPoints-1);
itk::Point<float, 3> itkEnd;
itkEnd[0] = end[0]; itkEnd[1] = end[1]; itkEnd[2] = end[2];
itk::Index<3> idxEnd;
labelImage->TransformPhysicalPointToIndex(itkEnd, idxEnd);
if ( labelImage->GetPixel(idxStart)==0 || labelImage->GetPixel(idxEnd)==0 )
{
noConnection++;
if (verbose)
{
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for (int j=0; j<numPoints; j++)
{
double* p = points->GetPoint(j);
vtkIdType id = noConnPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
}
noConnCells->InsertNextCell(container);
}
}
else
{
bool invalid = true;
for (unsigned int i=0; i<labelsvector.size(); i++)
{
bool outside = false;
ItkUcharImgType::Pointer bundle = bundleMasks.at(i);
std::pair< short, short > l = labelsvector.at(i);
if ( (labelImage->GetPixel(idxStart)==l.first && labelImage->GetPixel(idxEnd)==l.second) ||
(labelImage->GetPixel(idxStart)==l.second && labelImage->GetPixel(idxEnd)==l.first) )
{
for (int j=0; j<numPoints; j++)
{
double* p = points->GetPoint(j);
itk::Point<float, 3> itkP;
itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
itk::Index<3> idx;
bundle->TransformPhysicalPointToIndex(itkP, idx);
if ( !bundle->GetPixel(idx)>0 && bundle->GetLargestPossibleRegion().IsInside(idx) )
{
outside=true;
}
}
if (!outside)
{
validConnections++;
if (detected.at(i)==false)
validBundles++;
detected.at(i) = true;
invalid = false;
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for (int j=0; j<numPoints; j++)
{
double* p = points->GetPoint(j);
vtkIdType id = validPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
itk::Point<float, 3> itkP;
itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
itk::Index<3> idx;
coverage->TransformPhysicalPointToIndex(itkP, idx);
if ( coverage->GetLargestPossibleRegion().IsInside(idx) )
coverage->SetPixel(idx, 1);
}
validCells->InsertNextCell(container);
}
break;
}
}
if (invalid==true)
{
invalidConnections++;
int x = labelImage->GetPixel(idxStart)-1;
int y = labelImage->GetPixel(idxEnd)-1;
if (x>=0 && y>0 && x<matrix.cols() && y<matrix.rows() && (matrix[x][y]==0 || matrix[y][x]==0) )
{
invalidBundles++;
matrix[x][y]=1;
matrix[y][x]=1;
}
if (verbose)
{
vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
for (int j=0; j<numPoints; j++)
{
double* p = points->GetPoint(j);
vtkIdType id = invalidPoints->InsertNextPoint(p);
container->GetPointIds()->InsertNextId(id);
}
invalidCells->InsertNextCell(container);
}
}
}
}
}
if (verbose)
{
mitk::CoreObjectFactory::FileWriterList fileWriters = mitk::CoreObjectFactory::GetInstance()->GetFileWriters();
vtkSmartPointer<vtkPolyData> noConnPolyData = vtkSmartPointer<vtkPolyData>::New();
noConnPolyData->SetPoints(noConnPoints);
noConnPolyData->SetLines(noConnCells);
mitk::FiberBundleX::Pointer noConnFib = mitk::FiberBundleX::New(noConnPolyData);
- for (mitk::CoreObjectFactory::FileWriterList::iterator it = fileWriters.begin() ; it != fileWriters.end() ; ++it)
- {
- if ( (*it)->CanWriteBaseDataType(noConnFib.GetPointer()) ) {
- (*it)->SetFileName( (outRoot+"_NC.fib").c_str() );
- (*it)->DoWrite( noConnFib.GetPointer() );
- }
- }
+
+ string ncfilename = outRoot;
+ ncfilename.append("_NC.fib");
+
+ mitk::IOUtil::SaveBaseData(noConnFib.GetPointer(), ncfilename );
vtkSmartPointer<vtkPolyData> invalidPolyData = vtkSmartPointer<vtkPolyData>::New();
invalidPolyData->SetPoints(invalidPoints);
invalidPolyData->SetLines(invalidCells);
mitk::FiberBundleX::Pointer invalidFib = mitk::FiberBundleX::New(invalidPolyData);
- for (mitk::CoreObjectFactory::FileWriterList::iterator it = fileWriters.begin() ; it != fileWriters.end() ; ++it)
- {
- if ( (*it)->CanWriteBaseDataType(invalidFib.GetPointer()) ) {
- (*it)->SetFileName( (outRoot+"_IC.fib").c_str() );
- (*it)->DoWrite( invalidFib.GetPointer() );
- }
- }
+
+ string icfilename = outRoot;
+ icfilename.append("_IC.fib");
+
+ mitk::IOUtil::SaveBaseData(invalidFib.GetPointer(), icfilename );
vtkSmartPointer<vtkPolyData> validPolyData = vtkSmartPointer<vtkPolyData>::New();
validPolyData->SetPoints(validPoints);
validPolyData->SetLines(validCells);
mitk::FiberBundleX::Pointer validFib = mitk::FiberBundleX::New(validPolyData);
- for (mitk::CoreObjectFactory::FileWriterList::iterator it = fileWriters.begin() ; it != fileWriters.end() ; ++it)
- {
- if ( (*it)->CanWriteBaseDataType(validFib.GetPointer()) ) {
- (*it)->SetFileName( (outRoot+"_VC.fib").c_str() );
- (*it)->DoWrite( validFib.GetPointer() );
- }
- }
+
+ string vcfilename = outRoot;
+ vcfilename.append("_VC.fib");
+
+ mitk::IOUtil::SaveBaseData(validFib.GetPointer(), vcfilename );
{
typedef itk::ImageFileWriter< ItkUcharImgType > WriterType;
WriterType::Pointer writer = WriterType::New();
writer->SetFileName(outRoot+"_ABC.nrrd");
writer->SetInput(coverage);
writer->Update();
}
}
// calculate coverage
int wmVoxels = 0;
int coveredVoxels = 0;
itk::ImageRegionIterator<ItkUcharImgType> it (coverage, coverage->GetLargestPossibleRegion());
while(!it.IsAtEnd())
{
bool wm = false;
for (unsigned int i=0; i<bundleMasksCoverage.size(); i++)
{
ItkUcharImgType::Pointer bundle = bundleMasksCoverage.at(i);
if (bundle->GetPixel(it.GetIndex())>0)
{
wm = true;
wmVoxels++;
break;
}
}
if (wm && it.Get()>0)
coveredVoxels++;
++it;
}
int numFibers = inputTractogram->GetNumFibers();
double nc = (double)noConnection/numFibers;
double vc = (double)validConnections/numFibers;
double ic = (double)invalidConnections/numFibers;
if (numFibers==0)
{
nc = 0.0;
vc = 0.0;
ic = 0.0;
}
int vb = validBundles;
int ib = invalidBundles;
double abc = (double)coveredVoxels/wmVoxels;
MITK_INFO << "NC: " << nc;
MITK_INFO << "VC: " << vc;
MITK_INFO << "IC: " << ic;
MITK_INFO << "VB: " << vb;
MITK_INFO << "IB: " << ib;
MITK_INFO << "ABC: " << abc;
string logFile = outRoot;
logFile.append("_TRACTOMETER.csv");
ofstream file;
file.open (logFile.c_str());
{
string sens = itksys::SystemTools::GetFilenameWithoutLastExtension(fibFile);
if (!fileID.empty())
sens = fileID;
sens.append(",");
sens.append(boost::lexical_cast<string>(nc));
sens.append(",");
sens.append(boost::lexical_cast<string>(vc));
sens.append(",");
sens.append(boost::lexical_cast<string>(ic));
sens.append(",");
sens.append(boost::lexical_cast<string>(validBundles));
sens.append(",");
sens.append(boost::lexical_cast<string>(invalidBundles));
sens.append(",");
sens.append(boost::lexical_cast<string>(abc));
sens.append(";\n");
file << sens;
}
file.close();
}
catch (itk::ExceptionObject e)
{
MITK_INFO << e;
return EXIT_FAILURE;
}
catch (std::exception e)
{
MITK_INFO << e.what();
return EXIT_FAILURE;
}
catch (...)
{
MITK_INFO << "ERROR!?!";
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
RegisterDiffusionMiniApp(TractometerMetrics);