int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setTitle("Multishell Methods");
parser.setCategory("Fiber Tracking and Processing Methods");
parser.setDescription("");
parser.setContributor("MBI");
parser.setArgumentPrefix("--", "-");
parser.addArgument("in", "i", mitkCommandLineParser::InputFile, "Input:", "input file", us::Any(), false);
parser.addArgument("out", "o", mitkCommandLineParser::OutputFile, "Output:", "output file", us::Any(), false);
parser.addArgument("adc", "D", mitkCommandLineParser::Bool, "ADC:", "ADC Average", us::Any(), false);
parser.addArgument("akc", "K", mitkCommandLineParser::Bool, "Kurtosis fit:", "Kurtosis Fit", us::Any(), false);
parser.addArgument("biexp", "B", mitkCommandLineParser::Bool, "BiExp fit:", "BiExp fit", us::Any(), false);
parser.addArgument("targetbvalue", "b", mitkCommandLineParser::String, "b Value:", "target bValue (mean, min, max)", us::Any(), false);
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
// mandatory arguments
string inName = us::any_cast<string>(parsedArgs["in"]);
string outName = us::any_cast<string>(parsedArgs["out"]);
bool applyADC = us::any_cast<bool>(parsedArgs["adc"]);
bool applyAKC = us::any_cast<bool>(parsedArgs["akc"]);
bool applyBiExp = us::any_cast<bool>(parsedArgs["biexp"]);
string targetType = us::any_cast<string>(parsedArgs["targetbvalue"]);
try
{
std::cout << "Loading " << inName;
mitk::Image::Pointer dwi = mitk::IOUtil::LoadImage(inName);
if ( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dwi ) )
{
typedef itk::RadialMultishellToSingleshellImageFilter<short, short> FilterType;
typedef itk::DwiGradientLengthCorrectionFilter CorrectionFilterType;
CorrectionFilterType::Pointer roundfilter = CorrectionFilterType::New();
roundfilter->SetRoundingValue( 1000 );
roundfilter->SetReferenceBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue( dwi ));
roundfilter->SetReferenceGradientDirectionContainer(mitk::DiffusionPropertyHelper::GetGradientContainer(dwi));
roundfilter->Update();
dwi->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( roundfilter->GetNewBValue() ) );
dwi->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( roundfilter->GetOutputGradientDirectionContainer() ) );
// filter input parameter
const mitk::DiffusionPropertyHelper::BValueMapType
&originalShellMap = mitk::DiffusionPropertyHelper::GetBValueMap(dwi);
mitk::DiffusionPropertyHelper::ImageType::Pointer vectorImage = mitk::DiffusionPropertyHelper::ImageType::New();
mitk::CastToItkImage(dwi, vectorImage);
const mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer
gradientContainer = mitk::DiffusionPropertyHelper::GetGradientContainer(dwi);
const unsigned int
&bValue = mitk::DiffusionPropertyHelper::GetReferenceBValue( dwi );
// filter call
vnl_vector<double> bValueList(originalShellMap.size()-1);
double targetBValue = bValueList.mean();
mitk::DiffusionPropertyHelper::BValueMapType::const_iterator it = originalShellMap.begin();
++it; int i = 0 ;
for(; it != originalShellMap.end(); ++it)
bValueList.put(i++,it->first);
if( targetType == "mean" )
targetBValue = bValueList.mean();
else if( targetType == "min" )
targetBValue = bValueList.min_value();
else if( targetType == "max" )
targetBValue = bValueList.max_value();
if(applyADC)
{
FilterType::Pointer filter = FilterType::New();
filter->SetInput(vectorImage);
filter->SetOriginalGradientDirections(gradientContainer);
filter->SetOriginalBValueMap(originalShellMap);
filter->SetOriginalBValue(bValue);
itk::ADCAverageFunctor::Pointer functor = itk::ADCAverageFunctor::New();
functor->setListOfBValues(bValueList);
functor->setTargetBValue(targetBValue);
filter->SetFunctor(functor);
filter->Update();
// create new DWI image
mitk::Image::Pointer outImage = mitk::GrabItkImageMemory( filter->GetOutput() );
outImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( targetBValue ) );
outImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetTargetGradientDirections() ) );
mitk::DiffusionPropertyHelper propertyHelper( outImage );
propertyHelper.InitializeImage();
mitk::IOUtil::Save(outImage, (outName + "_ADC.dwi").c_str());
}
if(applyAKC)
{
FilterType::Pointer filter = FilterType::New();
filter->SetInput(vectorImage);
filter->SetOriginalGradientDirections(gradientContainer);
filter->SetOriginalBValueMap(originalShellMap);
filter->SetOriginalBValue(bValue);
itk::KurtosisFitFunctor::Pointer functor = itk::KurtosisFitFunctor::New();
functor->setListOfBValues(bValueList);
functor->setTargetBValue(targetBValue);
filter->SetFunctor(functor);
filter->Update();
// create new DWI image
mitk::Image::Pointer outImage = mitk::GrabItkImageMemory( filter->GetOutput() );
outImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( targetBValue ) );
outImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetTargetGradientDirections() ) );
mitk::DiffusionPropertyHelper propertyHelper( outImage );
propertyHelper.InitializeImage();
mitk::IOUtil::Save(outImage, (string(outName) + "_AKC.dwi").c_str());
}
if(applyBiExp)
{
FilterType::Pointer filter = FilterType::New();
filter->SetInput(vectorImage);
filter->SetOriginalGradientDirections(gradientContainer);
filter->SetOriginalBValueMap(originalShellMap);
filter->SetOriginalBValue(bValue);
itk::BiExpFitFunctor::Pointer functor = itk::BiExpFitFunctor::New();
functor->setListOfBValues(bValueList);
functor->setTargetBValue(targetBValue);
filter->SetFunctor(functor);
filter->Update();
// create new DWI image
mitk::Image::Pointer outImage = mitk::GrabItkImageMemory( filter->GetOutput() );
outImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( targetBValue ) );
outImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetTargetGradientDirections() ) );
mitk::DiffusionPropertyHelper propertyHelper( outImage );
propertyHelper.InitializeImage();
mitk::IOUtil::Save(outImage, (string(outName) + "_BiExp.dwi").c_str());
}
}
}
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;
}
int MultishellMethods(int argc, char* argv[])
{
ctkCommandLineParser parser;
parser.setArgumentPrefix("--", "-");
parser.addArgument("in", "i", ctkCommandLineParser::String, "input file", us::Any(), false);
parser.addArgument("out", "o", ctkCommandLineParser::String, "output file", us::Any(), false);
parser.addArgument("adc", "D", ctkCommandLineParser::Bool, "ADC Average", us::Any(), false);
parser.addArgument("akc", "K", ctkCommandLineParser::Bool, "Kurtosis Fit", us::Any(), false);
parser.addArgument("biexp", "B", ctkCommandLineParser::Bool, "BiExp fit", us::Any(), false);
parser.addArgument("targetbvalue", "b", ctkCommandLineParser::String, "target bValue (mean, min, max)", us::Any(), false);
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
// mandatory arguments
string inName = us::any_cast<string>(parsedArgs["in"]);
string outName = us::any_cast<string>(parsedArgs["out"]);
bool applyADC = us::any_cast<bool>(parsedArgs["adc"]);
bool applyAKC = us::any_cast<bool>(parsedArgs["akc"]);
bool applyBiExp = us::any_cast<bool>(parsedArgs["biexp"]);
string targetType = us::any_cast<string>(parsedArgs["targetbvalue"]);
try
{
MITK_INFO << "Loading " << inName;
const std::string s1="", s2="";
std::vector<mitk::BaseData::Pointer> infile = mitk::BaseDataIO::LoadBaseDataFromFile( inName, s1, s2, false );
mitk::BaseData::Pointer baseData = infile.at(0);
if ( dynamic_cast<mitk::DiffusionImage<short>*>(baseData.GetPointer()) )
{
MITK_INFO << "Writing " << outName;
mitk::DiffusionImage<short>::Pointer dwi = dynamic_cast<mitk::DiffusionImage<short>*>(baseData.GetPointer());
typedef itk::RadialMultishellToSingleshellImageFilter<short, short> FilterType;
typedef itk::DwiGradientLengthCorrectionFilter CorrectionFilterType;
CorrectionFilterType::Pointer roundfilter = CorrectionFilterType::New();
roundfilter->SetRoundingValue( 1000 );
roundfilter->SetReferenceBValue(dwi->GetReferenceBValue());
roundfilter->SetReferenceGradientDirectionContainer(dwi->GetDirections());
roundfilter->Update();
dwi->SetReferenceBValue( roundfilter->GetNewBValue() );
dwi->SetDirections( roundfilter->GetOutputGradientDirectionContainer());
// filter input parameter
const mitk::DiffusionImage<short>::BValueMap
&originalShellMap = dwi->GetBValueMap();
const mitk::DiffusionImage<short>::ImageType
*vectorImage = dwi->GetVectorImage();
const mitk::DiffusionImage<short>::GradientDirectionContainerType::Pointer
gradientContainer = dwi->GetDirections();
const unsigned int
&bValue = dwi->GetReferenceBValue();
// filter call
vnl_vector<double> bValueList(originalShellMap.size()-1);
double targetBValue = bValueList.mean();
mitk::DiffusionImage<short>::BValueMap::const_iterator it = originalShellMap.begin();
++it; int i = 0 ;
for(; it != originalShellMap.end(); ++it)
bValueList.put(i++,it->first);
if( targetType == "mean" )
targetBValue = bValueList.mean();
else if( targetType == "min" )
targetBValue = bValueList.min_value();
else if( targetType == "max" )
targetBValue = bValueList.max_value();
if(applyADC)
{
FilterType::Pointer filter = FilterType::New();
filter->SetInput(vectorImage);
filter->SetOriginalGradientDirections(gradientContainer);
filter->SetOriginalBValueMap(originalShellMap);
filter->SetOriginalBValue(bValue);
itk::ADCAverageFunctor::Pointer functor = itk::ADCAverageFunctor::New();
functor->setListOfBValues(bValueList);
functor->setTargetBValue(targetBValue);
filter->SetFunctor(functor);
filter->Update();
// create new DWI image
mitk::DiffusionImage<short>::Pointer outImage = mitk::DiffusionImage<short>::New();
outImage->SetVectorImage( filter->GetOutput() );
outImage->SetReferenceBValue( targetBValue );
outImage->SetDirections( filter->GetTargetGradientDirections() );
outImage->InitializeFromVectorImage();
mitk::NrrdDiffusionImageWriter<short>::Pointer writer = mitk::NrrdDiffusionImageWriter<short>::New();
writer->SetFileName((string(outName) + "_ADC.dwi"));
writer->SetInput(outImage);
writer->Update();
}
if(applyAKC)
{
FilterType::Pointer filter = FilterType::New();
filter->SetInput(vectorImage);
filter->SetOriginalGradientDirections(gradientContainer);
filter->SetOriginalBValueMap(originalShellMap);
filter->SetOriginalBValue(bValue);
itk::KurtosisFitFunctor::Pointer functor = itk::KurtosisFitFunctor::New();
functor->setListOfBValues(bValueList);
functor->setTargetBValue(targetBValue);
filter->SetFunctor(functor);
filter->Update();
// create new DWI image
mitk::DiffusionImage<short>::Pointer outImage = mitk::DiffusionImage<short>::New();
outImage->SetVectorImage( filter->GetOutput() );
outImage->SetReferenceBValue( targetBValue );
outImage->SetDirections( filter->GetTargetGradientDirections() );
outImage->InitializeFromVectorImage();
mitk::NrrdDiffusionImageWriter<short>::Pointer writer = mitk::NrrdDiffusionImageWriter<short>::New();
writer->SetFileName((string(outName) + "_AKC.dwi"));
writer->SetInput(outImage);
writer->Update();
}
if(applyBiExp)
{
FilterType::Pointer filter = FilterType::New();
filter->SetInput(vectorImage);
filter->SetOriginalGradientDirections(gradientContainer);
filter->SetOriginalBValueMap(originalShellMap);
filter->SetOriginalBValue(bValue);
itk::BiExpFitFunctor::Pointer functor = itk::BiExpFitFunctor::New();
functor->setListOfBValues(bValueList);
functor->setTargetBValue(targetBValue);
filter->SetFunctor(functor);
filter->Update();
// create new DWI image
mitk::DiffusionImage<short>::Pointer outImage = mitk::DiffusionImage<short>::New();
outImage->SetVectorImage( filter->GetOutput() );
outImage->SetReferenceBValue( targetBValue );
outImage->SetDirections( filter->GetTargetGradientDirections() );
outImage->InitializeFromVectorImage();
mitk::NrrdDiffusionImageWriter<short>::Pointer writer = mitk::NrrdDiffusionImageWriter<short>::New();
writer->SetFileName((string(outName) + "_BiExp.dwi"));
writer->SetInput(outImage);
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;
}
MITK_INFO << "DONE";
return EXIT_SUCCESS;
}
void QmitkSimpleRegistrationView::OnRegResultIsAvailable(mitk::MAPRegistrationWrapper::Pointer spResultRegistration, const QmitkRegistrationJob* job)
{
mitk::Image::Pointer movingImage = dynamic_cast<mitk::Image*>(m_MovingImageNode->GetData());
mitk::Image::Pointer image;
if (m_RegistrationType==0 && !m_Controls->m_ResampleBox->isChecked())
{
image = mitk::ImageMappingHelper::refineGeometry(movingImage, spResultRegistration, true);
mitk::DiffusionPropertyHelper::CopyProperties(movingImage, image, true);
auto reg = spResultRegistration->GetRegistration();
typedef mitk::DiffusionImageCorrectionFilter CorrectionFilterType;
CorrectionFilterType::Pointer corrector = CorrectionFilterType::New();
corrector->SetImage( image );
corrector->CorrectDirections( mitk::MITKRegistrationHelper::getAffineMatrix(reg, false)->GetMatrix().GetVnlMatrix() );
}
else
{
if (!mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(movingImage))
{
image = mitk::ImageMappingHelper::map(movingImage, spResultRegistration, false, 0, job->m_spTargetData->GetGeometry(), false, 0, mitk::ImageMappingInterpolator::BSpline_3);
}
else
{
typedef itk::ComposeImageFilter < ITKDiffusionVolumeType > ComposeFilterType;
ComposeFilterType::Pointer composer = ComposeFilterType::New();
ItkDwiType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::GetItkVectorImage(movingImage);
for (unsigned int i=0; i<itkVectorImagePointer->GetVectorLength(); ++i)
{
itk::ExtractDwiChannelFilter< short >::Pointer filter = itk::ExtractDwiChannelFilter< short >::New();
filter->SetInput( itkVectorImagePointer);
filter->SetChannelIndex(i);
filter->Update();
mitk::Image::Pointer gradientVolume = mitk::Image::New();
gradientVolume->InitializeByItk( filter->GetOutput() );
gradientVolume->SetImportChannel( filter->GetOutput()->GetBufferPointer() );
mitk::Image::Pointer registered_mitk_image = mitk::ImageMappingHelper::map(gradientVolume, spResultRegistration, false, 0, job->m_spTargetData->GetGeometry(), false, 0, mitk::ImageMappingInterpolator::BSpline_3);
ITKDiffusionVolumeType::Pointer registered_itk_image = ITKDiffusionVolumeType::New();
mitk::CastToItkImage(registered_mitk_image, registered_itk_image);
composer->SetInput(i, registered_itk_image);
}
composer->Update();
image = mitk::GrabItkImageMemory( composer->GetOutput() );
mitk::DiffusionPropertyHelper::CopyProperties(movingImage, image, true);
auto reg = spResultRegistration->GetRegistration();
typedef mitk::DiffusionImageCorrectionFilter CorrectionFilterType;
CorrectionFilterType::Pointer corrector = CorrectionFilterType::New();
corrector->SetImage( image );
corrector->CorrectDirections( mitk::MITKRegistrationHelper::getAffineMatrix(reg, false)->GetMatrix().GetVnlMatrix() );
}
}
if (mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image))
mitk::DiffusionPropertyHelper::InitializeImage( image );
mitk::DataNode::Pointer resultNode = mitk::DataNode::New();
resultNode->SetData(image);
if (m_MovingImageNode.IsNotNull())
{
m_MovingImageNode->SetVisibility(false);
QString name = m_MovingImageNode->GetName().c_str();
if (m_RegistrationType==0)
resultNode->SetName((name+"_registered (rigid)").toStdString().c_str());
else
resultNode->SetName((name+"_registered (affine)").toStdString().c_str());
}
else
{
if (m_RegistrationType==0)
resultNode->SetName("Registered (rigid)");
else
resultNode->SetName("Registered (affine)");
}
// resultNode->SetOpacity(0.6);
// resultNode->SetColor(0.0, 0.0, 1.0);
GetDataStorage()->Add(resultNode);
mitk::RenderingManager::GetInstance()->InitializeViews( resultNode->GetData()->GetTimeGeometry(),
mitk::RenderingManager::REQUEST_UPDATE_ALL,
true);
if (m_Controls->m_RegOutputBox->isChecked())
{
mitk::DataNode::Pointer registration_node = mitk::DataNode::New();
registration_node->SetData(spResultRegistration);
if (m_RegistrationType==0)
registration_node->SetName("Registration Object (rigid)");
else
registration_node->SetName("Registration Object (affine)");
GetDataStorage()->Add(registration_node, resultNode);
}
this->GetRenderWindowPart()->RequestUpdate();
m_Controls->m_RegistrationStartButton->setEnabled(true);
m_Controls->m_RegistrationStartButton->setText("Start Registration");
m_MovingImageNode = nullptr;
TractoChanged();
}
