diff --git a/Modules/CommandLine/src/mitkCommandLineParser.cpp b/Modules/CommandLine/src/mitkCommandLineParser.cpp
index 3d7ebad13f..d6b1ea79b6 100644
--- a/Modules/CommandLine/src/mitkCommandLineParser.cpp
+++ b/Modules/CommandLine/src/mitkCommandLineParser.cpp
@@ -1,996 +1,1050 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 /*=========================================================================
 
   Library:   CTK
 
   Copyright (c) Kitware Inc.
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
       http://www.apache.org/licenses/LICENSE-2.0.txt
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 
 =========================================================================*/
 
 // STL includes
 #include <iostream>
 #include <stdexcept>
 
 // MITK includes
 #include "mitkCommandLineParser.h"
 
 using namespace std;
 
 namespace
 {
   // --------------------------------------------------------------------------
   class CommandLineParserArgumentDescription
   {
   public:
     CommandLineParserArgumentDescription(const string &longArg,
                                          const string &longArgPrefix,
                                          const string &shortArg,
                                          const string &shortArgPrefix,
                                          mitkCommandLineParser::Type type,
                                          const string &argHelp,
                                          const string &argLabel,
                                          const us::Any &defaultValue,
                                          bool ignoreRest,
                                          bool deprecated,
                                          bool optional,
                                          string &argGroup,
                                          string &groupDescription)
       : LongArg(longArg),
         LongArgPrefix(longArgPrefix),
         ShortArg(shortArg),
         ShortArgPrefix(shortArgPrefix),
         ArgHelp(argHelp),
         ArgLabel(argLabel),
         ArgGroup(argGroup),
         ArgGroupDescription(groupDescription),
         IgnoreRest(ignoreRest),
         NumberOfParametersToProcess(0),
         Deprecated(deprecated),
         Optional(optional),
         DefaultValue(defaultValue),
         Value(type),
         ValueType(type)
     {
       Value = defaultValue;
 
       switch (type)
       {
         case mitkCommandLineParser::String:
         {
           NumberOfParametersToProcess = 1;
         }
         break;
         case mitkCommandLineParser::Bool:
         {
           NumberOfParametersToProcess = 0;
         }
         break;
         case mitkCommandLineParser::StringList:
         {
           NumberOfParametersToProcess = -1;
         }
         break;
         case mitkCommandLineParser::Int:
         {
           NumberOfParametersToProcess = 1;
         }
         break;
         case mitkCommandLineParser::Float:
         {
           NumberOfParametersToProcess = 1;
         }
         break;
 
         case mitkCommandLineParser::OutputDirectory:
         case mitkCommandLineParser::InputDirectory:
         {
           NumberOfParametersToProcess = 1;
         }
         break;
 
         case mitkCommandLineParser::OutputFile:
         case mitkCommandLineParser::InputFile:
         {
           NumberOfParametersToProcess = 1;
         }
         break;
         case mitkCommandLineParser::InputImage:
         {
           NumberOfParametersToProcess = 1;
         }
         break;
 
         default:
           std::cout << "Type not supported: " << static_cast<int>(type);
       }
     }
 
     ~CommandLineParserArgumentDescription() {}
     bool addParameter(const string &value);
 
     string helpText();
 
     string LongArg;
     string LongArgPrefix;
     string ShortArg;
     string ShortArgPrefix;
     string ArgHelp;
     string ArgLabel;
     string ArgGroup;
     string ArgGroupDescription;
     bool IgnoreRest;
     int NumberOfParametersToProcess;
     bool Deprecated;
     bool Optional;
 
     us::Any DefaultValue;
     us::Any Value;
     mitkCommandLineParser::Type ValueType;
   };
 
   // --------------------------------------------------------------------------
   bool CommandLineParserArgumentDescription::addParameter(const string &value)
   {
     switch (ValueType)
     {
       case mitkCommandLineParser::String:
       {
         Value = value;
       }
       break;
       case mitkCommandLineParser::Bool:
       {
         if (value.compare("true") == 0)
           Value = true;
         else
           Value = false;
       }
       break;
       case mitkCommandLineParser::StringList:
       {
         try
         {
           mitkCommandLineParser::StringContainerType list =
             us::any_cast<mitkCommandLineParser::StringContainerType>(Value);
           list.push_back(value);
           Value = list;
         }
         catch (...)
         {
           mitkCommandLineParser::StringContainerType list;
           list.push_back(value);
           Value = list;
         }
       }
       break;
       case mitkCommandLineParser::Int:
       {
         stringstream ss(value);
         int i;
         ss >> i;
         Value = i;
       }
       break;
       case mitkCommandLineParser::Float:
       {
         stringstream ss(value);
         float f;
         ss >> f;
         Value = f;
       }
       break;
 
       case mitkCommandLineParser::InputDirectory:
       case mitkCommandLineParser::OutputDirectory:
       {
         Value = value;
       }
       break;
 
       case mitkCommandLineParser::InputFile:
       case mitkCommandLineParser::InputImage:
       case mitkCommandLineParser::OutputFile:
       {
         Value = value;
       }
       break;
 
       default:
         return false;
     }
 
     return true;
   }
 
   // --------------------------------------------------------------------------
   string CommandLineParserArgumentDescription::helpText()
   {
     string text;
 
     string shortAndLongArg;
     if (!this->ShortArg.empty())
     {
       shortAndLongArg = "  ";
       shortAndLongArg += this->ShortArgPrefix;
       shortAndLongArg += this->ShortArg;
     }
 
     if (!this->LongArg.empty())
     {
       if (this->ShortArg.empty())
         shortAndLongArg.append("  ");
       else
         shortAndLongArg.append(", ");
 
       shortAndLongArg += this->LongArgPrefix;
       shortAndLongArg += this->LongArg;
     }
 
     text = text + shortAndLongArg + ", " + this->ArgHelp;
 
     if (this->Optional)
       text += " (optional)";
 
     if (!this->DefaultValue.Empty())
     {
       text = text + ", (default: " + this->DefaultValue.ToString() + ")";
     }
+    string value_type = "Unknown";
+    switch (this->ValueType)
+    {
+    case 0:
+    {
+      value_type = "String";
+      break;
+    }
+    case 1:
+    {
+      value_type = "Bool";
+      break;
+    }
+    case 2:
+    {
+      value_type = "StringList";
+      break;
+    }
+    case 3:
+    {
+      value_type = "Int";
+      break;
+    }
+    case 4:
+    {
+      value_type = "Float";
+      break;
+    }
+    case 5:
+    {
+      value_type = "InputDirectory";
+      break;
+    }
+    case 6:
+    {
+      value_type = "InputFile";
+      break;
+    }
+    case 7:
+    {
+      value_type = "OutputDirectory";
+      break;
+    }
+    case 8:
+    {
+      value_type = "OutputFile";
+      break;
+    }
+    case 9:
+    {
+      value_type = "InputImage";
+    }
+    }
+    text = text + ", Type: " + value_type;
     text += "\n";
     return text;
   }
 }
 
 // --------------------------------------------------------------------------
 // ctkCommandLineParser::ctkInternal class
 
 // --------------------------------------------------------------------------
 class mitkCommandLineParser::ctkInternal
 {
 public:
   ctkInternal() : Debug(false), FieldWidth(0), StrictMode(false) {}
   ~ctkInternal() {}
   CommandLineParserArgumentDescription *argumentDescription(const string &argument);
 
   vector<CommandLineParserArgumentDescription *> ArgumentDescriptionList;
   map<string, CommandLineParserArgumentDescription *> ArgNameToArgumentDescriptionMap;
   map<string, vector<CommandLineParserArgumentDescription *>> GroupToArgumentDescriptionListMap;
 
   StringContainerType UnparsedArguments;
   StringContainerType ProcessedArguments;
   string ErrorString;
   bool Debug;
   string::size_type FieldWidth;
   string LongPrefix;
   string ShortPrefix;
   string CurrentGroup;
   string DisableQSettingsLongArg;
   string DisableQSettingsShortArg;
   bool StrictMode;
 };
 
 // --------------------------------------------------------------------------
 // ctkCommandLineParser::ctkInternal methods
 
 // --------------------------------------------------------------------------
 CommandLineParserArgumentDescription *mitkCommandLineParser::ctkInternal::argumentDescription(const string &argument)
 {
   string unprefixedArg = argument;
 
   if (!LongPrefix.empty() && argument.compare(0, LongPrefix.size(), LongPrefix) == 0)
   {
     // Case when (ShortPrefix + UnPrefixedArgument) matches LongPrefix
     if (argument == LongPrefix && !ShortPrefix.empty() && argument.compare(0, ShortPrefix.size(), ShortPrefix) == 0)
     {
       unprefixedArg = argument.substr(ShortPrefix.size(), argument.size());
     }
     else
     {
       unprefixedArg = argument.substr(LongPrefix.size(), argument.size());
     }
   }
   else if (!ShortPrefix.empty() && argument.compare(0, ShortPrefix.size(), ShortPrefix) == 0)
   {
     unprefixedArg = argument.substr(ShortPrefix.size(), argument.size());
   }
   else if (!LongPrefix.empty() && !ShortPrefix.empty())
   {
     return nullptr;
   }
 
   if (ArgNameToArgumentDescriptionMap.count(unprefixedArg))
   {
     return this->ArgNameToArgumentDescriptionMap[unprefixedArg];
   }
   return nullptr;
 }
 
 // --------------------------------------------------------------------------
 // ctkCommandLineParser methods
 
 // --------------------------------------------------------------------------
 mitkCommandLineParser::mitkCommandLineParser()
 {
   this->Internal = new ctkInternal();
   this->Category = string();
   this->Title = string();
   this->Contributor = string();
   this->Description = string();
   this->ParameterGroupName = "Parameters";
   this->ParameterGroupDescription = "Parameters";
 }
 
 // --------------------------------------------------------------------------
 mitkCommandLineParser::~mitkCommandLineParser()
 {
   delete this->Internal;
 }
 
 // --------------------------------------------------------------------------
 map<string, us::Any> mitkCommandLineParser::parseArguments(const StringContainerType &arguments, bool *ok)
 {
   // Reset
   this->Internal->UnparsedArguments.clear();
   this->Internal->ProcessedArguments.clear();
   this->Internal->ErrorString.clear();
   // foreach (CommandLineParserArgumentDescription* desc, this->Internal->ArgumentDescriptionList)
   for (unsigned int i = 0; i < Internal->ArgumentDescriptionList.size(); i++)
   {
     CommandLineParserArgumentDescription *desc = Internal->ArgumentDescriptionList.at(i);
     desc->Value = us::Any(desc->ValueType);
     if (!desc->DefaultValue.Empty())
     {
       desc->Value = desc->DefaultValue;
     }
   }
   bool error = false;
   bool ignoreRest = false;
   CommandLineParserArgumentDescription *currentArgDesc = nullptr;
   vector<CommandLineParserArgumentDescription *> parsedArgDescriptions;
   for (unsigned int i = 1; i < arguments.size(); ++i)
   {
     string argument = arguments.at(i);
 
     if (this->Internal->Debug)
     {
       std::cout << "Processing" << argument;
     }
     if (!argument.compare("--version"))
     {
       std::cout << "Git commit hash: " << MITK_REVISION << std::endl;
       std::cout << "Git branch name: " << MITK_REVISION_NAME << std::endl;
     }
 
     if (!argument.compare("--xml") || !argument.compare("-xml") || !argument.compare("--XML") ||
         !argument.compare("-XML"))
     {
       this->generateXmlOutput();
       return map<string, us::Any>();
     }
 
     // should argument be ignored ?
     if (ignoreRest)
     {
       if (this->Internal->Debug)
       {
         std::cout << "  Skipping: IgnoreRest flag was been set";
       }
       this->Internal->UnparsedArguments.push_back(argument);
       continue;
     }
 
     // Skip if the argument does not start with the defined prefix
     if (!(argument.compare(0, Internal->LongPrefix.size(), Internal->LongPrefix) == 0 ||
           argument.compare(0, Internal->ShortPrefix.size(), Internal->ShortPrefix) == 0))
     {
       if (this->Internal->StrictMode)
       {
         this->Internal->ErrorString = "Unknown argument ";
         this->Internal->ErrorString += argument;
         error = true;
         break;
       }
       if (this->Internal->Debug)
       {
         std::cout << "  Skipping: It does not start with the defined prefix";
       }
       this->Internal->UnparsedArguments.push_back(argument);
       continue;
     }
 
     // Skip if argument has already been parsed ...
     bool alreadyProcessed = false;
     for (auto alreadyHandledArgument : Internal->ProcessedArguments)
       if (argument.compare(alreadyHandledArgument) == 0)
       {
         alreadyProcessed = true;
         break;
       }
 
     if (alreadyProcessed)
     {
       if (this->Internal->StrictMode)
       {
         this->Internal->ErrorString = "Argument ";
         this->Internal->ErrorString += argument;
         this->Internal->ErrorString += " already processed !";
         error = true;
         break;
       }
       if (this->Internal->Debug)
       {
         std::cout << "  Skipping: Already processed !";
       }
       continue;
     }
 
     // Retrieve corresponding argument description
     currentArgDesc = this->Internal->argumentDescription(argument);
 
     // Is there a corresponding argument description ?
     if (currentArgDesc)
     {
       // If the argument is deprecated, print the help text but continue processing
       if (currentArgDesc->Deprecated)
       {
         std::cout << "Deprecated argument " << argument << ": " << currentArgDesc->ArgHelp;
       }
       else
       {
         parsedArgDescriptions.push_back(currentArgDesc);
       }
 
       this->Internal->ProcessedArguments.push_back(currentArgDesc->ShortArg);
       this->Internal->ProcessedArguments.push_back(currentArgDesc->LongArg);
       int numberOfParametersToProcess = currentArgDesc->NumberOfParametersToProcess;
       ignoreRest = currentArgDesc->IgnoreRest;
       if (this->Internal->Debug && ignoreRest)
       {
         std::cout << "  IgnoreRest flag is True";
       }
 
       // Is the number of parameters associated with the argument being processed known ?
       if (numberOfParametersToProcess == 0)
       {
         currentArgDesc->addParameter("true");
       }
       else if (numberOfParametersToProcess > 0)
       {
         string missingParameterError = "Argument %1 has %2 value(s) associated whereas exacly %3 are expected.";
         for (int j = 1; j <= numberOfParametersToProcess; ++j)
         {
           if (i + j >= arguments.size())
           {
             // this->Internal->ErrorString =
             //         missingParameterError.arg(argument).arg(j-1).arg(numberOfParametersToProcess);
             // if (this->Internal->Debug) { std::cout << this->Internal->ErrorString; }
             if (ok)
             {
               *ok = false;
             }
             return map<string, us::Any>();
           }
           string parameter = arguments.at(i + j);
           if (this->Internal->Debug)
           {
             std::cout << "  Processing parameter" << j << ", value:" << parameter;
           }
           if (this->argumentAdded(parameter))
           {
             // this->Internal->ErrorString =
             //         missingParameterError.arg(argument).arg(j-1).arg(numberOfParametersToProcess);
             // if (this->Internal->Debug) { std::cout << this->Internal->ErrorString; }
             if (ok)
             {
               *ok = false;
             }
             return map<string, us::Any>();
           }
           if (!currentArgDesc->addParameter(parameter))
           {
             // this->Internal->ErrorString = string(
             //             "Value(s) associated with argument %1 are incorrect. %2").
             //         arg(argument).arg(currentArgDesc->ExactMatchFailedMessage);
             // if (this->Internal->Debug) { std::cout << this->Internal->ErrorString; }
             if (ok)
             {
               *ok = false;
             }
             return map<string, us::Any>();
           }
         }
         // Update main loop increment
         i = i + numberOfParametersToProcess;
       }
       else if (numberOfParametersToProcess == -1)
       {
         if (this->Internal->Debug)
         {
           std::cout << "  Proccessing StringList ...";
         }
         int j = 1;
         while (j + i < arguments.size())
         {
           if (this->argumentAdded(arguments.at(j + i)))
           {
             if (this->Internal->Debug)
             {
               std::cout << "  No more parameter for" << argument;
             }
             break;
           }
           string parameter = arguments.at(j + i);
 
           if (parameter.compare(0, Internal->LongPrefix.size(), Internal->LongPrefix) == 0 ||
               parameter.compare(0, Internal->ShortPrefix.size(), Internal->ShortPrefix) == 0)
           {
             j--;
             break;
           }
 
           if (this->Internal->Debug)
           {
             std::cout << "  Processing parameter" << j << ", value:" << parameter;
           }
           if (!currentArgDesc->addParameter(parameter))
           {
             // this->Internal->ErrorString = string(
             //             "Value(s) associated with argument %1 are incorrect. %2").
             //         arg(argument).arg(currentArgDesc->ExactMatchFailedMessage);
             // if (this->Internal->Debug) { std::cout << this->Internal->ErrorString; }
             if (ok)
             {
               *ok = false;
             }
             return map<string, us::Any>();
           }
           j++;
         }
         // Update main loop increment
         i = i + j;
       }
     }
     else
     {
       if (this->Internal->StrictMode)
       {
         this->Internal->ErrorString = "Unknown argument ";
         this->Internal->ErrorString += argument;
         error = true;
         break;
       }
       if (this->Internal->Debug)
       {
         std::cout << "  Skipping: Unknown argument";
       }
       this->Internal->UnparsedArguments.push_back(argument);
     }
   }
 
   if (ok)
   {
     *ok = !error;
   }
 
   map<string, us::Any> parsedArguments;
 
   int obligatoryArgs = 0;
   vector<CommandLineParserArgumentDescription *>::iterator it;
   for (it = Internal->ArgumentDescriptionList.begin(); it != Internal->ArgumentDescriptionList.end(); ++it)
   {
     CommandLineParserArgumentDescription *desc = *it;
 
     if (!desc->Optional)
       obligatoryArgs++;
   }
 
   int parsedObligatoryArgs = 0;
   for (it = parsedArgDescriptions.begin(); it != parsedArgDescriptions.end(); ++it)
   {
     CommandLineParserArgumentDescription *desc = *it;
 
     string key;
     if (!desc->LongArg.empty())
     {
       key = desc->LongArg;
     }
     else
     {
       key = desc->ShortArg;
     }
 
     if (!desc->Optional)
       parsedObligatoryArgs++;
 
     std::pair<string, us::Any> elem;
     elem.first = key;
     elem.second = desc->Value;
     parsedArguments.insert(elem);
   }
 
   if (obligatoryArgs > parsedObligatoryArgs)
   {
     parsedArguments.clear();
     cout << helpText();
   }
 
   return parsedArguments;
 }
 
 // -------------------------------------------------------------------------
 map<string, us::Any> mitkCommandLineParser::parseArguments(int argc, char **argv, bool *ok)
 {
   std::cout << "Running Command Line Utility *" << Title << "*" << std::endl;
   StringContainerType arguments;
 
   // Create a StringContainerType of arguments
   for (int i = 0; i < argc; ++i)
     arguments.push_back(argv[i]);
 
   return this->parseArguments(arguments, ok);
 }
 
 // -------------------------------------------------------------------------
 string mitkCommandLineParser::errorString() const
 {
   return this->Internal->ErrorString;
 }
 
 // -------------------------------------------------------------------------
 const mitkCommandLineParser::StringContainerType &mitkCommandLineParser::unparsedArguments() const
 {
   return this->Internal->UnparsedArguments;
 }
 
 // --------------------------------------------------------------------------
 void mitkCommandLineParser::addArgument(const string &longarg,
                                         const string &shortarg,
                                         Type type,
                                         const string &argLabel,
                                         const string &argHelp,
                                         const us::Any &defaultValue,
                                         bool optional,
                                         bool ignoreRest,
                                         bool deprecated)
 {
   if (longarg.empty() && shortarg.empty())
   {
     return;
   }
 
   /* Make sure it's not already added */
   bool added = (this->Internal->ArgNameToArgumentDescriptionMap.count(longarg) != 0);
   if (added)
   {
     return;
   }
 
   added = (this->Internal->ArgNameToArgumentDescriptionMap.count(shortarg) != 0);
   if (added)
   {
     return;
   }
 
   auto argDesc = new CommandLineParserArgumentDescription(longarg,
                                                           this->Internal->LongPrefix,
                                                           shortarg,
                                                           this->Internal->ShortPrefix,
                                                           type,
                                                           argHelp,
                                                           argLabel,
                                                           defaultValue,
                                                           ignoreRest,
                                                           deprecated,
                                                           optional,
                                                           ParameterGroupName,
                                                           ParameterGroupDescription);
 
   std::string::size_type argWidth = 0;
   if (!longarg.empty())
   {
     this->Internal->ArgNameToArgumentDescriptionMap[longarg] = argDesc;
     argWidth += longarg.size() + this->Internal->LongPrefix.size();
   }
   if (!shortarg.empty())
   {
     this->Internal->ArgNameToArgumentDescriptionMap[shortarg] = argDesc;
     argWidth += shortarg.size() + this->Internal->ShortPrefix.size() + 2;
   }
   argWidth += 5;
 
   // Set the field width for the arguments
   if (argWidth > this->Internal->FieldWidth)
   {
     this->Internal->FieldWidth = argWidth;
   }
 
   this->Internal->ArgumentDescriptionList.push_back(argDesc);
   this->Internal->GroupToArgumentDescriptionListMap[this->Internal->CurrentGroup].push_back(argDesc);
 }
 
 // --------------------------------------------------------------------------
 void mitkCommandLineParser::addDeprecatedArgument(const string &longarg,
                                                   const string &shortarg,
                                                   const string &argLabel,
                                                   const string &argHelp)
 {
   addArgument(longarg, shortarg, StringList, argLabel, argHelp, us::Any(), false, true, false);
 }
 
 // --------------------------------------------------------------------------
 std::vector < std::map<std::string, us::Any> > mitkCommandLineParser::getArgumentList()
 {
   std::vector < std::map<std::string, us::Any> > parameterList;
   //for (CommandLineParserArgumentDescription* argument : this->Internal->ArgumentDescriptionList)
   for (std::size_t i = 0; i< this->Internal->ArgumentDescriptionList.size(); ++i)
   {
     CommandLineParserArgumentDescription* argument = this->Internal->ArgumentDescriptionList[i];
     std::map<std::string, us::Any> tmpMap;
     //tmpMap["helptext"] = us::Any(argument->helpText);
     tmpMap["longarg"] = us::Any(argument->LongArg);
     tmpMap["longargprefix"] = us::Any(argument->LongArgPrefix);
     tmpMap["shortarg"] = us::Any(argument->ShortArg);
     tmpMap["shortargprefix"] = us::Any(argument->ShortArgPrefix);
     tmpMap["arghelp"] = us::Any(argument->ArgHelp);
     tmpMap["arglabel"] = us::Any(argument->ArgLabel);
     tmpMap["arggroup"] = us::Any(argument->ArgGroup);
     tmpMap["arggroupdescription"] = us::Any(argument->ArgGroupDescription);
     tmpMap["ignorerest"] = us::Any(argument->IgnoreRest);
     tmpMap["numberofparameterstoprocess"] = us::Any(argument->NumberOfParametersToProcess);
     tmpMap["deprecated"] = us::Any(argument->Deprecated);
     tmpMap["optional"] = us::Any(argument->Optional);
     tmpMap["defaultvalue"] = argument->DefaultValue;
     tmpMap["value"] = argument->Value;
     tmpMap["valuetype"] = us::Any(argument->ValueType);
     parameterList.push_back(tmpMap);
   }
   return parameterList;
 }
 
 // --------------------------------------------------------------------------
 std::string::size_type mitkCommandLineParser::fieldWidth() const
 {
   return this->Internal->FieldWidth;
 }
 
 // --------------------------------------------------------------------------
 void mitkCommandLineParser::beginGroup(const string &description)
 {
   this->Internal->CurrentGroup = description;
 }
 
 // --------------------------------------------------------------------------
 void mitkCommandLineParser::endGroup()
 {
   this->Internal->CurrentGroup.clear();
 }
 
 // --------------------------------------------------------------------------
 string mitkCommandLineParser::helpText() const
 {
   string text;
   vector<CommandLineParserArgumentDescription *> deprecatedArgs;
 
   text = "Command Line Utility *" + Title + "* in Category *" + Category + "*\n";
   text += Description + "\n";
   text += Contributor + "\n\n";
   text += "Use --xml to generate an XML description parsable as a CTK Command Line Module Plugin.\n";
   text += "Use --version to print MITK revision information.\n";
 
   // Loop over grouped argument descriptions
   map<string, vector<CommandLineParserArgumentDescription *>>::iterator it;
   for (it = Internal->GroupToArgumentDescriptionListMap.begin();
        it != Internal->GroupToArgumentDescriptionListMap.end();
        ++it)
   {
     if (!(*it).first.empty())
     {
       text = text + "\n" + (*it).first + "\n";
     }
 
     vector<CommandLineParserArgumentDescription *>::iterator it2;
     for (it2 = (*it).second.begin(); it2 != (*it).second.end(); ++it2)
     {
       CommandLineParserArgumentDescription *argDesc = *it2;
       if (argDesc->Deprecated)
       {
         deprecatedArgs.push_back(argDesc);
       }
       else
       {
         text += argDesc->helpText();
       }
     }
   }
 
   if (!deprecatedArgs.empty())
   {
     text += "\nDeprecated arguments:\n";
     vector<CommandLineParserArgumentDescription *>::iterator it2;
     for (it2 = deprecatedArgs.begin(); it2 != deprecatedArgs.end(); ++it2)
     {
       CommandLineParserArgumentDescription *argDesc = *it2;
       text += argDesc->helpText();
     }
   }
 
   return text;
 }
 
 // --------------------------------------------------------------------------
 bool mitkCommandLineParser::argumentAdded(const string &argument) const
 {
   return (this->Internal->ArgNameToArgumentDescriptionMap.count(argument) != 0);
 }
 
 // --------------------------------------------------------------------------
 bool mitkCommandLineParser::argumentParsed(const string &argument) const
 {
   for (unsigned int i = 0; i < Internal->ProcessedArguments.size(); i++)
     if (argument.compare(Internal->ProcessedArguments.at(i)) == 0)
       return true;
   return false;
 }
 
 // --------------------------------------------------------------------------
 void mitkCommandLineParser::setArgumentPrefix(const string &longPrefix, const string &shortPrefix)
 {
   this->Internal->LongPrefix = longPrefix;
   this->Internal->ShortPrefix = shortPrefix;
 }
 
 // --------------------------------------------------------------------------
 void mitkCommandLineParser::setStrictModeEnabled(bool strictMode)
 {
   this->Internal->StrictMode = strictMode;
 }
 
 
 void mitkCommandLineParser::generateXmlOutput()
 {
   std::stringstream xml;
 
   xml << "<executable>" << endl;
   xml << "<category>" << Category << "</category>" << endl;
   xml << "<title>" << Title << "</title>" << endl;
   xml << "<description>" << Description << "</description>" << endl;
   xml << "<contributor>" << Contributor << "</contributor>" << endl;
   xml << "<parameters>" << endl;
 
   std::vector<CommandLineParserArgumentDescription *>::iterator it;
 
   std::string lastParameterGroup = "";
   for (it = this->Internal->ArgumentDescriptionList.begin(); it != this->Internal->ArgumentDescriptionList.end(); it++)
   {
     std::string type;
     switch ((*it)->ValueType)
     {
       case mitkCommandLineParser::String:
         type = "string";
         break;
 
       case mitkCommandLineParser::Bool:
         type = "boolean";
         break;
 
       case mitkCommandLineParser::StringList:
         type = "string-vector";
         break;
 
       case mitkCommandLineParser::Int:
         type = "integer";
         break;
 
       case mitkCommandLineParser::Float:
         type = "float";
         break;
 
       case mitkCommandLineParser::OutputDirectory:
       case mitkCommandLineParser::InputDirectory:
         type = "directory";
         break;
 
       case mitkCommandLineParser::InputImage:
         type = "image";
         break;
 
       case mitkCommandLineParser::OutputFile:
       case mitkCommandLineParser::InputFile:
         type = "file";
         break;
     }
 
     if (lastParameterGroup.compare((*it)->ArgGroup))
     {
       if (it != this->Internal->ArgumentDescriptionList.begin())
       {
         xml << "</parameters>" << endl;
         xml << "<parameters>" << endl;
       }
       xml << "<label>" << (*it)->ArgGroup << "</label>" << endl;
       xml << "<description>" << (*it)->ArgGroupDescription << "</description>" << endl;
       lastParameterGroup = (*it)->ArgGroup;
     }
 
     // Skip help item, as it's no use in GUI
     if ((*it)->ShortArg == "h")
       continue;
 
     xml << "<" << type << ">" << endl;
     xml << "<name>" << (*it)->LongArg << "</name>" << endl;
     xml << "<description>" << (*it)->ArgHelp << "</description>" << endl;
     xml << "<label>" << (*it)->ArgLabel << "</label>" << endl;
     if (!(*it)->DefaultValue.Empty())
       xml << "<default>" << (*it)->DefaultValue.ToString() << "</default>" << endl;
 
     xml << "<longflag>" << (*it)->LongArg << "</longflag>" << endl;
     xml << "<flag>" << (*it)->ShortArg << "</flag>" << endl;
 
     if ((*it)->ValueType == mitkCommandLineParser::InputDirectory ||
         (*it)->ValueType == mitkCommandLineParser::InputFile || (*it)->ValueType == mitkCommandLineParser::InputImage)
     {
       xml << "<channel>input</channel>" << endl;
     }
     else if ((*it)->ValueType == mitkCommandLineParser::OutputDirectory ||
              (*it)->ValueType == mitkCommandLineParser::OutputFile)
     {
       xml << "<channel>output</channel>" << endl;
     }
     xml << "</" << type << ">" << endl;
   }
 
   xml << "</parameters>" << endl;
   xml << "</executable>" << endl;
 
   cout << xml.str();
 }
 
 void mitkCommandLineParser::setTitle(string title)
 {
   Title = title;
 }
 void mitkCommandLineParser::setContributor(string contributor)
 {
   Contributor = contributor;
 }
 
 void mitkCommandLineParser::setCategory(string category)
 {
   Category = category;
 }
 
 void mitkCommandLineParser::setDescription(string description)
 {
   Description = description;
 }
 
 void mitkCommandLineParser::changeParameterGroup(string name, string tooltip)
 {
   ParameterGroupName = name;
   ParameterGroupDescription = tooltip;
 }
diff --git a/Modules/DiffusionImaging/DiffusionCore/include/Algorithms/itkOdfMaximaExtractionFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/include/Algorithms/itkOdfMaximaExtractionFilter.cpp
index a3b3cea799..e53de6545c 100644
--- a/Modules/DiffusionImaging/DiffusionCore/include/Algorithms/itkOdfMaximaExtractionFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/include/Algorithms/itkOdfMaximaExtractionFilter.cpp
@@ -1,358 +1,362 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 #ifndef __itkOdfMaximaExtractionFilter_cpp
 #define __itkOdfMaximaExtractionFilter_cpp
 
 #include "itkOdfMaximaExtractionFilter.h"
 #include <itkImageRegionConstIterator.h>
 #include <itkImageRegionConstIteratorWithIndex.h>
 #include <itkImageRegionIterator.h>
 #include <vnl/vnl_vector.h>
 #include <itkOrientationDistributionFunction.h>
 #include <itkContinuousIndex.h>
 
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 
 #include <boost/math/special_functions.hpp>
 #include <boost/progress.hpp>
 
 using namespace boost::math;
 
 namespace itk {
 
 
 static bool CompareVectors(const vnl_vector_fixed< double, 3 >& v1, const vnl_vector_fixed< double, 3 >& v2)
 {
   return (v1.magnitude()>v2.magnitude());
 }
 
 template< class PixelType, int ShOrder, int NrOdfDirections >
 OdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
 ::OdfMaximaExtractionFilter()
   : m_NormalizationMethod(MAX_VEC_NORM)
   , m_MaxNumPeaks(2)
   , m_RelativePeakThreshold(0.4)
   , m_AbsolutePeakThreshold(0)
   , m_AngularThreshold(0.9)
   , m_NumCoeffs((ShOrder*ShOrder + ShOrder + 2)/2 + ShOrder)
   , m_Toolkit(MRTRIX)
   , m_FlipX(false)
   , m_FlipY(false)
   , m_FlipZ(false)
   , m_ApplyDirectionMatrix(false)
   , m_ScaleByGfa(false)
   , m_Iterations(10)
 {
   this->SetNumberOfRequiredInputs(1);
 }
 
 template< class PixelType, int ShOrder, int NrOdfDirections >
 double OdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
 ::FindCandidatePeaks(OdfType& odf, double thr, std::vector< DirectionType >& container)
 {
   double gfa = 1.0;
   if (m_ScaleByGfa)
     gfa = odf.GetGeneralizedFractionalAnisotropy();
 
   //Find the peaks using a finite difference method
   bool flag = true;
   vnl_vector_fixed< bool, NrOdfDirections > used; used.fill(false);
   //Find the peaks
   for (int i=0; i<NrOdfDirections; i++)
   {
     if (used[i])
       continue;
 
     double val = odf.GetElement(i);
     if (val>thr*0.9 && gfa*val>m_AbsolutePeakThreshold*0.9)
     {
       flag = true;
       std::vector< int > neighbours = odf.GetNeighbors(i);
       for (unsigned int j=0; j<neighbours.size(); j++)
         if (val<odf.GetElement(neighbours.at(j)))
         {
           flag = false;
           break;
         }
       if (flag)   // point is a peak
       {
         container.push_back(odf.GetDirection(i).normalize());
         used[i] = true;
         for (unsigned int j=0; j<neighbours.size(); j++)
           used[neighbours.at(j)] = true;
       }
     }
   }
   return gfa;
 }
 
 template< class PixelType, int ShOrder, int NrOdfDirections >
 void OdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
 ::BeforeThreadedGenerateData()
 {
   typename CoefficientImageType::Pointer ShCoeffImage = static_cast< CoefficientImageType* >( this->ProcessObject::GetInput(0) );
   itk::Vector<double,3> spacing = ShCoeffImage->GetSpacing();
   double minSpacing = spacing[0];
   if (spacing[1]<minSpacing)
     minSpacing = spacing[1];
   if (spacing[2]<minSpacing)
     minSpacing = spacing[2];
 
   mitk::Point3D origin = ShCoeffImage->GetOrigin();
   itk::Matrix<double, 3, 3> direction = ShCoeffImage->GetDirection();
   ImageRegion<3> imageRegion = ShCoeffImage->GetLargestPossibleRegion();
 
   if (m_MaskImage.IsNotNull())
   {
     origin = m_MaskImage->GetOrigin();
     direction = m_MaskImage->GetDirection();
     imageRegion = m_MaskImage->GetLargestPossibleRegion();
   }
 
   itk::Vector<double, 3> spacing3 = ShCoeffImage->GetSpacing();
   itk::Point<float, 3> origin3 = ShCoeffImage->GetOrigin();
   itk::Matrix<double, 3, 3> direction3 = ShCoeffImage->GetDirection();
   itk::ImageRegion<3> imageRegion3 = ShCoeffImage->GetLargestPossibleRegion();
 
   itk::Vector<double, 4> spacing4;
   itk::Point<float, 4> origin4;
   itk::Matrix<double, 4, 4> direction4;
   itk::ImageRegion<4> imageRegion4;
 
   spacing4[0] = spacing3[0]; spacing4[1] = spacing3[1]; spacing4[2] = spacing3[2]; spacing4[3] = 1;
   origin4[0] = origin3[0]; origin4[1] = origin3[1]; origin4[2] = origin3[2]; origin4[3] = 0;
   for (int r=0; r<3; r++)
     for (int c=0; c<3; c++)
       direction4[r][c] = direction3[r][c];
   direction4[3][3] = 1;
   imageRegion4.SetSize(0, imageRegion3.GetSize()[0]);
   imageRegion4.SetSize(1, imageRegion3.GetSize()[1]);
   imageRegion4.SetSize(2, imageRegion3.GetSize()[2]);
   imageRegion4.SetSize(3, m_MaxNumPeaks*3);
 
   m_PeakImage = PeakImageType::New();
   m_PeakImage->SetSpacing( spacing4 );
   m_PeakImage->SetOrigin( origin4 );
   m_PeakImage->SetDirection( direction4 );
   m_PeakImage->SetRegions( imageRegion4 );
   m_PeakImage->Allocate();
   m_PeakImage->FillBuffer(0.0);
 
   if (m_MaskImage.IsNull())
   {
     m_MaskImage = ItkUcharImgType::New();
     m_MaskImage->SetSpacing( spacing );
     m_MaskImage->SetOrigin( origin );
     m_MaskImage->SetDirection( direction );
     m_MaskImage->SetRegions( imageRegion );
     m_MaskImage->Allocate();
     m_MaskImage->FillBuffer(1);
   }
   m_NumDirectionsImage = ItkUcharImgType::New();
   m_NumDirectionsImage->SetSpacing( spacing );
   m_NumDirectionsImage->SetOrigin( origin );
   m_NumDirectionsImage->SetDirection( direction );
   m_NumDirectionsImage->SetRegions( imageRegion );
   m_NumDirectionsImage->Allocate();
   m_NumDirectionsImage->FillBuffer(0);
 
   // calculate SH basis
   OdfType odf;
   vnl_matrix< double > dir_matrix;
   dir_matrix.set_size(3, NrOdfDirections);
   for (int i=0; i<NrOdfDirections; i++)
   {
     dir_matrix(0, i) = odf.GetDirection(i)[0];
     dir_matrix(1, i) = odf.GetDirection(i)[1];
     dir_matrix(2, i) = odf.GetDirection(i)[2];
   }
 
   if (m_Toolkit==Toolkit::MRTRIX)
     m_ShBasis = mitk::sh::CalcShBasisForDirections(ShOrder, dir_matrix);
   else
     m_ShBasis = mitk::sh::CalcShBasisForDirections(ShOrder, dir_matrix, false);
 
   MITK_INFO << "Starting peak extraction";
   MITK_INFO << "SH order: " << ShOrder;
   MITK_INFO << "Maximum peaks: " << m_MaxNumPeaks;
   MITK_INFO << "Relative threshold: " << m_RelativePeakThreshold;
   MITK_INFO << "Absolute threshold: " << m_AbsolutePeakThreshold;
   MITK_INFO << "Angular threshold: " << m_AngularThreshold;
   this->SetNumberOfThreads(1);
 }
 
 template< class PixelType, int ShOrder, int NrOdfDirections >
 void OdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
 ::AfterThreadedGenerateData()
 {
 
 }
 
 template< class PixelType, int ShOrder, int NrOdfDirections >
 void OdfMaximaExtractionFilter< PixelType, ShOrder, NrOdfDirections>
 ::ThreadedGenerateData( const OutputImageRegionType& outputRegionForThread, ThreadIdType threadID )
 {
   typename CoefficientImageType::Pointer ShCoeffImage = static_cast< CoefficientImageType* >( this->ProcessObject::GetInput(0) );
 
   ImageRegionConstIterator< CoefficientImageType > cit(ShCoeffImage, outputRegionForThread );
 
+  boost::progress_display disp(outputRegionForThread.GetSize()[0]*outputRegionForThread.GetSize()[1]*outputRegionForThread.GetSize()[2]);
   OdfType odf;
   while( !cit.IsAtEnd() )
   {
     typename CoefficientImageType::IndexType idx3 = cit.GetIndex();
     if (m_MaskImage->GetPixel(idx3)==0)
     {
+      ++disp;
       ++cit;
       continue;
     }
 
     CoefficientPixelType c = cit.Get();
     vnl_vector<float> coeffs; coeffs.set_size((ShOrder*ShOrder + ShOrder + 2)/2 + ShOrder);
     for (int j=0; j<m_NumCoeffs; j++)
       coeffs[j] = c[j];
 
     double max = 0;
     for (int i=0; i<NrOdfDirections; i++)
     {
       odf[i] = 0;
       for (int j=0; j<m_NumCoeffs; j++)
         odf[i] += c[j]*m_ShBasis(i,j);
       if (odf[i]>max)
         max = odf[i];
     }
     if (max<0.0001)
     {
+      ++disp;
       ++cit;
       continue;
     }
 
     std::vector< DirectionType > candidates, final_peaks;
     double scale = FindCandidatePeaks(odf, max*m_RelativePeakThreshold, candidates);       // find all local maxima
 
     max = 0;
     for (unsigned int i=0; i<candidates.size(); ++i)
     {
       double spherical[3];
       mitk::sh::Cart2Sph(candidates[i][0], candidates[i][1], candidates[i][2], spherical);
       vnl_vector<double> x;
       x.set_size(2);
       x[0] = spherical[1];  // theta
       x[1] = spherical[0];  // phi
 
       VnlCostFunction cost;
       if (m_Toolkit==Toolkit::MRTRIX)
         cost.SetProblem(coeffs, ShOrder, true, max);
       else
         cost.SetProblem(coeffs, ShOrder, false, max);
 
       vnl_lbfgsb minimizer(cost);
       minimizer.set_f_tolerance(1e-6);
 //      minimizer.set_trace(true);
 
       vnl_vector<double> l; l.set_size(2); l[0] = 0; l[1] = -itk::Math::pi;
       vnl_vector<double> u; u.set_size(2); u[0] = itk::Math::pi; u[1] = itk::Math::pi;
       vnl_vector<long> bound_selection; bound_selection.set_size(2); bound_selection.fill(2);
       minimizer.set_bound_selection(bound_selection);
       minimizer.set_lower_bound(l);
       minimizer.set_upper_bound(u);
       if (m_Iterations>0)
         minimizer.set_max_function_evals(m_Iterations);
       minimizer.minimize(x);
 
       float v = -minimizer.get_end_error()*scale;
       candidates[i] = mitk::sh::Sph2Cart(x[0], x[1], v);
       if (v>max)
         max = v;
     }
 
     std::sort( candidates.begin(), candidates.end(), CompareVectors );  // sort peaks
 
     // kick out directions to close to a larger direction
     for (unsigned int i=0; i<candidates.size(); i++)
     {
       DirectionType v1 = candidates.at(i);
       double val = v1.magnitude();
       if (val<max*m_RelativePeakThreshold || val<m_AbsolutePeakThreshold)
         break;
 
       bool flag = true;
       for (unsigned int j=0; j<candidates.size(); j++)
         if (i!=j)
         {
           DirectionType v2 = candidates.at(j);
           double val2 = v2.magnitude();
           double angle = fabs(dot_product(v1,v2)/(val*val2));
           if (angle>m_AngularThreshold && val<val2)
           {
             flag = false;
             break;
           }
         }
 
       if (flag)
         final_peaks.push_back(v1);
     }
 
     itk::Index<4> idx4; idx4[0] = idx3[0]; idx4[1] = idx3[1]; idx4[2] = idx3[2];
 
     // fill output image
     unsigned int num = final_peaks.size();
     if ( num>m_MaxNumPeaks )
       num = m_MaxNumPeaks;
     for (unsigned int i=0; i<num; i++)
     {
       DirectionType dir = final_peaks.at(i);
       switch (m_NormalizationMethod)
       {
       case NO_NORM:
         break;
       case SINGLE_VEC_NORM:
         dir.normalize();
         break;
       case MAX_VEC_NORM:
         dir /= max;
         break;
       }
 
       if (m_ApplyDirectionMatrix)
         dir = m_MaskImage->GetDirection()*dir;
 
       if (m_FlipX)
         dir[0] = -dir[0];
       if (m_FlipY)
         dir[1] = -dir[1];
       if (m_FlipZ)
         dir[2] = -dir[2];
 
       for (unsigned int j = 0; j<3; j++)
       {
         idx4[3] = i*3 + j;
         m_PeakImage->SetPixel(idx4, dir[j]);
       }
     }
     m_NumDirectionsImage->SetPixel(idx3, num);
+    ++disp;
     ++cit;
   }
   MITK_INFO << "Thread " << threadID << " finished extraction";
 }
 
 }
 
 #endif // __itkOdfMaximaExtractionFilter_cpp