int mitkLocalFiberPlausibilityTest(int argc, char* argv[])
{
MITK_TEST_BEGIN("mitkLocalFiberPlausibilityTest");
MITK_TEST_CONDITION_REQUIRED(argc==8,"check for input data")
string fibFile = argv[1];
vector< string > referenceImages;
referenceImages.push_back(argv[2]);
referenceImages.push_back(argv[3]);
string LDFP_ERROR_IMAGE = argv[4];
string LDFP_NUM_DIRECTIONS = argv[5];
string LDFP_VECTOR_FIELD = argv[6];
string LDFP_ERROR_IMAGE_IGNORE = argv[7];
float angularThreshold = 25;
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->SetNumberOfThreads(1);
fOdfFilter->Update();
ItkDirectionImageContainerType::Pointer directionImageContainer = fOdfFilter->GetDirectionImageContainer();
// Get directions and num directions image
ItkUcharImgType::Pointer numDirImage = fOdfFilter->GetNumDirectionsImage();
mitk::Image::Pointer mitkNumDirImage = mitk::Image::New();
mitkNumDirImage->InitializeByItk( numDirImage.GetPointer() );
mitkNumDirImage->SetVolume( numDirImage->GetBufferPointer() );
mitk::FiberBundleX::Pointer testDirections = fOdfFilter->GetOutputFiberBundle();
// evaluate directions with missing directions
EvaluationFilterType::Pointer evaluationFilter = EvaluationFilterType::New();
evaluationFilter->SetImageSet(directionImageContainer);
evaluationFilter->SetReferenceImageSet(referenceImageContainer);
evaluationFilter->SetMaskImage(itkMaskImage);
evaluationFilter->SetIgnoreMissingDirections(false);
evaluationFilter->Update();
EvaluationFilterType::OutputImageType::Pointer angularErrorImage = evaluationFilter->GetOutput(0);
mitk::Image::Pointer mitkAngularErrorImage = mitk::Image::New();
mitkAngularErrorImage->InitializeByItk( angularErrorImage.GetPointer() );
mitkAngularErrorImage->SetVolume( angularErrorImage->GetBufferPointer() );
// evaluate directions without missing directions
evaluationFilter->SetIgnoreMissingDirections(true);
evaluationFilter->Update();
EvaluationFilterType::OutputImageType::Pointer angularErrorImageIgnore = evaluationFilter->GetOutput(0);
mitk::Image::Pointer mitkAngularErrorImageIgnore = mitk::Image::New();
mitkAngularErrorImageIgnore->InitializeByItk( angularErrorImageIgnore.GetPointer() );
mitkAngularErrorImageIgnore->SetVolume( angularErrorImageIgnore->GetBufferPointer() );
mitk::Image::Pointer gtAngularErrorImageIgnore = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(LDFP_ERROR_IMAGE_IGNORE)->GetData());
mitk::Image::Pointer gtAngularErrorImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(LDFP_ERROR_IMAGE)->GetData());
mitk::Image::Pointer gtNumTestDirImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(LDFP_NUM_DIRECTIONS)->GetData());
mitk::FiberBundleX::Pointer gtTestDirections = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(LDFP_VECTOR_FIELD)->GetData());
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(gtAngularErrorImageIgnore, mitkAngularErrorImageIgnore, 0.0001, true), "Check if error images are equal (ignored missing directions).");
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(gtAngularErrorImage, mitkAngularErrorImage, 0.0001, true), "Check if error images are equal.");
MITK_TEST_CONDITION_REQUIRED(testDirections->Equals(gtTestDirections), "Check if vector fields are equal.");
MITK_TEST_CONDITION_REQUIRED(mitk::Equal(gtNumTestDirImage, mitkNumDirImage, 0.0001, true), "Check if num direction images are equal.");
}
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_TEST_END();
}
void QmitkOdfMaximaExtractionView::GenerateDataFromDwi()
{
typedef itk::OdfMaximaExtractionFilter< float > MaximaExtractionFilterType;
MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
mitk::Geometry3D::Pointer geometry;
if (!m_ImageNodes.empty())
{
try{
Image::Pointer img = dynamic_cast<Image*>(m_ImageNodes.at(0)->GetData());
typedef ImageToItk< MaximaExtractionFilterType::CoefficientImageType > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(img);
caster->Update();
filter->SetShCoeffImage(caster->GetOutput());
geometry = img->GetGeometry();
}
catch(itk::ExceptionObject &e)
{
MITK_INFO << "wrong image type: " << e.what();
return;
}
}
else
return;
filter->SetMaxNumPeaks(m_Controls->m_MaxNumPeaksBox->value());
filter->SetPeakThreshold(m_Controls->m_PeakThresholdBox->value());
if (!m_BinaryImageNodes.empty())
{
ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
Image::Pointer mitkMaskImg = dynamic_cast<Image*>(m_BinaryImageNodes.at(0)->GetData());
CastToItkImage<ItkUcharImgType>(mitkMaskImg, itkMaskImage);
filter->SetMaskImage(itkMaskImage);
}
switch (m_Controls->m_NormalizationBox->currentIndex())
{
case 0:
filter->SetNormalizationMethod(MaximaExtractionFilterType::NO_NORM);
break;
case 1:
filter->SetNormalizationMethod(MaximaExtractionFilterType::MAX_VEC_NORM);
break;
case 2:
filter->SetNormalizationMethod(MaximaExtractionFilterType::SINGLE_VEC_NORM);
break;
}
filter->GenerateData();
ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
if (m_Controls->m_OutputDirectionImagesBox->isChecked())
{
typedef MaximaExtractionFilterType::ItkDirectionImageContainer ItkDirectionImageContainer;
ItkDirectionImageContainer::Pointer container = filter->GetDirectionImageContainer();
for (int i=0; i<container->Size(); i++)
{
MaximaExtractionFilterType::ItkDirectionImage::Pointer itkImg = container->GetElement(i);
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk( itkImg.GetPointer() );
img->SetVolume( itkImg->GetBufferPointer() );
DataNode::Pointer node = DataNode::New();
node->SetData(img);
QString name(m_ImageNodes.at(0)->GetName().c_str());
name += "_Direction";
name += QString::number(i+1);
node->SetName(name.toStdString().c_str());
GetDataStorage()->Add(node);
}
}
if (m_Controls->m_OutputNumDirectionsBox->isChecked())
{
mitk::Image::Pointer image2 = mitk::Image::New();
image2->InitializeByItk( numDirImage.GetPointer() );
image2->SetVolume( numDirImage->GetBufferPointer() );
DataNode::Pointer node = DataNode::New();
node->SetData(image2);
QString name(m_ImageNodes.at(0)->GetName().c_str());
name += "_NumDirections";
node->SetName(name.toStdString().c_str());
GetDataStorage()->Add(node);
}
if (m_Controls->m_OutputVectorFieldBox->isChecked())
{
mitk::Vector3D outImageSpacing = geometry->GetSpacing();
float minSpacing = 1;
if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
minSpacing = outImageSpacing[0];
else if (outImageSpacing[1] < outImageSpacing[2])
minSpacing = outImageSpacing[1];
else
minSpacing = outImageSpacing[2];
mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
directions->SetGeometry(geometry);
DataNode::Pointer node = DataNode::New();
node->SetData(directions);
QString name(m_ImageNodes.at(0)->GetName().c_str());
name += "_VectorField";
node->SetName(name.toStdString().c_str());
node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
GetDataStorage()->Add(node);
}
}
void QmitkDwiSoftwarePhantomView::GeneratePhantom()
{
typedef itk::DwiPhantomGenerationFilter< short > FilterType;
FilterType::GradientListType gradientList;
m_SignalRegions.clear();
for (int i=0; i<m_SignalRegionNodes.size(); i++)
{
mitk::Image::Pointer mitkBinaryImg = dynamic_cast<mitk::Image*>(m_SignalRegionNodes.at(i)->GetData());
ItkUcharImgType::Pointer signalRegion = ItkUcharImgType::New();
mitk::CastToItkImage<ItkUcharImgType>(mitkBinaryImg, signalRegion);
m_SignalRegions.push_back(signalRegion);
}
switch(m_Controls->m_TensorsToDWINumDirsSelect->currentIndex())
{
case 0:
gradientList = MakeGradientList<12>();
break;
case 1:
gradientList = MakeGradientList<42>();
break;
case 2:
gradientList = MakeGradientList<92>();
break;
case 3:
gradientList = MakeGradientList<162>();
break;
case 4:
gradientList = MakeGradientList<252>();
break;
case 5:
gradientList = MakeGradientList<362>();
break;
case 6:
gradientList = MakeGradientList<492>();
break;
case 7:
gradientList = MakeGradientList<642>();
break;
case 8:
gradientList = MakeGradientList<812>();
break;
case 9:
gradientList = MakeGradientList<1002>();
break;
default:
gradientList = MakeGradientList<92>();
}
double bVal = m_Controls->m_TensorsToDWIBValueEdit->value();
itk::ImageRegion<3> imageRegion;
imageRegion.SetSize(0, m_Controls->m_SizeX->value());
imageRegion.SetSize(1, m_Controls->m_SizeY->value());
imageRegion.SetSize(2, m_Controls->m_SizeZ->value());
mitk::Vector3D spacing;
spacing[0] = m_Controls->m_SpacingX->value();
spacing[1] = m_Controls->m_SpacingY->value();
spacing[2] = m_Controls->m_SpacingZ->value();
FilterType::Pointer filter = FilterType::New();
filter->SetGradientList(gradientList);
filter->SetBValue(bVal);
filter->SetSNR(m_Controls->m_NoiseLevel->value());
filter->SetSignalScale(m_Controls->m_SignalScale->value());
filter->SetImageRegion(imageRegion);
filter->SetSpacing(spacing);
filter->SetSignalRegions(m_SignalRegions);
filter->SetGreyMatterAdc(m_Controls->m_GmAdc->value());
std::vector< float > tensorFA;
std::vector< float > tensorADC;
std::vector< float > tensorWeight;
std::vector< vnl_vector_fixed<double, 3> > tensorDirection;
for (int i=0; i<m_SpinFa.size(); i++)
{
tensorFA.push_back(m_SpinFa.at(i)->value());
tensorADC.push_back(m_SpinAdc.at(i)->value());
vnl_vector_fixed<double, 3> dir;
dir[0] = m_SpinX.at(i)->value();
dir[1] = m_SpinY.at(i)->value();
dir[2] = m_SpinZ.at(i)->value();
dir.normalize();
tensorDirection.push_back(dir);
tensorWeight.push_back(m_SpinWeight.at(i)->value());
}
filter->SetTensorFA(tensorFA);
filter->SetTensorADC(tensorADC);
filter->SetTensorWeight(tensorWeight);
filter->SetTensorDirection(tensorDirection);
filter->Update();
mitk::DiffusionImage<short>::Pointer image = mitk::DiffusionImage<short>::New();
image->SetVectorImage( filter->GetOutput() );
image->SetB_Value(bVal);
image->SetDirections(gradientList);
image->InitializeFromVectorImage();
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData( image );
node->SetName(m_Controls->m_ImageName->text().toStdString());
GetDataStorage()->Add(node);
if (m_Controls->m_OutputNumDirectionsBox->isChecked())
{
ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
mitk::Image::Pointer image2 = mitk::Image::New();
image2->InitializeByItk( numDirImage.GetPointer() );
image2->SetVolume( numDirImage->GetBufferPointer() );
mitk::DataNode::Pointer node2 = mitk::DataNode::New();
node2->SetData(image2);
QString name(m_Controls->m_ImageName->text());
name += "_NumDirections";
node2->SetName(name.toStdString().c_str());
GetDataStorage()->Add(node2);
}
if (m_SignalRegionNodes.size()==0)
return;
if (m_Controls->m_OutputDirectionImagesBox->isChecked())
{
typedef FilterType::ItkDirectionImageContainer ItkDirectionImageContainer;
ItkDirectionImageContainer::Pointer container = filter->GetDirectionImageContainer();
for (int i=0; i<container->Size(); i++)
{
FilterType::ItkDirectionImage::Pointer itkImg = container->GetElement(i);
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk( itkImg.GetPointer() );
img->SetVolume( itkImg->GetBufferPointer() );
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(img);
QString name(m_Controls->m_ImageName->text());
name += "_Direction";
name += QString::number(i+1);
node->SetName(name.toStdString().c_str());
GetDataStorage()->Add(node);
}
}
if (m_Controls->m_OutputVectorFieldBox->isChecked())
{
mitk::Geometry3D::Pointer geometry = image->GetGeometry();
mitk::Vector3D outImageSpacing = geometry->GetSpacing();
float minSpacing = 1;
if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
minSpacing = outImageSpacing[0];
else if (outImageSpacing[1] < outImageSpacing[2])
minSpacing = outImageSpacing[1];
else
minSpacing = outImageSpacing[2];
mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
directions->SetGeometry(geometry);
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(directions);
QString name(m_Controls->m_ImageName->text());
name += "_VectorField";
node->SetName(name.toStdString().c_str());
node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
GetDataStorage()->Add(node);
}
}
void QmitkOdfMaximaExtractionView::StartTensor()
{
if (m_TensorImageNodes.empty())
return;
typedef itk::DiffusionTensorPrincipalDirectionImageFilter< float, float > MaximaExtractionFilterType;
MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
mitk::Geometry3D::Pointer geometry;
try{
TensorImage::Pointer img = dynamic_cast<TensorImage*>(m_TensorImageNodes.at(0)->GetData());
ItkTensorImage::Pointer itkImage = ItkTensorImage::New();
CastToItkImage<ItkTensorImage>(img, itkImage);
filter->SetInput(itkImage);
geometry = img->GetGeometry();
}
catch(itk::ExceptionObject &e)
{
MITK_INFO << "wrong image type: " << e.what();
throw e;
}
if (!m_BinaryImageNodes.empty())
{
ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
Image::Pointer mitkMaskImg = dynamic_cast<Image*>(m_BinaryImageNodes.at(0)->GetData());
CastToItkImage<ItkUcharImgType>(mitkMaskImg, itkMaskImage);
filter->SetMaskImage(itkMaskImage);
}
if (m_Controls->m_NormalizationBox->currentIndex()==0)
filter->SetNormalizeVectors(false);
filter->Update();
if (m_Controls->m_OutputDirectionImagesBox->isChecked())
{
MaximaExtractionFilterType::OutputImageType::Pointer itkImg = filter->GetOutput();
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk( itkImg.GetPointer() );
img->SetVolume( itkImg->GetBufferPointer() );
DataNode::Pointer node = DataNode::New();
node->SetData(img);
QString name(m_TensorImageNodes.at(0)->GetName().c_str());
name += "_PrincipalDirection";
node->SetName(name.toStdString().c_str());
GetDataStorage()->Add(node);
}
if (m_Controls->m_OutputNumDirectionsBox->isChecked())
{
ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
mitk::Image::Pointer image2 = mitk::Image::New();
image2->InitializeByItk( numDirImage.GetPointer() );
image2->SetVolume( numDirImage->GetBufferPointer() );
DataNode::Pointer node2 = DataNode::New();
node2->SetData(image2);
QString name(m_TensorImageNodes.at(0)->GetName().c_str());
name += "_NumDirections";
node2->SetName(name.toStdString().c_str());
GetDataStorage()->Add(node2);
}
if (m_Controls->m_OutputVectorFieldBox->isChecked())
{
mitk::Vector3D outImageSpacing = geometry->GetSpacing();
float minSpacing = 1;
if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
minSpacing = outImageSpacing[0];
else if (outImageSpacing[1] < outImageSpacing[2])
minSpacing = outImageSpacing[1];
else
minSpacing = outImageSpacing[2];
mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
directions->SetGeometry(geometry);
DataNode::Pointer node = DataNode::New();
node->SetData(directions);
QString name(m_TensorImageNodes.at(0)->GetName().c_str());
name += "_VectorField";
node->SetName(name.toStdString().c_str());
node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
GetDataStorage()->Add(node);
}
}