/**
* Calculate indices derived from Qball or tensor images
*/
int DiffusionIndices(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("index", "idx", ctkCommandLineParser::String, "index (fa, gfa, ra, ad, rd, ca, l2, l3, md)", us::Any(), false);
parser.addArgument("outFile", "o", ctkCommandLineParser::String, "output file", 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 index = us::any_cast<string>(parsedArgs["index"]);
string outFileName = us::any_cast<string>(parsedArgs["outFile"]);
string ext = itksys::SystemTools::GetFilenameLastExtension(outFileName);
if (ext.empty())
outFileName += ".nrrd";
try
{
// load input image
const std::string s1="", s2="";
std::vector<mitk::BaseData::Pointer> infile = mitk::BaseDataIO::LoadBaseDataFromFile( inFileName, s1, s2, false );
if( boost::algorithm::ends_with(inFileName, ".qbi") && index=="gfa" )
{
typedef itk::Vector<float, QBALL_ODFSIZE> OdfVectorType;
typedef itk::Image<OdfVectorType,3> ItkQballImageType;
mitk::QBallImage::Pointer mitkQballImage = dynamic_cast<mitk::QBallImage*>(infile.at(0).GetPointer());
ItkQballImageType::Pointer itk_qbi = ItkQballImageType::New();
mitk::CastToItkImage<ItkQballImageType>(mitkQballImage, itk_qbi);
typedef itk::DiffusionQballGeneralizedFaImageFilter<float,float,QBALL_ODFSIZE> GfaFilterType;
GfaFilterType::Pointer gfaFilter = GfaFilterType::New();
gfaFilter->SetInput(itk_qbi);
gfaFilter->SetComputationMethod(GfaFilterType::GFA_STANDARD);
gfaFilter->Update();
MITK_INFO << "Writing " << outFileName;
itk::ImageFileWriter< itk::Image<float,3> >::Pointer fileWriter = itk::ImageFileWriter< itk::Image<float,3> >::New();
fileWriter->SetInput(gfaFilter->GetOutput());
fileWriter->SetFileName(outFileName);
fileWriter->Update();
}
else if( boost::algorithm::ends_with(inFileName, ".dti") )
{
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);
typedef itk::TensorDerivedMeasurementsFilter<float> MeasurementsType;
MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
measurementsCalculator->SetInput(itk_dti.GetPointer() );
if(index=="fa")
measurementsCalculator->SetMeasure(MeasurementsType::FA);
else if(index=="ra")
measurementsCalculator->SetMeasure(MeasurementsType::RA);
else if(index=="ad")
measurementsCalculator->SetMeasure(MeasurementsType::AD);
else if(index=="rd")
measurementsCalculator->SetMeasure(MeasurementsType::RD);
else if(index=="ca")
measurementsCalculator->SetMeasure(MeasurementsType::CA);
else if(index=="l2")
measurementsCalculator->SetMeasure(MeasurementsType::L2);
else if(index=="l3")
measurementsCalculator->SetMeasure(MeasurementsType::L3);
else if(index=="md")
measurementsCalculator->SetMeasure(MeasurementsType::MD);
else
{
MITK_WARN << "No valid diffusion index for input image (tensor image) defined";
return EXIT_FAILURE;
}
measurementsCalculator->Update();
MITK_INFO << "Writing " << outFileName;
itk::ImageFileWriter< itk::Image<float,3> >::Pointer fileWriter = itk::ImageFileWriter< itk::Image<float,3> >::New();
fileWriter->SetInput(measurementsCalculator->GetOutput());
fileWriter->SetFileName(outFileName);
fileWriter->Update();
}
else
MITK_INFO << "Diffusion index " << index << " not supported for supplied file type.";
}
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;
}
void QmitkDiffusionQuantificationView::QBIQuantification(
mitk::DataStorage::SetOfObjects::Pointer inImages, int method)
{
itk::TimeProbe clock;
QString status;
int nrFiles = inImages->size();
if (!nrFiles) return;
mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
std::vector<mitk::DataNode::Pointer> nodes;
while ( itemiter != itemiterend ) // for all items
{
typedef float TOdfPixelType;
const int odfsize = QBALL_ODFSIZE;
typedef itk::Vector<TOdfPixelType,odfsize> OdfVectorType;
typedef itk::Image<OdfVectorType,3> OdfVectorImgType;
mitk::Image* vol =
static_cast<mitk::Image*>((*itemiter)->GetData());
OdfVectorImgType::Pointer itkvol = OdfVectorImgType::New();
mitk::CastToItkImage<OdfVectorImgType>(vol, itkvol);
std::string nodename;
(*itemiter)->GetStringProperty("name", nodename);
++itemiter;
float p1 = m_Controls->m_ParamKEdit->text().toFloat();
float p2 = m_Controls->m_ParamPEdit->text().toFloat();
// COMPUTE RA
clock.Start();
MBI_INFO << "Computing GFA ";
mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
"Computing GFA for %s", nodename.c_str()).toAscii());
typedef OdfVectorType::ValueType RealValueType;
typedef itk::Image< RealValueType, 3 > RAImageType;
typedef itk::DiffusionQballGeneralizedFaImageFilter<TOdfPixelType,TOdfPixelType,odfsize>
GfaFilterType;
GfaFilterType::Pointer gfaFilter = GfaFilterType::New();
gfaFilter->SetInput(itkvol);
double scale = 1;
std::string newname;
newname.append(nodename);
switch(method)
{
case 0:
{
gfaFilter->SetComputationMethod(GfaFilterType::GFA_STANDARD);
newname.append("GFA");
break;
}
case 1:
{
gfaFilter->SetComputationMethod(GfaFilterType::GFA_QUANTILES_HIGH_LOW);
newname.append("01");
break;
}
case 2:
{
gfaFilter->SetComputationMethod(GfaFilterType::GFA_QUANTILE_HIGH);
newname.append("02");
break;
}
case 3:
{
gfaFilter->SetComputationMethod(GfaFilterType::GFA_MAX_ODF_VALUE);
newname.append("03");
break;
}
case 4:
{
gfaFilter->SetComputationMethod(GfaFilterType::GFA_DECONVOLUTION_COEFFS);
newname.append("04");
break;
}
case 5:
{
gfaFilter->SetComputationMethod(GfaFilterType::GFA_MIN_MAX_NORMALIZED_STANDARD);
newname.append("05");
break;
}
case 6:
{
gfaFilter->SetComputationMethod(GfaFilterType::GFA_NORMALIZED_ENTROPY);
newname.append("06");
break;
}
case 7:
{
gfaFilter->SetComputationMethod(GfaFilterType::GFA_NEMATIC_ORDER_PARAMETER);
newname.append("07");
break;
}
case 8:
{
gfaFilter->SetComputationMethod(GfaFilterType::GFA_QUANTILES_LOW_HIGH);
newname.append("08");
break;
}
case 9:
{
gfaFilter->SetComputationMethod(GfaFilterType::GFA_QUANTILE_LOW);
newname.append("09");
break;
}
case 10:
{
gfaFilter->SetComputationMethod(GfaFilterType::GFA_MIN_ODF_VALUE);
newname.append("10");
break;
}
case 11:
{
gfaFilter->SetComputationMethod(GfaFilterType::GFA_STD_BY_MAX);
newname.append("11");
break;
}
case 12:
{
p1 = m_Controls->MinAngle->text().toFloat();
p2 = m_Controls->MaxAngle->text().toFloat();
gfaFilter->SetComputationMethod(GfaFilterType::GFA_PRINCIPLE_CURVATURE);
QString paramString;
paramString = paramString.append("PC%1-%2").arg(p1).arg(p2);
newname.append(paramString.toAscii());
gfaFilter->SetParam1(p1);
gfaFilter->SetParam2(p2);
break;
}
case 13:
{
gfaFilter->SetComputationMethod(GfaFilterType::GFA_GENERALIZED_GFA);
QString paramString;
paramString = paramString.append("GFAK%1P%2").arg(p1).arg(p2);
newname.append(paramString.toAscii());
gfaFilter->SetParam1(p1);
gfaFilter->SetParam2(p2);
break;
}
default:
{
newname.append("0");
gfaFilter->SetComputationMethod(GfaFilterType::GFA_STANDARD);
}
}
gfaFilter->Update();
clock.Stop();
MBI_DEBUG << "took " << clock.GetMeanTime() << "s.";
typedef itk::Image<TOdfPixelType, 3> ImgType;
ImgType::Pointer img = ImgType::New();
img->SetSpacing( gfaFilter->GetOutput()->GetSpacing() ); // Set the image spacing
img->SetOrigin( gfaFilter->GetOutput()->GetOrigin() ); // Set the image origin
img->SetDirection( gfaFilter->GetOutput()->GetDirection() ); // Set the image direction
img->SetLargestPossibleRegion( gfaFilter->GetOutput()->GetLargestPossibleRegion());
img->SetBufferedRegion( gfaFilter->GetOutput()->GetLargestPossibleRegion() );
img->Allocate();
itk::ImageRegionIterator<ImgType> ot (img, img->GetLargestPossibleRegion() );
ot = ot.Begin();
itk::ImageRegionConstIterator<GfaFilterType::OutputImageType> it
(gfaFilter->GetOutput(), gfaFilter->GetOutput()->GetLargestPossibleRegion() );
it = it.Begin();
for (it = it.Begin(); !it.IsAtEnd(); ++it)
{
GfaFilterType::OutputImageType::PixelType val = it.Get();
ot.Set(val * m_Controls->m_ScaleImageValuesBox->value());
++ot;
}
// GFA TO DATATREE
mitk::Image::Pointer image = mitk::Image::New();
image->InitializeByItk( img.GetPointer() );
image->SetVolume( img->GetBufferPointer() );
mitk::DataNode::Pointer node=mitk::DataNode::New();
node->SetData( image );
node->SetProperty( "name", mitk::StringProperty::New(newname) );
nodes.push_back(node);
mitk::StatusBar::GetInstance()->DisplayText("Computation complete.");
}
std::vector<mitk::DataNode::Pointer>::iterator nodeIt;
for(nodeIt = nodes.begin(); nodeIt != nodes.end(); ++nodeIt)
GetDefaultDataStorage()->Add(*nodeIt);
m_MultiWidget->RequestUpdate();
}
