diff --git a/CMakeExternals/Caffe.cmake b/CMakeExternals/Caffe.cmake
index 0b22496325..a586e27174 100644
--- a/CMakeExternals/Caffe.cmake
+++ b/CMakeExternals/Caffe.cmake
@@ -1,57 +1,64 @@
 #-----------------------------------------------------------------------------
 # Caffe
 #-----------------------------------------------------------------------------
 
 if(MITK_USE_Caffe)
 
   # Sanity checks
   if(DEFINED Caffe_DIR AND NOT EXISTS ${Caffe_DIR})
     message(FATAL_ERROR "Caffe_DIR variable is defined but corresponds to non-existing directory")
   endif()
 
   set(proj Caffe)
   set(proj_DEPENDENCIES )
   set(Caffe_DEPENDS ${proj})
 
   if(WIN32)
     set(COPY_COMMAND copy)
   else()
     set(COPY_COMMAND cp)
   endif()
   
   if(NOT DEFINED Caffe_DIR)
   
     find_path(Boost_INCLUDE_DIR boost)
     find_library(Boost_LIBRARY boost_system)    
     get_filename_component(Boost_LIBRARY_DIR ${Boost_LIBRARY} DIRECTORY)
+    
+    if(${CMAKE_BUILD_TYPE} MATCHES "Debug")
+      find_library(GFLAGS_LIBRARY gflagsd PATHS ${ep_prefix}/lib NO_DEFAULT_PATH) 
+    else()
+      find_library(GFLAGS_LIBRARY gflags PATHS ${ep_prefix}/lib NO_DEFAULT_PATH) 
+    endif()
         
     #set(revision_tag 63cad96)
     ExternalProject_Add(${proj}
        GIT_REPOSITORY https://github.com/BVLC/caffe.git
        #GIT_TAG ${revision_tag}
        CMAKE_GENERATOR ${gen}
        CMAKE_ARGS
          ${ep_common_args}
          ${additional_args}
          -DCMAKE_CXX_FLAGS=-std=c++11
          -DCMAKE_CXX_STANDARD=11
          -DUSE_OPENMP:BOOL=ON
          -DBoost_INCLUDE_DIR:PATH=${Boost_INCLUDE_DIR}
          -DBoost_LIBRARY_DIR_RELEASE:PATH=${Boost_LIBRARY_DIR}
          -DBoost_LIBRARY_DIR_DEBUG:PATH=${Boost_LIBRARY_DIR}
+         -DGFLAGS_LIBRARY:FILEPATH=${GFLAGS_LIBRARY}
        CMAKE_CACHE_ARGS
          ${ep_common_cache_args}
        CMAKE_CACHE_DEFAULT_ARGS
          ${ep_common_cache_default_args}
        DEPENDS ${proj_DEPENDENCIES}
       )
 
     set(Caffe_DIR ${ep_prefix})
     mitkFunctionInstallExternalCMakeProject(${proj})
 
   else()
 
     mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}")
 
   endif()
 endif(MITK_USE_Caffe)
diff --git a/Modules/DiffusionImaging/Connectomics/cmdapps/NetworkCreation.cpp b/Modules/DiffusionImaging/Connectomics/cmdapps/NetworkCreation.cpp
index cebf9e8b6a..95072fcd2e 100644
--- a/Modules/DiffusionImaging/Connectomics/cmdapps/NetworkCreation.cpp
+++ b/Modules/DiffusionImaging/Connectomics/cmdapps/NetworkCreation.cpp
@@ -1,140 +1,135 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // std includes
 #include <string>
 
 // CTK includes
 #include "mitkCommandLineParser.h"
 
 // MITK includes
 #include "mitkConnectomicsNetworkCreator.h"
 #include <mitkCoreObjectFactory.h>
 #include <mitkIOUtil.h>
 
 using namespace std;
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Network Creation");
   parser.setCategory("Connectomics");
   parser.setDescription("");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("fiberImage", "f", mitkCommandLineParser::InputFile, "Input image", "input fiber image (.fib)", us::Any(), false);
   parser.addArgument("parcellation", "p", mitkCommandLineParser::InputFile, "Parcellation image", "parcellation image", us::Any(), false);
   parser.addArgument("outputNetwork", "o", mitkCommandLineParser::String, "Output network", "where to save the output (.cnf)", us::Any(), false);
 
   parser.addArgument("radius", "r", mitkCommandLineParser::Int, "Radius", "Search radius in mm", 15, true);
   parser.addArgument("noCenterOfMass", "com", mitkCommandLineParser::Bool, "No center of mass", "Do not use center of mass for node positions");
 
-  parser.setCategory("Connectomics");
-  parser.setTitle("Network Creation");
-  parser.setDescription("");
-  parser.setContributor("MIC");
-
   map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   //default values
   int searchRadius( 15 );
   bool noCenterOfMass( false );
 
   // parse command line arguments
   std::string fiberFilename = us::any_cast<std::string>(parsedArgs["fiberImage"]);
   std::string parcellationFilename = us::any_cast<std::string>(parsedArgs["parcellation"]);
   std::string outputFilename = us::any_cast<std::string>(parsedArgs["outputNetwork"]);
 
   if (parsedArgs.count("radius"))
     searchRadius = us::any_cast<int>(parsedArgs["radius"]);
 
 
   if (parsedArgs.count("noCenterOfMass"))
     noCenterOfMass = us::any_cast<bool>(parsedArgs["noCenterOfMass"]);
 
   try
   {
 
     const std::string s1="", s2="";
 
     // load fiber image
     std::vector<mitk::BaseData::Pointer> fiberInfile =
       mitk::IOUtil::Load( fiberFilename);
     if( fiberInfile.empty() )
     {
       std::string errorMessage = "Fiber Image at " + fiberFilename + " could not be read. Aborting.";
       MITK_ERROR << errorMessage;
       return EXIT_FAILURE;
     }
     mitk::BaseData* fiberBaseData = fiberInfile.at(0);
     mitk::FiberBundle* fiberBundle = dynamic_cast<mitk::FiberBundle*>( fiberBaseData );
 
     // load parcellation
     std::vector<mitk::BaseData::Pointer> parcellationInFile =
       mitk::IOUtil::Load( parcellationFilename);
     if( parcellationInFile.empty() )
     {
       std::string errorMessage = "Parcellation at " + parcellationFilename + " could not be read. Aborting.";
       MITK_ERROR << errorMessage;
       return EXIT_FAILURE;
     }
     mitk::BaseData* parcellationBaseData = parcellationInFile.at(0);
     mitk::Image* parcellationImage = dynamic_cast<mitk::Image*>( parcellationBaseData );
 
 
 
     // do creation
     mitk::ConnectomicsNetworkCreator::Pointer connectomicsNetworkCreator = mitk::ConnectomicsNetworkCreator::New();
     connectomicsNetworkCreator->SetSegmentation( parcellationImage );
     connectomicsNetworkCreator->SetFiberBundle( fiberBundle );
     if( !noCenterOfMass )
     {
       connectomicsNetworkCreator->CalculateCenterOfMass();
     }
     connectomicsNetworkCreator->SetEndPointSearchRadius( searchRadius );
     connectomicsNetworkCreator->CreateNetworkFromFibersAndSegmentation();
 
 
     mitk::ConnectomicsNetwork::Pointer network = connectomicsNetworkCreator->GetNetwork();
 
     std::cout << "searching writer";
 
     mitk::IOUtil::SaveBaseData(network.GetPointer(), outputFilename );
 
     return EXIT_SUCCESS;
   }
   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;
   }
   std::cout << "DONE";
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/Connectomics/cmdapps/NetworkStatistics.cpp b/Modules/DiffusionImaging/Connectomics/cmdapps/NetworkStatistics.cpp
index 587fb4500f..324a5f1c11 100644
--- a/Modules/DiffusionImaging/Connectomics/cmdapps/NetworkStatistics.cpp
+++ b/Modules/DiffusionImaging/Connectomics/cmdapps/NetworkStatistics.cpp
@@ -1,574 +1,569 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // std includes
 #include <string>
 #include <sstream>
 #include <fstream>
 #include <vector>
 #include <map>
 #include <utility>
 
 // boost includes
 #include <boost/algorithm/string.hpp>
 
 // ITK includes
 #include <itkImageFileWriter.h>
 
 // CTK includes
 #include "mitkCommandLineParser.h"
 
 // MITK includes
 #include <mitkConnectomicsStatisticsCalculator.h>
 #include <mitkConnectomicsNetworkThresholder.h>
 #include <itkConnectomicsNetworkToConnectivityMatrixImageFilter.h>
 #include <mitkIOUtil.h>
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Network Creation");
   parser.setCategory("Connectomics");
   parser.setDescription("");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
 
   parser.addArgument("inputNetwork", "i", mitkCommandLineParser::InputFile, "Input network", "input connectomics network (.cnf)", us::Any(), false);
   parser.addArgument("outputFile", "o", mitkCommandLineParser::OutputFile, "Output file", "name of output file", us::Any(), false);
 
   parser.addArgument("noGlobalStatistics", "g", mitkCommandLineParser::Bool, "No global statistics", "Do not calculate global statistics");
   parser.addArgument("createConnectivityMatriximage", "I", mitkCommandLineParser::Bool, "Write connectivity matrix image", "Write connectivity matrix image");
   parser.addArgument("binaryConnectivity", "b", mitkCommandLineParser::Bool, "Binary connectivity", "Whether to create a binary connectivity matrix");
   parser.addArgument("rescaleConnectivity", "r", mitkCommandLineParser::Bool, "Rescale connectivity", "Whether to rescale the connectivity matrix");
   parser.addArgument("localStatistics", "L", mitkCommandLineParser::StringList, "Local statistics", "Provide a list of node labels for local statistics", us::Any());
   parser.addArgument("regionList", "R", mitkCommandLineParser::StringList, "Region list", "A space separated list of regions. Each region has the format\n regionname;label1;label2;...;labelN", us::Any());
   parser.addArgument("granularity", "gr", mitkCommandLineParser::Int, "Granularity", "How finely to test the density range and how many thresholds to consider",1);
   parser.addArgument("startDensity", "d", mitkCommandLineParser::Float, "Start Density", "Largest density for the range",1.0);
   parser.addArgument("thresholdStepSize", "t", mitkCommandLineParser::Int, "Step size threshold", "Distance of two adjacent thresholds",3);
 
-  parser.setCategory("Connectomics");
-  parser.setTitle("Network Statistics");
-  parser.setDescription("");
-  parser.setContributor("MIC");
-
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   //default values
   bool noGlobalStatistics( false );
   bool binaryConnectivity( false );
   bool rescaleConnectivity( false );
   bool createConnectivityMatriximage( false );
   int granularity( 1 );
   double startDensity( 1.0 );
   int thresholdStepSize( 3 );
 
 
   // parse command line arguments
   std::string networkName = us::any_cast<std::string>(parsedArgs["inputNetwork"]);
   std::string outName = us::any_cast<std::string>(parsedArgs["outputFile"]);
 
   mitkCommandLineParser::StringContainerType localLabels;
 
   if(parsedArgs.count("localStatistics"))
   {
     localLabels = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["localStatistics"]);
   }
 
   mitkCommandLineParser::StringContainerType unparsedRegions;
   std::map< std::string, std::vector<std::string> > parsedRegions;
   std::map< std::string, std::vector<std::string> >::iterator parsedRegionsIterator;
 
   if(parsedArgs.count("regionList"))
   {
     unparsedRegions = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["regionList"]);
 
     for(unsigned int index(0); index < unparsedRegions.size(); index++ )
     {
       std::vector< std::string > tempRegionVector;
 
       boost::split(tempRegionVector, unparsedRegions.at(index), boost::is_any_of(";"));
 
       std::vector< std::string >::const_iterator begin = tempRegionVector.begin();
       std::vector< std::string >::const_iterator last = tempRegionVector.begin() + tempRegionVector.size();
       std::vector< std::string > insertRegionVector(begin + 1, last);
 
       if( parsedRegions.count( tempRegionVector.at(0) ) == 0 )
       {
         parsedRegions.insert( std::pair< std::string, std::vector<std::string>  >( tempRegionVector.at(0), insertRegionVector) );
       }
       else
       {
         MITK_ERROR << "Region already exists. Skipping second occurrence.";
       }
     }
   }
 
   if (parsedArgs.count("noGlobalStatistics"))
     noGlobalStatistics = us::any_cast<bool>(parsedArgs["noGlobalStatistics"]);
   if (parsedArgs.count("binaryConnectivity"))
     binaryConnectivity = us::any_cast<bool>(parsedArgs["binaryConnectivity"]);
   if (parsedArgs.count("rescaleConnectivity"))
     rescaleConnectivity = us::any_cast<bool>(parsedArgs["rescaleConnectivity"]);
   if (parsedArgs.count("createConnectivityMatriximage"))
     createConnectivityMatriximage = us::any_cast<bool>(parsedArgs["createConnectivityMatriximage"]);
   if (parsedArgs.count("granularity"))
     granularity = us::any_cast<int>(parsedArgs["granularity"]);
   if (parsedArgs.count("startDensity"))
     startDensity = us::any_cast<float>(parsedArgs["startDensity"]);
   if (parsedArgs.count("thresholdStepSize"))
     thresholdStepSize = us::any_cast<int>(parsedArgs["thresholdStepSize"]);
 
   try
   {
     // load network
     std::vector<mitk::BaseData::Pointer> networkFile =
       mitk::IOUtil::Load( networkName);
     if( networkFile.empty() )
     {
       std::string errorMessage = "File at " + networkName + " could not be read. Aborting.";
       MITK_ERROR << errorMessage;
       return EXIT_FAILURE;
     }
     mitk::BaseData* networkBaseData = networkFile.at(0);
     mitk::ConnectomicsNetwork* network = dynamic_cast<mitk::ConnectomicsNetwork*>( networkBaseData );
 
     if( !network )
     {
       std::string errorMessage = "Read file at " + networkName + " could not be recognized as network. Aborting.";
       MITK_ERROR << errorMessage;
       return EXIT_FAILURE;
     }
 
     // streams
     std::stringstream globalHeaderStream;
     globalHeaderStream  << "NumberOfVertices "
       << "NumberOfEdges "
       << "AverageDegree "
       << "ConnectionDensity "
       << "NumberOfConnectedComponents "
       << "AverageComponentSize "
       << "LargestComponentSize "
       << "RatioOfNodesInLargestComponent "
       << "HopPlotExponent "
       << "EffectiveHopDiameter "
       << "AverageClusteringCoefficientsC "
       << "AverageClusteringCoefficientsD "
       << "AverageClusteringCoefficientsE "
       << "AverageVertexBetweennessCentrality "
       << "AverageEdgeBetweennessCentrality "
       << "NumberOfIsolatedPoints "
       << "RatioOfIsolatedPoints "
       << "NumberOfEndPoints "
       << "RatioOfEndPoints "
       << "Diameter "
       << "Diameter90 "
       << "Radius "
       << "Radius90 "
       << "AverageEccentricity "
       << "AverageEccentricity90 "
       << "AveragePathLength "
       << "NumberOfCentralPoints "
       << "RatioOfCentralPoints "
       << "SpectralRadius "
       << "SecondLargestEigenValue "
       << "AdjacencyTrace "
       << "AdjacencyEnergy "
       << "LaplacianTrace "
       << "LaplacianEnergy "
       << "LaplacianSpectralGap "
       << "NormalizedLaplacianTrace "
       << "NormalizedLaplacianEnergy "
       << "NormalizedLaplacianNumberOf2s "
       << "NormalizedLaplacianNumberOf1s "
       << "NormalizedLaplacianNumberOf0s "
       << "NormalizedLaplacianLowerSlope "
       << "NormalizedLaplacianUpperSlope "
       << "SmallWorldness"
       << std::endl;
 
     std::stringstream localHeaderStream;
     std::stringstream regionalHeaderStream;
 
     std::stringstream globalDataStream;
     std::stringstream localDataStream;
     std::stringstream regionalDataStream;
 
     std::string globalOutName = outName + "_global.txt";
     std::string localOutName = outName + "_local.txt";
     std::string regionalOutName = outName + "_regional.txt";
 
     bool firstRun( true );
     // iterate over all three possible methods
     for(unsigned int method( 0 ); method < 3; method++)
     {
       // 0 - Random removal threshold
       // 1 - Largest density below threshold
       // 2 - Threshold based
 
       // iterate over possible targets
       for( unsigned int step( 0 ); step < granularity; step++ )
       {
         double targetValue( 0.0 );
         bool newStep( true );
 
         switch ( method )
         {
         case mitk::ConnectomicsNetworkThresholder::RandomRemovalOfWeakest :
         case mitk::ConnectomicsNetworkThresholder::LargestLowerThanDensity :
           targetValue = startDensity * (1 - static_cast<double>( step ) / ( granularity + 0.5 ) );
           break;
         case mitk::ConnectomicsNetworkThresholder::ThresholdBased :
           targetValue = static_cast<double>( thresholdStepSize * step );
           break;
         default:
           MITK_ERROR << "Invalid thresholding method called, aborting.";
           return EXIT_FAILURE;
           break;
         }
 
         mitk::ConnectomicsNetworkThresholder::Pointer thresholder = mitk::ConnectomicsNetworkThresholder::New();
         thresholder->SetNetwork( network );
         thresholder->SetTargetThreshold( targetValue );
         thresholder->SetTargetDensity( targetValue );
         thresholder->SetThresholdingScheme( static_cast<mitk::ConnectomicsNetworkThresholder::ThresholdingSchemes>(method) );
         mitk::ConnectomicsNetwork::Pointer thresholdedNetwork = thresholder->GetThresholdedNetwork();
 
         mitk::ConnectomicsStatisticsCalculator::Pointer statisticsCalculator = mitk::ConnectomicsStatisticsCalculator::New();
         statisticsCalculator->SetNetwork( thresholdedNetwork );
         statisticsCalculator->Update();
 
         // global statistics
         if( !noGlobalStatistics )
         {
           globalDataStream << statisticsCalculator->GetNumberOfVertices() << " "
             << statisticsCalculator->GetNumberOfEdges() << " "
             << statisticsCalculator->GetAverageDegree() << " "
             << statisticsCalculator->GetConnectionDensity() << " "
             << statisticsCalculator->GetNumberOfConnectedComponents() << " "
             << statisticsCalculator->GetAverageComponentSize() << " "
             << statisticsCalculator->GetLargestComponentSize() << " "
             << statisticsCalculator->GetRatioOfNodesInLargestComponent() << " "
             << statisticsCalculator->GetHopPlotExponent() << " "
             << statisticsCalculator->GetEffectiveHopDiameter() << " "
             << statisticsCalculator->GetAverageClusteringCoefficientsC() << " "
             << statisticsCalculator->GetAverageClusteringCoefficientsD() << " "
             << statisticsCalculator->GetAverageClusteringCoefficientsE() << " "
             << statisticsCalculator->GetAverageVertexBetweennessCentrality() << " "
             << statisticsCalculator->GetAverageEdgeBetweennessCentrality() << " "
             << statisticsCalculator->GetNumberOfIsolatedPoints() << " "
             << statisticsCalculator->GetRatioOfIsolatedPoints() << " "
             << statisticsCalculator->GetNumberOfEndPoints() << " "
             << statisticsCalculator->GetRatioOfEndPoints() << " "
             << statisticsCalculator->GetDiameter() << " "
             << statisticsCalculator->GetDiameter90() << " "
             << statisticsCalculator->GetRadius() << " "
             << statisticsCalculator->GetRadius90() << " "
             << statisticsCalculator->GetAverageEccentricity() << " "
             << statisticsCalculator->GetAverageEccentricity90() << " "
             << statisticsCalculator->GetAveragePathLength() << " "
             << statisticsCalculator->GetNumberOfCentralPoints() << " "
             << statisticsCalculator->GetRatioOfCentralPoints() << " "
             << statisticsCalculator->GetSpectralRadius() << " "
             << statisticsCalculator->GetSecondLargestEigenValue() << " "
             << statisticsCalculator->GetAdjacencyTrace() << " "
             << statisticsCalculator->GetAdjacencyEnergy() << " "
             << statisticsCalculator->GetLaplacianTrace() << " "
             << statisticsCalculator->GetLaplacianEnergy() << " "
             << statisticsCalculator->GetLaplacianSpectralGap() << " "
             << statisticsCalculator->GetNormalizedLaplacianTrace() << " "
             << statisticsCalculator->GetNormalizedLaplacianEnergy() << " "
             << statisticsCalculator->GetNormalizedLaplacianNumberOf2s() << " "
             << statisticsCalculator->GetNormalizedLaplacianNumberOf1s() << " "
             << statisticsCalculator->GetNormalizedLaplacianNumberOf0s() << " "
             << statisticsCalculator->GetNormalizedLaplacianLowerSlope() << " "
             << statisticsCalculator->GetNormalizedLaplacianUpperSlope() << " "
             << statisticsCalculator->GetSmallWorldness()
             << std::endl;
 
         } // end global statistics
 
         //create connectivity matrix png
         if( createConnectivityMatriximage )
         {
           std::string connectivity_png_postfix = "_connectivity";
           if( binaryConnectivity )
           {
             connectivity_png_postfix += "_binary";
           }
           else if( rescaleConnectivity )
           {
             connectivity_png_postfix += "_rescaled";
           }
           connectivity_png_postfix += ".png";
 
           /* File format
           * A png file depicting the binary connectivity matrix
           */
           itk::ConnectomicsNetworkToConnectivityMatrixImageFilter::Pointer filter = itk::ConnectomicsNetworkToConnectivityMatrixImageFilter::New();
           filter->SetInputNetwork( network );
           filter->SetBinaryConnectivity( binaryConnectivity );
           filter->SetRescaleConnectivity( rescaleConnectivity );
           filter->Update();
 
           typedef itk::ConnectomicsNetworkToConnectivityMatrixImageFilter::OutputImageType connectivityMatrixImageType;
 
           itk::ImageFileWriter< connectivityMatrixImageType >::Pointer connectivityWriter = itk::ImageFileWriter< connectivityMatrixImageType >::New();
 
           connectivityWriter->SetInput( filter->GetOutput() );
           connectivityWriter->SetFileName( outName + connectivity_png_postfix);
           connectivityWriter->Update();
 
           std::cout << "Connectivity matrix image written.";
         } // end create connectivity matrix png
 
         /*
          * We can either calculate local indices for specific nodes, or specific regions
          */
 
         // Create LabelToIndex translation
         std::map< std::string, int > labelToIdMap;
         std::vector< mitk::ConnectomicsNetwork::NetworkNode > nodeVector = thresholdedNetwork->GetVectorOfAllNodes();
         for(int loop(0); loop < nodeVector.size(); loop++)
         {
           labelToIdMap.insert( std::pair< std::string, int>(nodeVector.at(loop).label, nodeVector.at(loop).id) );
         }
 
         std::vector< int > degreeVector = thresholdedNetwork->GetDegreeOfNodes();
         std::vector< double > ccVector = thresholdedNetwork->GetLocalClusteringCoefficients( );
         std::vector< double > bcVector = thresholdedNetwork->GetNodeBetweennessVector( );
 
 
         // calculate local indices
 
         {
           // only add to header for the first step of the first method
           if( firstRun )
           {
             localHeaderStream << "Th_method " << "Th_target " << "density";
           }
 
           double density = statisticsCalculator->GetConnectionDensity();
 
           localDataStream << "\n"
             << method << " "
             << targetValue << " "
             << density;
 
           for(unsigned int loop(0); loop < localLabels.size(); loop++ )
           {
             if( network->CheckForLabel(localLabels.at( loop )) )
             {
               if( firstRun )
               {
                 localHeaderStream  << " "
                   << localLabels.at( loop ) << "_Degree "
                   << localLabels.at( loop ) << "_CC "
                   << localLabels.at( loop ) << "_BC";
               }
 
           localDataStream  << " " << degreeVector.at( labelToIdMap.find( localLabels.at( loop ) )->second )
             << " " << ccVector.at( labelToIdMap.find( localLabels.at( loop ) )->second )
             << " " << bcVector.at( labelToIdMap.find( localLabels.at( loop ) )->second );
             }
             else
             {
               MITK_ERROR << "Illegal label. Label: \"" << localLabels.at( loop ) << "\" not found.";
             }
           }
         }
 
         // calculate regional indices
 
         {
           // only add to header for the first step of the first method
           if( firstRun )
           {
             regionalHeaderStream << "Th_method " << "Th_target " << "density";
           }
 
           double density = statisticsCalculator->GetConnectionDensity();
 
           regionalDataStream << "\n"
             << method << " "
             << targetValue << " "
             << density;
 
           for( parsedRegionsIterator = parsedRegions.begin(); parsedRegionsIterator != parsedRegions.end(); parsedRegionsIterator++ )
           {
             std::vector<std::string> regionLabelsVector = parsedRegionsIterator->second;
             std::string regionName = parsedRegionsIterator->first;
 
             double sumDegree( 0 );
             double sumCC( 0 );
             double sumBC( 0 );
             double count( 0 );
 
             for( int loop(0); loop < regionLabelsVector.size(); loop++ )
             {
               if( thresholdedNetwork->CheckForLabel(regionLabelsVector.at( loop )) )
               {
                 sumDegree = sumDegree + degreeVector.at( labelToIdMap.find( regionLabelsVector.at( loop ) )->second );
                 sumCC = sumCC + ccVector.at( labelToIdMap.find( regionLabelsVector.at( loop ) )->second );
                 sumBC = sumBC + bcVector.at( labelToIdMap.find( regionLabelsVector.at( loop ) )->second );
                 count = count + 1;
               }
               else
               {
                 MITK_ERROR << "Illegal label. Label: \"" << regionLabelsVector.at( loop ) << "\" not found.";
               }
             }
 
             // only add to header for the first step of the first method
             if( firstRun )
             {
               regionalHeaderStream  << " " << regionName << "_LocalAverageDegree "
                 << regionName << "_LocalAverageCC "
                 << regionName << "_LocalAverageBC "
                 << regionName << "_NumberOfNodes";
             }
 
             regionalDataStream  << " " << sumDegree / count
               << " " << sumCC / count
               << " " << sumBC / count
               << " " << count;
 
             // count number of connections and fibers between regions
             std::map< std::string, std::vector<std::string> >::iterator loopRegionsIterator;
             for (loopRegionsIterator = parsedRegionsIterator; loopRegionsIterator != parsedRegions.end(); loopRegionsIterator++)
             {
               int numberConnections(0), possibleConnections(0);
               double summedFiberCount(0.0);
               std::vector<std::string> loopLabelsVector = loopRegionsIterator->second;
               std::string loopName = loopRegionsIterator->first;
 
               for (int loop(0); loop < regionLabelsVector.size(); loop++)
               {
                 if (thresholdedNetwork->CheckForLabel(regionLabelsVector.at(loop)))
                 {
                   for (int innerLoop(0); innerLoop < loopLabelsVector.size(); innerLoop++)
                   {
                     if (thresholdedNetwork->CheckForLabel(loopLabelsVector.at(loop)))
                     {
                       bool exists = thresholdedNetwork->EdgeExists(
                         labelToIdMap.find(regionLabelsVector.at(loop))->second,
                         labelToIdMap.find(loopLabelsVector.at(innerLoop))->second);
                       possibleConnections++;
                       if (exists)
                       {
                         numberConnections++;
                         summedFiberCount += thresholdedNetwork->GetEdge(
                           labelToIdMap.find(regionLabelsVector.at(loop))->second,
                           labelToIdMap.find(loopLabelsVector.at(innerLoop))->second).weight;
                       }
                     }
                     else
                     {
                       MITK_ERROR << "Illegal label. Label: \"" << loopLabelsVector.at(loop) << "\" not found.";
                     }
                   }
                 }
                 else
                 {
                   MITK_ERROR << "Illegal label. Label: \"" << regionLabelsVector.at(loop) << "\" not found.";
                 }
               }
 
               if (firstRun)
               {
                 regionalHeaderStream << " " << regionName << "_" << loopName << "_Connections "
                   << " " << regionName << "_" << loopName << "_possibleConnections "
                   << " " << regionName << "_" << loopName << "_ConnectingFibers";
               }
 
               regionalDataStream << " " << numberConnections
                 << " " << possibleConnections
                 << " " << summedFiberCount;
 
             }
           }
         }
 
         firstRun = false;
       }
 
     }// end calculate local averages
 
     if( !noGlobalStatistics )
     {
       std::cout << "Writing to " << globalOutName;
       std::ofstream glocalOutFile( globalOutName.c_str(), ios::out );
       if( ! glocalOutFile.is_open() )
       {
         std::string errorMessage = "Could not open " + globalOutName + " for writing.";
         MITK_ERROR << errorMessage;
         return EXIT_FAILURE;
       }
       glocalOutFile << globalHeaderStream.str() << globalDataStream.str();
       glocalOutFile.close();
     }
 
     if( localLabels.size() > 0 )
     {
       std::cout << "Writing to " << localOutName;
       std::ofstream localOutFile( localOutName.c_str(), ios::out );
       if( ! localOutFile.is_open() )
       {
         std::string errorMessage = "Could not open " + localOutName + " for writing.";
         MITK_ERROR << errorMessage;
         return EXIT_FAILURE;
       }
       localOutFile << localHeaderStream.str() << localDataStream.str();
       localOutFile.close();
     }
 
     if( parsedRegions.size() > 0 )
     {
       std::cout << "Writing to " << regionalOutName;
       std::ofstream regionalOutFile( regionalOutName.c_str(), ios::out );
       if( ! regionalOutFile.is_open() )
       {
         std::string errorMessage = "Could not open " + regionalOutName + " for writing.";
         MITK_ERROR << errorMessage;
         return EXIT_FAILURE;
       }
       regionalOutFile << regionalHeaderStream.str() << regionalDataStream.str();
       regionalOutFile.close();
     }
 
     return EXIT_SUCCESS;
   }
   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;
   }
   std::cout << "DONE";
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/DeepDiffusion/cmdapps/Caffe2Test.cpp b/Modules/DiffusionImaging/DeepDiffusion/cmdapps/Caffe2Test.cpp
index b245a70053..696714589a 100755
--- a/Modules/DiffusionImaging/DeepDiffusion/cmdapps/Caffe2Test.cpp
+++ b/Modules/DiffusionImaging/DeepDiffusion/cmdapps/Caffe2Test.cpp
@@ -1,197 +1,197 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkImageCast.h>
 #include <mitkITKImageImport.h>
 #include <mitkProperties.h>
 #include <mitkImage.h>
 #include <mitkIOUtil.h>
 #include "mitkCommandLineParser.h"
 #include <boost/lexical_cast.hpp>
 
 // Caffe2
 #include <google/protobuf/text_format.h>
 #include "caffe2/core/context.h"
 #include "caffe2/core/operator.h"
 #include "caffe2/core/predictor.h"
 #include "caffe2/core/tensor.h"
 #include "caffe2/utils/math.h"
 #include <caffe2/core/context.h>
 #include <caffe2/core/context_gpu.h>
 #include <caffe2/core/workspace.h>
 
 #include <gtest/gtest.h>
 
 // OpenCV
 #include <opencv2/core/core.hpp>
 #include <opencv2/highgui/highgui.hpp>
 
 template<class TensorType>
 void to_tensor(cv::Mat &img, TensorType &tensor)
 {
     const int num_channel = tensor.dim(1);
     const int height = tensor.dim(2);
     const int width = tensor.dim(3);
 
     assert(img.channels() == num_channel);
     assert(img.cols == width);
     assert(img.rows == height);
 
     // convert to float
     if (num_channel==3 && img.type()!=CV_32FC3)
         img.convertTo(img, CV_32FC3);
     else if(num_channel==1 && img.type()!=CV_32FC1)
         img.convertTo(img, CV_32FC1);
 
     // subtract mean
     img -= 128;  // necessary?
 
 //    caffe2::CPUContext cpu_context;
 //    caffe2::TensorCPU cpu_input(tensor, &cpu_context);
 //    float* tensor_data = cpu_input.template mutable_data<float>();
     float* tensor_data = tensor.template mutable_data<float>();
 
     // create array of cv::Mat where each matrix points to the tensor data
     std::vector<cv::Mat> bgr;
     for (int i = 0; i < num_channel; ++i)
     {
         bgr.push_back(cv::Mat(height, width, CV_32FC1, tensor_data));
         tensor_data += width * height;
     }
 
     // HWC to CHW
     // splits 3 channel matrix into three single channel matrices
     cv::split(img, bgr);
 }
 
 /*!
 * \brief Minimal example for Caffe2 prediction in MITK
 *
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
   parser.setTitle("Caffe2Test");
-  parser.setCategory("Fiber Tracking and Processing Methods");
+  parser.setCategory("MITK Diffusion Deep Learning");
   parser.setContributor("MIC");
   parser.setDescription("Minimal example for Caffe2 prediction in MITK");
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("image", "", mitkCommandLineParser::String, "image:", "", us::Any());
   parser.addArgument("init_net", "", mitkCommandLineParser::String, "init_net:", "the network weights (.pb)", us::Any());
   parser.addArgument("predict_net", "", mitkCommandLineParser::String, "predict_net:", "the network definition (.pb)", us::Any());
 
 //  typedef caffe2::TensorCPU TensorType;
   typedef caffe2::TensorCUDA TensorType;
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   std::string init_net_filename = us::any_cast<std::string>(parsedArgs["init_net"]);
   std::string predict_net_filename = us::any_cast<std::string>(parsedArgs["predict_net"]);
 //  std::string image_filename = us::any_cast<std::string>(parsedArgs["image"]);
 //  cv::Mat img = cv::imread(image_filename, CV_LOAD_IMAGE_COLOR);
 //  cv::Mat img = cv::Mat(64,64,CV_32FC3,128);
 //  cv::namedWindow( "Display window", cv::WINDOW_AUTOSIZE );// Create a window for display.
 //  cv::imshow( "Display w30indow", img2 );                   // Show our image inside it.
 //  cv::waitKey(0);                                          // Wait for a keystroke in the window
 
   caffe2::NetDef init_net, predict_net;
   CAFFE_ENFORCE(ReadProtoFromFile(init_net_filename, &init_net));
   CAFFE_ENFORCE(ReadProtoFromFile(predict_net_filename, &predict_net));
 
   MITK_INFO << "Predict net: " << ProtoDebugString(predict_net);
   std::vector<TensorType*> outputVec;
 
   int w,h,c; w=64; h=64; c=1;
   TensorType input(std::vector<int>({1, h, w, c}));
 
 //// TRYING TO ACCESS TENSOR DATA (RESULTS IN ERROR FOR caffe2::TensorCUDA)
 //  caffe2::CPUContext cpu_context;
 //  caffe2::TensorCPU cpu_input(input, &cpu_context);
 //  float* input_data = cpu_input.template mutable_data<float>();
   float* input_data = input.mutable_data<float>();
 
   // create input image (simply a square of size 10x10 in a 64x64 image)
   // test image for segmentation
   int counter = 0;
   for (int x = 0; x < h; x++)
       for (int y = 0; y < w; y++)
       {
           for (int j = 0; j < c; j++)
           {
             input_data[counter] = 0;
             if (x>20 && x<30 && y>20 && y<30)
                 input_data[counter] = 1;
             counter++;
           }
       }
 
   // show input image
   cv::Mat img = cv::Mat(64,64,CV_32FC1,input_data);
   cv::namedWindow( "Display window", cv::WINDOW_AUTOSIZE );// Create a window for display.
   cv::imshow( "Display window", img );                   // Show our image inside it.
   cv::waitKey(0);                                          // Wait for a keystroke in the window
 
   // run network
   std::vector<TensorType> inputVec{input};
   caffe2::Workspace ws;
   ws.RunNetOnce(init_net);
   ws.CreateNet(predict_net, true);
 
   for (auto i = 0; i < inputVec.size(); ++i)
   {
     auto* blob = ws.GetBlob(predict_net.external_input(i));
     TensorType* tensor = blob->template GetMutable<TensorType>();
     tensor->ResizeLike(inputVec[i]);
     tensor->ShareData(inputVec[i]);
   }
   CAFFE_ENFORCE(ws.RunNet(predict_net.name()));
 
   outputVec.resize(predict_net.external_output_size());
   for (auto i = 0; i < outputVec.size(); ++i)
   {
     auto* blob = ws.GetBlob(predict_net.external_output(i));
     outputVec[i] = blob->template GetMutable<TensorType>();
   }
 
 ////  auto predictor = caffe2::make_unique<caffe2::Predictor>(init_net, predict_net);
 ////  predictor->run(inputVec, &outputVec);
 
   // get ourput from network
   TensorType* output = outputVec[outputVec.size()];
 
   const float* output_data =  output->data<float>();
   cv::Mat out_img = cv::Mat(64,64,CV_32FC3,output->mutable_data<float>());
 
   cv::namedWindow( "Display window", cv::WINDOW_AUTOSIZE );// Create a window for display.
   cv::imshow( "Display window", out_img );                   // Show our image inside it.
   cv::waitKey(0);                                          // Wait for a keystroke in the window
 
 //// remainder of the classification test
 //  int max_class = -1;
 //  float max_prob = 0;
 //  for (int i=0; i<output->size(); i++)
 //  {
 //      if(output_data[i]>max_prob)
 //      {
 //          max_prob = output_data[i];
 //          max_class = i;
 //      }
 //  }
 //  MITK_INFO << "Class: " << max_class;
 //  MITK_INFO << "Probability: " << max_prob;
 
   return EXIT_SUCCESS;
 }
 
diff --git a/Modules/DiffusionImaging/DeepDiffusion/cmdapps/CaffeSegmentationTest.cpp b/Modules/DiffusionImaging/DeepDiffusion/cmdapps/CaffeSegmentationTest.cpp
index 75b62ad646..553d687d1b 100755
--- a/Modules/DiffusionImaging/DeepDiffusion/cmdapps/CaffeSegmentationTest.cpp
+++ b/Modules/DiffusionImaging/DeepDiffusion/cmdapps/CaffeSegmentationTest.cpp
@@ -1,123 +1,123 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkImageCast.h>
 #include <mitkITKImageImport.h>
 #include <mitkProperties.h>
 #include <mitkImage.h>
 #include <mitkIOUtil.h>
 #include <mitkCommandLineParser.h>
 #include <boost/lexical_cast.hpp>
 #include <random>
 
 // Caffe
 #include <caffe/caffe.hpp>
 #include <caffe/sgd_solvers.hpp>
 #include <caffe/layers/memory_data_layer.hpp>
 #include <memory>
 
 
 // OpenCV
 #include <opencv2/core/core.hpp>
 #include <opencv2/highgui/highgui.hpp>
 
 std::default_random_engine generator;
 std::normal_distribution<double> distribution(0.0,0.1);
 
 void predict(caffe::shared_ptr<caffe::Net<float>> network)
 {
   caffe::Blob<float>* input_layer = network->input_blobs()[0];
   float* input_data = input_layer->mutable_cpu_data();
 
   int counter = 0;
   for (int x = 0; x < input_layer->height(); x++)
       for (int y = 0; y < input_layer->width(); y++)
           for (int j = 0; j < input_layer->channels(); j++)
           {
             input_data[counter] = 0;
             if (x>20 && x<40 && y>20 && y<40)
                 input_data[counter] = 1;
             if (x>35 && x<55 && y>25 && y<45)
                 input_data[counter] = 2;
 
             if (x>2 && x<12 && y>45 && y<55)
                 input_data[counter] = 1;
 
             if (x>50 && x<60 && y>50 && y<60)
                 input_data[counter] = 1;
 
             input_data[counter] += distribution(generator);
 
             counter++;
           }
 
 //  // not necessary here
 //  input_layer->Reshape(1, num_channels, height, width);
 //  network->Reshape();
 
   network->Forward();
 
   cv::Mat input_img = cv::Mat(input_layer->height(), input_layer->width(), CV_32FC1, input_data) * 100;
   input_img.convertTo(input_img, CV_8UC1);
   cv::namedWindow( "Input", cv::WINDOW_NORMAL );
   cv::imshow( "Input", input_img );
 
   boost::shared_ptr<caffe::Blob<float> > output_layer = network->blob_by_name("argmax");
   cv::Mat out_img = cv::Mat(input_layer->height(), input_layer->width(), CV_32FC1, output_layer->mutable_cpu_data()) * 100;
   out_img.convertTo(out_img, CV_8UC1);
 
   cv::namedWindow( "Output", cv::WINDOW_NORMAL );
   cv::imshow( "Output", out_img );
   cv::waitKey(0);
 }
 
 /*!
 * \brief Segmentation example for Caffe in MITK
 *
 */
 int main(int argc, char* argv[])
 {
   caffe::Caffe::set_mode(caffe::Caffe::GPU);
 
   mitkCommandLineParser parser;
   parser.setTitle("CaffeTest");
-  parser.setCategory("Fiber Tracking and Processing Methods");
+  parser.setCategory("MITK Diffusion Deep Learning");
   parser.setContributor("MIC");
   parser.setDescription("Minimal example for Caffe usage in MITK");
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("network_file", "", mitkCommandLineParser::String, "network_file:", ".prototxt", us::Any());
   parser.addArgument("weights_file", "", mitkCommandLineParser::String, "weights_file:", ".caffemodel", us::Any());
 
 //  google::InitGoogleLogging(argv[0]);
 //  google::SetCommandLineOption("GLOG_minloglevel", "0");
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   std::string network_file = us::any_cast<std::string>(parsedArgs["network_file"]);
   std::string weights_file = us::any_cast<std::string>(parsedArgs["weights_file"]);
 
   caffe::shared_ptr<caffe::Net<float>> network;
   const std::vector<std::string> stages = {"deploy"};
   network.reset(new caffe::Net<float>(network_file, caffe::TEST, 0, &stages));
   network->CopyTrainedLayersFrom(weights_file);
 
   predict(network);
 
   return EXIT_SUCCESS;
 }
 
diff --git a/Modules/DiffusionImaging/DeepDiffusion/cmdapps/CaffeTest.cpp b/Modules/DiffusionImaging/DeepDiffusion/cmdapps/CaffeTest.cpp
index de1e99be15..ca4d4aba30 100755
--- a/Modules/DiffusionImaging/DeepDiffusion/cmdapps/CaffeTest.cpp
+++ b/Modules/DiffusionImaging/DeepDiffusion/cmdapps/CaffeTest.cpp
@@ -1,189 +1,189 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkImageCast.h>
 #include <mitkITKImageImport.h>
 #include <mitkProperties.h>
 #include <mitkImage.h>
 #include <mitkIOUtil.h>
 #include <mitkCommandLineParser.h>
 #include <boost/lexical_cast.hpp>
 #include <random>
 
 // Caffe
 #include <caffe/caffe.hpp>
 #include <caffe/sgd_solvers.hpp>
 #include <caffe/layers/memory_data_layer.hpp>
 #include <memory>
 
 
 // OpenCV
 #include <opencv2/core/core.hpp>
 #include <opencv2/highgui/highgui.hpp>
 
 caffe::shared_ptr<caffe::Net<float>> train(caffe::Solver<float>* solver)
 {
   int num_samples = 64;
   int num_features = 100;
   float *data = new float[1*1*num_features*num_samples];
   float *label = new float[1*1*1*num_samples];
   float *directions = new float[1*1*3*num_samples];
 
   caffe::MemoryDataLayer<float> *image_input_layer = (caffe::MemoryDataLayer<float> *) (solver->net()->layer_by_name("image_data").get());
   caffe::MemoryDataLayer<float> *target_input_layer = (caffe::MemoryDataLayer<float> *) (solver->net()->layer_by_name("target_data").get());
 
   image_input_layer->Reset(data, label, num_samples);
   target_input_layer->Reset(directions, label, num_samples);
   solver->Solve();
   return solver->net();
 }
 
 caffe::Solver<float>* read_solver(std::string solver_file)
 {
   caffe::SolverParameter solver_param;
   caffe::ReadSolverParamsFromTextFileOrDie(solver_file, &solver_param);
   return new caffe::AdamSolver<float>(solver_param);
 }
 
 std::default_random_engine generator;
 std::normal_distribution<double> distribution(0.0,0.1);
 
 void predict(caffe::shared_ptr<caffe::Net<float>> network)
 {
   caffe::Blob<float>* input_layer = network->input_blobs()[0];
   float* input_data = input_layer->mutable_cpu_data();
 
   int counter = 0;
   for (int x = 0; x < input_layer->height(); x++)
       for (int y = 0; y < input_layer->width(); y++)
           for (int j = 0; j < input_layer->channels(); j++)
           {
             input_data[counter] = 0;
             if (x>20 && x<40 && y>20 && y<40)
                 input_data[counter] = 1;
             if (x>35 && x<55 && y>25 && y<45)
                 input_data[counter] = 2;
 
             if (x>2 && x<12 && y>45 && y<55)
                 input_data[counter] = 1;
 
             if (x>50 && x<60 && y>50 && y<60)
                 input_data[counter] = 1;
 
             input_data[counter] += distribution(generator);
 
             counter++;
           }
 
   network->Forward();
 
   cv::Mat input_img = cv::Mat(input_layer->height(), input_layer->width(), CV_32FC1, input_data) * 100;
   input_img.convertTo(input_img, CV_8UC1);
   cv::namedWindow( "Input", cv::WINDOW_NORMAL );
   cv::imshow( "Input", input_img );
 
   boost::shared_ptr<caffe::Blob<float> > output_layer = network->blob_by_name("argmax");
   cv::Mat out_img = cv::Mat(input_layer->height(), input_layer->width(), CV_32FC1, output_layer->mutable_cpu_data()) * 100;
   out_img.convertTo(out_img, CV_8UC1);
 
   cv::namedWindow( "Output", cv::WINDOW_NORMAL );
   cv::imshow( "Output", out_img );
   cv::waitKey(0);
 }
 
 std::vector<float> predict_data_layer(const cv::Mat& img, caffe::shared_ptr<caffe::Net<float>> network) {
   caffe::Blob<float>* input_layer = network->input_blobs()[0];
 
   assert(img.channels() == input_layer->channels());
   assert(img.cols == input_layer->width());
   assert(img.rows == input_layer->height());
 
   cv::Mat img2;
   // convert to float
   if (img.channels()==3 && img.type()!=CV_32FC3)
       img.convertTo(img2, CV_32FC3);
   else if(img.channels()==1 && img.type()!=CV_32FC1)
       img.convertTo(img2, CV_32FC1);
 
   float* input_data = input_layer->mutable_cpu_data();  // pointer to the memory data layer
   std::vector<cv::Mat> bgr;
   for (int i = 0; i < img2.channels(); ++i) {
     cv::Mat channel(input_layer->height(), input_layer->width(), CV_32FC1, input_data);
     bgr.push_back(channel);
     input_data += input_layer->width() * input_layer->height();
   }
   cv::split(img2, bgr);
 
   network->Forward();
 
   /* Copy the output layer to a std::vector */
   caffe::Blob<float>* output_layer = network->output_blobs()[0];
   const float* begin = output_layer->cpu_data();
   const float* end = begin + output_layer->channels();
   return std::vector<float>(begin, end);
 }
 
 /*!
 * \brief Segmentation example for Caffe in MITK
 *
 */
 int main(int argc, char* argv[])
 {
   caffe::Caffe::set_mode(caffe::Caffe::GPU);
 
   mitkCommandLineParser parser;
   parser.setTitle("CaffeTest");
-  parser.setCategory("Fiber Tracking and Processing Methods");
+  parser.setCategory("MITK Diffusion Deep Learning");
   parser.setContributor("MIC");
   parser.setDescription("Minimal example for Caffe usage in MITK");
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("image", "", mitkCommandLineParser::String, "image:", "", us::Any());
   parser.addArgument("solver_file", "", mitkCommandLineParser::String, "solver_file:", "the caffe solver file (.prototxt)", us::Any());
   parser.addArgument("network_file", "", mitkCommandLineParser::String, "network_file:", ".prototxt", us::Any());
   parser.addArgument("weights_file", "", mitkCommandLineParser::String, "weights_file:", ".caffemodel", us::Any());
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   std::string image_filename = us::any_cast<std::string>(parsedArgs["image"]);
   cv::Mat img = cv::imread(image_filename, CV_LOAD_IMAGE_GRAYSCALE);
 //  cv::namedWindow( "Display window", cv::WINDOW_AUTOSIZE );// Create a window for display.
 //  cv::imshow( "Display window", img );                   // Show our image inside it.
 //  cv::waitKey(0);                                          // Wait for a keystroke in the window
 
   //// TRAINING
 //  std::string solver_file = us::any_cast<std::string>(parsedArgs["solver_file"]);
 //  caffe::Solver<float>* solver = read_solver(solver_file);
 //  caffe::shared_ptr<caffe::Net<float>> trained_net = train(solver);
 //  const float* test_output = test(trained_net);
 
   std::string network_file = us::any_cast<std::string>(parsedArgs["network_file"]);
   std::string weights_file = us::any_cast<std::string>(parsedArgs["weights_file"]);
 
   caffe::shared_ptr<caffe::Net<float>> network;
   const std::vector<std::string> stages = {"deploy"};
   network.reset(new caffe::Net<float>(network_file, caffe::TEST, 0, &stages));
   network->CopyTrainedLayersFrom(weights_file);
 
   MITK_INFO << "predicting";
   predict(network);
   MITK_INFO << "DONE";
 
 
   return EXIT_SUCCESS;
 }
 
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/Sift2WeightCopy.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/Sift2WeightCopy.cpp
index 182039cdeb..266285afae 100644
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/Sift2WeightCopy.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/Sift2WeightCopy.cpp
@@ -1,108 +1,108 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <vector>
 #include <iostream>
 #include <fstream>
 #include <algorithm>
 #include <string>
 #include <istream>
 
 #include <itkImageFileWriter.h>
 #include <itkMetaDataObject.h>
 #include <itkVectorImage.h>
 #include <mitkImageCast.h>
 
 #include <mitkBaseData.h>
 #include <mitkFiberBundle.h>
 #include "mitkCommandLineParser.h"
 #include <boost/lexical_cast.hpp>
 #include <mitkCoreObjectFactory.h>
 #include <mitkIOUtil.h>
 #include <itkTractDensityImageFilter.h>
 #include <itkTractsToFiberEndingsImageFilter.h>
 
 
 mitk::FiberBundle::Pointer LoadFib(std::string filename)
 {
     std::vector<mitk::BaseData::Pointer> fibInfile = mitk::IOUtil::Load(filename);
     if( fibInfile.empty() )
         std::cout << "File " << filename << " could not be read!";
     mitk::BaseData::Pointer baseData = fibInfile.at(0);
     return dynamic_cast<mitk::FiberBundle*>(baseData.GetPointer());
 }
 
 /*!
 \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", 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(int i = 0; i != weights.size(); i++) {
           fib->SetFiberWeight(i, weights[i]);
         }
 
         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;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/Fiberfox/Fiberfox.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/Fiberfox/Fiberfox.cpp
index 4a321e1761..644de8bf95 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/Fiberfox/Fiberfox.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/Fiberfox/Fiberfox.cpp
@@ -1,214 +1,214 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkImageCast.h>
 #include <mitkITKImageImport.h>
 #include <mitkProperties.h>
 #include <mitkImage.h>
 #include <mitkIOUtil.h>
 #include <mitkFiberBundle.h>
 #include <mitkFiberfoxParameters.h>
 #include "mitkCommandLineParser.h"
 
 #include <itkTractsToDWIImageFilter.h>
 #include <boost/lexical_cast.hpp>
 #include <mitkPreferenceListReaderOptionsFunctor.h>
 #include <itksys/SystemTools.hxx>
 
 using namespace mitk;
 
 /*!
 * \brief Command line interface to Fiberfox.
 * Simulate a diffusion-weighted image from a tractogram using the specified parameter file.
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
   parser.setTitle("Fiberfox");
-  parser.setCategory("Fiber Tracking and Processing Methods");
+  parser.setCategory("Diffusion Simulation Tools");
   parser.setContributor("MIC");
   parser.setDescription("Command line interface to Fiberfox."
                         " Simulate a diffusion-weighted image from a tractogram using the specified parameter file.");
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("out", "o", mitkCommandLineParser::OutputFile, "Output root:",
                      "output root", us::Any(), false);
   parser.addArgument("parameters", "p", mitkCommandLineParser::InputFile, "Parameter file:",
                      "fiberfox parameter file (.ffp)", us::Any(), false);
   parser.addArgument("input", "i", mitkCommandLineParser::String, "Input:",
                      "Input tractogram or diffusion-weighted image.", us::Any(), false);
   parser.addArgument("verbose", "v", mitkCommandLineParser::Bool, "Output additional images:",
                      "output volume fraction images etc.", us::Any());
 
   map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
   {
     return EXIT_FAILURE;
   }
   string outName = us::any_cast<string>(parsedArgs["out"]);
   string paramName = us::any_cast<string>(parsedArgs["parameters"]);
 
   string input="";
   if (parsedArgs.count("input"))
   {
     input = us::any_cast<string>(parsedArgs["input"]);
   }
   bool verbose = false;
   if (parsedArgs.count("verbose"))
   {
     verbose = us::any_cast<bool>(parsedArgs["verbose"]);
   }
   FiberfoxParameters<double> parameters;
   parameters.LoadParameters(paramName);
 
   // Test if /path/dir is an existing directory:
   string file_extension = "";
   if( itksys::SystemTools::FileIsDirectory( outName ) )
   {
     while( *(--(outName.cend())) == '/')
     {
       outName.pop_back();
     }
     outName = outName + '/';
     parameters.m_Misc.m_OutputPath = outName;
     outName = outName + parameters.m_Misc.m_OutputPrefix; // using default m_OutputPrefix as initialized.
   }
   else
   {
     // outName is NOT an existing directory, so we need to remove all trailing slashes:
     while( *(--(outName.cend())) == '/')
     {
       outName.pop_back();
     }
 
     // now split up the given outName into directory and (prefix of) filename:
     if( ! itksys::SystemTools::GetFilenamePath( outName ).empty()
         && itksys::SystemTools::FileIsDirectory(itksys::SystemTools::GetFilenamePath( outName ) ) )
     {
       parameters.m_Misc.m_OutputPath = itksys::SystemTools::GetFilenamePath( outName ) + '/';
     }
     else
     {
       parameters.m_Misc.m_OutputPath = itksys::SystemTools::GetCurrentWorkingDirectory() + '/';
     }
 
     file_extension = itksys::SystemTools::GetFilenameExtension(outName);
     if( ! itksys::SystemTools::GetFilenameWithoutExtension( outName ).empty() )
     {
       parameters.m_Misc.m_OutputPrefix = itksys::SystemTools::GetFilenameWithoutExtension( outName );
     }
     else
     {
       parameters.m_Misc.m_OutputPrefix = "fiberfox";
     }
 
     outName = parameters.m_Misc.m_OutputPath + parameters.m_Misc.m_OutputPrefix;
   }
 
   // check if log file already exists and avoid overwriting existing files:
   std::string NameTest = outName;
   int c = 0;
   while( itksys::SystemTools::FileExists( outName + ".log" )
          && c <= std::numeric_limits<int>::max() )
   {
     outName = NameTest + "_" + boost::lexical_cast<std::string>(c);
     ++c;
   }
 
   if (verbose)
   {
     MITK_DEBUG << outName << ".ffp";
     parameters.SaveParameters(outName+".ffp");
   }
 
   mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Diffusion Weighted Images", "Fiberbundles"}, {});
   mitk::BaseData::Pointer inputData = mitk::IOUtil::Load(input, &functor)[0];
 
   itk::TractsToDWIImageFilter< short >::Pointer tractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
 
   if ( dynamic_cast<mitk::FiberBundle*>(inputData.GetPointer()) )   // simulate dataset from fibers
   {
     tractsToDwiFilter->SetFiberBundle(dynamic_cast<mitk::FiberBundle*>(inputData.GetPointer()));
   }
   else if ( dynamic_cast<mitk::Image*>(inputData.GetPointer()) )  // add artifacts to existing image
   {
     typedef itk::VectorImage< short, 3 >    ItkDwiType;
     mitk::Image::Pointer diffImg = dynamic_cast<mitk::Image*>(inputData.GetPointer());
     ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
     mitk::CastToItkImage(diffImg, itkVectorImagePointer);
 
     parameters.m_SignalGen.m_SignalScale = 1;
     parameters.m_SignalGen.m_ImageRegion = itkVectorImagePointer->GetLargestPossibleRegion();
     parameters.m_SignalGen.m_ImageSpacing = itkVectorImagePointer->GetSpacing();
     parameters.m_SignalGen.m_ImageOrigin = itkVectorImagePointer->GetOrigin();
     parameters.m_SignalGen.m_ImageDirection = itkVectorImagePointer->GetDirection();
     parameters.m_SignalGen.m_Bvalue = static_cast<mitk::FloatProperty*>
         (diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
         ->GetValue();
     parameters.m_SignalGen.SetGradienDirections( static_cast<mitk::GradientDirectionsProperty*>
         ( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
         ->GetGradientDirectionsContainer() );
 
     tractsToDwiFilter->SetInputImage(itkVectorImagePointer);
   }
   tractsToDwiFilter->SetParameters(parameters);
   tractsToDwiFilter->Update();
 
   mitk::Image::Pointer image = mitk::GrabItkImageMemory( tractsToDwiFilter->GetOutput() );
   image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(),
                       mitk::GradientDirectionsProperty::New( parameters.m_SignalGen.GetGradientDirections() ) );
   image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(),
                       mitk::FloatProperty::New( parameters.m_SignalGen.m_Bvalue ) );
   mitk::DiffusionPropertyHelper propertyHelper( image );
   propertyHelper.InitializeImage();
 
   if (file_extension=="")
     mitk::IOUtil::Save(image, "application/vnd.mitk.nii.gz", outName+".nii.gz");
   else if (file_extension==".nii" || file_extension==".nii.gz")
     mitk::IOUtil::Save(image, "application/vnd.mitk.nii.gz", outName+file_extension);
   else
     mitk::IOUtil::Save(image, outName+file_extension);
 
   if (verbose)
   {
     std::vector< itk::TractsToDWIImageFilter< short >::ItkDoubleImgType::Pointer > volumeFractions = tractsToDwiFilter->GetVolumeFractions();
     for (unsigned int k=0; k<volumeFractions.size(); k++)
     {
       mitk::Image::Pointer image = mitk::Image::New();
       image->InitializeByItk(volumeFractions.at(k).GetPointer());
       image->SetVolume(volumeFractions.at(k)->GetBufferPointer());
       mitk::IOUtil::Save(image, outName+"_Compartment"+boost::lexical_cast<string>(k+1)+".nrrd");
     }
 
     if (tractsToDwiFilter->GetPhaseImage().IsNotNull())
     {
       mitk::Image::Pointer image = mitk::Image::New();
       itk::TractsToDWIImageFilter< short >::DoubleDwiType::Pointer itkPhase = tractsToDwiFilter->GetPhaseImage();
       image = mitk::GrabItkImageMemory( itkPhase.GetPointer() );
       mitk::IOUtil::Save(image, outName+"_Phase.nrrd");
     }
 
     if (tractsToDwiFilter->GetKspaceImage().IsNotNull())
     {
       mitk::Image::Pointer image = mitk::Image::New();
       itk::TractsToDWIImageFilter< short >::DoubleDwiType::Pointer itkImage = tractsToDwiFilter->GetKspaceImage();
       image = mitk::GrabItkImageMemory( itkImage.GetPointer() );
       mitk::IOUtil::Save(image, outName+"_kSpace.nrrd");
     }
   }
 
   return EXIT_SUCCESS;
 }
 
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/Misc/FileFormatConverter.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/Misc/FileFormatConverter.cpp
index b08f5921d6..d5a405a5d2 100644
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/Misc/FileFormatConverter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/Misc/FileFormatConverter.cpp
@@ -1,83 +1,83 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkImageCast.h>
 #include <mitkImage.h>
 #include <mitkIOUtil.h>
 #include "mitkCommandLineParser.h"
 #include <mitkPreferenceListReaderOptionsFunctor.h>
 #include <mitkFiberBundle.h>
 
 using namespace mitk;
 using namespace std;
 
 /*!
 \brief Load image and save as specified file type.
 */
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
 
     parser.setTitle("Format Converter");
-    parser.setCategory("Fiber Tracking and Processing Methods");
+    parser.setCategory("Preprocessing Tools");
     parser.setDescription("Load image and save as specified file type.");
     parser.setContributor("MIC");
 
     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);
 
     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"]);
 
     try
     {
         mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Diffusion Weighted Images"}, {});
         std::vector<mitk::BaseData::Pointer> baseData = mitk::IOUtil::Load(inName, &functor);
 
         if ( baseData.size()>0 && dynamic_cast<Image*>(baseData[0].GetPointer()) )
         {
             mitk::IOUtil::Save(dynamic_cast<Image*>(baseData[0].GetPointer()), outName.c_str());
         }
         else if ( baseData.size()>0 && dynamic_cast<FiberBundle*>(baseData[0].GetPointer()) )
         {
             mitk::IOUtil::Save(dynamic_cast<FiberBundle*>(baseData[0].GetPointer()) ,outName.c_str());
         }
         else
             std::cout << "File type currently not supported!";
     }
     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;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/LocalDirectionalFiberPlausibility.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/LocalDirectionalFiberPlausibility.cpp
index c18dc2ce66..a659842e8b 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/LocalDirectionalFiberPlausibility.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/LocalDirectionalFiberPlausibility.cpp
@@ -1,320 +1,320 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkBaseData.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <itkEvaluateDirectionImagesFilter.h>
 #include <metaCommand.h>
 #include "mitkCommandLineParser.h"
 #include <itkTractsToVectorImageFilter.h>
 #include <usAny.h>
 #include <itkImageFileWriter.h>
 #include <mitkIOUtil.h>
 #include <boost/lexical_cast.hpp>
 #include <iostream>
 #include <fstream>
 #include <itksys/SystemTools.hxx>
 #include <mitkCoreObjectFactory.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 using namespace std;
 
 /*!
 \brief Calculate angular error of a tractogram with respect to the input reference directions.
 */
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
 
     parser.setTitle("Local Directional Fiber Plausibility");
-    parser.setCategory("Fiber Tracking and Processing Methods");
+    parser.setCategory("Fiber Tracking Evaluation");
     parser.setDescription("Calculate angular error of a tractogram with respect to the input reference directions.");
     parser.setContributor("MIC");
 
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input tractogram (.fib, vtk ascii file format)", us::Any(), false);
     parser.addArgument("reference", "r", mitkCommandLineParser::StringList, "Reference images:", "reference direction images", us::Any(), false);
     parser.addArgument("out", "o", mitkCommandLineParser::OutputDirectory, "Output:", "output root", us::Any(), false);
     parser.addArgument("mask", "m", mitkCommandLineParser::StringList, "Masks:", "mask images");
     parser.addArgument("athresh", "a", mitkCommandLineParser::Float, "Angular threshold:", "angular threshold in degrees. closer fiber directions are regarded as one direction and clustered together.", 25, true);
     parser.addArgument("sthresh", "s", mitkCommandLineParser::Float, "Size threshold:", "Relative peak size threshold per voxel.", 0.0, true);
     parser.addArgument("maxdirs", "md", mitkCommandLineParser::Int, "Max. Clusters:", "Maximum number of fiber clusters.", 0, true);
     parser.addArgument("verbose", "v", mitkCommandLineParser::Bool, "Verbose:", "output optional and intermediate calculation results");
     parser.addArgument("ignore", "n", mitkCommandLineParser::Bool, "Ignore:", "don't increase error for missing or too many directions");
     parser.addArgument("empty", "e", mitkCommandLineParser::Bool, "Empty Voxels:", "don't increase error for empty voxels");
     parser.addArgument("fileID", "id", mitkCommandLineParser::String, "ID:", "optional ID field");
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     mitkCommandLineParser::StringContainerType referenceImages = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["reference"]);
     mitkCommandLineParser::StringContainerType maskImages;
     if (parsedArgs.count("mask"))
         maskImages = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["mask"]);
 
     string fibFile = us::any_cast<string>(parsedArgs["input"]);
 
     float angularThreshold = 25;
     if (parsedArgs.count("athresh"))
         angularThreshold = us::any_cast<float>(parsedArgs["athresh"]);
 
     float sizeThreshold = 0;
     if (parsedArgs.count("sthresh"))
         sizeThreshold = us::any_cast<float>(parsedArgs["sthresh"]);
 
     int maxDirs = 0;
     if (parsedArgs.count("maxdirs"))
         maxDirs = us::any_cast<int>(parsedArgs["maxdirs"]);
 
     string outRoot = us::any_cast<string>(parsedArgs["out"]);
 
     bool verbose = false;
     if (parsedArgs.count("verbose"))
         verbose = us::any_cast<bool>(parsedArgs["verbose"]);
 
     bool ignoreMissing = false;
     if (parsedArgs.count("ignore"))
         ignoreMissing = us::any_cast<bool>(parsedArgs["ignore"]);
 
     bool ignoreEmpty = false;
     if (parsedArgs.count("empty"))
         ignoreEmpty = us::any_cast<bool>(parsedArgs["empty"]);
 
     string fileID = "";
     if (parsedArgs.count("fileID"))
         fileID = us::any_cast<string>(parsedArgs["fileID"]);
 
 
     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::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(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(...){ std::cout << "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->SetSizeThreshold(sizeThreshold);
         fOdfFilter->SetMaxNumDirections(maxDirs);
         fOdfFilter->Update();
 
         if (verbose)
         {
             // write vector field
             mitk::FiberBundle::Pointer directions = fOdfFilter->GetOutputFiberBundle();
 
             string outfilename = outRoot;
             outfilename.append("_VECTOR_FIELD.fib");
 
             mitk::IOUtil::SaveBaseData(directions.GetPointer(), outfilename );
 
             // write direction images
             {
                 itk::TractsToVectorImageFilter<float>::ItkDirectionImageType::Pointer itkImg = fOdfFilter->GetDirectionImage();
                 typedef itk::ImageFileWriter< itk::TractsToVectorImageFilter<float>::ItkDirectionImageType > WriterType;
                 WriterType::Pointer writer = WriterType::New();
 
                 string outfilename = outRoot;
                 outfilename.append("_DIRECTIONS.nrrd");
 
                 writer->SetFileName(outfilename.c_str());
                 writer->SetInput(itkImg);
                 writer->Update();
             }
 
             // write num direction image
             {
                 ItkUcharImgType::Pointer numDirImage = fOdfFilter->GetNumDirectionsImage();
                 typedef itk::ImageFileWriter< ItkUcharImgType > WriterType;
                 WriterType::Pointer writer = WriterType::New();
 
                 string outfilename = outRoot;
                 outfilename.append("_NUM_DIRECTIONS.nrrd");
 
                 writer->SetFileName(outfilename.c_str());
                 writer->SetInput(numDirImage);
                 writer->Update();
             }
         }
 
         string logFile = outRoot;
         logFile.append("_ANGULAR_ERROR.csv");
         ofstream file;
         file.open (logFile.c_str());
 
         if (maskImages.size()>0)
         {
             for (unsigned int i=0; i<maskImages.size(); i++)
             {
                 mitk::Image::Pointer mitkMaskImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(maskImages.at(i))->GetData());
                 mitk::CastToItkImage(mitkMaskImage, itkMaskImage);
 
                 // evaluate directions
                 EvaluationFilterType::Pointer evaluationFilter = EvaluationFilterType::New();
                 //evaluationFilter->SetImageSet(directionImageContainer);
                 evaluationFilter->SetReferenceImageSet(referenceImageContainer);
                 evaluationFilter->SetMaskImage(itkMaskImage);
                 evaluationFilter->SetIgnoreMissingDirections(ignoreMissing);
                 evaluationFilter->SetIgnoreEmptyVoxels(ignoreEmpty);
                 evaluationFilter->Update();
 
                 if (verbose)
                 {
                     EvaluationFilterType::OutputImageType::Pointer angularErrorImage = evaluationFilter->GetOutput(0);
                     typedef itk::ImageFileWriter< EvaluationFilterType::OutputImageType > WriterType;
                     WriterType::Pointer writer = WriterType::New();
 
                     string outfilename = outRoot;
                     outfilename.append("_ERROR_IMAGE.nrrd");
 
                     writer->SetFileName(outfilename.c_str());
                     writer->SetInput(angularErrorImage);
                     writer->Update();
                 }
 
                 string maskFileName = itksys::SystemTools::GetFilenameWithoutExtension(maskImages.at(i));
                 unsigned found = maskFileName.find_last_of("_");
 
                 string sens = itksys::SystemTools::GetFilenameWithoutLastExtension(fibFile);
                 if (!fileID.empty())
                     sens = fileID;
                 sens.append(",");
 
                 sens.append(maskFileName.substr(found+1));
                 sens.append(",");
 
                 sens.append(boost::lexical_cast<string>(evaluationFilter->GetMeanAngularError()));
                 sens.append(",");
 
                 sens.append(boost::lexical_cast<string>(evaluationFilter->GetMedianAngularError()));
                 sens.append(",");
 
                 sens.append(boost::lexical_cast<string>(evaluationFilter->GetMaxAngularError()));
                 sens.append(",");
 
                 sens.append(boost::lexical_cast<string>(evaluationFilter->GetMinAngularError()));
                 sens.append(",");
 
                 sens.append(boost::lexical_cast<string>(std::sqrt(evaluationFilter->GetVarAngularError())));
                 sens.append(";\n");
                 file << sens;
             }
         }
         else
         {
             // evaluate directions
             EvaluationFilterType::Pointer evaluationFilter = EvaluationFilterType::New();
             //evaluationFilter->SetImageSet(directionImageContainer);
             evaluationFilter->SetReferenceImageSet(referenceImageContainer);
             evaluationFilter->SetMaskImage(itkMaskImage);
             evaluationFilter->SetIgnoreMissingDirections(ignoreMissing);
             evaluationFilter->SetIgnoreEmptyVoxels(ignoreEmpty);
             evaluationFilter->Update();
 
             if (verbose)
             {
                 EvaluationFilterType::OutputImageType::Pointer angularErrorImage = evaluationFilter->GetOutput(0);
                 typedef itk::ImageFileWriter< EvaluationFilterType::OutputImageType > WriterType;
                 WriterType::Pointer writer = WriterType::New();
 
                 string outfilename = outRoot;
                 outfilename.append("_ERROR_IMAGE.nrrd");
 
                 writer->SetFileName(outfilename.c_str());
                 writer->SetInput(angularErrorImage);
                 writer->Update();
             }
 
             string sens = itksys::SystemTools::GetFilenameWithoutLastExtension(fibFile);
             if (!fileID.empty())
                 sens = fileID;
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(evaluationFilter->GetMeanAngularError()));
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(evaluationFilter->GetMedianAngularError()));
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(evaluationFilter->GetMaxAngularError()));
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(evaluationFilter->GetMinAngularError()));
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(std::sqrt(evaluationFilter->GetVarAngularError())));
             sens.append(";\n");
             file << sens;
         }
         file.close();
     }
     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;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/PeaksAngularError.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/PeaksAngularError.cpp
index c422e8a4a9..14d1bb6fa7 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/PeaksAngularError.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/PeaksAngularError.cpp
@@ -1,209 +1,209 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkBaseData.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <itkEvaluateDirectionImagesFilter.h>
 #include <metaCommand.h>
 #include "mitkCommandLineParser.h"
 #include <itkTractsToVectorImageFilter.h>
 #include <usAny.h>
 #include <itkImageFileWriter.h>
 #include <mitkIOUtil.h>
 #include <boost/lexical_cast.hpp>
 #include <iostream>
 #include <fstream>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 using namespace std;
 
 /*!
 \brief Calculate angular error between two sets of directions stored in multiple 3D vector images where each pixel corresponds to a vector (itk::Image< itk::Vector< float, 3>, 3 >)
 */
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("test", "t", mitkCommandLineParser::StringList, "Test images", "test direction images", us::Any(), false);
     parser.addArgument("reference", "r", mitkCommandLineParser::StringList, "Reference images", "reference direction images", us::Any(), false);
     parser.addArgument("out", "o", mitkCommandLineParser::OutputDirectory, "Output directory", "output root", us::Any(), false);
     parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Mask", "mask image");
     parser.addArgument("verbose", "v", mitkCommandLineParser::Bool, "Verbose", "output optional and intermediate calculation results");
     parser.addArgument("ignore", "i", mitkCommandLineParser::Bool, "Ignore", "don't increase error for missing or too many directions");
 
-    parser.setCategory("Preprocessing Tools");
+    parser.setCategory("Fiber Tracking Evaluation");
     parser.setTitle("Peaks Angular Error");
     parser.setDescription("Calculate angular error between two sets of directions stored in multiple 3D vector images where each pixel corresponds to a vector (itk::Image< itk::Vector< float, 3>, 3 >)");
     parser.setContributor("MIC");
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     mitkCommandLineParser::StringContainerType testImages = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["test"]);
     mitkCommandLineParser::StringContainerType referenceImages = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["reference"]);
 
     string maskImage("");
     if (parsedArgs.count("mask"))
         maskImage = us::any_cast<string>(parsedArgs["mask"]);
 
     string outRoot = us::any_cast<string>(parsedArgs["out"]);
 
     bool verbose = false;
     if (parsedArgs.count("verbose"))
         verbose = us::any_cast<bool>(parsedArgs["verbose"]);
 
     bool ignore = false;
     if (parsedArgs.count("ignore"))
         ignore = us::any_cast<bool>(parsedArgs["ignore"]);
 
     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;
 
         ItkDirectionImageContainerType::Pointer directionImageContainer = ItkDirectionImageContainerType::New();
         for (unsigned int i=0; i<testImages.size(); i++)
         {
             try
             {
                 mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(testImages.at(i))->GetData());
                 typedef mitk::ImageToItk< ItkDirectionImage3DType > CasterType;
                 CasterType::Pointer caster = CasterType::New();
                 caster->SetInput(img);
                 caster->Update();
                 ItkDirectionImage3DType::Pointer itkImg = caster->GetOutput();
                 directionImageContainer->InsertElement(directionImageContainer->Size(),itkImg);
             }
             catch(...){ std::cout << "could not load: " << referenceImages.at(i); }
         }
 
         // 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(...){ std::cout << "could not load: " << referenceImages.at(i); }
         }
 
         // load/create mask image
         ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
         if (maskImage.compare("")==0)
         {
             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);
         }
         else
         {
             mitk::Image::Pointer mitkMaskImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(maskImage)->GetData());
             mitk::CastToItkImage(mitkMaskImage, itkMaskImage);
         }
 
         // evaluate directions
         EvaluationFilterType::Pointer evaluationFilter = EvaluationFilterType::New();
         evaluationFilter->SetImageSet(directionImageContainer);
         evaluationFilter->SetReferenceImageSet(referenceImageContainer);
         evaluationFilter->SetMaskImage(itkMaskImage);
         evaluationFilter->SetIgnoreMissingDirections(ignore);
         evaluationFilter->Update();
 
         if (verbose)
         {
             EvaluationFilterType::OutputImageType::Pointer angularErrorImage = evaluationFilter->GetOutput(0);
             typedef itk::ImageFileWriter< EvaluationFilterType::OutputImageType > WriterType;
             WriterType::Pointer writer = WriterType::New();
 
             string outfilename = outRoot;
             outfilename.append("_ERROR_IMAGE.nrrd");
 
             writer->SetFileName(outfilename.c_str());
             writer->SetInput(angularErrorImage);
             writer->Update();
         }
 
         string logFile = outRoot;
         logFile.append("_ANGULAR_ERROR.csv");
 
         ofstream file;
         file.open (logFile.c_str());
 
         string sens = "Mean:";
         sens.append(",");
         sens.append(boost::lexical_cast<string>(evaluationFilter->GetMeanAngularError()));
         sens.append(";\n");
 
         sens.append("Median:");
         sens.append(",");
         sens.append(boost::lexical_cast<string>(evaluationFilter->GetMedianAngularError()));
         sens.append(";\n");
 
         sens.append("Maximum:");
         sens.append(",");
         sens.append(boost::lexical_cast<string>(evaluationFilter->GetMaxAngularError()));
         sens.append(";\n");
 
         sens.append("Minimum:");
         sens.append(",");
         sens.append(boost::lexical_cast<string>(evaluationFilter->GetMinAngularError()));
         sens.append(";\n");
 
         sens.append("STDEV:");
         sens.append(",");
         sens.append(boost::lexical_cast<string>(std::sqrt(evaluationFilter->GetVarAngularError())));
         sens.append(";\n");
 
         file << sens;
 
         file.close();
     }
     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;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/TractometerMetrics.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/TractometerMetrics.cpp
index 169b1f1588..303a218b5f 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/TractometerMetrics.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/TractometerMetrics.cpp
@@ -1,418 +1,418 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkBaseData.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <itkEvaluateDirectionImagesFilter.h>
 #include <metaCommand.h>
 #include "mitkCommandLineParser.h"
 #include <itkTractsToVectorImageFilter.h>
 #include <usAny.h>
 #include <itkImageFileWriter.h>
 #include <mitkIOUtil.h>
 #include <boost/lexical_cast.hpp>
 #include <iostream>
 #include <fstream>
 #include <itksys/SystemTools.hxx>
 #include <mitkCoreObjectFactory.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 using namespace std;
 
 /*!
 \brief Calculates the Tractometer evaluation metrics for tractograms (http://www.tractometer.org/)
 */
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
 
     parser.setTitle("Tractometer Metrics");
-    parser.setCategory("Fiber Tracking and Processing Methods");
+    parser.setCategory("Fiber Tracking Evaluation");
     parser.setDescription("Calculates the Tractometer evaluation metrics for tractograms (http://www.tractometer.org/)");
     parser.setContributor("MIC");
 
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input tractogram (.fib, vtk ascii file format)", us::Any(), false);
     parser.addArgument("out", "o", mitkCommandLineParser::OutputDirectory, "Output:", "output root", us::Any(), false);
     parser.addArgument("labels", "l", mitkCommandLineParser::StringList, "Label pairs:", "label pairs", false);
     parser.addArgument("labelimage", "li", mitkCommandLineParser::String, "Label image:", "label image", false);
     parser.addArgument("verbose", "v", mitkCommandLineParser::Bool, "Verbose:", "output valid, invalid and no connections as fiber bundles");
     parser.addArgument("fileID", "id", mitkCommandLineParser::String, "ID:", "optional ID field");
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     mitkCommandLineParser::StringContainerType labelpairs = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["labels"]);
 
     string fibFile = us::any_cast<string>(parsedArgs["input"]);
     string labelImageFile = us::any_cast<string>(parsedArgs["labelimage"]);
 
     string outRoot = us::any_cast<string>(parsedArgs["out"]);
 
     string fileID = "";
     if (parsedArgs.count("fileID"))
         fileID = us::any_cast<string>(parsedArgs["fileID"]);
 
     bool verbose = false;
     if (parsedArgs.count("verbose"))
         verbose = us::any_cast<bool>(parsedArgs["verbose"]);
 
     try
     {
         typedef itk::Image<short, 3>    ItkShortImgType;
         typedef itk::Image<unsigned char, 3>    ItkUcharImgType;
 
         // load fiber bundle
         mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
 
         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(labelImageFile)->GetData());
         typedef mitk::ImageToItk< ItkShortImgType > CasterType;
         CasterType::Pointer caster = CasterType::New();
         caster->SetInput(img);
         caster->Update();
         ItkShortImgType::Pointer labelImage = caster->GetOutput();
 
         string path = itksys::SystemTools::GetFilenamePath(labelImageFile);
 
         std::vector< bool > detected;
         std::vector< std::pair< int, int > > labelsvector;
         std::vector< ItkUcharImgType::Pointer > bundleMasks;
         std::vector< ItkUcharImgType::Pointer > bundleMasksCoverage;
         short max = 0;
         for (unsigned int i=0; i<labelpairs.size()-1; i+=2)
         {
             std::pair< short, short > l;
             l.first = boost::lexical_cast<short>(labelpairs.at(i));
             l.second = boost::lexical_cast<short>(labelpairs.at(i+1));
             std::cout << labelpairs.at(i);
             std::cout << labelpairs.at(i+1);
             if (l.first>max)
                 max=l.first;
             if (l.second>max)
                 max=l.second;
 
             labelsvector.push_back(l);
             detected.push_back(false);
 
             {
                 mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(path+"/Bundle"+boost::lexical_cast<string>(labelsvector.size())+"_MASK.nrrd")->GetData());
                 typedef mitk::ImageToItk< ItkUcharImgType > CasterType;
                 CasterType::Pointer caster = CasterType::New();
                 caster->SetInput(img);
                 caster->Update();
                 ItkUcharImgType::Pointer bundle = caster->GetOutput();
                 bundleMasks.push_back(bundle);
             }
 
             {
                 mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(path+"/Bundle"+boost::lexical_cast<string>(labelsvector.size())+"_MASK_COVERAGE.nrrd")->GetData());
                 typedef mitk::ImageToItk< ItkUcharImgType > CasterType;
                 CasterType::Pointer caster = CasterType::New();
                 caster->SetInput(img);
                 caster->Update();
                 ItkUcharImgType::Pointer bundle = caster->GetOutput();
                 bundleMasksCoverage.push_back(bundle);
             }
         }
         vnl_matrix< unsigned char > matrix; matrix.set_size(max, max); matrix.fill(0);
 
         vtkSmartPointer<vtkPolyData> polyData = inputTractogram->GetFiberPolyData();
 
         int validConnections = 0;
         int noConnection = 0;
         int validBundles = 0;
         int invalidBundles = 0;
         int invalidConnections = 0;
 
         ItkUcharImgType::Pointer coverage = ItkUcharImgType::New();
         coverage->SetSpacing(labelImage->GetSpacing());
         coverage->SetOrigin(labelImage->GetOrigin());
         coverage->SetDirection(labelImage->GetDirection());
         coverage->SetLargestPossibleRegion(labelImage->GetLargestPossibleRegion());
         coverage->SetBufferedRegion( labelImage->GetLargestPossibleRegion() );
         coverage->SetRequestedRegion( labelImage->GetLargestPossibleRegion() );
         coverage->Allocate();
         coverage->FillBuffer(0);
 
         vtkSmartPointer<vtkPoints> noConnPoints = vtkSmartPointer<vtkPoints>::New();
         vtkSmartPointer<vtkCellArray> noConnCells = vtkSmartPointer<vtkCellArray>::New();
 
         vtkSmartPointer<vtkPoints> invalidPoints = vtkSmartPointer<vtkPoints>::New();
         vtkSmartPointer<vtkCellArray> invalidCells = vtkSmartPointer<vtkCellArray>::New();
 
         vtkSmartPointer<vtkPoints> validPoints = vtkSmartPointer<vtkPoints>::New();
         vtkSmartPointer<vtkCellArray> validCells = vtkSmartPointer<vtkCellArray>::New();
 
         boost::progress_display disp(inputTractogram->GetNumFibers());
         for (int i=0; i<inputTractogram->GetNumFibers(); i++)
         {
             ++disp;
 
             vtkCell* cell = polyData->GetCell(i);
             int numPoints = cell->GetNumberOfPoints();
             vtkPoints* points = cell->GetPoints();
 
 
             if (numPoints>1)
             {
                 double* start = points->GetPoint(0);
                 itk::Point<float, 3> itkStart;
                 itkStart[0] = start[0]; itkStart[1] = start[1]; itkStart[2] = start[2];
                 itk::Index<3> idxStart;
                 labelImage->TransformPhysicalPointToIndex(itkStart, idxStart);
 
                 double* end = points->GetPoint(numPoints-1);
                 itk::Point<float, 3> itkEnd;
                 itkEnd[0] = end[0]; itkEnd[1] = end[1]; itkEnd[2] = end[2];
                 itk::Index<3> idxEnd;
                 labelImage->TransformPhysicalPointToIndex(itkEnd, idxEnd);
 
 
                 if ( labelImage->GetPixel(idxStart)==0 || labelImage->GetPixel(idxEnd)==0 )
                 {
                     noConnection++;
 
                     if (verbose)
                     {
                         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
                         for (int j=0; j<numPoints; j++)
                         {
                             double* p = points->GetPoint(j);
                             vtkIdType id = noConnPoints->InsertNextPoint(p);
                             container->GetPointIds()->InsertNextId(id);
                         }
                         noConnCells->InsertNextCell(container);
                     }
                 }
                 else
                 {
                     bool invalid = true;
                     for (unsigned int i=0; i<labelsvector.size(); i++)
                     {
                         bool outside = false;
                         ItkUcharImgType::Pointer bundle = bundleMasks.at(i);
                         std::pair< short, short > l = labelsvector.at(i);
                         if ( (labelImage->GetPixel(idxStart)==l.first && labelImage->GetPixel(idxEnd)==l.second) ||
                              (labelImage->GetPixel(idxStart)==l.second && labelImage->GetPixel(idxEnd)==l.first) )
                         {
                             for (int j=0; j<numPoints; j++)
                             {
                                 double* p = points->GetPoint(j);
 
                                 itk::Point<float, 3> itkP;
                                 itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
                                 itk::Index<3> idx;
                                 bundle->TransformPhysicalPointToIndex(itkP, idx);
 
                                 if ( !bundle->GetPixel(idx)>0 && bundle->GetLargestPossibleRegion().IsInside(idx) )
                                 {
                                     outside=true;
                                 }
                             }
 
                             if (!outside)
                             {
                                 validConnections++;
                                 if (detected.at(i)==false)
                                     validBundles++;
                                 detected.at(i) = true;
                                 invalid = false;
 
 
                                 vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
                                 for (int j=0; j<numPoints; j++)
                                 {
                                     double* p = points->GetPoint(j);
                                     vtkIdType id = validPoints->InsertNextPoint(p);
                                     container->GetPointIds()->InsertNextId(id);
 
                                     itk::Point<float, 3> itkP;
                                     itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
                                     itk::Index<3> idx;
                                     coverage->TransformPhysicalPointToIndex(itkP, idx);
                                     if ( coverage->GetLargestPossibleRegion().IsInside(idx) )
                                         coverage->SetPixel(idx, 1);
                                 }
                                 validCells->InsertNextCell(container);
                             }
                             break;
                         }
                     }
                     if (invalid==true)
                     {
                         invalidConnections++;
                         int x = labelImage->GetPixel(idxStart)-1;
                         int y = labelImage->GetPixel(idxEnd)-1;
                         if (x>=0 && y>0 && x<matrix.cols() && y<matrix.rows() && (matrix[x][y]==0 || matrix[y][x]==0) )
                         {
                             invalidBundles++;
                             matrix[x][y]=1;
                             matrix[y][x]=1;
                         }
 
                         if (verbose)
                         {
                             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
                             for (int j=0; j<numPoints; j++)
                             {
                                 double* p = points->GetPoint(j);
                                 vtkIdType id = invalidPoints->InsertNextPoint(p);
                                 container->GetPointIds()->InsertNextId(id);
                             }
                             invalidCells->InsertNextCell(container);
                         }
                     }
                 }
             }
         }
 
         if (verbose)
         {
             mitk::CoreObjectFactory::FileWriterList fileWriters = mitk::CoreObjectFactory::GetInstance()->GetFileWriters();
             vtkSmartPointer<vtkPolyData> noConnPolyData = vtkSmartPointer<vtkPolyData>::New();
             noConnPolyData->SetPoints(noConnPoints);
             noConnPolyData->SetLines(noConnCells);
             mitk::FiberBundle::Pointer noConnFib = mitk::FiberBundle::New(noConnPolyData);
 
             string ncfilename = outRoot;
             ncfilename.append("_NC.fib");
 
             mitk::IOUtil::SaveBaseData(noConnFib.GetPointer(), ncfilename );
 
             vtkSmartPointer<vtkPolyData> invalidPolyData = vtkSmartPointer<vtkPolyData>::New();
             invalidPolyData->SetPoints(invalidPoints);
             invalidPolyData->SetLines(invalidCells);
             mitk::FiberBundle::Pointer invalidFib = mitk::FiberBundle::New(invalidPolyData);
 
             string icfilename = outRoot;
             icfilename.append("_IC.fib");
 
             mitk::IOUtil::SaveBaseData(invalidFib.GetPointer(), icfilename );
 
             vtkSmartPointer<vtkPolyData> validPolyData = vtkSmartPointer<vtkPolyData>::New();
             validPolyData->SetPoints(validPoints);
             validPolyData->SetLines(validCells);
             mitk::FiberBundle::Pointer validFib = mitk::FiberBundle::New(validPolyData);
 
             string vcfilename = outRoot;
             vcfilename.append("_VC.fib");
 
             mitk::IOUtil::SaveBaseData(validFib.GetPointer(), vcfilename );
 
             {
                 typedef itk::ImageFileWriter< ItkUcharImgType > WriterType;
                 WriterType::Pointer writer = WriterType::New();
                 writer->SetFileName(outRoot+"_ABC.nrrd");
                 writer->SetInput(coverage);
                 writer->Update();
             }
         }
 
         // calculate coverage
         int wmVoxels = 0;
         int coveredVoxels = 0;
         itk::ImageRegionIterator<ItkUcharImgType> it (coverage, coverage->GetLargestPossibleRegion());
         while(!it.IsAtEnd())
         {
             bool wm = false;
             for (unsigned int i=0; i<bundleMasksCoverage.size(); i++)
             {
                 ItkUcharImgType::Pointer bundle = bundleMasksCoverage.at(i);
                 if (bundle->GetPixel(it.GetIndex())>0)
                 {
                     wm = true;
                     wmVoxels++;
                     break;
                 }
             }
             if (wm && it.Get()>0)
                 coveredVoxels++;
             ++it;
         }
 
         int numFibers = inputTractogram->GetNumFibers();
         double nc = (double)noConnection/numFibers;
         double vc = (double)validConnections/numFibers;
         double ic = (double)invalidConnections/numFibers;
         if (numFibers==0)
         {
             nc = 0.0;
             vc = 0.0;
             ic = 0.0;
         }
         int vb = validBundles;
         int ib = invalidBundles;
         double abc = (double)coveredVoxels/wmVoxels;
 
         std::cout << "NC: " << nc;
         std::cout << "VC: " << vc;
         std::cout << "IC: " << ic;
         std::cout << "VB: " << vb;
         std::cout << "IB: " << ib;
         std::cout << "ABC: " << abc;
 
         string logFile = outRoot;
         logFile.append("_TRACTOMETER.csv");
         ofstream file;
         file.open (logFile.c_str());
         {
             string sens = itksys::SystemTools::GetFilenameWithoutLastExtension(fibFile);
             if (!fileID.empty())
                 sens = fileID;
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(nc));
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(vc));
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(ic));
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(validBundles));
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(invalidBundles));
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(abc));
             sens.append(";\n");
             file << sens;
         }
         file.close();
     }
     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;
 }
diff --git a/Modules/DiffusionImaging/Quantification/cmdapps/DiffusionKurtosisFit.cpp b/Modules/DiffusionImaging/Quantification/cmdapps/DiffusionKurtosisFit.cpp
index 363498ee22..9850df25b7 100644
--- a/Modules/DiffusionImaging/Quantification/cmdapps/DiffusionKurtosisFit.cpp
+++ b/Modules/DiffusionImaging/Quantification/cmdapps/DiffusionKurtosisFit.cpp
@@ -1,254 +1,254 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkCommandLineParser.h"
 #include <mitkIOUtil.h>
 #include <mitkDiffusionPropertyHelper.h>
 
 #include <mitkImageCaster.h>
 #include <itkDiffusionKurtosisReconstructionImageFilter.h>
 
 #include "mitkImage.h"
 #include <iostream>
 #include <usAny.h>
 #include <fstream>
 #include "mitkIOUtil.h"
 
 #include <itkFileTools.h>
 #include <itksys/SystemTools.hxx>
 
 
 //vnl_includes
 #include "vnl/vnl_math.h"
 #include "vnl/vnl_cost_function.h"
 #include "vnl/vnl_least_squares_function.h"
 #include "vnl/algo/vnl_lbfgsb.h"
 #include "vnl/algo/vnl_lbfgs.h"
 
 #include "vnl/algo/vnl_levenberg_marquardt.h"
 
 typedef mitk::DiffusionPropertyHelper DPH;
 
 #include <itkGaussianBlurImageFunction.h>
 #include <itkUnaryFunctorImageFilter.h>
 
 #include <itkImageFileWriter.h>
 
 #include <itkVectorIndexSelectionCastImageFilter.h>
 #include <itkComposeImageFilter.h>
 #include <itkDiscreteGaussianImageFilter.h>
 #include <mitkPreferenceListReaderOptionsFunctor.h>
 
 
 DPH::ImageType::Pointer GetBlurredVectorImage( DPH::ImageType::Pointer vectorImage, double sigma)
 {
   typedef itk::DiscreteGaussianImageFilter< itk::Image<DPH::DiffusionPixelType, 3 >, itk::Image<DPH::DiffusionPixelType, 3 > > GaussianFilterType;
 
   typedef itk::VectorIndexSelectionCastImageFilter< DPH::ImageType, itk::Image<DPH::DiffusionPixelType, 3 > > IndexSelectionType;
   IndexSelectionType::Pointer indexSelectionFilter = IndexSelectionType::New();
   indexSelectionFilter->SetInput( vectorImage );
 
   typedef itk::ComposeImageFilter< itk::Image<DPH::DiffusionPixelType, 3>, DPH::ImageType > ComposeFilterType;
   ComposeFilterType::Pointer vec_composer = ComposeFilterType::New();
 
   for( unsigned int i=0; i<vectorImage->GetVectorLength(); ++i)
   {
     GaussianFilterType::Pointer gaussian_filter = GaussianFilterType::New();
 
     indexSelectionFilter->SetIndex( i );
 
     gaussian_filter->SetInput( indexSelectionFilter->GetOutput() );
     gaussian_filter->SetVariance( sigma );
 
     vec_composer->SetInput(i, gaussian_filter->GetOutput() );
 
     gaussian_filter->Update();
   }
 
   try
   {
     vec_composer->Update();
   }
   catch(const itk::ExceptionObject &e)
   {
     mitkThrow() << "[VectorImage.GaussianSmoothing] !! Failed with ITK Exception: " << e.what();
   }
 
   DPH::ImageType::Pointer smoothed_vector = vec_composer->GetOutput();
 
   /*
   itk::ImageFileWriter< DPH::ImageType >::Pointer writer =
       itk::ImageFileWriter< DPH::ImageType >::New();
 
   writer->SetInput( smoothed_vector );
   writer->SetFileName( "/tmp/itk_smoothed_vector.nrrd");
   writer->Update();*/
 
   return smoothed_vector;
 
 
 }
 
 void KurtosisMapComputation( mitk::Image::Pointer input,
                              std::string output_prefix ,
                              std::string output_type,
                              std::string maskPath,
                              bool omitBZero,
                              double lower,
                              double upper )
 {
   DPH::ImageType::Pointer vectorImage = DPH::ImageType::New();
   mitk::CastToItkImage( input, vectorImage );
 
   typedef itk::DiffusionKurtosisReconstructionImageFilter< short, double > KurtosisFilterType;
   KurtosisFilterType::Pointer kurtosis_filter = KurtosisFilterType::New();
   kurtosis_filter->SetInput( GetBlurredVectorImage( vectorImage, 1.5 ) );
   kurtosis_filter->SetReferenceBValue( DPH::GetReferenceBValue( input.GetPointer() ) );
   kurtosis_filter->SetGradientDirections( DPH::GetGradientContainer( input.GetPointer() ) );
 //  kurtosis_filter->SetNumberOfThreads(1);
   kurtosis_filter->SetOmitUnweightedValue(omitBZero);
   kurtosis_filter->SetBoundariesForKurtosis(-lower,upper);
 //  kurtosis_filter->SetInitialSolution(const vnl_vector<double>& x0 );
 
 
   if(maskPath != "")
   {
     mitk::Image::Pointer segmentation;
     segmentation = mitk::IOUtil::LoadImage(maskPath);
     typedef itk::Image< short , 3>            MaskImageType;
     MaskImageType::Pointer vectorSeg = MaskImageType::New() ;
     mitk::CastToItkImage( segmentation, vectorSeg );
     kurtosis_filter->SetImageMask(vectorSeg) ;
   }
 
   try
   {
     kurtosis_filter->Update();
   }
   catch( const itk::ExceptionObject& e)
   {
     mitkThrow() << "Kurtosis fit failed with an ITK Exception: " << e.what();
   }
 
   mitk::Image::Pointer d_image = mitk::Image::New();
   d_image->InitializeByItk( kurtosis_filter->GetOutput(0) );
   d_image->SetVolume( kurtosis_filter->GetOutput(0)->GetBufferPointer() );
 
   mitk::Image::Pointer k_image = mitk::Image::New();
   k_image->InitializeByItk( kurtosis_filter->GetOutput(1) );
   k_image->SetVolume( kurtosis_filter->GetOutput(1)->GetBufferPointer() );
 
   std::string outputD_FileName = output_prefix + "_ADC_map." + output_type;
   std::string outputK_FileName = output_prefix + "_AKC_map." + output_type;
 
   try
   {
     mitk::IOUtil::Save(  d_image,  outputD_FileName );
     mitk::IOUtil::Save(  k_image,  outputK_FileName );
   }
   catch( const itk::ExceptionObject& e)
   {
     mitkThrow() << "Failed to save the KurtosisFit Results due to exception: " << e.what();
   }
 
 }
 
 int main( int argc, char* argv[] )
 {
 
   mitkCommandLineParser parser;
 
   parser.setTitle("Diffusion Kurtosis Fit");
-  parser.setCategory("Signal Reconstruction");
+  parser.setCategory("Diffusion Related Measures");
   parser.setContributor("MIC");
   parser.setDescription("Fitting Kurtosis");
   parser.setArgumentPrefix("--","-");
 
   // mandatory arguments
   parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input: ", "input image (DWI)", us::Any(), false);
   parser.addArgument("output", "o", mitkCommandLineParser::String, "Output Preifx: ", "Prefix for the output images, will append _f, _K, _D accordingly ", us::Any(), false);
   parser.addArgument("output_type", "ot", mitkCommandLineParser::String, "Output Type: ", "choose data type of output image, e.g. '.nii' or '.nrrd' ", us::Any(), false);
 
   // optional arguments
   parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Masking Image: ", "ROI (segmentation)", us::Any());
   parser.addArgument("help", "h", mitkCommandLineParser::Bool, "Help", "Show this help text");
   parser.addArgument("omitbzero", "om", mitkCommandLineParser::Bool, "Omit b0:", "Omit b0 value during fit (default = false)", us::Any());
   parser.addArgument("lowerkbound", "kl", mitkCommandLineParser::Float, "lower Kbound:", "Set (unsigned) lower boundary for Kurtosis parameter (default = -1000)", us::Any());
   parser.addArgument("upperkbound", "ku", mitkCommandLineParser::Float, "upper Kbound:", "Set upper boundary for Kurtosis parameter (default = 1000)", us::Any());
 
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
 
   if (parsedArgs.size()==0 || parsedArgs.count("help") || parsedArgs.count("h")){
     std::cout << parser.helpText();
     return EXIT_SUCCESS;
   }
 
   // mandatory arguments
   std::string inFileName = us::any_cast<std::string>(parsedArgs["input"]);
   std::string out_prefix = us::any_cast<std::string>(parsedArgs["output"]);
   std::string maskPath = "";
 
   mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Diffusion Weighted Images"}, {});
   mitk::Image::Pointer inputImage = mitk::IOUtil::LoadImage(inFileName, &functor);
 
   bool omitBZero = false;
   double lower = -1000;
   double upper = 1000;
   std::string  out_type = "nrrd";
 
   if (parsedArgs.count("mask") || parsedArgs.count("m"))
   {
     maskPath = us::any_cast<std::string>(parsedArgs["mask"]);
   }
 
   if (parsedArgs.count("output_type") || parsedArgs.count("ot"))
   {
     out_type = us::any_cast<std::string>(parsedArgs["output_type"]);
   }
 
   if (parsedArgs.count("omitbzero") || parsedArgs.count("om"))
   {
     omitBZero = us::any_cast<bool>(parsedArgs["omitbzero"]);
   }
 
   if (parsedArgs.count("lowerkbound") || parsedArgs.count("kl"))
   {
     lower = us::any_cast<float>(parsedArgs["lowerkbound"]);
   }
 
   if (parsedArgs.count("upperkbound") || parsedArgs.count("ku"))
   {
     upper = us::any_cast<float>(parsedArgs["upperkbound"]);
   }
 
   if( !DPH::IsDiffusionWeightedImage( inputImage ) )
   {
     MITK_ERROR("DiffusionIVIMFit.Input") << "No valid diffusion-weighted image provided, failed to load " << inFileName << " as DW Image. Aborting...";
     return EXIT_FAILURE;
   }
 
 
 
 KurtosisMapComputation( inputImage,
                         out_prefix ,
                         out_type,
                         maskPath,
                         omitBZero,
                         lower,
                         upper);
 
 }
diff --git a/Modules/DiffusionImaging/Quantification/cmdapps/QballReconstruction.cpp b/Modules/DiffusionImaging/Quantification/cmdapps/QballReconstruction.cpp
index 462e09df84..942573a283 100644
--- a/Modules/DiffusionImaging/Quantification/cmdapps/QballReconstruction.cpp
+++ b/Modules/DiffusionImaging/Quantification/cmdapps/QballReconstruction.cpp
@@ -1,263 +1,263 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkCoreObjectFactory.h>
 #include "mitkImage.h"
 #include "itkAnalyticalDiffusionQballReconstructionImageFilter.h"
 #include <boost/lexical_cast.hpp>
 #include "mitkCommandLineParser.h"
 #include <mitkIOUtil.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkDiffusionPropertyHelper.h>
 #include <mitkITKImageImport.h>
 #include <mitkImageCast.h>
 #include <mitkProperties.h>
 #include <mitkIOUtil.h>
 
 using namespace mitk;
 using namespace std;
 
 /**
  * Perform Q-ball reconstruction using a spherical harmonics basis
  */
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input file", "input raw dwi (.dwi or .fsl/.fslgz)", us::Any(), false);
     parser.addArgument("outFile", "o", mitkCommandLineParser::OutputFile, "Output file", "output file", us::Any(), false);
     parser.addArgument("shOrder", "sh", mitkCommandLineParser::Int, "Spherical harmonics order", "spherical harmonics order", 4, true);
     parser.addArgument("b0Threshold", "t", mitkCommandLineParser::Int, "b0 threshold", "baseline image intensity threshold", 0, true);
     parser.addArgument("lambda", "r", mitkCommandLineParser::Float, "Lambda", "ragularization factor lambda", 0.006, true);
     parser.addArgument("csa", "csa", mitkCommandLineParser::Bool, "Constant solid angle consideration", "use constant solid angle consideration");
     parser.addArgument("outputCoeffs", "shc", mitkCommandLineParser::Bool, "Output coefficients", "output file containing the SH coefficients");
     parser.addArgument("mrtrix", "mb", mitkCommandLineParser::Bool, "MRtrix", "use MRtrix compatible spherical harmonics definition");
 
-    parser.setCategory("Preprocessing Tools");
+    parser.setCategory("Signal Modelling");
     parser.setTitle("Qball Reconstruction");
     parser.setDescription("");
     parser.setContributor("MIC");
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     std::string inFileName = us::any_cast<string>(parsedArgs["input"]);
     std::string outfilename = us::any_cast<string>(parsedArgs["outFile"]);
     outfilename = itksys::SystemTools::GetFilenamePath(outfilename)+"/"+itksys::SystemTools::GetFilenameWithoutExtension(outfilename);
 
     int threshold = 0;
     if (parsedArgs.count("b0Threshold"))
         threshold = us::any_cast<int>(parsedArgs["b0Threshold"]);
 
     int shOrder = 4;
     if (parsedArgs.count("shOrder"))
         shOrder = us::any_cast<int>(parsedArgs["shOrder"]);
 
     float lambda = 0.006;
     if (parsedArgs.count("lambda"))
         lambda = us::any_cast<float>(parsedArgs["lambda"]);
 
     int normalization = 0;
     if (parsedArgs.count("csa") && us::any_cast<bool>(parsedArgs["csa"]))
         normalization = 6;
 
     bool outCoeffs = false;
     if (parsedArgs.count("outputCoeffs"))
         outCoeffs = us::any_cast<bool>(parsedArgs["outputCoeffs"]);
 
     bool mrTrix = false;
     if (parsedArgs.count("mrtrix"))
         mrTrix = us::any_cast<bool>(parsedArgs["mrtrix"]);
 
     try
     {
         std::vector<BaseData::Pointer> infile = mitk::IOUtil::Load(inFileName);
         Image::Pointer dwi = dynamic_cast<Image*>(infile.at(0).GetPointer());
         mitk::DiffusionPropertyHelper propertyHelper(dwi);
         propertyHelper.AverageRedundantGradients(0.001);
         propertyHelper.InitializeImage();
 
         mitk::QBallImage::Pointer image = mitk::QBallImage::New();
         mitk::Image::Pointer coeffsImage = mitk::Image::New();
 
         std::cout << "SH order: " << shOrder;
         std::cout << "lambda: " << lambda;
         std::cout << "B0 threshold: " << threshold;
         switch ( shOrder )
         {
         case 4:
         {
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,QBALL_ODFSIZE> FilterType;
             mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
             mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
             FilterType::Pointer filter = FilterType::New();
             filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
             filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
             filter->SetThreshold( threshold );
             filter->SetLambda(lambda);
             filter->SetUseMrtrixBasis(mrTrix);
             if (normalization==0)
                 filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
             else
                 filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
             filter->Update();
             image->InitializeByItk( filter->GetOutput() );
             image->SetVolume( filter->GetOutput()->GetBufferPointer() );
             coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
             coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
             break;
         }
         case 6:
         {
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,6,QBALL_ODFSIZE> FilterType;
             mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
             mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
             FilterType::Pointer filter = FilterType::New();
             filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
             filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
             filter->SetThreshold( threshold );
             filter->SetLambda(lambda);
             filter->SetUseMrtrixBasis(mrTrix);
             if (normalization==0)
                 filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
             else
                 filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
             filter->Update();
             image->InitializeByItk( filter->GetOutput() );
             image->SetVolume( filter->GetOutput()->GetBufferPointer() );
             coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
             coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
             break;
         }
         case 8:
         {
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,8,QBALL_ODFSIZE> FilterType;
             mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
             mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
             FilterType::Pointer filter = FilterType::New();
             filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
             filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
             filter->SetThreshold( threshold );
             filter->SetLambda(lambda);
             filter->SetUseMrtrixBasis(mrTrix);
             if (normalization==0)
                 filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
             else
                 filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
             filter->Update();
             image->InitializeByItk( filter->GetOutput() );
             image->SetVolume( filter->GetOutput()->GetBufferPointer() );
             coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
             coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
             break;
         }
         case 10:
         {
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,10,QBALL_ODFSIZE> FilterType;
             mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
             mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
             FilterType::Pointer filter = FilterType::New();
             filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
             filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
             filter->SetThreshold( threshold );
             filter->SetLambda(lambda);
             filter->SetUseMrtrixBasis(mrTrix);
             if (normalization==0)
                 filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
             else
                 filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
             filter->Update();
             image->InitializeByItk( filter->GetOutput() );
             image->SetVolume( filter->GetOutput()->GetBufferPointer() );
             coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
             coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
             break;
         }
         case 12:
         {
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,12,QBALL_ODFSIZE> FilterType;
             mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
             mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
             FilterType::Pointer filter = FilterType::New();
             filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
             filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
             filter->SetThreshold( threshold );
             filter->SetLambda(lambda);
             if (normalization==0)
                 filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
             else
                 filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
             filter->Update();
             image->InitializeByItk( filter->GetOutput() );
             image->SetVolume( filter->GetOutput()->GetBufferPointer() );
             coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
             coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
             break;
         }
         default:
         {
             std::cout << "Supplied SH order not supported. Using default order of 4.";
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,QBALL_ODFSIZE> FilterType;
             mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
             mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
             FilterType::Pointer filter = FilterType::New();
             filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
             filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
             filter->SetThreshold( threshold );
             filter->SetLambda(lambda);
             filter->SetUseMrtrixBasis(mrTrix);
             if (normalization==0)
                 filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
             else
                 filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
             filter->Update();
             image->InitializeByItk( filter->GetOutput() );
             image->SetVolume( filter->GetOutput()->GetBufferPointer() );
             coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
             coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
         }
         }
 
         std::string coeffout = outfilename;
         coeffout += "_shcoeffs.nrrd";
 
         outfilename += ".qbi";
         mitk::IOUtil::SaveBaseData(image, outfilename);
 
         if (outCoeffs)
             mitk::IOUtil::SaveImage(coeffsImage, coeffout);
     }
     catch ( itk::ExceptionObject &err)
     {
         std::cout << "Exception: " << err;
     }
     catch ( std::exception err)
     {
         std::cout << "Exception: " << err.what();
     }
     catch ( ... )
     {
         std::cout << "Exception!";
     }
     return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/Quantification/cmdapps/TensorReconstruction.cpp b/Modules/DiffusionImaging/Quantification/cmdapps/TensorReconstruction.cpp
index 51b3e521ec..e30f0aa811 100644
--- a/Modules/DiffusionImaging/Quantification/cmdapps/TensorReconstruction.cpp
+++ b/Modules/DiffusionImaging/Quantification/cmdapps/TensorReconstruction.cpp
@@ -1,101 +1,101 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkImage.h"
 #include <mitkImageCast.h>
 #include "mitkBaseData.h"
 #include <mitkDiffusionPropertyHelper.h>
 
 #include <itkDiffusionTensor3DReconstructionImageFilter.h>
 #include <itkDiffusionTensor3D.h>
 #include <itkImageFileWriter.h>
 #include <itkNrrdImageIO.h>
 #include "mitkCommandLineParser.h"
 #include <itksys/SystemTools.hxx>
 #include <mitkIOUtil.h>
 
 using namespace mitk;
 using namespace std;
 /**
  * Convert files from one ending to the other
  */
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input file", "input raw dwi (.dwi or .fsl/.fslgz)", us::Any(), false);
     parser.addArgument("outFile", "o", mitkCommandLineParser::OutputFile, "Output file", "output file", us::Any(), false);
     parser.addArgument("b0Threshold", "t", mitkCommandLineParser::Int, "b0 threshold", "baseline image intensity threshold", 0, true);
 
-    parser.setCategory("Preprocessing Tools");
+    parser.setCategory("Signal Modelling");
     parser.setTitle("Tensor Reconstruction");
     parser.setDescription("");
     parser.setContributor("MIC");
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     std::string inFileName = us::any_cast<string>(parsedArgs["input"]);
     std::string outfilename = us::any_cast<string>(parsedArgs["outFile"]);
     outfilename = itksys::SystemTools::GetFilenamePath(outfilename)+"/"+itksys::SystemTools::GetFilenameWithoutExtension(outfilename);
     outfilename += ".dti";
 
     int threshold = 0;
     if (parsedArgs.count("b0Threshold"))
         threshold = us::any_cast<int>(parsedArgs["b0Threshold"]);
 
     try
     {
         Image::Pointer dwi = IOUtil::LoadImage(inFileName);
 
         mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
         mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
         typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, float > TensorReconstructionImageFilterType;
         TensorReconstructionImageFilterType::Pointer filter = TensorReconstructionImageFilterType::New();
         filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
         filter->SetBValue( mitk::DiffusionPropertyHelper::GetReferenceBValue( dwi ));
         filter->SetThreshold(threshold);
         filter->Update();
 
         // Save tensor image
         itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
         io->SetFileType( itk::ImageIOBase::Binary );
         io->UseCompressionOn();
 
         itk::ImageFileWriter< itk::Image< itk::DiffusionTensor3D< float >, 3 > >::Pointer writer = itk::ImageFileWriter< itk::Image< itk::DiffusionTensor3D< float >, 3 > >::New();
         writer->SetInput(filter->GetOutput());
         writer->SetFileName(outfilename);
         writer->SetImageIO(io);
         writer->UseCompressionOn();
         writer->Update();
     }
     catch ( itk::ExceptionObject &err)
     {
         std::cout << "Exception: " << err;
     }
     catch ( std::exception err)
     {
         std::cout << "Exception: " << err.what();
     }
     catch ( ... )
     {
         std::cout << "Exception!";
     }
     return EXIT_SUCCESS;
 
 }