int GibbsTracking(int argc, char* argv[])
{
ctkCommandLineParser parser;
parser.setArgumentPrefix("--", "-");
parser.addArgument("input", "i", ctkCommandLineParser::String, "input image (tensor, Q-ball or FSL/MRTrix SH-coefficient image)", us::Any(), false);
parser.addArgument("parameters", "p", ctkCommandLineParser::String, "parameter file (.gtp)", us::Any(), false);
parser.addArgument("mask", "m", ctkCommandLineParser::String, "binary mask image");
parser.addArgument("shConvention", "s", ctkCommandLineParser::String, "sh coefficient convention (FSL, MRtrix)", string("FSL"), true);
parser.addArgument("outFile", "o", ctkCommandLineParser::String, "output fiber bundle (.fib)", us::Any(), false);
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"]);
try
{
RegisterDiffusionCoreObjectFactory();
RegisterFiberTrackingObjectFactory();
// 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 );
// 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<ItkQballImageType>(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<ItkTensorImage>(mitkTensorImage, itk_dti);
gibbsTracker->SetTensorImage(itk_dti);
}
else if ( boost::algorithm::ends_with(inFileName, ".nii") )
{
MITK_INFO << "Loading sh-coefficient image ...";
mitk::Image::Pointer mitkImage = dynamic_cast<mitk::Image*>(infile.at(0).GetPointer());
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));
break;
case 6:
gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<6>(mitkImage, toolkitConvention));
break;
case 8:
gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<8>(mitkImage, toolkitConvention));
break;
case 10:
gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<10>(mitkImage, toolkitConvention));
break;
case 12:
gibbsTracker->SetQBallImage(TemplatedConvertShCoeffs<12>(mitkImage, toolkitConvention));
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<MaskImgType>(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());
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() );
}
}
}
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;
}
/**Documentation
* Test for gibbs tracking filter
*/
int mitkGibbsTrackingTest(int argc, char* argv[])
{
MITK_TEST_BEGIN("mitkGibbsTrackingTest");
MITK_TEST_CONDITION_REQUIRED(argc>4,"check for input data")
QBallImage::Pointer mitkQballImage;
Image::Pointer mitkMaskImage;
mitk::FiberBundleX::Pointer fib1;
try{
MITK_INFO << "Q-Ball image: " << argv[1];
MITK_INFO << "Mask image: " << argv[2];
MITK_INFO << "Parameter file: " << argv[3];
MITK_INFO << "Reference bundle: " << argv[4];
RegisterDiffusionCoreObjectFactory();
RegisterFiberTrackingObjectFactory();
const std::string s1="", s2="";
std::vector<mitk::BaseData::Pointer> infile = mitk::BaseDataIO::LoadBaseDataFromFile( argv[1], s1, s2, false );
mitkQballImage = dynamic_cast<mitk::QBallImage*>(infile.at(0).GetPointer());
MITK_TEST_CONDITION_REQUIRED(mitkQballImage.IsNotNull(),"check qball image")
infile = mitk::BaseDataIO::LoadBaseDataFromFile( argv[2], s1, s2, false );
mitkMaskImage = dynamic_cast<mitk::Image*>(infile.at(0).GetPointer());
MITK_TEST_CONDITION_REQUIRED(mitkMaskImage.IsNotNull(),"check mask image")
infile = mitk::BaseDataIO::LoadBaseDataFromFile( argv[4], s1, s2, false );
fib1 = dynamic_cast<mitk::FiberBundleX*>(infile.at(0).GetPointer());
MITK_TEST_CONDITION_REQUIRED(fib1.IsNotNull(),"check fiber bundle")
typedef itk::Vector<float, QBALL_ODFSIZE> OdfVectorType;
typedef itk::Image<OdfVectorType,3> OdfVectorImgType;
typedef itk::Image<float,3> MaskImgType;
typedef itk::GibbsTrackingFilter<OdfVectorImgType> GibbsTrackingFilterType;
OdfVectorImgType::Pointer itk_qbi = OdfVectorImgType::New();
mitk::CastToItkImage<OdfVectorImgType>(mitkQballImage, itk_qbi);
MaskImgType::Pointer itk_mask = MaskImgType::New();
mitk::CastToItkImage<MaskImgType>(mitkMaskImage, itk_mask);
GibbsTrackingFilterType::Pointer gibbsTracker = GibbsTrackingFilterType::New();
gibbsTracker->SetQBallImage(itk_qbi.GetPointer());
gibbsTracker->SetMaskImage(itk_mask);
gibbsTracker->SetDuplicateImage(false);
gibbsTracker->SetRandomSeed(1);
gibbsTracker->SetLoadParameterFile(argv[3]);
gibbsTracker->Update();
mitk::FiberBundleX::Pointer fib2 = mitk::FiberBundleX::New(gibbsTracker->GetFiberBundle());
MITK_TEST_CONDITION_REQUIRED(fib1->Equals(fib2), "check if gibbs tracking has changed");
gibbsTracker->SetRandomSeed(0);
gibbsTracker->Update();
fib2 = mitk::FiberBundleX::New(gibbsTracker->GetFiberBundle());
MITK_TEST_CONDITION_REQUIRED(!fib1->Equals(fib2), "check if gibbs tracking has changed after wrong seed");
}
catch(...)
{
return EXIT_FAILURE;
}
// always end with this!
MITK_TEST_END();
}
int main(int argc, char* argv[])
{
std::cout << "GibbsTracking";
mitkCommandLineParser parser;
parser.setTitle("Gibbs Tracking");
parser.setCategory("Fiber Tracking and Processing Methods");
parser.setDescription("");
parser.setContributor("MBI");
parser.setArgumentPrefix("--", "-");
parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input image (tensor, Q-ball or FSL/MRTrix SH-coefficient image)", us::Any(), false);
parser.addArgument("parameters", "p", mitkCommandLineParser::InputFile, "Parameters:", "parameter file (.gtp)", us::Any(), false);
parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Mask:", "binary mask image");
parser.addArgument("shConvention", "s", mitkCommandLineParser::String, "SH coefficient:", "sh coefficient convention (FSL, MRtrix)", string("FSL"), true);
parser.addArgument("outFile", "o", mitkCommandLineParser::OutputFile, "Output:", "output fiber bundle (.fib)", us::Any(), false);
parser.addArgument("noFlip", "f", mitkCommandLineParser::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") )
{
std::cout << "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") )
{
std::cout << "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") )
{
std::cout << "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;
std::cout << "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;
std::cout << "Using MRtrix style sh-coefficient convention";
}
else
std::cout << "Using FSL style sh-coefficient convention";
}
else
std::cout << "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:
std::cout << "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::IOUtil::SaveBaseData(mitkFiberBundle.GetPointer(), outFileName );
}
catch (itk::ExceptionObject e)
{
std::cout << e;
return EXIT_FAILURE;
}
catch (std::exception e)
{
std::cout << e.what();
return EXIT_FAILURE;
}
catch (...)
{
std::cout << "ERROR!?!";
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
