diff --git a/Modules/Classification/CLMiniApps/CLImageTypeConverter.cpp b/Modules/Classification/CLMiniApps/CLImageTypeConverter.cpp
index aad5b7927f..9f11ba3be7 100644
--- a/Modules/Classification/CLMiniApps/CLImageTypeConverter.cpp
+++ b/Modules/Classification/CLMiniApps/CLImageTypeConverter.cpp
@@ -1,103 +1,103 @@
 /*===================================================================
 
 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 <mitkImageCast.h>
 #include <typeinfo>
 
 #define CONVERT_IMAGE(TYPE, DIM) itk::Image<TYPE, DIM>::Pointer itkImage = itk::Image<TYPE, DIM>::New();    \
   MITK_INFO << "Data Type for Conversion: "<< typeid(TYPE).name();                                    \
   mitk::CastToItkImage(image, itkImage);                                                              \
   mitk::CastToMitkImage(itkImage, outputImage)
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Image Type Converter");
   parser.setCategory("Preprocessing Tools");
   parser.setDescription("");
   parser.setContributor("MBI");
 
   parser.setArgumentPrefix("--","-");
   // Add command line argument names
   parser.addArgument("help", "h",mitkCommandLineParser::Bool, "Help:", "Show this help text");
   parser.addArgument("input", "i", mitkCommandLineParser::InputDirectory, "Input file:", "Input file",us::Any(),false);
   parser.addArgument("output", "o", mitkCommandLineParser::OutputFile, "Output file:", "Output file", us::Any(), false);
   parser.addArgument("type", "t", mitkCommandLineParser::OutputFile, "Type definition:", "Define Scalar data type: int, uint, short, ushort, char, uchar, float, double", us::Any(), false);
 
-  map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
+  std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
 
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   // Show a help message
   if ( parsedArgs.count("help") || parsedArgs.count("h"))
   {
     std::cout << parser.helpText();
     return EXIT_SUCCESS;
   }
 
-  std::string inputName = us::any_cast<string>(parsedArgs["input"]);
-  std::string outputName = us::any_cast<string>(parsedArgs["output"]);
-  std::string type = us::any_cast<string>(parsedArgs["type"]);
+  std::string inputName = us::any_cast<std::string>(parsedArgs["input"]);
+  std::string outputName = us::any_cast<std::string>(parsedArgs["output"]);
+  std::string type = us::any_cast<std::string>(parsedArgs["type"]);
 
   mitk::Image::Pointer image = mitk::IOUtil::LoadImage(inputName);
   mitk::Image::Pointer outputImage = mitk::Image::New();
 
   if (type.compare("int") == 0)
   {
     CONVERT_IMAGE(int, 3);
   }
   else if (type.compare("uint") == 0)
   {
     CONVERT_IMAGE(unsigned int, 3);
   }
   else if (type.compare("char") == 0)
   {
     CONVERT_IMAGE(char, 3);
   }
   else if (type.compare("uchar") == 0)
   {
     CONVERT_IMAGE(unsigned char, 3);
   }
   else if (type.compare("short") == 0)
   {
     CONVERT_IMAGE(short, 3);
   }
   else if (type.compare("ushort") == 0)
   {
     CONVERT_IMAGE(unsigned short, 3);
   }
   else if (type.compare("float") == 0)
   {
     CONVERT_IMAGE(float, 3);
   }
   else if (type.compare("double") == 0)
   {
     CONVERT_IMAGE(double, 3);
   }
   else
   {
     CONVERT_IMAGE(double, 3);
   }
 
 
   mitk::IOUtil::SaveImage(outputImage, outputName);
 
   return EXIT_SUCCESS;
 }
\ No newline at end of file
diff --git a/Modules/Classification/CLMiniApps/CLMRNormalization.cpp b/Modules/Classification/CLMiniApps/CLMRNormalization.cpp
index 47ad30bf60..3dbcc57e48 100644
--- a/Modules/Classification/CLMiniApps/CLMRNormalization.cpp
+++ b/Modules/Classification/CLMiniApps/CLMRNormalization.cpp
@@ -1,134 +1,134 @@
 /*===================================================================
 
 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 mitkCLPolyToNrrd_cpp
 #define mitkCLPolyToNrrd_cpp
 
 #include "time.h"
 #include <sstream>
 #include <fstream>
 
 #include <mitkIOUtil.h>
 #include "mitkCommandLineParser.h"
 
 #include "itkImageRegionIterator.h"
 // MITK
 #include <mitkITKImageImport.h>
 #include <mitkImageCast.h>
 #include <mitkImageAccessByItk.h>
 
 #include <mitkMRNormLinearStatisticBasedFilter.h>
 #include <mitkMRNormTwoRegionBasedFilter.h>
 // ITK
 #include <itkLabelStatisticsImageFilter.h>
 #include <itkMinimumMaximumImageCalculator.h>
 
 typedef itk::Image< double, 3 >                 FloatImageType;
 typedef itk::Image< unsigned char, 3 >          MaskImageType;
 
 int main(int argc, char* argv[])
 {
   MITK_INFO << "Start";
   mitkCommandLineParser parser;
   parser.setArgumentPrefix("--", "-");
   // required params
   parser.addArgument("image", "i", mitkCommandLineParser::InputImage, "Input Image", "Path to the input VTK polydata", us::Any(), false);
   parser.addArgument("mode", "mode", mitkCommandLineParser::InputImage, "Normalisation mode", "1,2,3: Single Area normalization to Mean, Median, Mode, 4,5,6: Mean, Median, Mode of two regions. ", us::Any(), false);
   parser.addArgument("mask0", "m0", mitkCommandLineParser::InputImage, "Input Mask", "The median of the area covered by this mask will be set to 0", us::Any(), false);
   parser.addArgument("mask1", "m1", mitkCommandLineParser::InputImage, "Input Mask", "The median of the area covered by this mask will be set to 1", us::Any(), true);
   parser.addArgument("output", "o", mitkCommandLineParser::OutputFile, "Output Image", "Target file. The output statistic is appended to this file.", us::Any(), false);
 
   // Miniapp Infos
   parser.setCategory("Classification Tools");
   parser.setTitle("MR Normalization Tool");
   parser.setDescription("Normalizes a MR image. Sets the Median of the tissue covered by mask 0 to 0 and the median of the area covered by mask 1 to 1.");
   parser.setContributor("MBI");
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
 
   if (parsedArgs.size()==0)
   {
     return EXIT_FAILURE;
   }
   if ( parsedArgs.count("help") || parsedArgs.count("h"))
   {
     return EXIT_SUCCESS;
   }
 
   MITK_INFO << "Mode access";
-  int mode =stoi(us::any_cast<string>(parsedArgs["mode"]));
+  int mode =std::stoi(us::any_cast<std::string>(parsedArgs["mode"]));
   MITK_INFO << "Mode: " << mode;
 
   MITK_INFO << "Read images";
   mitk::Image::Pointer mask1;
   mitk::Image::Pointer image = mitk::IOUtil::LoadImage(parsedArgs["image"].ToString());
   mitk::Image::Pointer mask0 = mitk::IOUtil::LoadImage(parsedArgs["mask0"].ToString());
   if (mode > 3)
   {
     mask1 = mitk::IOUtil::LoadImage(parsedArgs["mask1"].ToString());
   }
   mitk::MRNormLinearStatisticBasedFilter::Pointer oneRegion = mitk::MRNormLinearStatisticBasedFilter::New();
   mitk::MRNormTwoRegionsBasedFilter::Pointer twoRegion = mitk::MRNormTwoRegionsBasedFilter::New();
   mitk::Image::Pointer output;
 
   oneRegion->SetInput(image);
   oneRegion->SetMask(mask0);
   twoRegion->SetInput(image);
   twoRegion->SetMask1(mask0);
   twoRegion->SetMask2(mask1);
 
   switch (mode)
   {
   case 1:
     oneRegion->SetCenterMode(mitk::MRNormLinearStatisticBasedFilter::MEAN);
     oneRegion->Update();
     output=oneRegion->GetOutput();
     break;
   case 2:
     oneRegion->SetCenterMode(mitk::MRNormLinearStatisticBasedFilter::MEDIAN);
     oneRegion->Update();
     output=oneRegion->GetOutput();
     break;
   case 3:
     oneRegion->SetCenterMode(mitk::MRNormLinearStatisticBasedFilter::MODE);
     oneRegion->Update();
     output=oneRegion->GetOutput();
     break;
   case 4:
     twoRegion->SetArea1(mitk::MRNormTwoRegionsBasedFilter::MEAN);
     twoRegion->SetArea2(mitk::MRNormTwoRegionsBasedFilter::MEAN);
     twoRegion->Update();
     output=twoRegion->GetOutput();
     break;
   case 5:
     twoRegion->SetArea1(mitk::MRNormTwoRegionsBasedFilter::MEDIAN);
     twoRegion->SetArea2(mitk::MRNormTwoRegionsBasedFilter::MEDIAN);
     twoRegion->Update();
     output=twoRegion->GetOutput();
     break;
   case 6:
     twoRegion->SetArea1(mitk::MRNormTwoRegionsBasedFilter::MODE);
     twoRegion->SetArea2(mitk::MRNormTwoRegionsBasedFilter::MODE);
     twoRegion->Update();
     output=twoRegion->GetOutput();
     break;
   }
 
   mitk::IOUtil::SaveImage(output, parsedArgs["output"].ToString());
 
   return 0;
 }
 
 #endif
\ No newline at end of file
diff --git a/Modules/Classification/CLMiniApps/CLN4.cpp b/Modules/Classification/CLMiniApps/CLN4.cpp
index 837ab399fd..65e742a61b 100644
--- a/Modules/Classification/CLMiniApps/CLN4.cpp
+++ b/Modules/Classification/CLMiniApps/CLN4.cpp
@@ -1,112 +1,112 @@
 /*===================================================================
 
 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 <mitkImageCast.h>
 #include "mitkCommandLineParser.h"
 #include <itkN4BiasFieldCorrectionImageFilter.h>
 
 #include <itkSTAPLEImageFilter.h>
 
 int main(int argc, char* argv[])
 {
   typedef itk::Image<unsigned char, 3> MaskImageType;
   typedef itk::Image<float, 3> ImageType;
   typedef itk::N4BiasFieldCorrectionImageFilter < ImageType, MaskImageType, ImageType > FilterType;
 
   mitkCommandLineParser parser;
   parser.setTitle("N4 Bias Field Correction");
   parser.setCategory("Classification Command Tools");
   parser.setDescription("");
   parser.setContributor("MBI");
 
   parser.setArgumentPrefix("--", "-");
   // Add command line argument names
   parser.addArgument("help", "h", mitkCommandLineParser::Bool, "Help:", "Show this help text");
   parser.addArgument("input", "i", mitkCommandLineParser::InputDirectory, "Input file:", "Input file", us::Any(), false);
   parser.addArgument("mask", "m", mitkCommandLineParser::OutputFile, "Output file:", "Mask file", us::Any(), false);
   parser.addArgument("output", "o", mitkCommandLineParser::OutputFile, "Output file:", "Output file", us::Any(), false);
 
   parser.addArgument("number-of-controllpoints", "noc", mitkCommandLineParser::Int, "Parameter", "The noc for the point grid size defining the B-spline estimate (default 4)", us::Any(), true);
   parser.addArgument("number-of-fitting-levels", "nofl", mitkCommandLineParser::Int, "Parameter", "Number of fitting levels for the multi-scale approach (default 1)", us::Any(), true);
   parser.addArgument("number-of-histogram-bins", "nofl", mitkCommandLineParser::Int, "Parameter", "number of bins defining the log input intensity histogram (default 200)", us::Any(), true);
   parser.addArgument("spline-order", "so", mitkCommandLineParser::Int, "Parameter", "Define the spline order (default 3)", us::Any(), true);
   parser.addArgument("winer-filter-noise", "wfn", mitkCommandLineParser::Float, "Parameter", "Noise estimate defining the Wiener filter (default 0.01)", us::Any(), true);
 
 
-  map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
+  std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
 
   // Show a help message
   if (parsedArgs.count("help") || parsedArgs.count("h"))
   {
     std::cout << parser.helpText();
     return EXIT_SUCCESS;
   }
 
   MaskImageType::Pointer itkMsk = MaskImageType::New();
   mitk::Image::Pointer img = mitk::IOUtil::LoadImage(parsedArgs["mask"].ToString());
   mitk::CastToItkImage(img, itkMsk);
 
   ImageType::Pointer itkImage = ImageType::New();
   mitk::Image::Pointer img2 = mitk::IOUtil::LoadImage(parsedArgs["input"].ToString());
   mitk::CastToItkImage(img2, itkImage);
 
   FilterType::Pointer filter = FilterType::New();
   filter->SetInput(itkImage);
   filter->SetMaskImage(itkMsk);
 
 
 
   if (parsedArgs.count("number-of-controllpoints") > 0)
   {
     int variable = us::any_cast<int>(parsedArgs["maximum-iterations"]);
     MITK_INFO << "Number of controll points: " << variable;
     filter->SetNumberOfControlPoints(variable);
   }
   if (parsedArgs.count("number-of-fitting-levels") > 0)
   {
     int variable = us::any_cast<int>(parsedArgs["number-of-fitting-levels"]);
     MITK_INFO << "Number of fitting levels: " << variable;
     filter->SetNumberOfFittingLevels(variable);
   }
   if (parsedArgs.count("number-of-histogram-bins") > 0)
   {
     int variable = us::any_cast<int>(parsedArgs["number-of-histogram-bins"]);
     MITK_INFO << "Number of histogram bins: " << variable;
     filter->SetNumberOfHistogramBins(variable);
   }
   if (parsedArgs.count("spline-order") > 0)
   {
     int variable = us::any_cast<int>(parsedArgs["spline-order"]);
     MITK_INFO << "Spline Order " << variable;
     filter->SetSplineOrder(variable);
   }
   if (parsedArgs.count("winer-filter-noise") > 0)
   {
     float variable = us::any_cast<float>(parsedArgs["winer-filter-noise"]);
     MITK_INFO << "Number of histogram bins: " << variable;
     filter->SetWienerFilterNoise(variable);
   }
 
   filter->Update();
   auto out = filter->GetOutput();
   mitk::Image::Pointer outImg = mitk::Image::New();
   mitk::CastToMitkImage(out, outImg);
   mitk::IOUtil::SaveImage(outImg, parsedArgs["output"].ToString());
 
   return EXIT_SUCCESS;
 }
\ No newline at end of file
diff --git a/Modules/Classification/CLMiniApps/CLNrrdToPoly.cpp b/Modules/Classification/CLMiniApps/CLNrrdToPoly.cpp
index 3dead7c22d..b7eb90a499 100644
--- a/Modules/Classification/CLMiniApps/CLNrrdToPoly.cpp
+++ b/Modules/Classification/CLMiniApps/CLNrrdToPoly.cpp
@@ -1,78 +1,78 @@
 /*===================================================================
 
 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 mitkCLPolyToNrrd_cpp
 #define mitkCLPolyToNrrd_cpp
 
 #include "time.h"
 #include <sstream>
 #include <fstream>
 
 #include <mitkIOUtil.h>
 #include "mitkCommandLineParser.h"
 
 // VTK
 #include <vtkSmartPointer.h>
 #include <vtkImageMarchingCubes.h>
 #include <vtkXMLPolyDataWriter.h>
 
 typedef itk::Image< double, 3 >                 FloatImageType;
 typedef itk::Image< unsigned char, 3 >          MaskImageType;
 
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
   parser.setArgumentPrefix("--", "-");
   // required params
   parser.addArgument("mask", "m", mitkCommandLineParser::InputImage, "Input Mask", "Mask Image that specifies the area over for the statistic, (Values = 1)", us::Any(), false);
   parser.addArgument("output", "o", mitkCommandLineParser::OutputFile, "Output text file", "Target file. The output statistic is appended to this file.", us::Any(), false);
 
   // Miniapp Infos
   parser.setCategory("Classification Tools");
   parser.setTitle("Segmentation to Mask");
   parser.setDescription("Estimates a Mesh from a segmentation");
   parser.setContributor("MBI");
 
-  map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
+  std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
 
   if (parsedArgs.size()==0)
   {
     return EXIT_FAILURE;
   }
   if ( parsedArgs.count("help") || parsedArgs.count("h"))
   {
     return EXIT_SUCCESS;
   }
 
   MITK_INFO << "Version: "<< 1.0;
 
   mitk::Image::Pointer mask = mitk::IOUtil::LoadImage(parsedArgs["mask"].ToString());
 
 
   vtkSmartPointer<vtkImageData> image = mask->GetVtkImageData();
   image->SetOrigin(mask->GetGeometry()->GetOrigin()[0], mask->GetGeometry()->GetOrigin()[1], mask->GetGeometry()->GetOrigin()[2]);
   vtkSmartPointer<vtkImageMarchingCubes> mesher = vtkSmartPointer<vtkImageMarchingCubes>::New();
   mesher->SetInputData(image);
   mitk::Surface::Pointer surf = mitk::Surface::New();
   mesher->SetValue(0,0.5);
   mesher->Update();
   surf->SetVtkPolyData(mesher->GetOutput());
   mitk::IOUtil::Save(surf, parsedArgs["output"].ToString());
 
   return 0;
 }
 
 #endif
\ No newline at end of file
diff --git a/Modules/Classification/CLMiniApps/CLRandomSampling.cpp b/Modules/Classification/CLMiniApps/CLRandomSampling.cpp
index ea98e3ee26..42b59ae7db 100644
--- a/Modules/Classification/CLMiniApps/CLRandomSampling.cpp
+++ b/Modules/Classification/CLMiniApps/CLRandomSampling.cpp
@@ -1,158 +1,158 @@
 /*===================================================================
 
 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 <mitkRandomImageSampler.h>
 
-static vector<double> splitDouble(string str, char delimiter) {
-  vector<double> internal;
-  stringstream ss(str); // Turn the string into a stream.
-  string tok;
+static std::vector<double> splitDouble(std::string str, char delimiter) {
+  std::vector<double> internal;
+  std::stringstream ss(str); // Turn the string into a stream.
+  std::string tok;
   double val;
   while (getline(ss, tok, delimiter)) {
-    stringstream s2(tok);
+    std::stringstream s2(tok);
     s2 >> val;
     internal.push_back(val);
   }
 
   return internal;
 }
 
-static vector<unsigned int> splitUInt(string str, char delimiter) {
-  vector<unsigned int> internal;
-  stringstream ss(str); // Turn the string into a stream.
-  string tok;
+static std::vector<unsigned int> splitUInt(std::string str, char delimiter) {
+  std::vector<unsigned int> internal;
+  std::stringstream ss(str); // Turn the string into a stream.
+  std::string tok;
   unsigned int val;
   while (getline(ss, tok, delimiter)) {
-    stringstream s2(tok);
+    std::stringstream s2(tok);
     s2 >> val;
     internal.push_back(val);
   }
 
   return internal;
 }
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Random Sampling");
   parser.setCategory("Classification Command Tools");
   parser.setDescription("");
   parser.setContributor("MBI");
 
   parser.setArgumentPrefix("--", "-");
   // Add command line argument names
   parser.addArgument("help", "h", mitkCommandLineParser::Bool, "Help:", "Show this help text");
   parser.addArgument("input", "i", mitkCommandLineParser::InputDirectory, "Input file:", "Input file", us::Any(), false);
   parser.addArgument("output", "o", mitkCommandLineParser::OutputFile, "Output file:", "Output file", us::Any(), false);
 
   parser.addArgument("single-rate", "sr", mitkCommandLineParser::OutputFile, "Single Acceptance rate for all voxel", "Output file", us::Any(), true);
   parser.addArgument("class-rate", "cr", mitkCommandLineParser::OutputFile, "Class-dependend acceptance rate", "Output file", us::Any(), true);
   parser.addArgument("single-number", "sn", mitkCommandLineParser::OutputFile, "Single Number of Voxel for each class", "Output file", us::Any(), true);
   parser.addArgument("class-number", "cn", mitkCommandLineParser::OutputFile, "Class-dependedn number of voxels ", "Output file", us::Any(), true);
 
-  map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
+  std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
 
   if (parsedArgs.size() == 0)
     return EXIT_FAILURE;
 
   // Show a help message
   if (parsedArgs.count("help") || parsedArgs.count("h"))
   {
     std::cout << parser.helpText();
     return EXIT_SUCCESS;
   }
 
   if (parsedArgs.count("single-rate") + parsedArgs.count("class-rate") + parsedArgs.count("single-number") + parsedArgs.count("class-number") < 1)
   {
     std::cout << "Please specify the sampling rate or number of voxels to be labeled" << std::endl << std::endl;
     std::cout << parser.helpText();
     return EXIT_SUCCESS;
   }
 
   if (parsedArgs.count("single-rate") + parsedArgs.count("class-rate") + parsedArgs.count("single-number") + parsedArgs.count("class-number") > 2)
   {
     std::cout << "Please specify only one way for the sampling rate or number of voxels to be labeled" << std::endl << std::endl;
     std::cout << parser.helpText();
     return EXIT_SUCCESS;
   }
 
 
-  std::string inputName = us::any_cast<string>(parsedArgs["input"]);
-  std::string outputName = us::any_cast<string>(parsedArgs["output"]);
+  std::string inputName = us::any_cast<std::string>(parsedArgs["input"]);
+  std::string outputName = us::any_cast<std::string>(parsedArgs["output"]);
   mitk::Image::Pointer image = mitk::IOUtil::LoadImage(inputName);
 
   mitk::RandomImageSampler::Pointer filter = mitk::RandomImageSampler::New();
   filter->SetInput(image);
 
   if (parsedArgs.count("single-rate"))
   {
     filter->SetSamplingMode(mitk::RandomImageSamplerMode::SINGLE_ACCEPTANCE_RATE);
     auto rate = splitDouble(parsedArgs["single-rate"].ToString(), ';');
     if (rate.size() != 1)
     {
       std::cout << "Please specify a single double value for single-rate, for example 0.3." << std::endl << std::endl;
       std::cout << parser.helpText();
       return EXIT_SUCCESS;
     }
     filter->SetAcceptanceRate(rate[0]);
   }
 
   else if (parsedArgs.count("class-rate"))
   {
     filter->SetSamplingMode(mitk::RandomImageSamplerMode::CLASS_DEPENDEND_ACCEPTANCE_RATE);
     auto rate = splitDouble(parsedArgs["class-rate"].ToString(), ';');
     if (rate.size() < 2)
     {
       std::cout << "Please specify at least two, semicolon separated values for class-rate, for example '0.3;0.2' ." << std::endl << std::endl;
       std::cout << parser.helpText();
       return EXIT_SUCCESS;
     }
     filter->SetAcceptanceRateVector(rate);
   }
 
   else if (parsedArgs.count("single-number"))
   {
     filter->SetSamplingMode(mitk::RandomImageSamplerMode::SINGLE_NUMBER_OF_ACCEPTANCE);
     auto rate = splitUInt(parsedArgs["single-number"].ToString(), ';');
     if (rate.size() != 1)
     {
       std::cout << "Please specify a single double value for single-number, for example 100." << std::endl << std::endl;
       std::cout << parser.helpText();
       return EXIT_SUCCESS;
     }
     filter->SetNumberOfSamples(rate[0]);
   }
 
   else if (parsedArgs.count("class-number"))
   {
     filter->SetSamplingMode(mitk::RandomImageSamplerMode::CLASS_DEPENDEND_NUMBER_OF_ACCEPTANCE);
     auto rate = splitUInt(parsedArgs["class-number"].ToString(), ';');
     if (rate.size() < 2)
     {
       std::cout << "Please specify at least two, semicolon separated values for class-number, for example '100;200' ." << std::endl << std::endl;
       std::cout << parser.helpText();
       return EXIT_SUCCESS;
     }
     filter->SetNumberOfSamplesVector(rate);
   }
   filter->Update();
   mitk::IOUtil::SaveImage(filter->GetOutput(), outputName);
 
   return EXIT_SUCCESS;
 }
\ No newline at end of file
diff --git a/Modules/Classification/CLMiniApps/CLRemoveEmptyVoxels.cpp b/Modules/Classification/CLMiniApps/CLRemoveEmptyVoxels.cpp
index 2f2a955c07..51275ae701 100644
--- a/Modules/Classification/CLMiniApps/CLRemoveEmptyVoxels.cpp
+++ b/Modules/Classification/CLMiniApps/CLRemoveEmptyVoxels.cpp
@@ -1,159 +1,159 @@
 /*===================================================================
 
 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 "mitkImageCast.h"
 #include <itkImageRegionConstIterator.h>
 #include <itkImageRegionIterator.h>
 #include "mitkImageGenerator.h"
 
 int main(int argc, char* argv[])
 {
   typedef itk::Image<double, 3> ImageType;
   typedef itk::Image<unsigned char, 3> MaskImageType;
   typedef ImageType::Pointer ImagePointerType;
   typedef MaskImageType::Pointer MaskImagePointerType;
 
   typedef itk::ImageRegionConstIterator<ImageType> ConstIteratorType;
   typedef itk::ImageRegionConstIterator<MaskImageType> ConstMaskIteratorType;
   typedef itk::ImageRegionIterator<ImageType> IteratorType;
   typedef itk::ImageRegionIterator<MaskImageType> MaskIteratorType;
 
   mitkCommandLineParser parser;
 
   parser.setTitle("Remove empty voxels Sampling");
   parser.setCategory("Classification Command Tools");
   parser.setDescription("");
   parser.setContributor("MBI");
 
   parser.setArgumentPrefix("--", "-");
   // Add command line argument names
   parser.addArgument("help", "h", mitkCommandLineParser::Bool, "Help:", "Show this help text");
   parser.addArgument("mask-input", "mi", mitkCommandLineParser::InputDirectory, "Input file:", "Input file", us::Any(), false);
   parser.addArgument("mask-output", "mo", mitkCommandLineParser::OutputFile, "Output file:", "Output file", us::Any(), false);
 
   for (int i = 0; i < 100; ++i)
   {
-    stringstream s1; s1 << i; std::string number = s1.str();
+    std::stringstream s1; s1 << i; std::string number = s1.str();
     parser.addArgument("input"+number, "i"+number, mitkCommandLineParser::OutputFile, "Input file", "input file", us::Any(), true);
     parser.addArgument("output" + number, "o" + number, mitkCommandLineParser::OutputFile, "Output File", "Output file", us::Any(), true);
   }
 
-  map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
+  std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
 
   if (parsedArgs.size() == 0)
     return EXIT_FAILURE;
 
   // Show a help message
   if (parsedArgs.count("help") || parsedArgs.count("h"))
   {
     std::cout << parser.helpText();
     return EXIT_SUCCESS;
   }
 
   // Load Mask Image and count number of non-zero voxels
   mitk::Image::Pointer mask = mitk::IOUtil::LoadImage(parsedArgs["mask-input"].ToString());
   MaskImagePointerType itkMask = MaskImageType::New();
   mitk::CastToItkImage(mask, itkMask);
   ConstMaskIteratorType maskIter(itkMask, itkMask->GetLargestPossibleRegion());
   std::size_t nonZero = 0;
   while (!maskIter.IsAtEnd())
   {
     if (maskIter.Value() > 0)
     {
       ++nonZero;
     }
     ++maskIter;
   }
   maskIter.GoToBegin();
 
   // Create new mask image
   auto mitkNewMask = mitk::ImageGenerator::GenerateGradientImage<unsigned char>(nonZero, 1, 1, 1, 1, 1);
   MaskImagePointerType itkNewMask = MaskImageType::New();
   mitk::CastToItkImage(mitkNewMask, itkNewMask);
   MaskIteratorType newMaskIter(itkNewMask, itkNewMask->GetLargestPossibleRegion());
 
   // Read additional image
   std::vector<mitk::Image::Pointer> mitkImagesVector;
   std::vector<ImagePointerType> itkImageVector;
   std::vector<ImagePointerType> itkOutputImageVector;
   std::vector<ConstIteratorType> inputIteratorVector;
   std::vector<IteratorType> outputIteratorVector;
   for (int i = 0; i < 100; ++i)
   {
-    stringstream s1; s1 << i; std::string number = s1.str();
+    std::stringstream s1; s1 << i; std::string number = s1.str();
     if (parsedArgs.count("input" + number) < 1)
       break;
     if (parsedArgs.count("output" + number) < 1)
       break;
 
     mitk::Image::Pointer image = mitk::IOUtil::LoadImage(parsedArgs["input"+number].ToString());
     mitkImagesVector.push_back(image);
 
     ImagePointerType itkImage = ImageType::New();
     mitk::CastToItkImage(image, itkImage);
     itkImageVector.push_back(itkImage);
 
     ConstIteratorType iter(itkImage, itkImage->GetLargestPossibleRegion());
     inputIteratorVector.push_back(iter);
 
     auto mitkNewImage = mitk::ImageGenerator::GenerateGradientImage<double>(nonZero, 1, 1, 1, 1, 1);
     ImagePointerType itkNewOutput = ImageType::New();
     mitk::CastToItkImage(mitkNewImage, itkNewOutput);
     IteratorType outputIter(itkNewOutput, itkNewOutput->GetLargestPossibleRegion());
     itkOutputImageVector.push_back(itkNewOutput);
     outputIteratorVector.push_back(outputIter);
   }
 
   // Convert non-zero voxels to the new images
   while (!maskIter.IsAtEnd())
   {
     if (maskIter.Value() > 0)
     {
       newMaskIter.Set(maskIter.Value());
       ++newMaskIter;
       for (int i = 0; i < outputIteratorVector.size(); ++i)
       {
         outputIteratorVector[i].Set(inputIteratorVector[i].Value());
         ++(outputIteratorVector[i]);
       }
     }
     ++maskIter;
     for (int i = 0; i < inputIteratorVector.size(); ++i)
     {
       ++(inputIteratorVector[i]);
     }
 
   }
 
   // Save the new images
   for (int i = 0; i < outputIteratorVector.size(); ++i)
   {
-    stringstream s1; s1 << i; std::string number = s1.str();
+    std::stringstream s1; s1 << i; std::string number = s1.str();
     mitk::Image::Pointer mitkImage = mitk::Image::New();
     mitk::CastToMitkImage(itkOutputImageVector[i], mitkImage);
     mitk::IOUtil::SaveImage(mitkImage, parsedArgs["output" + number].ToString());
   }
   // Save the new mask
   {
     mitk::Image::Pointer mitkImage = mitk::Image::New();
     mitk::CastToMitkImage(itkNewMask, mitkImage);
     mitk::IOUtil::SaveImage(mitkImage, parsedArgs["mask-output"].ToString());
   }
 
   return EXIT_SUCCESS;
 }
\ No newline at end of file
diff --git a/Modules/Classification/CLMiniApps/CLResampleImageToReference.cpp b/Modules/Classification/CLMiniApps/CLResampleImageToReference.cpp
index def14065c3..3d00cc041f 100644
--- a/Modules/Classification/CLMiniApps/CLResampleImageToReference.cpp
+++ b/Modules/Classification/CLMiniApps/CLResampleImageToReference.cpp
@@ -1,116 +1,116 @@
 /*===================================================================
 
 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 mitkCLResampleImageToReference_cpp
 #define mitkCLResampleImageToReference_cpp
 
 #include "mitkCommandLineParser.h"
 #include <mitkImageAccessByItk.h>
 #include <mitkIOUtil.h>
 #include <mitkImage.h>
 #include <mitkImageCast.h>
 #include <mitkITKImageImport.h>
 #include <mitkImageTimeSelector.h>
 
 // ITK
 #include "itkLinearInterpolateImageFunction.h"
 #include "itkWindowedSincInterpolateImageFunction.h"
 #include "itkNearestNeighborInterpolateImageFunction.h"
 #include "itkIdentityTransform.h"
 #include "itkResampleImageFilter.h"
 
 
 template<typename TPixel, unsigned int VImageDimension>
 void
 ResampleImageToReferenceFunction(itk::Image<TPixel, VImageDimension>* itkReference, mitk::Image::Pointer moving, std::string ergPath)
 {
   typedef itk::Image<TPixel, VImageDimension> InputImageType;
 
   // Identify Transform
   typedef itk::IdentityTransform<double, VImageDimension> T_Transform;
   typename T_Transform::Pointer _pTransform = T_Transform::New();
   _pTransform->SetIdentity();
 
   typedef itk::WindowedSincInterpolateImageFunction< InputImageType, VImageDimension> WindowedSincInterpolatorType;
   typename WindowedSincInterpolatorType::Pointer sinc_interpolator = WindowedSincInterpolatorType::New();
 
   typedef itk::LinearInterpolateImageFunction< InputImageType> LinearInterpolateImageFunctionType;
   typename LinearInterpolateImageFunctionType::Pointer lin_interpolator = LinearInterpolateImageFunctionType::New();
 
   typedef itk::NearestNeighborInterpolateImageFunction< InputImageType> NearestNeighborInterpolateImageFunctionType;
   typename NearestNeighborInterpolateImageFunctionType::Pointer nn_interpolator = NearestNeighborInterpolateImageFunctionType::New();
 
   typename InputImageType::Pointer itkMoving = InputImageType::New();
   mitk::CastToItkImage(moving,itkMoving);
   typedef itk::ResampleImageFilter<InputImageType, InputImageType>  ResampleFilterType;
 
   typename ResampleFilterType::Pointer resampler = ResampleFilterType::New();
   resampler->SetInput(itkMoving);
   resampler->SetReferenceImage( itkReference );
   resampler->UseReferenceImageOn();
   resampler->SetTransform(_pTransform);
   //if ( sincInterpol)
   //  resampler->SetInterpolator(sinc_interpolator);
   //else
     resampler->SetInterpolator(lin_interpolator);
 
   resampler->Update();
 
   // Convert back to mitk
   mitk::Image::Pointer result = mitk::Image::New();
   result->InitializeByItk(resampler->GetOutput());
   GrabItkImageMemory(resampler->GetOutput(), result);
   MITK_INFO << "writing result to: " << ergPath;
   mitk::IOUtil::SaveImage(result, ergPath);
   //return result;
 }
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
   parser.setArgumentPrefix("--", "-");
   // required params
   parser.addArgument("fix", "f", mitkCommandLineParser::InputImage, "Input Image", "Path to the input VTK polydata", us::Any(), false);
   parser.addArgument("moving", "m", mitkCommandLineParser::OutputFile, "Output text file", "Target file. The output statistic is appended to this file.", us::Any(), false);
   parser.addArgument("output", "o", mitkCommandLineParser::OutputFile, "Extension", "File extension. Default is .nii.gz", us::Any(), false);
 
   // Miniapp Infos
   parser.setCategory("Classification Tools");
   parser.setTitle("Resample Image To Reference");
   parser.setDescription("Resamples an image (moving) to an given image (fix) without additional registration.");
   parser.setContributor("MBI");
 
-  map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
+  std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
 
   if (parsedArgs.size() == 0)
   {
     return EXIT_FAILURE;
   }
   if (parsedArgs.count("help") || parsedArgs.count("h"))
   {
     return EXIT_SUCCESS;
   }
 
   mitk::Image::Pointer fix = mitk::IOUtil::LoadImage(parsedArgs["fix"].ToString());
   mitk::Image::Pointer moving = mitk::IOUtil::LoadImage(parsedArgs["moving"].ToString());
   mitk::Image::Pointer erg = mitk::Image::New();
 
   AccessByItk_2(fix, ResampleImageToReferenceFunction, moving, parsedArgs["output"].ToString());
 
 }
 
 
 
 #endif
diff --git a/Modules/Classification/CLMiniApps/CMakeLists.txt b/Modules/Classification/CLMiniApps/CMakeLists.txt
index c093d569b4..5c2ff09056 100644
--- a/Modules/Classification/CLMiniApps/CMakeLists.txt
+++ b/Modules/Classification/CLMiniApps/CMakeLists.txt
@@ -1,135 +1,136 @@
 option(BUILD_ClassificationMiniApps "Build commandline tools for classification" OFF)
 
 if(BUILD_ClassificationMiniApps OR MITK_BUILD_ALL_APPS)
 
 
   include_directories(
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${CMAKE_CURRENT_BINARY_DIR}
     )
 
     # list of miniapps
     # if an app requires additional dependencies
     # they are added after a "^^" and separated by "_"
     set( classificationminiapps
         RandomForestTraining^^MitkCLVigraRandomForest
         NativeHeadCTSegmentation^^MitkCLVigraRandomForest
         ManualSegmentationEvaluation^^MitkCLVigraRandomForest
         CLGlobalImageFeatures^^MitkCore_MitkCLUtilities
         CLMRNormalization^^MitkCore_MitkCLUtilities_MitkCLMRUtilities
         CLStaple^^MitkCore_MitkCLUtilities
         CLVoxelFeatures^^MitkCore_MitkCLUtilities
         CLDicom2Nrrd^^MitkCore
         CLPolyToNrrd^^MitkCore
         CLImageTypeConverter^^MitkCore
         CLResampleImageToReference^^MitkCore
         CLRandomSampling^^MitkCore_MitkCLUtilities
         CLRemoveEmptyVoxels^^MitkCore
         CLN4^^MitkCore
         CLMultiForestPrediction^^MitkDataCollection_MitkCLVigraRandomForest
         CLNrrdToPoly^^MitkCore
     #    RandomForestPrediction^^MitkCLVigraRandomForest
     )
 
     foreach(classificationminiapps ${classificationminiapps})
       # extract mini app name and dependencies
       string(REPLACE "^^" "\\;" miniapp_info ${classificationminiapps})
       set(miniapp_info_list ${miniapp_info})
       list(GET miniapp_info_list 0 appname)
       list(GET miniapp_info_list 1 raw_dependencies)
       string(REPLACE "_" "\\;" dependencies "${raw_dependencies}")
       set(dependencies_list ${dependencies})
 
       mitk_create_executable(${appname}
-      DEPENDS MitkCore MitkCLCore ${dependencies_list}
-      PACKAGE_DEPENDS ITK Qt4|QtCore Qt5|Core Vigra
-      CPP_FILES ${appname}.cpp mitkCommandLineParser.cpp
+      DEPENDS MitkCore MitkCLCore MitkCommandLine ${dependencies_list}
+      PACKAGE_DEPENDS ITK Qt5|Core Vigra
+      CPP_FILES ${appname}.cpp
       )
+      # CPP_FILES ${appname}.cpp mitkCommandLineParser.cpp
 
       if(EXECUTABLE_IS_ENABLED)
 
         # On Linux, create a shell script to start a relocatable application
         if(UNIX AND NOT APPLE)
           install(PROGRAMS "${MITK_SOURCE_DIR}/CMake/RunInstalledApp.sh" DESTINATION "." RENAME ${EXECUTABLE_TARGET}.sh)
         endif()
 
         get_target_property(_is_bundle ${EXECUTABLE_TARGET} MACOSX_BUNDLE)
 
         if(APPLE)
          if(_is_bundle)
            set(_target_locations ${EXECUTABLE_TARGET}.app)
            set(${_target_locations}_qt_plugins_install_dir ${EXECUTABLE_TARGET}.app/Contents/MacOS)
            set(_bundle_dest_dir ${EXECUTABLE_TARGET}.app/Contents/MacOS)
            set(_qt_plugins_for_current_bundle ${EXECUTABLE_TARGET}.app/Contents/MacOS)
            set(_qt_conf_install_dirs ${EXECUTABLE_TARGET}.app/Contents/Resources)
            install(TARGETS ${EXECUTABLE_TARGET} BUNDLE DESTINATION . )
          else()
            if(NOT MACOSX_BUNDLE_NAMES)
              set(_qt_conf_install_dirs bin)
              set(_target_locations bin/${EXECUTABLE_TARGET})
              set(${_target_locations}_qt_plugins_install_dir bin)
              install(TARGETS ${EXECUTABLE_TARGET} RUNTIME DESTINATION bin)
            else()
              foreach(bundle_name ${MACOSX_BUNDLE_NAMES})
                list(APPEND _qt_conf_install_dirs ${bundle_name}.app/Contents/Resources)
                set(_current_target_location ${bundle_name}.app/Contents/MacOS/${EXECUTABLE_TARGET})
                list(APPEND _target_locations ${_current_target_location})
                set(${_current_target_location}_qt_plugins_install_dir ${bundle_name}.app/Contents/MacOS)
                message( "  set(${_current_target_location}_qt_plugins_install_dir ${bundle_name}.app/Contents/MacOS) ")
 
                install(TARGETS ${EXECUTABLE_TARGET} RUNTIME DESTINATION ${bundle_name}.app/Contents/MacOS/)
              endforeach()
            endif()
          endif()
        else()
          set(_target_locations bin/${EXECUTABLE_TARGET}${CMAKE_EXECUTABLE_SUFFIX})
          set(${_target_locations}_qt_plugins_install_dir bin)
          set(_qt_conf_install_dirs bin)
          install(TARGETS ${EXECUTABLE_TARGET} RUNTIME DESTINATION bin)
        endif()
       endif()
     endforeach()
 
   # This mini app does not depend on mitkDiffusionImaging at all
 
   #mitk_create_executable(CLGlobalImageFeatures
   #  DEPENDS MitkCore MitkCLUtilities
   #  CPP_FILES CLGlobalImageFeatures.cpp mitkCommandLineParser.cpp
   #)
 
   mitk_create_executable(CLSimpleVoxelClassification
     DEPENDS MitkCore MitkCLCore MitkDataCollection MitkCLVigraRandomForest MitkCommandLine
     CPP_FILES CLSimpleVoxelClassification.cpp
   )
   # This mini app does not depend on mitkDiffusionImaging at all
   mitk_create_executable(CLVoxelClassification
     DEPENDS MitkCore MitkCLCore MitkDataCollection MitkCLImportanceWeighting MitkCLVigraRandomForest
     CPP_FILES CLVoxelClassification.cpp
   )
-  mitk_create_executable(CLBrainMask
-    DEPENDS MitkCore MitkCLUtilities
-    CPP_FILES CLBrainMask.cpp mitkCommandLineParser.cpp
-  )
-  mitk_create_executable(CLImageConverter
-    DEPENDS MitkCore
-    CPP_FILES CLImageConverter.cpp mitkCommandLineParser.cpp
-  )
-  mitk_create_executable(CLSurWeighting
-    DEPENDS MitkCore MitkCLUtilities MitkDataCollection MitkCLImportanceWeighting
-    CPP_FILES CLSurWeighting.cpp mitkCommandLineParser.cpp
-  )
-  mitk_create_executable(CLImageCropper
-    DEPENDS MitkCore MitkCLUtilities MitkAlgorithmsExt
-    CPP_FILES CLImageCropper.cpp mitkCommandLineParser.cpp
-  )
+  #mitk_create_executable(CLBrainMask
+  #  DEPENDS MitkCore MitkCLUtilities
+  #  CPP_FILES CLBrainMask.cpp mitkCommandLineParser.cpp
+  #)
+  #mitk_create_executable(CLImageConverter
+  #  DEPENDS MitkCore
+  #  CPP_FILES CLImageConverter.cpp mitkCommandLineParser.cpp
+  #)
+  #mitk_create_executable(CLSurWeighting
+  #  DEPENDS MitkCore MitkCLUtilities MitkDataCollection #MitkCLImportanceWeighting
+  #  CPP_FILES CLSurWeighting.cpp mitkCommandLineParser.cpp
+  #)
+  #mitk_create_executable(CLImageCropper
+  #  DEPENDS MitkCore MitkCLUtilities MitkAlgorithmsExt
+  #  CPP_FILES CLImageCropper.cpp mitkCommandLineParser.cpp
+  #)
 
         # On Linux, create a shell script to start a relocatable application
         if(UNIX AND NOT APPLE)
           install(PROGRAMS "${MITK_SOURCE_DIR}/CMake/RunInstalledApp.sh" DESTINATION "." RENAME ${EXECUTABLE_TARGET}.sh)
         endif()
 
   if(EXECUTABLE_IS_ENABLED)
     MITK_INSTALL_TARGETS(EXECUTABLES ${EXECUTABLE_TARGET})
   endif()
 
 endif()
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter.hxx b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter.hxx
index 530611c05a..2f1343d659 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter.hxx
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter.hxx
@@ -1,400 +1,400 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 /*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  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.
 *
 *=========================================================================*/
 #ifndef __itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter_hxx
 #define __itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter_hxx
 
 #include "itkEnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter.h"
 
 #include "itkConstNeighborhoodIterator.h"
 #include "itkNeighborhood.h"
 #include "vnl/vnl_math.h"
 #include "itkMacro.h"
 #include "itkRescaleIntensityImageFilter.h"
 #include "itkMaskImageFilter.h"
 #include "itkLabelStatisticsImageFilter.h"
 #include "itkScalarConnectedComponentImageFilter.h"
 #include "itkRelabelComponentImageFilter.h"
 #include "itkCastImageFilter.h"
 
 #include <mitkLogMacros.h>
 
 namespace itk
 {
 namespace Statistics
 {
 template<typename TImageType, typename THistogramFrequencyContainer>
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter() :
   m_NumberOfBinsPerAxis( itkGetStaticConstMacro( DefaultBinsPerAxis ) ),
   m_Min( NumericTraits<PixelType>::NonpositiveMin() ),
   m_Max( NumericTraits<PixelType>::max() ),
   m_MinDistance( NumericTraits<RealType>::ZeroValue() ),
   m_MaxDistance( NumericTraits<RealType>::max() ),
   m_InsidePixelValue( NumericTraits<PixelType>::OneValue() )
 {
   this->SetNumberOfRequiredInputs( 1 );
   this->SetNumberOfRequiredOutputs( 1 );
 
   const unsigned int measurementVectorSize = 1;
 
   this->ProcessObject::SetNthOutput( 0, this->MakeOutput( 0 ) );
   this->ProcessObject::SetNthOutput( 1, this->MakeOutput( 1 ) );
   HistogramType *output = const_cast<HistogramType *>( this->GetOutput() );
   output->SetMeasurementVectorSize( measurementVectorSize );
 
   m_siMatrix = new double[m_NumberOfBinsPerAxis];
   for(int i = 0; i < m_NumberOfBinsPerAxis; i++)
   {
     m_siMatrix[i] = 0;
   }
 
   this->m_LowerBound.SetSize( measurementVectorSize );
   this->m_UpperBound.SetSize( measurementVectorSize );
 
   this->m_LowerBound[0] = this->m_Min;
   this->m_LowerBound[1] = this->m_MinDistance;
   this->m_UpperBound[0] = this->m_Max;
   this->m_UpperBound[1] = this->m_MaxDistance;
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::SetOffset( const OffsetType offset )
 {
   OffsetVectorPointer offsetVector = OffsetVector::New();
   offsetVector->push_back( offset );
   this->SetOffsets( offsetVector );
   MITK_WARN << "We now have " << this->GetOffsets()->size() << " offsets in matrixgenerator";
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::AddOffsets( const std::vector<OffsetType> _offsets )
 {
   OffsetVectorPointer offsetVector = OffsetVector::New();
   typename OffsetVector::ConstIterator offsets;
   //MITK_WARN << "We have " << this->GetOffsets()->size() << " offsets!";
   for( int i = 0; i < _offsets.size(); i++)
   {
   offsetVector->push_back(_offsets[i]);
   auto k = _offsets[i];
   this->NormalizeOffsetDirection(k);
   offsetVector->push_back(k);
   }
   this->SetOffsets( offsetVector );
   MITK_WARN << "We now have " << this->GetOffsets()->size() << " offsets in matrixgenerator";
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::SetInput( const ImageType *image )
 {
   // Process object is not const-correct so the const_cast is required here
   this->ProcessObject::SetNthInput( 0, const_cast<ImageType *>( image ) );
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::SetMaskImage( const ImageType *image )
 {
   // Process object is not const-correct so the const_cast is required here
   this->ProcessObject::SetNthInput( 1, const_cast<ImageType *>( image ) );
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 const TImageType *
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::GetInput() const
 {
   if( this->GetNumberOfInputs() < 1 )
   {
     return ITK_NULLPTR;
   }
   return static_cast<const ImageType *>( this->ProcessObject::GetInput( 0 ) );
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 const TImageType *
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::GetMaskImage() const
 {
   if( this->GetNumberOfInputs() < 2 )
   {
     return ITK_NULLPTR;
   }
   return static_cast<const ImageType *>( this->ProcessObject::GetInput( 1 ) );
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 const typename EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType,
 THistogramFrequencyContainer >::HistogramType *
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::GetOutput() const
 {
   const HistogramType *output =
       static_cast<const HistogramType *>( this->ProcessObject::GetOutput( 0 ) );
   return output;
 }
 
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 double* EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::GetSiMatrix() const
 {
   return m_siMatrix;
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 typename EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType,
 THistogramFrequencyContainer>::DataObjectPointer
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::MakeOutput( DataObjectPointerArraySizeType itkNotUsed( idx ) )
 {
   return HistogramType::New().GetPointer();
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::GenerateData()
 {
   HistogramType *output =
       static_cast<HistogramType *>( this->ProcessObject::GetOutput( 0 ) );
 
   const ImageType * inputImage = this->GetInput();
   const ImageType * maskImage = this->GetMaskImage();
 
   // First, create an appropriate histogram with the right number of bins
   // and mins and maxes correct for the image type.
   typename HistogramType::SizeType size( output->GetMeasurementVectorSize() );
 
   size.Fill( this->m_NumberOfBinsPerAxis );
   this->m_LowerBound[0] = this->m_Min;
   this->m_LowerBound[1] = this->m_MinDistance;
   this->m_UpperBound[0] = this->m_Max;
   this->m_UpperBound[1] = this->m_MaxDistance;
 
   output->Initialize( size, this->m_LowerBound, this->m_UpperBound );
 
   MeasurementVectorType run( output->GetMeasurementVectorSize() );
   typename HistogramType::IndexType hIndex;
 
   //Cast the image to a float image - with no respect to the incoming image
   //to prevent some non-templated itk issues
   typedef itk::Image<float, 3> FloatImageType;
   typedef itk::CastImageFilter<ImageType, FloatImageType> CastFilterType;
 
   typename CastFilterType::Pointer caster = CastFilterType::New();
   caster->SetInput(inputImage);
   caster->Update();
   typename FloatImageType::Pointer floatImage = caster->GetOutput();
 
   //Cast the mask to an unsigned short image - with no respect to the incomimg maskimage
   //to prevent some non-templated itk issues
   typedef unsigned short                 LabelPixelType;
   typedef itk::Image<LabelPixelType, 3 > LabelImageType;
 
   typedef itk::CastImageFilter<ImageType, LabelImageType> MaskCastFilterType;
   typename MaskCastFilterType::Pointer maskCaster = MaskCastFilterType::New();
   maskCaster->SetInput(maskImage);
   maskCaster->Update();
 
   //Set all values out of the mask to nans.
   typedef itk::MaskImageFilter< FloatImageType, LabelImageType, FloatImageType > MaskFilterType;
   typename MaskFilterType::Pointer maskFilter = MaskFilterType::New();
   maskFilter->SetInput(floatImage);
   maskFilter->SetMaskImage(maskCaster->GetOutput());
   maskFilter->SetOutsideValue( std::numeric_limits<float>::quiet_NaN());
   maskFilter->Update();
   FloatImageType::Pointer floatImageMasked = maskFilter->GetOutput();
 
   typedef ConstNeighborhoodIterator<ImageType> NeighborhoodIteratorType;
   typename NeighborhoodIteratorType::RadiusType radius;
   radius.Fill( 1 );
   NeighborhoodIteratorType neighborIt( radius,
                                        inputImage, inputImage->GetRequestedRegion() );
 
   for( neighborIt.GoToBegin(); !neighborIt.IsAtEnd(); ++neighborIt )
   {
     const PixelType centerPixelIntensity = neighborIt.GetCenterPixel();
     IndexType centerIndex = neighborIt.GetIndex();
 
     FloatImageType::IndexType cIndex;
     cIndex[0] = centerIndex[0];
     cIndex[1] = centerIndex[1];
     cIndex[2] = centerIndex[2];
     float centerFloatPixel = floatImageMasked->GetPixel(cIndex);
 
     int px = 0;
     PixelType sum = 0.0;
     bool canCalculate = true;
 
     typename OffsetVector::ConstIterator offsets;
     for( offsets = this->GetOffsets()->Begin();
          offsets != this->GetOffsets()->End(); offsets++ )
     {
       OffsetType offset = offsets.Value();
       IndexType index;
 
       index = centerIndex + offset;
 
       if(!inputImage->GetRequestedRegion().IsInside(index))
       {
         canCalculate = false;
         break;
       }
 
       PixelType offsetPixel = inputImage->GetPixel(index);
 
       FloatImageType::IndexType fIndex;
       fIndex[0] = index[0];
       fIndex[1] = index[1];
       fIndex[2] = index[2];
 
       float floatPixel = floatImageMasked->GetPixel(fIndex);
 
       //We have a nan here
       if(floatPixel != floatPixel || centerFloatPixel!= centerFloatPixel)
       {
         canCalculate = false;
         break;
       }
 
       sum += offsetPixel;
       px++;
     }
     //If we have a nan in the neighbourhood, continue
     if(!canCalculate)
       continue;
 
     PixelType mean = sum / px;
 
-    double si = std::abs(mean-centerPixelIntensity);
+    double si = std::abs<double>(mean-centerPixelIntensity);
 
     run[0] = centerPixelIntensity;
 
     //Check for NaN and inf
     if(run[0] == run[0] && !std::isinf(std::abs(run[0])))
     {
       output->GetIndex( run, hIndex );
       output->IncreaseFrequencyOfIndex( hIndex, 1 );
 
       m_siMatrix[hIndex[0]] += si;
     }
     //MITK_WARN << " -> In this round we added: " << centerIndex << " with value " << centerPixelIntensity << " and si = " << si;
     //MITK_WARN << " -> Values are now siMatrix["<<hIndex[0]<<"]: " << m_siMatrix[hIndex[0]];
     //MITK_WARN << " -> Values are now niMatrix: " << output->GetFrequency(hIndex) << "/" << run;
   }
 }
 
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::SetPixelValueMinMax( PixelType min, PixelType max )
 {
   if( this->m_Min != min || this->m_Max != max )
   {
     itkDebugMacro( "setting Min to " << min << "and Max to " << max );
     this->m_Min = min;
     this->m_Max = max;
     this->Modified();
   }
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::SetDistanceValueMinMax( RealType min, RealType max )
 {
   if( this->m_MinDistance != min || this->m_MaxDistance != max )
   {
     itkDebugMacro( "setting MinDistance to " << min << "and MaxDistance to "
                    << max );
     this->m_MinDistance = min;
     this->m_MaxDistance = max;
     this->Modified();
   }
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::PrintSelf( std::ostream& os, Indent indent ) const
 {
   Superclass::PrintSelf( os,indent );
   os << indent << "Offsets: " << this->GetOffsets() << std::endl;
   os << indent << "Min: " << this->m_Min << std::endl;
   os << indent << "Max: " << this->m_Max << std::endl;
   os << indent << "Min distance: " << this->m_MinDistance << std::endl;
   os << indent << "Max distance: " << this->m_MaxDistance << std::endl;
   os << indent << "NumberOfBinsPerAxis: " << this->m_NumberOfBinsPerAxis
      << std::endl;
   os << indent << "InsidePixelValue: " << this->m_InsidePixelValue << std::endl;
 }
 
 template<typename TImageType, typename THistogramFrequencyContainer>
 void
 EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter<TImageType, THistogramFrequencyContainer>
 ::NormalizeOffsetDirection(OffsetType &offset)
 {
   //MITK_WARN <<" -> NGTDM old offset = " << offset;
   itkDebugMacro("old offset = " << offset << std::endl);
   int sign = 1;
   bool metLastNonZero = false;
   for (int i = offset.GetOffsetDimension()-1; i>=0; i--)
   {
     if (metLastNonZero)
     {
       offset[i] *= sign;
     }
     else if (offset[i] != 0)
     {
       sign = (offset[i] > 0 ) ? 1 : -1;
       metLastNonZero = true;
       offset[i] *= sign;
     }
   }
 
   //MITK_WARN << " ->NGTDM new  offset = " << offset;
   itkDebugMacro("new  offset = " << offset << std::endl);
 }
 } // end of namespace Statistics
 } // end of namespace itk
 
 #endif
diff --git a/Modules/Classification/CLUtilities/src/GlobalImageFeatures/mitkGIFFirstOrderStatistics.cpp b/Modules/Classification/CLUtilities/src/GlobalImageFeatures/mitkGIFFirstOrderStatistics.cpp
index de573335b9..0692ded20f 100644
--- a/Modules/Classification/CLUtilities/src/GlobalImageFeatures/mitkGIFFirstOrderStatistics.cpp
+++ b/Modules/Classification/CLUtilities/src/GlobalImageFeatures/mitkGIFFirstOrderStatistics.cpp
@@ -1,209 +1,208 @@
 /*===================================================================
 
 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 <mitkGIFFirstOrderStatistics.h>
 
 // MITK
 #include <mitkITKImageImport.h>
 #include <mitkImageCast.h>
 #include <mitkImageAccessByItk.h>
 
 // ITK
 #include <itkLabelStatisticsImageFilter.h>
 #include <itkMinimumMaximumImageCalculator.h>
 
 // STL
 #include <sstream>
 
 template<typename TPixel, unsigned int VImageDimension>
 void
 CalculateFirstOrderStatistics(itk::Image<TPixel, VImageDimension>* itkImage, mitk::Image::Pointer mask, mitk::GIFFirstOrderStatistics::FeatureListType & featureList, mitk::GIFFirstOrderStatistics::ParameterStruct params)
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef itk::Image<int, VImageDimension> MaskType;
   typedef itk::LabelStatisticsImageFilter<ImageType, MaskType> FilterType;
   typedef typename FilterType::HistogramType HistogramType;
   typedef typename HistogramType::IndexType HIndexType;
   typedef itk::MinimumMaximumImageCalculator<ImageType> MinMaxComputerType;
 
   typename MaskType::Pointer maskImage = MaskType::New();
   mitk::CastToItkImage(mask, maskImage);
 
   typename MinMaxComputerType::Pointer minMaxComputer = MinMaxComputerType::New();
   minMaxComputer->SetImage(itkImage);
   minMaxComputer->Compute();
   double imageRange = minMaxComputer->GetMaximum() -  minMaxComputer->GetMinimum();
 
   typename FilterType::Pointer labelStatisticsImageFilter = FilterType::New();
   labelStatisticsImageFilter->SetInput( itkImage );
   labelStatisticsImageFilter->SetLabelInput(maskImage);
   labelStatisticsImageFilter->SetUseHistograms(true);
   if (params.m_UseCtRange)
   {
     labelStatisticsImageFilter->SetHistogramParameters(1024.5+3096.5, -1024.5,3096.5);
   } else {
     labelStatisticsImageFilter->SetHistogramParameters(params.m_HistogramSize, minMaxComputer->GetMinimum(),minMaxComputer->GetMaximum());
   }
   labelStatisticsImageFilter->Update();
 
   // --------------- Range --------------------
   double range = labelStatisticsImageFilter->GetMaximum(1) - labelStatisticsImageFilter->GetMinimum(1);
   // --------------- Uniformity, Entropy --------------------
   double count = labelStatisticsImageFilter->GetCount(1);
   //double std_dev = labelStatisticsImageFilter->GetSigma(1);
   double uncorrected_std_dev = std::sqrt((count - 1) / count * labelStatisticsImageFilter->GetVariance(1));
   double mean = labelStatisticsImageFilter->GetMean(1);
   auto histogram = labelStatisticsImageFilter->GetHistogram(1);
   HIndexType index;
   index.SetSize(1);
   double binWidth = histogram->GetBinMax(0, 0) - histogram->GetBinMin(0, 0);
 
   double uniformity = 0;
   double entropy = 0;
   double squared_sum = 0;
   double kurtosis = 0;
   double mean_absolut_deviation = 0;
   double skewness = 0;
   double sum_prob = 0;
 
   double p10th = histogram->Quantile(0,0.10);
   double p25th = histogram->Quantile(0,0.25);
   double p75th = histogram->Quantile(0,0.75);
   double p90th = histogram->Quantile(0,0.90);
 
   double Log2=log(2);
   for (int i = 0; i < (int)(histogram->GetSize(0)); ++i)
   {
     index[0] = i;
     double prob = histogram->GetFrequency(index);
 
     if (prob < 0.1)
       continue;
 
     double voxelValue = histogram->GetBinMin(0, i) +binWidth * 0.5;
 
     sum_prob += prob;
     squared_sum += prob * voxelValue*voxelValue;
 
     prob /= count;
     mean_absolut_deviation += prob* std::abs(voxelValue - mean);
 
     kurtosis +=prob* (voxelValue - mean) * (voxelValue - mean) * (voxelValue - mean) * (voxelValue - mean);
     skewness += prob* (voxelValue - mean) * (voxelValue - mean) * (voxelValue - mean);
 
     uniformity += prob*prob;
     if (prob > 0)
     {
       entropy += prob * std::log(prob) / Log2;
     }
   }
 
   double rms = std::sqrt(squared_sum / count);
   kurtosis = kurtosis / (uncorrected_std_dev*uncorrected_std_dev * uncorrected_std_dev*uncorrected_std_dev);
   skewness = skewness / (uncorrected_std_dev*uncorrected_std_dev * uncorrected_std_dev);
   //mean_absolut_deviation = mean_absolut_deviation;
   double coveredGrayValueRange = range / imageRange;
 
   featureList.push_back(std::make_pair("FirstOrder Range",range));
   featureList.push_back(std::make_pair("FirstOrder Uniformity",uniformity));
   featureList.push_back(std::make_pair("FirstOrder Entropy",entropy));
   featureList.push_back(std::make_pair("FirstOrder Energy",squared_sum));
   featureList.push_back(std::make_pair("FirstOrder RMS",rms));
   featureList.push_back(std::make_pair("FirstOrder Kurtosis",kurtosis));
   featureList.push_back(std::make_pair("FirstOrder Skewness",skewness));
   featureList.push_back(std::make_pair("FirstOrder Mean absolute deviation",mean_absolut_deviation));
   featureList.push_back(std::make_pair("FirstOrder Covered Image Intensity Range",coveredGrayValueRange));
 
   featureList.push_back(std::make_pair("FirstOrder Minimum",labelStatisticsImageFilter->GetMinimum(1)));
   featureList.push_back(std::make_pair("FirstOrder Maximum",labelStatisticsImageFilter->GetMaximum(1)));
   featureList.push_back(std::make_pair("FirstOrder Mean",labelStatisticsImageFilter->GetMean(1)));
   featureList.push_back(std::make_pair("FirstOrder Variance",labelStatisticsImageFilter->GetVariance(1)));
   featureList.push_back(std::make_pair("FirstOrder Sum",labelStatisticsImageFilter->GetSum(1)));
   featureList.push_back(std::make_pair("FirstOrder Median",labelStatisticsImageFilter->GetMedian(1)));
   featureList.push_back(std::make_pair("FirstOrder Standard deviation",labelStatisticsImageFilter->GetSigma(1)));
   featureList.push_back(std::make_pair("FirstOrder No. of Voxel",labelStatisticsImageFilter->GetCount(1)));
 
   featureList.push_back(std::make_pair("FirstOrder 10th Percentile",p10th));
   featureList.push_back(std::make_pair("FirstOrder 90th Percentile",p90th));
   featureList.push_back(std::make_pair("FirstOrder Interquartile Range",(p75th - p25th)));
 
   //Calculate the robus mean absolute deviation
   //First, set all frequencies to 0 that are <10th or >90th percentile
   for (int i = 0; i < (int)(histogram->GetSize(0)); ++i)
   {
     index[0] = i;
     if(histogram->GetBinMin(0,i) < p10th)
       histogram->SetFrequencyOfIndex(index, 0);
     else if(histogram->GetBinMin(0,i) > p90th)
       histogram->SetFrequencyOfIndex(index, 0);
-
   }
 
   //Calculate the mean
   double meanRobust = 0.0;
   for (int i = 0; i < (int)(histogram->GetSize(0)); ++i)
   {
     index[0] = i;
     meanRobust += histogram->GetFrequency(index) * 0.5 * (histogram->GetBinMin(0,i) + histogram->GetBinMax(0,i));
   }
   meanRobust = meanRobust / histogram->GetTotalFrequency();
 
   double robustMeanAbsoluteDeviation = 0.0;
   for (int i = 0; i < (int)(histogram->GetSize(0)); ++i)
   {
     index[0] = i;
     robustMeanAbsoluteDeviation += std::abs(histogram->GetFrequency(index) *
                                             ( (0.5 * (histogram->GetBinMin(0,i) + histogram->GetBinMax(0,i)))
                                               - meanRobust
                                               ));
   }
   robustMeanAbsoluteDeviation = robustMeanAbsoluteDeviation / histogram->GetTotalFrequency();
 
   featureList.push_back(std::make_pair("FirstOrder Robust Mean Absolute Deviation",robustMeanAbsoluteDeviation));
 
 }
 
 mitk::GIFFirstOrderStatistics::GIFFirstOrderStatistics() :
   m_HistogramSize(256), m_UseCtRange(false)
 {
 }
 
 mitk::GIFFirstOrderStatistics::FeatureListType mitk::GIFFirstOrderStatistics::CalculateFeatures(const Image::Pointer & image, const Image::Pointer &mask)
 {
   FeatureListType featureList;
 
   ParameterStruct params;
   params.m_HistogramSize = this->m_HistogramSize;
   params.m_UseCtRange = this->m_UseCtRange;
 
   AccessByItk_3(image, CalculateFirstOrderStatistics, mask, featureList, params);
 
   return featureList;
 }
 
 mitk::GIFFirstOrderStatistics::FeatureNameListType mitk::GIFFirstOrderStatistics::GetFeatureNames()
 {
   FeatureNameListType featureList;
   featureList.push_back("FirstOrder Minimum");
   featureList.push_back("FirstOrder Maximum");
   featureList.push_back("FirstOrder Mean");
   featureList.push_back("FirstOrder Variance");
   featureList.push_back("FirstOrder Sum");
   featureList.push_back("FirstOrder Median");
   featureList.push_back("FirstOrder Standard deviation");
   featureList.push_back("FirstOrder No. of Voxel");
   return featureList;
 }