void setUp() override
{
std::vector<mitk::FiberBundle::Pointer> tracts;
tracts.push_back(LoadFib("Cluster_0.fib"));
tracts.push_back(LoadFib("Cluster_1.fib"));
tracts.push_back(LoadFib("Cluster_2.fib"));
tracts.push_back(LoadFib("Cluster_3.fib"));
tracts.push_back(LoadFib("Cluster_4.fib"));
mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Peak Image"}, {});
mitk::PeakImage::Pointer peaks = mitk::IOUtil::Load<mitk::PeakImage>(GetTestDataFilePath("DiffusionImaging/FiberFit/csd_peak_image.nii.gz"), &functor);
typedef mitk::ImageToItk< mitk::PeakImage::ItkPeakImageType > CasterType;
CasterType::Pointer caster = CasterType::New();
caster->SetInput(peaks);
caster->Update();
mitk::PeakImage::ItkPeakImageType::Pointer peak_image = caster->GetOutput();
fitter = FitterType::New();
fitter->SetPeakImage(peak_image);
fitter->SetTractograms(tracts);
}
void Fit6()
{
omp_set_num_threads(1);
fitter->SetLambda(10);
fitter->SetFilterOutliers(false);
fitter->SetRegularization(VnlCostFunction::GROUP_LASSO);
fitter->Update();
std::vector< mitk::FiberBundle::Pointer > output_tracts = fitter->GetTractograms();
mitk::FiberBundle::Pointer test = mitk::FiberBundle::New();
test = test->AddBundles(output_tracts);
mitk::FiberBundle::Pointer ref = LoadFib("out/GroupLasso_fitted.fib");
CompareFibs(test, ref, "GroupLasso_fitted.fib");
CompareImages(fitter->GetFittedImage(), "GroupLasso_fitted_image.nrrd");
CompareImages(fitter->GetResidualImage(), "GroupLasso_residual_image.nrrd");
}
void Fit4()
{
omp_set_num_threads(1);
fitter->SetLambda(0.1);
fitter->SetFilterOutliers(false);
fitter->SetRegularization(VnlCostFunction::VOXEL_VARIANCE);
fitter->Update();
std::vector< mitk::FiberBundle::Pointer > output_tracts = fitter->GetTractograms();
mitk::FiberBundle::Pointer test = mitk::FiberBundle::New();
test = test->AddBundles(output_tracts);
mitk::FiberBundle::Pointer ref = LoadFib("out/LocalMSE_fitted.fib");
CompareFibs(test, ref, "LocalMSE_fitted.fib");
CompareImages(fitter->GetFittedImage(), "LocalMSE_fitted_image.nrrd");
CompareImages(fitter->GetResidualImage(), "LocalMSE_residual_image.nrrd");
}
/*!
\brief Import Sift2 Fiber Weights txt file.
*/
int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setTitle("Sift2 Fiber Weight Import");
parser.setCategory("Fiber Tracking and Processing Methods");
parser.setDescription("Import sift2 fiber weights.");
parser.setContributor("MIC");
parser.setArgumentPrefix("--", "-");
parser.addArgument("input", "i", mitkCommandLineParser::String, "Input:", "input fiber bundle", us::Any(), false);
parser.addArgument("weights", "w", mitkCommandLineParser::String, "Weights:", "input weights file (.txt)", us::Any(), false);
parser.addArgument("output", "o", mitkCommandLineParser::String, "Output:", "output fiber bundle (.fib)", us::Any(), false);
std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
std::string inFileName = us::any_cast<std::string>(parsedArgs["input"]);
std::string weightsFileName = us::any_cast<std::string>(parsedArgs["weights"]);
std::string outFileName = us::any_cast<std::string>(parsedArgs["output"]);
try
{
mitk::FiberBundle::Pointer fib = LoadFib(inFileName);
std::ifstream fin;
fin.open(weightsFileName);
if (!fin.good())
return 1; // exit if file not found
std::vector<float> weights;
for (float d; fin >> d; ) { weights.push_back(d); }
for(std::size_t i = 0; i != weights.size(); i++) {
fib->SetFiberWeight(i, weights[i]);
}
mitk::IOUtil::Save(fib.GetPointer(), outFileName );
}
int FiberProcessing(int argc, char* argv[])
{
std::cout << "FiberProcessing";
mitkCommandLineParser parser;
parser.setTitle("Fiber Processing");
parser.setCategory("Fiber Tracking and Processing Methods");
parser.setDescription("");
parser.setContributor("MBI");
parser.setArgumentPrefix("--", "-");
parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input fiber bundle (.fib)", us::Any(), false);
parser.addArgument("outFile", "o", mitkCommandLineParser::OutputFile, "Output:", "output fiber bundle (.fib)", us::Any(), false);
parser.addArgument("smooth", "s", mitkCommandLineParser::Float, "Spline resampling:", "Resample fiber using splines with the given point distance (in mm)");
parser.addArgument("compress", "c", mitkCommandLineParser::Float, "Compress:", "Compress fiber using the given error threshold (in mm)");
parser.addArgument("minLength", "l", mitkCommandLineParser::Float, "Minimum length:", "Minimum fiber length (in mm)");
parser.addArgument("maxLength", "m", mitkCommandLineParser::Float, "Maximum length:", "Maximum fiber length (in mm)");
parser.addArgument("minCurv", "a", mitkCommandLineParser::Float, "Minimum curvature radius:", "Minimum curvature radius (in mm)");
parser.addArgument("mirror", "p", mitkCommandLineParser::Int, "Invert coordinates:", "Invert fiber coordinates XYZ (e.g. 010 to invert y-coordinate of each fiber point)");
parser.addArgument("rotate-x", "rx", mitkCommandLineParser::Float, "Rotate x-axis:", "Rotate around x-axis (if copy is given the copy is rotated, in deg)");
parser.addArgument("rotate-y", "ry", mitkCommandLineParser::Float, "Rotate y-axis:", "Rotate around y-axis (if copy is given the copy is rotated, in deg)");
parser.addArgument("rotate-z", "rz", mitkCommandLineParser::Float, "Rotate z-axis:", "Rotate around z-axis (if copy is given the copy is rotated, in deg)");
parser.addArgument("scale-x", "sx", mitkCommandLineParser::Float, "Scale x-axis:", "Scale in direction of x-axis (if copy is given the copy is scaled)");
parser.addArgument("scale-y", "sy", mitkCommandLineParser::Float, "Scale y-axis:", "Scale in direction of y-axis (if copy is given the copy is scaled)");
parser.addArgument("scale-z", "sz", mitkCommandLineParser::Float, "Scale z-axis", "Scale in direction of z-axis (if copy is given the copy is scaled)");
parser.addArgument("translate-x", "tx", mitkCommandLineParser::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", mitkCommandLineParser::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", mitkCommandLineParser::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 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 (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){
std::cout << "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::IOUtil::SaveBaseData(fib.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;
}
/*!
\brief Modify input tractogram: fiber resampling, compression, pruning and transformation.
*/
int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setTitle("Tract Density");
parser.setCategory("Fiber Tracking and Processing Methods");
parser.setDescription("Generate tract density image, fiber envelope or fiber endpoints image.");
parser.setContributor("MIC");
parser.setArgumentPrefix("--", "-");
parser.addArgument("input", "i", mitkCommandLineParser::String, "Input:", "input fiber bundle (.fib)", us::Any(), false);
parser.addArgument("output", "o", mitkCommandLineParser::String, "Output:", "output image", us::Any(), false);
parser.addArgument("binary", "", mitkCommandLineParser::Bool, "Binary output:", "calculate binary tract envelope", us::Any());
parser.addArgument("endpoints", "", mitkCommandLineParser::Bool, "Output endpoints image:", "calculate image of fiber endpoints instead of mask", us::Any());
parser.addArgument("reference_image", "", mitkCommandLineParser::String, "Reference image:", "output image will have geometry of this reference image", us::Any());
std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
bool binary = false;
if (parsedArgs.count("binary"))
binary = us::any_cast<bool>(parsedArgs["binary"]);
bool endpoints = false;
if (parsedArgs.count("endpoints"))
endpoints = us::any_cast<bool>(parsedArgs["endpoints"]);
std::string reference_image = "";
if (parsedArgs.count("reference_image"))
reference_image = us::any_cast<std::string>(parsedArgs["reference_image"]);
std::string inFileName = us::any_cast<std::string>(parsedArgs["input"]);
std::string outFileName = us::any_cast<std::string>(parsedArgs["output"]);
try
{
mitk::FiberBundle::Pointer fib = LoadFib(inFileName);
mitk::Image::Pointer ref_img;
MITK_INFO << reference_image;
if (!reference_image.empty())
ref_img = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(reference_image)[0].GetPointer());
if (endpoints)
{
typedef unsigned int OutPixType;
typedef itk::Image<OutPixType, 3> OutImageType;
typedef itk::TractsToFiberEndingsImageFilter< OutImageType > ImageGeneratorType;
ImageGeneratorType::Pointer generator = ImageGeneratorType::New();
generator->SetFiberBundle(fib);
if (ref_img.IsNotNull())
{
OutImageType::Pointer itkImage = OutImageType::New();
CastToItkImage(ref_img, itkImage);
generator->SetInputImage(itkImage);
generator->SetUseImageGeometry(true);
}
generator->Update();
// get output image
typedef itk::Image<OutPixType,3> OutType;
OutType::Pointer outImg = generator->GetOutput();
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk(outImg.GetPointer());
img->SetVolume(outImg->GetBufferPointer());
mitk::IOUtil::Save(img, outFileName );
}
else if (binary)
{
typedef unsigned char OutPixType;
typedef itk::Image<OutPixType, 3> OutImageType;
itk::TractDensityImageFilter< OutImageType >::Pointer generator = itk::TractDensityImageFilter< OutImageType >::New();
generator->SetFiberBundle(fib);
generator->SetBinaryOutput(binary);
generator->SetOutputAbsoluteValues(false);
generator->SetWorkOnFiberCopy(false);
if (ref_img.IsNotNull())
{
OutImageType::Pointer itkImage = OutImageType::New();
CastToItkImage(ref_img, itkImage);
generator->SetInputImage(itkImage);
generator->SetUseImageGeometry(true);
}
generator->Update();
// get output image
typedef itk::Image<OutPixType,3> OutType;
OutType::Pointer outImg = generator->GetOutput();
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk(outImg.GetPointer());
img->SetVolume(outImg->GetBufferPointer());
mitk::IOUtil::Save(img, outFileName );
}
else
{
typedef float OutPixType;
typedef itk::Image<OutPixType, 3> OutImageType;
itk::TractDensityImageFilter< OutImageType >::Pointer generator = itk::TractDensityImageFilter< OutImageType >::New();
generator->SetFiberBundle(fib);
generator->SetBinaryOutput(binary);
generator->SetOutputAbsoluteValues(false);
generator->SetWorkOnFiberCopy(false);
if (ref_img.IsNotNull())
{
OutImageType::Pointer itkImage = OutImageType::New();
CastToItkImage(ref_img, itkImage);
generator->SetInputImage(itkImage);
generator->SetUseImageGeometry(true);
}
generator->Update();
// get output image
typedef itk::Image<OutPixType,3> OutType;
OutType::Pointer outImg = generator->GetOutput();
mitk::Image::Pointer img = mitk::Image::New();
img->InitializeByItk(outImg.GetPointer());
img->SetVolume(outImg->GetBufferPointer());
mitk::IOUtil::Save(img, 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;
}
/*!
\brief Modify input tractogram: fiber resampling, compression, pruning and transformation.
*/
int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setTitle("Fiber Processing");
parser.setCategory("Fiber Tracking and Processing Methods");
parser.setDescription("Modify input tractogram: fiber resampling, compression, pruning and transformation.");
parser.setContributor("MIC");
parser.setArgumentPrefix("--", "-");
parser.beginGroup("1. Mandatory arguments:");
parser.addArgument("", "i", mitkCommandLineParser::String, "Input:", "Input fiber bundle (.fib, .trk, .tck)", us::Any(), false, false, false, mitkCommandLineParser::Input);
parser.addArgument("", "o", mitkCommandLineParser::String, "Output:", "Output fiber bundle (.fib, .trk)", us::Any(), false, false, false, mitkCommandLineParser::Output);
parser.endGroup();
parser.beginGroup("2. Resampling:");
parser.addArgument("spline_resampling", "", mitkCommandLineParser::Float, "Spline resampling:", "Resample fiber using splines with the given point distance (in mm)");
parser.addArgument("linear_resampling", "", mitkCommandLineParser::Float, "Linear resampling:", "Resample fiber linearly with the given point distance (in mm)");
parser.addArgument("num_resampling", "", mitkCommandLineParser::Int, "Num. fiber points resampling:", "Resample all fibers to the given number of points");
parser.addArgument("compress", "", mitkCommandLineParser::Float, "Compress:", "Compress fiber using the given error threshold (in mm)");
parser.endGroup();
parser.beginGroup("3. Filtering:");
parser.addArgument("min_length", "", mitkCommandLineParser::Float, "Minimum length:", "Minimum fiber length (in mm)");
parser.addArgument("max_length", "", mitkCommandLineParser::Float, "Maximum length:", "Maximum fiber length (in mm)");
parser.addArgument("max_angle", "", mitkCommandLineParser::Float, "Maximum angle:", "Maximum angular STDEV (in degree) over given distance");
parser.addArgument("max_angle_dist", "", mitkCommandLineParser::Float, "Distance:", "Distance in mm", 10);
parser.addArgument("remove", "", mitkCommandLineParser::Bool, "Remove fibers exceeding curvature threshold:", "If false, only the high curvature parts are removed");
parser.addArgument("subsample", "", mitkCommandLineParser::Float, "Randomly select fraction of streamlines:", "Randomly select the specified fraction of streamlines from the input tractogram");
parser.addArgument("random_subsample", "", mitkCommandLineParser::Bool, "Randomly seed subsampling:", "Randomly seed subsampling. Else, use seed 0.");
parser.endGroup();
parser.beginGroup("4. Transformation:");
parser.addArgument("mirror", "", mitkCommandLineParser::Int, "Invert coordinates:", "Invert fiber coordinates XYZ (e.g. 010 to invert y-coordinate of each fiber point)");
parser.addArgument("rotate_x", "", mitkCommandLineParser::Float, "Rotate x-axis:", "Rotate around x-axis (in deg)");
parser.addArgument("rotate_y", "", mitkCommandLineParser::Float, "Rotate y-axis:", "Rotate around y-axis (in deg)");
parser.addArgument("rotate_z", "", mitkCommandLineParser::Float, "Rotate z-axis:", "Rotate around z-axis (in deg)");
parser.addArgument("scale_x", "", mitkCommandLineParser::Float, "Scale x-axis:", "Scale in direction of x-axis");
parser.addArgument("scale_y", "", mitkCommandLineParser::Float, "Scale y-axis:", "Scale in direction of y-axis");
parser.addArgument("scale_z", "", mitkCommandLineParser::Float, "Scale z-axis", "Scale in direction of z-axis");
parser.addArgument("translate_x", "", mitkCommandLineParser::Float, "Translate x-axis:", "Translate in direction of x-axis (in mm)");
parser.addArgument("translate_y", "", mitkCommandLineParser::Float, "Translate y-axis:", "Translate in direction of y-axis (in mm)");
parser.addArgument("translate_z", "", mitkCommandLineParser::Float, "Translate z-axis:", "Translate in direction of z-axis (in mm)");
parser.endGroup();
std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
bool remove = false;
if (parsedArgs.count("remove"))
remove = us::any_cast<bool>(parsedArgs["remove"]);
bool random_subsample = false;
if (parsedArgs.count("random_subsample"))
random_subsample = us::any_cast<bool>(parsedArgs["random_subsample"]);
float spline_resampling = -1;
if (parsedArgs.count("spline_resampling"))
spline_resampling = us::any_cast<float>(parsedArgs["spline_resampling"]);
float linear_resampling = -1;
if (parsedArgs.count("linear_resampling"))
linear_resampling = us::any_cast<float>(parsedArgs["linear_resampling"]);
int num_resampling = -1;
if (parsedArgs.count("num_resampling"))
num_resampling = us::any_cast<int>(parsedArgs["num_resampling"]);
float subsample = -1;
if (parsedArgs.count("subsample"))
subsample = us::any_cast<float>(parsedArgs["subsample"]);
float compress = -1;
if (parsedArgs.count("compress"))
compress = us::any_cast<float>(parsedArgs["compress"]);
float minFiberLength = -1;
if (parsedArgs.count("min_length"))
minFiberLength = us::any_cast<float>(parsedArgs["min_length"]);
float maxFiberLength = -1;
if (parsedArgs.count("max_length"))
maxFiberLength = us::any_cast<float>(parsedArgs["max_length"]);
float max_angle_dist = 10;
if (parsedArgs.count("max_angle_dist"))
max_angle_dist = us::any_cast<float>(parsedArgs["max_angle_dist"]);
float maxAngularDev = -1;
if (parsedArgs.count("max_angle"))
maxAngularDev = us::any_cast<float>(parsedArgs["max_angle"]);
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"]);
std::string inFileName = us::any_cast<std::string>(parsedArgs["i"]);
std::string outFileName = us::any_cast<std::string>(parsedArgs["o"]);
try
{
mitk::FiberBundle::Pointer fib = LoadFib(inFileName);
if (subsample>0)
fib = fib->SubsampleFibers(subsample, random_subsample);
if (maxAngularDev>0)
{
auto filter = itk::FiberCurvatureFilter::New();
filter->SetInputFiberBundle(fib);
filter->SetAngularDeviation(maxAngularDev);
filter->SetDistance(max_angle_dist);
filter->SetRemoveFibers(remove);
filter->Update();
fib = filter->GetOutputFiberBundle();
}
if (minFiberLength>0)
fib->RemoveShortFibers(minFiberLength);
if (maxFiberLength>0)
fib->RemoveLongFibers(maxFiberLength);
if (spline_resampling>0)
fib->ResampleSpline(spline_resampling);
if (linear_resampling>0)
fib->ResampleLinear(linear_resampling);
if (num_resampling>0)
fib->ResampleToNumPoints(num_resampling);
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){
std::cout << "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::IOUtil::Save(fib.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;
}
/*!
\brief Spatially cluster fibers
*/
int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setTitle("Extract Similar Tracts");
parser.setCategory("Fiber Tracking Evaluation");
parser.setContributor("MIC");
parser.setArgumentPrefix("--", "-");
parser.addArgument("", "i", mitkCommandLineParser::InputFile, "Input:", "input fiber bundle (.fib, .trk, .tck)", us::Any(), false);
parser.addArgument("ref_tracts", "", mitkCommandLineParser::StringList, "Ref. Tracts:", "reference tracts (.fib, .trk, .tck)", us::Any(), false);
parser.addArgument("ref_masks", "", mitkCommandLineParser::StringList, "Ref. Masks:", "reference bundle masks", us::Any());
parser.addArgument("", "o", mitkCommandLineParser::OutputDirectory, "Output:", "output root", us::Any(), false);
parser.addArgument("distance", "", mitkCommandLineParser::Int, "Distance:", "", 10);
parser.addArgument("metric", "", mitkCommandLineParser::String, "Metric:", "");
parser.addArgument("subsample", "", mitkCommandLineParser::Float, "Subsampling factor:", "Only use specified fraction of input fibers", 1.0);
std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
std::string in_fib = us::any_cast<std::string>(parsedArgs["i"]);
std::string out_root = us::any_cast<std::string>(parsedArgs["o"]);
mitkCommandLineParser::StringContainerType ref_bundle_files = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["ref_tracts"]);
mitkCommandLineParser::StringContainerType ref_mask_files;
if (parsedArgs.count("ref_masks"))
ref_mask_files = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["ref_masks"]);
if (ref_mask_files.size()>0 && ref_mask_files.size()!=ref_bundle_files.size())
{
MITK_INFO << "If reference masks are used, there has to be one mask per reference tract.";
return EXIT_FAILURE;
}
int distance = 10;
if (parsedArgs.count("distance"))
distance = us::any_cast<int>(parsedArgs["distance"]);
std::string metric = "EU_MEAN";
if (parsedArgs.count("metric"))
metric = us::any_cast<std::string>(parsedArgs["metric"]);
float subsample = 1.0;
if (parsedArgs.count("subsample"))
subsample = us::any_cast<float>(parsedArgs["subsample"]);
try
{
mitk::FiberBundle::Pointer fib = LoadFib(in_fib);
std::srand(0);
if (subsample<1.0)
fib = fib->SubsampleFibers(subsample);
mitk::FiberBundle::Pointer resampled_fib = fib->GetDeepCopy();
resampled_fib->ResampleToNumPoints(12);
std::vector< mitk::FiberBundle::Pointer > ref_fibs;
std::vector< ItkFloatImgType::Pointer > ref_masks;
for (std::size_t i=0; i<ref_bundle_files.size(); ++i)
{
MITK_INFO << "Loading " << ist::GetFilenameName(ref_bundle_files.at(i));
if (i<ref_mask_files.size())
MITK_INFO << "Loading " << ist::GetFilenameName(ref_mask_files.at(i));
std::streambuf *old = cout.rdbuf(); // <-- save
std::stringstream ss;
std::cout.rdbuf (ss.rdbuf()); // <-- redirect
try
{
ref_fibs.push_back(LoadFib(ref_bundle_files.at(i)));
if (i<ref_mask_files.size())
ref_masks.push_back(LoadItkImage(ref_mask_files.at(i)));
else
ref_masks.push_back(nullptr);
std::cout.rdbuf (old); // <-- restore
}
catch(...){
std::cout.rdbuf (old); // <-- restore
std::cout << "could not load: " << ref_bundle_files.at(i);
return EXIT_FAILURE;
}
}
std::vector< float > distances;
distances.push_back(distance);
mitk::FiberBundle::Pointer anchor_tractogram = mitk::FiberBundle::New(nullptr);
unsigned int c = 0;
for (auto ref_fib : ref_fibs)
{
MITK_INFO << "Extracting " << ist::GetFilenameName(ref_bundle_files.at(c));
// std::streambuf *old = cout.rdbuf(); // <-- save
// std::stringstream ss;
// std::cout.rdbuf (ss.rdbuf()); // <-- redirect
try
{
itk::TractClusteringFilter::Pointer segmenter = itk::TractClusteringFilter::New();
// calculate centroids from reference bundle
{
MITK_INFO << "TEST 1";
itk::TractClusteringFilter::Pointer clusterer = itk::TractClusteringFilter::New();
clusterer->SetDistances({10,20,30});
clusterer->SetTractogram(ref_fib);
clusterer->SetMetrics({new mitk::ClusteringMetricEuclideanStd()});
clusterer->SetMergeDuplicateThreshold(0.0);
clusterer->Update();
MITK_INFO << "TEST 2";
std::vector<mitk::FiberBundle::Pointer> tracts = clusterer->GetOutCentroids();
ref_fib = mitk::FiberBundle::New(nullptr);
ref_fib = ref_fib->AddBundles(tracts);
MITK_INFO << "TEST 3";
mitk::IOUtil::Save(ref_fib, out_root + "centroids_" + ist::GetFilenameName(ref_bundle_files.at(c)));
segmenter->SetInCentroids(ref_fib);
MITK_INFO << "TEST 4";
}
// segment tract
segmenter->SetFilterMask(ref_masks.at(c));
segmenter->SetOverlapThreshold(0.8);
segmenter->SetDistances(distances);
segmenter->SetTractogram(resampled_fib);
segmenter->SetMergeDuplicateThreshold(0.0);
segmenter->SetDoResampling(false);
if (metric=="EU_MEAN")
segmenter->SetMetrics({new mitk::ClusteringMetricEuclideanMean()});
else if (metric=="EU_STD")
segmenter->SetMetrics({new mitk::ClusteringMetricEuclideanStd()});
else if (metric=="EU_MAX")
segmenter->SetMetrics({new mitk::ClusteringMetricEuclideanMax()});
segmenter->Update();
std::vector< std::vector< long > > clusters = segmenter->GetOutFiberIndices();
if (clusters.size()>0)
{
vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
mitk::FiberBundle::Pointer result = mitk::FiberBundle::New(nullptr);
std::vector< mitk::FiberBundle::Pointer > result_fibs;
for (unsigned int cluster_index=0; cluster_index<clusters.size()-1; ++cluster_index)
result_fibs.push_back(mitk::FiberBundle::New(fib->GeneratePolyDataByIds(clusters.at(cluster_index), weights)));
result = result->AddBundles(result_fibs);
anchor_tractogram = anchor_tractogram->AddBundle(result);
mitk::IOUtil::Save(result, out_root + "anchor_" + ist::GetFilenameName(ref_bundle_files.at(c)));
fib = mitk::FiberBundle::New(fib->GeneratePolyDataByIds(clusters.back(), weights));
resampled_fib = mitk::FiberBundle::New(resampled_fib->GeneratePolyDataByIds(clusters.back(), weights));
}
}
catch(itk::ExceptionObject& excpt)
{
MITK_INFO << "Exception while processing " << ist::GetFilenameName(ref_bundle_files.at(c));
MITK_INFO << excpt.GetDescription();
}
catch(std::exception& excpt)
{
MITK_INFO << "Exception while processing " << ist::GetFilenameName(ref_bundle_files.at(c));
MITK_INFO << excpt.what();
}
// std::cout.rdbuf (old); // <-- restore
if (fib->GetNumFibers()==0)
break;
++c;
}
MITK_INFO << "Streamlines in anchor tractogram: " << anchor_tractogram->GetNumFibers();
mitk::IOUtil::Save(anchor_tractogram, out_root + "anchor_tractogram.trk");
MITK_INFO << "Streamlines remaining in candidate tractogram: " << fib->GetNumFibers();
mitk::IOUtil::Save(fib, out_root + "candidate_tractogram.trk");
}
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;
}
/*!
\brief Spatially cluster fibers
*/
int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setTitle("Fiber Clustering");
parser.setCategory("Fiber Processing");
parser.setContributor("MIC");
parser.setArgumentPrefix("--", "-");
parser.addArgument("", "i", mitkCommandLineParser::InputFile, "Input:", "input fiber bundle (.fib, .trk, .tck)", us::Any(), false);
parser.addArgument("", "o", mitkCommandLineParser::OutputDirectory, "Output:", "output root", us::Any(), false);
parser.addArgument("cluster_size", "", mitkCommandLineParser::Int, "Cluster size:", "", 10);
parser.addArgument("fiber_points", "", mitkCommandLineParser::Int, "Fiber points:", "", 12);
parser.addArgument("min_fibers", "", mitkCommandLineParser::Int, "Min. fibers per cluster:", "", 1);
parser.addArgument("max_clusters", "", mitkCommandLineParser::Int, "Max. clusters:", "");
parser.addArgument("merge_clusters", "", mitkCommandLineParser::Float, "Merge clusters:", "", -1.0);
parser.addArgument("output_centroids", "", mitkCommandLineParser::Bool, "Output centroids:", "");
parser.addArgument("metrics", "", mitkCommandLineParser::StringList, "Metrics:", "EU_MEAN, EU_STD, EU_MAX, ANAT, MAP, LENGTH");
parser.addArgument("metric_weights", "", mitkCommandLineParser::StringList, "Metric weights:", "add one float weight for each used metric");
parser.addArgument("input_centroids", "", mitkCommandLineParser::String, "Input centroids:", "");
parser.addArgument("scalar_map", "", mitkCommandLineParser::String, "Scalar map:", "");
parser.addArgument("parcellation", "", mitkCommandLineParser::String, "Parcellation:", "");
parser.addArgument("file_ending", "", mitkCommandLineParser::String, "File ending:", "");
std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
return EXIT_FAILURE;
std::string inFileName = us::any_cast<std::string>(parsedArgs["i"]);
std::string out_root = us::any_cast<std::string>(parsedArgs["o"]);
int cluster_size = 10;
if (parsedArgs.count("cluster_size"))
cluster_size = us::any_cast<int>(parsedArgs["cluster_size"]);
int fiber_points = 12;
if (parsedArgs.count("fiber_points"))
fiber_points = us::any_cast<int>(parsedArgs["fiber_points"]);
int min_fibers = 1;
if (parsedArgs.count("min_fibers"))
min_fibers = us::any_cast<int>(parsedArgs["min_fibers"]);
int max_clusters = 0;
if (parsedArgs.count("max_clusters"))
max_clusters = us::any_cast<int>(parsedArgs["max_clusters"]);
float merge_clusters = -1.0;
if (parsedArgs.count("merge_clusters"))
merge_clusters = us::any_cast<float>(parsedArgs["merge_clusters"]);
bool output_centroids = false;
if (parsedArgs.count("output_centroids"))
output_centroids = us::any_cast<bool>(parsedArgs["output_centroids"]);
std::vector< std::string > metric_strings = {"EU_MEAN"};
if (parsedArgs.count("metrics"))
metric_strings = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["metrics"]);
std::vector< std::string > metric_weights = {"1.0"};
if (parsedArgs.count("metric_weights"))
metric_weights = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["metric_weights"]);
std::string input_centroids = "";
if (parsedArgs.count("input_centroids"))
input_centroids = us::any_cast<std::string>(parsedArgs["input_centroids"]);
std::string scalar_map = "";
if (parsedArgs.count("scalar_map"))
scalar_map = us::any_cast<std::string>(parsedArgs["scalar_map"]);
std::string parcellation = "";
if (parsedArgs.count("parcellation"))
parcellation = us::any_cast<std::string>(parsedArgs["parcellation"]);
std::string file_ending = ".fib";
if (parsedArgs.count("file_ending"))
file_ending = us::any_cast<std::string>(parsedArgs["file_ending"]);
if (metric_strings.size()!=metric_weights.size())
{
MITK_INFO << "Each metric needs an associated metric weight!";
return EXIT_FAILURE;
}
try
{
typedef itk::Image< float, 3 > FloatImageType;
typedef itk::Image< short, 3 > ShortImageType;
mitk::FiberBundle::Pointer fib = LoadFib(inFileName);
float max_d = 0;
int i=1;
std::vector< float > distances;
while (max_d < fib->GetGeometry()->GetDiagonalLength()/2)
{
distances.push_back(cluster_size*i);
max_d = cluster_size*i;
++i;
}
itk::TractClusteringFilter::Pointer clusterer = itk::TractClusteringFilter::New();
clusterer->SetDistances(distances);
clusterer->SetTractogram(fib);
if (input_centroids!="")
{
mitk::FiberBundle::Pointer in_centroids = LoadFib(input_centroids);
clusterer->SetInCentroids(in_centroids);
}
std::vector< mitk::ClusteringMetric* > metrics;
int mc = 0;
for (auto m : metric_strings)
{
float w = boost::lexical_cast<float>(metric_weights.at(mc));
MITK_INFO << "Metric: " << m << " (w=" << w << ")";
if (m=="EU_MEAN")
metrics.push_back({new mitk::ClusteringMetricEuclideanMean()});
else if (m=="EU_STD")
metrics.push_back({new mitk::ClusteringMetricEuclideanStd()});
else if (m=="EU_MAX")
metrics.push_back({new mitk::ClusteringMetricEuclideanMax()});
else if (m=="ANGLES")
metrics.push_back({new mitk::ClusteringMetricInnerAngles()});
else if (m=="LENGTH")
metrics.push_back({new mitk::ClusteringMetricLength()});
else if (m=="MAP" && scalar_map!="")
{
mitk::Image::Pointer mitk_map = mitk::IOUtil::Load<mitk::Image>(scalar_map);
if (mitk_map->GetDimension()==3)
{
FloatImageType::Pointer itk_map = FloatImageType::New();
mitk::CastToItkImage(mitk_map, itk_map);
mitk::ClusteringMetricScalarMap* metric = new mitk::ClusteringMetricScalarMap();
metric->SetImages({itk_map});
metric->SetScale(distances.at(0));
metrics.push_back(metric);
}
}
else if (m=="ANAT" && parcellation!="")
{
mitk::Image::Pointer mitk_map = mitk::IOUtil::Load<mitk::Image>(parcellation);
if (mitk_map->GetDimension()==3)
{
ShortImageType::Pointer itk_map = ShortImageType::New();
mitk::CastToItkImage(mitk_map, itk_map);
mitk::ClusteringMetricAnatomic* metric = new mitk::ClusteringMetricAnatomic();
metric->SetParcellations({itk_map});
metrics.push_back(metric);
}
}
metrics.back()->SetScale(w);
mc++;
}
if (metrics.empty())
{
MITK_INFO << "No metric selected!";
return EXIT_FAILURE;
}
clusterer->SetMetrics(metrics);
clusterer->SetMergeDuplicateThreshold(merge_clusters);
clusterer->SetNumPoints(fiber_points);
clusterer->SetMaxClusters(max_clusters);
clusterer->SetMinClusterSize(min_fibers);
clusterer->Update();
std::vector<mitk::FiberBundle::Pointer> tracts = clusterer->GetOutTractograms();
std::vector<mitk::FiberBundle::Pointer> centroids = clusterer->GetOutCentroids();
MITK_INFO << "Saving clusters";
std::streambuf *old = cout.rdbuf(); // <-- save
std::stringstream ss;
std::cout.rdbuf (ss.rdbuf()); // <-- redirect
unsigned int c = 0;
for (auto f : tracts)
{
mitk::IOUtil::Save(f, out_root + "Cluster_" + boost::lexical_cast<std::string>(c) + file_ending);
if (output_centroids)
mitk::IOUtil::Save(centroids.at(c), out_root + "Centroid_" + boost::lexical_cast<std::string>(c) + file_ending);
++c;
}
std::cout.rdbuf (old); // <-- restore
}
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;
}
