diff --git a/Modules/Classification/CLMiniApps/CL2Dto3DImage.cpp b/Modules/Classification/CLMiniApps/CL2Dto3DImage.cpp
index 6d49b49a00..66e1acaa53 100644
--- a/Modules/Classification/CLMiniApps/CL2Dto3DImage.cpp
+++ b/Modules/Classification/CLMiniApps/CL2Dto3DImage.cpp
@@ -1,60 +1,59 @@
 /*===================================================================
 
 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 <mitkConvert2Dto3DImageFilter.h>
 #include "mitkIOUtil.h"
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Dicom Loader");
   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);
 
   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<std::string>(parsedArgs["input"]);
   std::string outputName = us::any_cast<std::string>(parsedArgs["output"]);
-  
+
   mitk::Image::Pointer image = mitk::IOUtil::LoadImage(inputName);
   mitk::Convert2Dto3DImageFilter::Pointer multiFilter2 = mitk::Convert2Dto3DImageFilter::New();
   multiFilter2->SetInput(image);
   multiFilter2->Update();
   mitk::Image::Pointer image2 = multiFilter2->GetOutput();
-  
-  mitk::IOUtil::SaveImage(image2, outputName);
+  mitk::IOUtil::Save(image2, outputName);
 
   return EXIT_SUCCESS;
 }
\ No newline at end of file
diff --git a/Modules/Classification/CLMiniApps/CLGlobalImageFeatures.cpp b/Modules/Classification/CLMiniApps/CLGlobalImageFeatures.cpp
index b32580224e..d6ace96ce9 100644
--- a/Modules/Classification/CLMiniApps/CLGlobalImageFeatures.cpp
+++ b/Modules/Classification/CLMiniApps/CLGlobalImageFeatures.cpp
@@ -1,666 +1,666 @@
 /*===================================================================
 
 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 <mitkSplitParameterToVector.h>
 #include <mitkGlobalImageFeaturesParameter.h>
 
 #include <mitkGIFCooccurenceMatrix.h>
 #include <mitkGIFCooccurenceMatrix2.h>
 #include <mitkGIFGrayLevelRunLength.h>
 #include <mitkGIFFirstOrderStatistics.h>
 #include <mitkGIFVolumetricStatistics.h>
 #include <mitkGIFGreyLevelSizeZone.h>
 #include <mitkGIFNeighbouringGreyLevelDependenceFeatures.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkImageCast.h>
 #include <mitkITKImageImport.h>
 #include <mitkConvert2Dto3DImageFilter.h>
 
 #include <mitkCLResultWritter.h>
 
 #include <itkImageDuplicator.h>
 #include <itkImageRegionIterator.h>
 
 
 #include "itkNearestNeighborInterpolateImageFunction.h"
 #include "itkResampleImageFilter.h"
 
 #include <QApplication>
 #include <mitkStandaloneDataStorage.h>
 #include "QmitkRegisterClasses.h"
 #include "QmitkRenderWindow.h"
 #include "vtkRenderLargeImage.h"
 #include "vtkPNGWriter.h"
 
 
 
 typedef itk::Image< double, 3 >                 FloatImageType;
 typedef itk::Image< unsigned char, 3 >          MaskImageType;
 
 template<typename TPixel, unsigned int VImageDimension>
 void
 ResampleImage(itk::Image<TPixel, VImageDimension>* itkImage, float resolution, mitk::Image::Pointer& newImage)
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef itk::ResampleImageFilter<ImageType, ImageType> ResampleFilterType;
 
   typename ResampleFilterType::Pointer resampler = ResampleFilterType::New();
   auto spacing = itkImage->GetSpacing();
   auto size = itkImage->GetLargestPossibleRegion().GetSize();
 
   for (int i = 0; i < VImageDimension; ++i)
   {
     size[i] = size[i] / (1.0*resolution)*(1.0*spacing[i])+1.0;
   }
   spacing.Fill(resolution);
 
   resampler->SetInput(itkImage);
   resampler->SetSize(size);
   resampler->SetOutputSpacing(spacing);
   resampler->SetOutputOrigin(itkImage->GetOrigin());
   resampler->SetOutputDirection(itkImage->GetDirection());
   resampler->Update();
 
   newImage->InitializeByItk(resampler->GetOutput());
   mitk::GrabItkImageMemory(resampler->GetOutput(), newImage);
 }
 
 
 template<typename TPixel, unsigned int VImageDimension>
 static void
 CreateNoNaNMask(itk::Image<TPixel, VImageDimension>* itkValue, mitk::Image::Pointer mask, mitk::Image::Pointer& newMask)
 {
   typedef itk::Image< TPixel, VImageDimension>                 LFloatImageType;
   typedef itk::Image< unsigned char, VImageDimension>          LMaskImageType;
   typename LMaskImageType::Pointer itkMask = LMaskImageType::New();
 
   mitk::CastToItkImage(mask, itkMask);
 
   typedef itk::ImageDuplicator< LMaskImageType > DuplicatorType;
   typename DuplicatorType::Pointer duplicator = DuplicatorType::New();
   duplicator->SetInputImage(itkMask);
   duplicator->Update();
 
   auto tmpMask = duplicator->GetOutput();
 
   itk::ImageRegionIterator<LMaskImageType> mask1Iter(itkMask, itkMask->GetLargestPossibleRegion());
   itk::ImageRegionIterator<LMaskImageType> mask2Iter(tmpMask, tmpMask->GetLargestPossibleRegion());
   itk::ImageRegionIterator<LFloatImageType> imageIter(itkValue, itkValue->GetLargestPossibleRegion());
   while (!mask1Iter.IsAtEnd())
   {
     mask2Iter.Set(0);
     if (mask1Iter.Value() > 0)
     {
       // Is not NaN
       if (imageIter.Value() == imageIter.Value())
       {
         mask2Iter.Set(1);
       }
     }
     ++mask1Iter;
     ++mask2Iter;
     ++imageIter;
   }
 
   newMask->InitializeByItk(tmpMask);
   mitk::GrabItkImageMemory(tmpMask, newMask);
 }
 
 template<typename TPixel, unsigned int VImageDimension>
 static void
 ResampleMask(itk::Image<TPixel, VImageDimension>* itkMoving, mitk::Image::Pointer ref, mitk::Image::Pointer& newMask)
 {
   typedef itk::Image< TPixel, VImageDimension>          LMaskImageType;
   typedef itk::NearestNeighborInterpolateImageFunction< LMaskImageType> NearestNeighborInterpolateImageFunctionType;
   typedef itk::ResampleImageFilter<LMaskImageType, LMaskImageType> ResampleFilterType;
 
   typename NearestNeighborInterpolateImageFunctionType::Pointer nn_interpolator = NearestNeighborInterpolateImageFunctionType::New();
   typename LMaskImageType::Pointer itkRef = LMaskImageType::New();
   mitk::CastToItkImage(ref, itkRef);
 
 
   typename ResampleFilterType::Pointer resampler = ResampleFilterType::New();
   resampler->SetInput(itkMoving);
   resampler->SetReferenceImage(itkRef);
   resampler->UseReferenceImageOn();
   resampler->SetInterpolator(nn_interpolator);
   resampler->Update();
 
   newMask->InitializeByItk(resampler->GetOutput());
   mitk::GrabItkImageMemory(resampler->GetOutput(), newMask);
 }
 
 static void
 ExtractSlicesFromImages(mitk::Image::Pointer image, mitk::Image::Pointer mask, mitk::Image::Pointer maskNoNaN,
                         int direction,
                         std::vector<mitk::Image::Pointer> &imageVector,
                         std::vector<mitk::Image::Pointer> &maskVector,
                         std::vector<mitk::Image::Pointer> &maskNoNaNVector)
 {
   typedef itk::Image< double, 2 >                 FloatImage2DType;
   typedef itk::Image< unsigned char, 2 >          MaskImage2DType;
 
   FloatImageType::Pointer itkFloat = FloatImageType::New();
   MaskImageType::Pointer itkMask = MaskImageType::New();
   MaskImageType::Pointer itkMaskNoNaN = MaskImageType::New();
   mitk::CastToItkImage(mask, itkMask);
   mitk::CastToItkImage(maskNoNaN, itkMaskNoNaN);
   mitk::CastToItkImage(image, itkFloat);
 
   int idxA, idxB, idxC;
   switch (direction)
   {
   case 0:
     idxA = 1; idxB = 2; idxC = 0;
     break;
   case 1:
     idxA = 0; idxB = 2; idxC = 1;
     break;
   case 2:
     idxA = 0; idxB = 1; idxC = 2;
     break;
   default:
     idxA = 1; idxB = 2; idxC = 0;
     break;
   }
 
   auto imageSize = image->GetLargestPossibleRegion().GetSize();
   FloatImageType::IndexType index3D;
   FloatImage2DType::IndexType index2D;
   FloatImage2DType::SpacingType spacing2D;
   spacing2D[0] = itkFloat->GetSpacing()[idxA];
   spacing2D[1] = itkFloat->GetSpacing()[idxB];
 
   for (int i = 0; i < imageSize[idxC]; ++i)
   {
     FloatImage2DType::RegionType region;
     FloatImage2DType::IndexType start;
     FloatImage2DType::SizeType size;
     start[0] = 0; start[1] = 0;
     size[0] = imageSize[idxA];
     size[1] = imageSize[idxB];
     region.SetIndex(start);
     region.SetSize(size);
 
     FloatImage2DType::Pointer image2D = FloatImage2DType::New();
     image2D->SetRegions(region);
     image2D->Allocate();
 
     MaskImage2DType::Pointer mask2D = MaskImage2DType::New();
     mask2D->SetRegions(region);
     mask2D->Allocate();
 
     MaskImage2DType::Pointer masnNoNaN2D = MaskImage2DType::New();
     masnNoNaN2D->SetRegions(region);
     masnNoNaN2D->Allocate();
 
     unsigned long voxelsInMask = 0;
 
     for (int a = 0; a < imageSize[idxA]; ++a)
     {
       for (int b = 0; b < imageSize[idxB]; ++b)
       {
         index3D[idxA] = a;
         index3D[idxB] = b;
         index3D[idxC] = i;
         index2D[0] = a;
         index2D[1] = b;
         image2D->SetPixel(index2D, itkFloat->GetPixel(index3D));
         mask2D->SetPixel(index2D, itkMask->GetPixel(index3D));
         masnNoNaN2D->SetPixel(index2D, itkMaskNoNaN->GetPixel(index3D));
         voxelsInMask += (itkMask->GetPixel(index3D) > 0) ? 1 : 0;
 
       }
     }
 
     image2D->SetSpacing(spacing2D);
     mask2D->SetSpacing(spacing2D);
     masnNoNaN2D->SetSpacing(spacing2D);
 
     mitk::Image::Pointer tmpFloatImage = mitk::Image::New();
     tmpFloatImage->InitializeByItk(image2D.GetPointer());
     mitk::GrabItkImageMemory(image2D, tmpFloatImage);
 
     mitk::Image::Pointer tmpMaskImage = mitk::Image::New();
     tmpMaskImage->InitializeByItk(mask2D.GetPointer());
     mitk::GrabItkImageMemory(mask2D, tmpMaskImage);
 
     mitk::Image::Pointer tmpMaskNoNaNImage = mitk::Image::New();
     tmpMaskNoNaNImage->InitializeByItk(masnNoNaN2D.GetPointer());
     mitk::GrabItkImageMemory(masnNoNaN2D, tmpMaskNoNaNImage);
 
     if (voxelsInMask > 0)
     {
       imageVector.push_back(tmpFloatImage);
       maskVector.push_back(tmpMaskImage);
       maskNoNaNVector.push_back(tmpMaskNoNaNImage);
     }
   }
 }
 
 static
 void SaveSliceOrImageAsPNG(mitk::Image::Pointer image, mitk::Image::Pointer mask, std::string path, int index)
 {
   // Create a Standalone Datastorage for the single purpose of saving screenshots..
   mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
   QmitkRenderWindow renderWindow;
   renderWindow.GetRenderer()->SetDataStorage(ds);
 
   auto nodeI = mitk::DataNode::New();
   nodeI->SetData(image);
   auto nodeM = mitk::DataNode::New();
   nodeM->SetData(mask);
   ds->Add(nodeI);
   ds->Add(nodeM);
 
   mitk::TimeGeometry::Pointer geo = ds->ComputeBoundingGeometry3D(ds->GetAll());
   mitk::RenderingManager::GetInstance()->InitializeViews(geo);
 
   mitk::SliceNavigationController::Pointer sliceNaviController = renderWindow.GetSliceNavigationController();
   unsigned int numberOfSteps = 1;
   if (sliceNaviController)
   {
     numberOfSteps = sliceNaviController->GetSlice()->GetSteps();
     sliceNaviController->GetSlice()->SetPos(0);
   }
 
   renderWindow.show();
   renderWindow.resize(256, 256);
 
   for (unsigned int currentStep = 0; currentStep < numberOfSteps; ++currentStep)
   {
     if (sliceNaviController)
     {
       sliceNaviController->GetSlice()->SetPos(currentStep);
     }
 
     renderWindow.GetRenderer()->PrepareRender();
 
     vtkRenderWindow* renderWindow2 = renderWindow.GetVtkRenderWindow();
     mitk::BaseRenderer* baserenderer = mitk::BaseRenderer::GetInstance(renderWindow2);
     auto vtkRender = baserenderer->GetVtkRenderer();
     vtkRender->GetRenderWindow()->WaitForCompletion();
 
     vtkRenderLargeImage* magnifier = vtkRenderLargeImage::New();
     magnifier->SetInput(vtkRender);
     magnifier->SetMagnification(3.0);
 
     std::stringstream ss;
     ss << path << "_Idx-" << index << "_Step-"<<currentStep<<".png";
     std::string tmpImageName;
     ss >> tmpImageName;
     auto fileWriter = vtkPNGWriter::New();
     fileWriter->SetInputConnection(magnifier->GetOutputPort());
     fileWriter->SetFileName(tmpImageName.c_str());
     fileWriter->Write();
     fileWriter->Delete();
   }
 }
 
 int main(int argc, char* argv[])
 {
 
   mitk::GIFFirstOrderStatistics::Pointer firstOrderCalculator = mitk::GIFFirstOrderStatistics::New();
   mitk::GIFVolumetricStatistics::Pointer volCalculator = mitk::GIFVolumetricStatistics::New();
   mitk::GIFCooccurenceMatrix::Pointer coocCalculator = mitk::GIFCooccurenceMatrix::New();
   mitk::GIFCooccurenceMatrix2::Pointer cooc2Calculator = mitk::GIFCooccurenceMatrix2::New();
   mitk::GIFNeighbouringGreyLevelDependenceFeature::Pointer ngldCalculator = mitk::GIFNeighbouringGreyLevelDependenceFeature::New();
   mitk::GIFGrayLevelRunLength::Pointer rlCalculator = mitk::GIFGrayLevelRunLength::New();
   mitk::GIFGreyLevelSizeZone::Pointer glszCalculator = mitk::GIFGreyLevelSizeZone::New();
 
   std::vector<mitk::AbstractGlobalImageFeature::Pointer> features;
   features.push_back(firstOrderCalculator.GetPointer());
   features.push_back(volCalculator.GetPointer());
   features.push_back(coocCalculator.GetPointer());
   features.push_back(cooc2Calculator.GetPointer());
   features.push_back(ngldCalculator.GetPointer());
   features.push_back(rlCalculator.GetPointer());
   features.push_back(glszCalculator.GetPointer());
 
   mitkCommandLineParser parser;
   parser.setArgumentPrefix("--", "-");
   mitk::cl::GlobalImageFeaturesParameter param;
   param.AddParameter(parser);
 
   parser.addArgument("--","-", mitkCommandLineParser::String, "---", "---", us::Any(),true);
   for (auto cFeature : features)
   {
     cFeature->AddArguments(parser);
   }
 
   parser.addArgument("--", "-", mitkCommandLineParser::String, "---", "---", us::Any(), true);
   parser.addArgument("description","d",mitkCommandLineParser::String,"Text","Description that is added to the output",us::Any());
   parser.addArgument("direction", "dir", mitkCommandLineParser::String, "Int", "Allows to specify the direction for Cooc and RL. 0: All directions, 1: Only single direction (Test purpose), 2,3,4... Without dimension 0,1,2... ", us::Any());
   parser.addArgument("slice-wise", "slice", mitkCommandLineParser::String, "Int", "Allows to specify if the image is processed slice-wise (number giving direction) ", us::Any());
   parser.addArgument("output-mode", "omode", mitkCommandLineParser::Int, "Int", "Defines if the results of an image / slice are written in a single row (0 , default) or column (1).");
 
   // Miniapp Infos
   parser.setCategory("Classification Tools");
   parser.setTitle("Global Image Feature calculator");
   parser.setDescription("Calculates different global statistics for a given segmentation / image combination");
   parser.setContributor("MBI");
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   param.ParseParameter(parsedArgs);
 
   if (parsedArgs.size()==0)
   {
     return EXIT_FAILURE;
   }
   if ( parsedArgs.count("help") || parsedArgs.count("h"))
   {
     return EXIT_SUCCESS;
   }
 
   bool savePNGofSlices = true;
   std::string folderForPNGOfSlices = "E:\\tmp\\bonekamp\\fig\\";
 
-  std::string version = "Version: 1.19";
+  std::string version = "Version: 1.20";
   MITK_INFO << version;
 
   std::ofstream log;
   if (param.useLogfile)
   {
     log.open(param.logfilePath, std::ios::app);
     log << version;
     log << "Image: " << param.imagePath;
     log << "Mask: " << param.maskPath;
   }
 
   mitk::Image::Pointer image;
   mitk::Image::Pointer mask;
 
   mitk::Image::Pointer tmpImage = mitk::IOUtil::LoadImage(param.imagePath);
   mitk::Image::Pointer tmpMask = mitk::IOUtil::LoadImage(param.maskPath);
   image = tmpImage;
   mask = tmpMask;
 
   if ((image->GetDimension() != mask->GetDimension()))
   {
     MITK_INFO << "Dimension of image does not match. ";
     MITK_INFO << "Correct one image, may affect the result";
     if (image->GetDimension() == 2)
     {
       mitk::Convert2Dto3DImageFilter::Pointer multiFilter2 = mitk::Convert2Dto3DImageFilter::New();
       multiFilter2->SetInput(tmpImage);
       multiFilter2->Update();
       image = multiFilter2->GetOutput();
     }
     if (mask->GetDimension() == 2)
     {
       mitk::Convert2Dto3DImageFilter::Pointer multiFilter3 = mitk::Convert2Dto3DImageFilter::New();
       multiFilter3->SetInput(tmpMask);
       multiFilter3->Update();
       mask = multiFilter3->GetOutput();
     }
   }
 
   int writeDirection = 0;
   if (parsedArgs.count("output-mode"))
   {
     writeDirection = us::any_cast<int>(parsedArgs["output-mode"]);
   }
 
 
   if (param.resampleToFixIsotropic)
   {
     mitk::Image::Pointer newImage = mitk::Image::New();
     AccessByItk_2(image, ResampleImage, param.resampleResolution, newImage);
     image = newImage;
   }
   if ( ! mitk::Equal(mask->GetGeometry(0)->GetOrigin(), image->GetGeometry(0)->GetOrigin()))
   {
     MITK_INFO << "Not equal Origins";
     if (param.ensureSameSpace)
     {
       MITK_INFO << "Warning!";
       MITK_INFO << "The origin of the input image and the mask do not match. They are";
       MITK_INFO << "now corrected. Please check to make sure that the images still match";
       image->GetGeometry(0)->SetOrigin(mask->GetGeometry(0)->GetOrigin());
     } else
     {
       return -1;
     }
   }
 
   if (param.resampleMask)
   {
     mitk::Image::Pointer newMaskImage = mitk::Image::New();
     AccessByItk_2(mask, ResampleMask, image, newMaskImage);
     mask = newMaskImage;
   }
 
   if ( ! mitk::Equal(mask->GetGeometry(0)->GetSpacing(), image->GetGeometry(0)->GetSpacing()))
   {
     MITK_INFO << "Not equal Sapcings";
     if (param.ensureSameSpace)
     {
       MITK_INFO << "Warning!";
       MITK_INFO << "The spacing of the mask was set to match the spacing of the input image.";
       MITK_INFO << "This might cause unintended spacing of the mask image";
       image->GetGeometry(0)->SetSpacing(mask->GetGeometry(0)->GetSpacing());
     } else
     {
       MITK_INFO << "The spacing of the mask and the input images is not equal.";
       MITK_INFO << "Terminating the programm. You may use the '-fi' option";
       return -1;
     }
   }
 
   int direction = 0;
   if (parsedArgs.count("direction"))
   {
     direction = mitk::cl::splitDouble(parsedArgs["direction"].ToString(), ';')[0];
   }
 
   MITK_INFO << "Start creating Mask without NaN";
 
   mitk::Image::Pointer maskNoNaN = mitk::Image::New();
   AccessByItk_2(image, CreateNoNaNMask,  mask, maskNoNaN);
   //CreateNoNaNMask(mask, image, maskNoNaN);
 
 
   bool sliceWise = false;
   int sliceDirection = 0;
   int currentSlice = 0;
   bool imageToProcess = true;
 
   std::vector<mitk::Image::Pointer> floatVector;
   std::vector<mitk::Image::Pointer> maskVector;
   std::vector<mitk::Image::Pointer> maskNoNaNVector;
 
   if ((parsedArgs.count("slice-wise")) && image->GetDimension() > 2)
   {
     MITK_INFO << "Enabled slice-wise";
     sliceWise = true;
     sliceDirection = mitk::cl::splitDouble(parsedArgs["slice-wise"].ToString(), ';')[0];
     MITK_INFO << sliceDirection;
     ExtractSlicesFromImages(image, mask, maskNoNaN, sliceDirection, floatVector, maskVector, maskNoNaNVector);
     MITK_INFO << "Slice";
   }
 
   for (auto cFeature : features)
   {
     if (param.defineGlobalMinimumIntensity)
     {
       cFeature->SetMinimumIntensity(param.globalMinimumIntensity);
       cFeature->SetUseMinimumIntensity(true);
     }
     if (param.defineGlobalMaximumIntensity)
     {
       cFeature->SetMaximumIntensity(param.globalMaximumIntensity);
       cFeature->SetUseMaximumIntensity(true);
     }
     if (param.defineGlobalNumberOfBins)
     {
       cFeature->SetBins(param.globalNumberOfBins);
       MITK_INFO << param.globalNumberOfBins;
     }
     cFeature->SetParameter(parsedArgs);
     cFeature->SetDirection(direction);
   }
 
   bool addDescription = parsedArgs.count("description");
   mitk::cl::FeatureResultWritter writer(param.outputPath, writeDirection);
 
   std::string description = "";
   if (addDescription)
   {
     description = parsedArgs["description"].ToString();
   }
 
   mitk::Image::Pointer cImage = image;
   mitk::Image::Pointer cMask = mask;
   mitk::Image::Pointer cMaskNoNaN = maskNoNaN;
 
   if (param.useHeader)
   {
     writer.AddColumn("Patient");
     writer.AddColumn("Image");
     writer.AddColumn("Segmentation");
   }
 
 
   // Create a QTApplication and a Datastorage
   // This is necessary in order to save screenshots of
   // each image / slice.
   QApplication qtapplication(argc, argv);
   QmitkRegisterClasses();
 
   std::vector<mitk::AbstractGlobalImageFeature::FeatureListType> allStats;
 
   while (imageToProcess)
   {
     if (sliceWise)
     {
       cImage = floatVector[currentSlice];
       cMask = maskVector[currentSlice];
       cMaskNoNaN = maskNoNaNVector[currentSlice];
       imageToProcess = (floatVector.size()-1 > (currentSlice)) ? true : false ;
     }
     else
     {
       imageToProcess = false;
     }
 
     if (param.writePNGScreenshots)
     {
       SaveSliceOrImageAsPNG(cImage, cMask, param.pngScreenshotsPath, currentSlice);
     }
     if (param.writeAnalysisImage)
     {
-      mitk::IOUtil::SaveImage(cImage, param.anaylsisImagePath);
+      mitk::IOUtil::Save(cImage, param.anaylsisImagePath);
     }
     if (param.writeAnalysisMask)
     {
-      mitk::IOUtil::SaveImage(cImage, param.analysisMaskPath);
+      mitk::IOUtil::Save(cMask, param.analysisMaskPath);
     }
 
     mitk::AbstractGlobalImageFeature::FeatureListType stats;
 
     for (auto cFeature : features)
     {
       cFeature->CalculateFeaturesUsingParameters(cImage, cMask, cMaskNoNaN, stats);
     }
 
     for (std::size_t i = 0; i < stats.size(); ++i)
     {
       std::cout << stats[i].first << " - " << stats[i].second << std::endl;
     }
 
     writer.AddHeader(description, currentSlice, stats, param.useHeader, addDescription);
     if (true)
     {
       writer.AddColumn(param.imageFolder);
       writer.AddColumn(param.imageName);
       writer.AddColumn(param.maskName);
     }
     writer.AddResult(description, currentSlice, stats, param.useHeader, addDescription);
 
     allStats.push_back(stats);
     ++currentSlice;
   }
 
   if (sliceWise)
   {
     mitk::AbstractGlobalImageFeature::FeatureListType statMean, statStd;
     for (std::size_t i = 0; i < allStats[0].size(); ++i)
     {
       auto cElement1 = allStats[0][i];
       cElement1.first = "SliceWise Mean " + cElement1.first;
       cElement1.second = 0.0;
       auto cElement2 = allStats[0][i];
       cElement2.first = "SliceWise Var. " + cElement2.first;
       cElement2.second = 0.0;
       statMean.push_back(cElement1);
       statStd.push_back(cElement2);
     }
 
     for (auto cStat : allStats)
     {
       for (std::size_t i = 0; i < cStat.size(); ++i)
       {
         statMean[i].second += cStat[i].second / (1.0*allStats.size());
       }
     }
 
     for (auto cStat : allStats)
     {
       for (std::size_t i = 0; i < cStat.size(); ++i)
       {
         statStd[i].second += (cStat[i].second - statMean[i].second)*(cStat[i].second - statMean[i].second) / (1.0*allStats.size());
       }
     }
 
     for (std::size_t i = 0; i < statMean.size(); ++i)
     {
       std::cout << statMean[i].first << " - " << statMean[i].second << std::endl;
       std::cout << statStd[i].first << " - " << statStd[i].second << std::endl;
     }
     if (true)
     {
       writer.AddColumn(param.imageFolder);
       writer.AddColumn(param.imageName);
       writer.AddColumn(param.maskName + " - Mean");
     }
     writer.AddResult(description, currentSlice, statMean, param.useHeader, addDescription);
     if (true)
     {
       writer.AddColumn(param.imageFolder);
       writer.AddColumn(param.imageName);
       writer.AddColumn(param.maskName + " - Var.");
     }
     writer.AddResult(description, currentSlice, statStd, param.useHeader, addDescription);
   }
 
   if (param.useLogfile)
   {
     log << "Finished calculation";
     log.close();
   }
   return 0;
 }
 
 #endif
diff --git a/Modules/Classification/CLMiniApps/CLImageTypeConverter.cpp b/Modules/Classification/CLMiniApps/CLImageTypeConverter.cpp
index c636160a8b..41ab9734a5 100644
--- a/Modules/Classification/CLMiniApps/CLImageTypeConverter.cpp
+++ b/Modules/Classification/CLMiniApps/CLImageTypeConverter.cpp
@@ -1,108 +1,108 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "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);
 
   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<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 if (type.compare("none") == 0)
   {
     MITK_INFO << " No conversion performed";
     outputImage = image;
   }
   else
   {
     CONVERT_IMAGE(double, 3);
   }
 
 
-  mitk::IOUtil::SaveImage(outputImage, outputName);
+  mitk::IOUtil::Save(outputImage, outputName);
 
   return EXIT_SUCCESS;
 }
\ No newline at end of file
diff --git a/Modules/Classification/CLMiniApps/CLLungSegmentation.cpp b/Modules/Classification/CLMiniApps/CLLungSegmentation.cpp
index 1259482ed3..e642880a54 100644
--- a/Modules/Classification/CLMiniApps/CLLungSegmentation.cpp
+++ b/Modules/Classification/CLMiniApps/CLLungSegmentation.cpp
@@ -1,154 +1,154 @@
 /*===================================================================
 
 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 "mitkDicomSeriesReader.h"
 #include "mitkProperties.h"
 
 #include "mitkCommandLineParser.h"
 #include "mitkIOUtil.h"
 
 #include <mitkOtsuSegmentationFilter.h>
 #include "mitkLabelSetImage.h"
 
 #include "mitkImageCast.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkITKImageImport.h"
 #include "mitkImageAccessByItk.h"
 
 #include <mitkMorphologicalOperations.h>
 
 #include <itkConnectedThresholdImageFilter.h>
 
 template<typename TPixel, unsigned int VImageDimension>
 void StartRegionGrowing(itk::Image<TPixel, VImageDimension>* itkImage, mitk::Image::Pointer &result, mitk::BaseGeometry* imageGeometry)
 {
   typedef itk::Image<TPixel, VImageDimension> InputImageType;
   typedef typename InputImageType::IndexType IndexType;
   typedef itk::ConnectedThresholdImageFilter<InputImageType, InputImageType> RegionGrowingFilterType;
   typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
 
   // convert world coordinates to image indices
   IndexType startIndex;
   IndexType seedIndex;
   startIndex[0] = itkImage->GetLargestPossibleRegion().GetSize()[0]/2;
   startIndex[1] = itkImage->GetLargestPossibleRegion().GetSize()[1]/2;
   startIndex[2] = itkImage->GetLargestPossibleRegion().GetSize()[2]/2;
 
   for (int x = -50; x < 50; ++x)
   {
     for (int y = -50; y < 50; ++y)
     {
       for (int z = -50; z < 50; ++z)
       {
         seedIndex[0] = startIndex[0] + x;
         seedIndex[1] = startIndex[1] + y;
         seedIndex[2] = startIndex[2] + z;
         if (itkImage->GetPixel(seedIndex) > 0)
         {
           x = 100; y = 100; z = 100;
         }
       }
     }
   }
 
   MITK_INFO << "Seedpoint: " << seedIndex;
   //perform region growing in desired segmented region
   regionGrower->SetInput(itkImage);
   regionGrower->AddSeed(seedIndex);
 
   regionGrower->SetLower(1);
   regionGrower->SetUpper(255);
 
   try
   {
     regionGrower->Update();
   }
   catch (const itk::ExceptionObject&)
   {
     return; // can't work
   }
   catch (...)
   {
     return;
   }
 
   //Store result and preview
   mitk::CastToMitkImage(regionGrower->GetOutput(), result);
 }
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Dicom Loader");
   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 folder:", "Input folder", us::Any(), false);
   parser.addArgument("output", "o", mitkCommandLineParser::OutputFile, "Output file:", "Output file",us::Any(),false);
 
 
   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 inputFile = us::any_cast<std::string>(parsedArgs["input"]);
   std::string outFileName = us::any_cast<std::string>(parsedArgs["output"]);
 
   mitk::Image::Pointer image = mitk::IOUtil::LoadImage(inputFile);
 
   mitk::OtsuSegmentationFilter::Pointer otsuFilter = mitk::OtsuSegmentationFilter::New();
   otsuFilter->SetNumberOfThresholds(2);
   otsuFilter->SetValleyEmphasis(false);
   otsuFilter->SetNumberOfBins(128);
   otsuFilter->SetInput(image);
   try
   {
     otsuFilter->Update();
   }
   catch (...)
   {
     mitkThrow() << "itkOtsuFilter error (image dimension must be in {2, 3} and image must not be RGB)";
   }
 
   mitk::LabelSetImage::Pointer resultImage = mitk::LabelSetImage::New();
   resultImage->InitializeByLabeledImage(otsuFilter->GetOutput());
   mitk::Image::Pointer rawMask = resultImage->CreateLabelMask(1);
   mitk::Image::Pointer pickedMask;
 
   AccessByItk_2(rawMask, StartRegionGrowing, pickedMask, rawMask->GetGeometry());
 
   mitk::MorphologicalOperations::FillHoles(pickedMask);
   mitk::MorphologicalOperations::Closing(pickedMask, 5, mitk::MorphologicalOperations::StructuralElementType::Ball);
   mitk::MorphologicalOperations::FillHoles(pickedMask);
 
 
-  mitk::IOUtil::SaveImage(pickedMask, outFileName);
+  mitk::IOUtil::Save(pickedMask, outFileName);
 
   return EXIT_SUCCESS;
 }
diff --git a/Modules/Classification/CLMiniApps/CLN4.cpp b/Modules/Classification/CLMiniApps/CLN4.cpp
index 4ff96603bc..f7a65eb60f 100644
--- a/Modules/Classification/CLMiniApps/CLN4.cpp
+++ b/Modules/Classification/CLMiniApps/CLN4.cpp
@@ -1,121 +1,121 @@
 /*===================================================================
 
 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);
   parser.addArgument("number-of-maximum-iterations", "nomi", mitkCommandLineParser::Int, "Parameter", "Spezifies the maximum number of iterations per run", us::Any(), true);
   // ToDo: Number Of Maximum Iterations durchschleifen
 
   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);
   }
   if (parsedArgs.count("number-of-maximum-iterations") > 0)
   {
     int variable = us::any_cast<int>(parsedArgs["number-of-maximum-iterations"]);
     MITK_INFO << "Number of Maximum Iterations: " << variable;
     auto list = filter->GetMaximumNumberOfIterations();
     list.Fill(variable);
     filter->SetMaximumNumberOfIterations(list);
   }
 
   filter->Update();
   auto out = filter->GetOutput();
   mitk::Image::Pointer outImg = mitk::Image::New();
   mitk::CastToMitkImage(out, outImg);
-  mitk::IOUtil::SaveImage(outImg, parsedArgs["output"].ToString());
+  mitk::IOUtil::Save(outImg, parsedArgs["output"].ToString());
 
   return EXIT_SUCCESS;
 }
\ No newline at end of file
diff --git a/Modules/Classification/CLMiniApps/CLRandomSampling.cpp b/Modules/Classification/CLMiniApps/CLRandomSampling.cpp
index 42b59ae7db..fd8632de2a 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 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)) {
     std::stringstream s2(tok);
     s2 >> val;
     internal.push_back(val);
   }
 
   return internal;
 }
 
 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)) {
     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);
 
   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<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);
+  mitk::IOUtil::Save(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 51275ae701..83759c1263 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)
   {
     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);
   }
 
   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)
   {
     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)
   {
     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());
+    mitk::IOUtil::Save(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());
+    mitk::IOUtil::Save(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 3d00cc041f..e58acfba58 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);
+  mitk::IOUtil::Save(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");
 
   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/CLVoxelClassification.cpp b/Modules/Classification/CLMiniApps/CLVoxelClassification.cpp
index bfc2cd48bf..750a8a3b42 100644
--- a/Modules/Classification/CLMiniApps/CLVoxelClassification.cpp
+++ b/Modules/Classification/CLMiniApps/CLVoxelClassification.cpp
@@ -1,481 +1,481 @@
 /*===================================================================
 
 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 mitkForest_cpp
 #define mitkForest_cpp
 
 #include "time.h"
 #include <sstream>
 
 #include <mitkConfigFileReader.h>
 #include <mitkDataCollection.h>
 #include <mitkCollectionReader.h>
 #include <mitkCollectionWriter.h>
 #include <mitkCollectionStatistic.h>
 #include <mitkCostingStatistic.h>
 #include <vtkSmartPointer.h>
 #include <mitkIOUtil.h>
 
 #include <mitkDataCollectionUtilities.h>
 #include <mitkRandomForestIO.h>
 
 // ----------------------- Forest Handling ----------------------
 //#include <mitkDecisionForest.h>
 #include <mitkVigraRandomForestClassifier.h>
 //#include <mitkThresholdSplit.h>
 //#include <mitkImpurityLoss.h>
 //#include <mitkLinearSplitting.h>
 //#include <mitkVigraConverter.h>
 // ----------------------- Point weighting ----------------------
 //#include <mitkForestWeighting.h>
 //#include <mitkKliepDensityEstimation.h>
 //#include <mitkExternalWeighting.h>
 #include <mitkLRDensityEstimation.h>
 //#include <mitkKNNDensityEstimation.h>
 //#include <mitkZadroznyWeighting.h>
 //#include <mitkSpectralDensityEstimation.h>
 //#include <mitkULSIFDensityEstimation.h>
 
 int main(int argc, char* argv[])
 {
   MITK_INFO << "Starting MITK_Forest Mini-App";
 
   //////////////////////////////////////////////////////////////////////////////
   // Read Console Input Parameter
   //////////////////////////////////////////////////////////////////////////////
   ConfigFileReader allConfig(argv[1]);
 
   bool readFile = true;
   std::stringstream ss;
   for (int i = 0; i < argc; ++i )
   {
     MITK_INFO << "-----"<< argv[i]<<"------";
     if (readFile)
     {
       if (argv[i][0] == '+')
       {
         readFile = false;
         continue;
       } else
       {
         try
         {
           allConfig.ReadFile(argv[i]);
         }
         catch (std::exception &e)
         {
           MITK_INFO << e.what();
         }
       }
     }
     else
     {
       std::string input = argv[i];
       std::replace(input.begin(), input.end(),'_',' ');
       ss << input << std::endl;
     }
   }
   allConfig.ReadStream(ss);
 
   try
   {
     //////////////////////////////////////////////////////////////////////////////
     // General
     //////////////////////////////////////////////////////////////////////////////
     int currentRun = allConfig.IntValue("General","Run",0);
     int doTraining = allConfig.IntValue("General","Do Training",1);
     std::string forestPath = allConfig.Value("General","Forest Path");
     std::string trainingCollectionPath = allConfig.Value("General","Patient Collection");
     std::string testCollectionPath = allConfig.Value("General", "Patient Test Collection", trainingCollectionPath);
 
     //////////////////////////////////////////////////////////////////////////////
     // Read Default Classification
     //////////////////////////////////////////////////////////////////////////////
     std::vector<std::string> trainPatients = allConfig.Vector("Training Group",currentRun);
     std::vector<std::string> testPatients = allConfig.Vector("Test Group",currentRun);
     std::vector<std::string> modalities = allConfig.Vector("Modalities", 0);
     std::vector<std::string> outputFilter = allConfig.Vector("Output Filter", 0);
     std::string trainMask = allConfig.Value("Data","Training Mask");
     std::string completeTrainMask = allConfig.Value("Data","Complete Training Mask");
     std::string testMask = allConfig.Value("Data","Test Mask");
     std::string resultMask = allConfig.Value("Data", "Result Mask");
     std::string resultProb = allConfig.Value("Data", "Result Propability");
     std::string outputFolder = allConfig.Value("General","Output Folder");
 
     std::string writeDataFilePath = allConfig.Value("Forest","File to write data to");
 
     //////////////////////////////////////////////////////////////////////////////
     // Read Data Forest Parameter
     //////////////////////////////////////////////////////////////////////////////
     int testSingleDataset = allConfig.IntValue("Data", "Test Single Dataset",0);
     std::string singleDatasetName = allConfig.Value("Data", "Single Dataset Name", "none");
     int trainSingleDataset = allConfig.IntValue("Data", "Train Single Dataset", 0);
     std::string singleTrainDatasetName = allConfig.Value("Data", "Train Single Dataset Name", "none");
 
     //////////////////////////////////////////////////////////////////////////////
     // Read Forest Parameter
     //////////////////////////////////////////////////////////////////////////////
     int minimumSplitNodeSize = allConfig.IntValue("Forest", "Minimum split node size",1);
     int numberOfTrees = allConfig.IntValue("Forest", "Number of Trees",255);
     double samplesPerTree = atof(allConfig.Value("Forest", "Samples per Tree").c_str());
     if (samplesPerTree <= 0.0000001)
     {
       samplesPerTree = 1.0;
     }
     MITK_INFO << "Samples per Tree: " << samplesPerTree;
     int sampleWithReplacement = allConfig.IntValue("Forest", "Sample with replacement",1);
     double trainPrecision = atof(allConfig.Value("Forest", "Precision").c_str());
     if (trainPrecision <= 0.0000000001)
     {
       trainPrecision = 0.0;
     }
     double weightLambda = atof(allConfig.Value("Forest", "Weight Lambda").c_str());
     if (weightLambda <= 0.0000000001)
     {
       weightLambda = 0.0;
     }
     int maximumTreeDepth =  allConfig.IntValue("Forest", "Maximum Tree Depth",10000);
     // TODO int randomSplit = allConfig.IntValue("Forest","Use RandomSplit",0);
     //////////////////////////////////////////////////////////////////////////////
     // Read Statistic Parameter
     //////////////////////////////////////////////////////////////////////////////
     std::string statisticFilePath = allConfig.Value("Evaluation", "Statistic output file");
     std::string statisticShortFilePath = allConfig.Value("Evaluation", "Statistic short output file");
     std::string statisticShortFileLabel = allConfig.Value("Evaluation", "Index for short file");
     std::string statisticGoldStandard = allConfig.Value("Evaluation", "Gold Standard Name","GTV");
     // TODO bool statisticWithHeader = allConfig.IntValue("Evaluation", "Write header in short file",0);
     std::vector<std::string> labelGroupA = allConfig.Vector("LabelsA",0);
     std::vector<std::string> labelGroupB = allConfig.Vector("LabelsB",0);
     //////////////////////////////////////////////////////////////////////////////
     // Read Special Parameter
     //////////////////////////////////////////////////////////////////////////////
-    // TODO bool useWeightedPoints = allConfig.IntValue("Forest", "Use point-based weighting",0);
+    bool useWeightedPoints = allConfig.IntValue("Forest", "Use point-based weighting",0);
     // TODO bool writePointsToFile = allConfig.IntValue("Forest", "Write points to file",0);
     // TODO int importanceWeightAlgorithm = allConfig.IntValue("Forest","Importance weight Algorithm",0);
     std::string importanceWeightName = allConfig.Value("Forest","Importance weight name","");
 
     std::ofstream timingFile;
     timingFile.open((statisticFilePath + ".timing").c_str(), std::ios::app);
     timingFile << statisticShortFileLabel << ";";
     std::time_t lastTimePoint;
     time(&lastTimePoint);
 
     //////////////////////////////////////////////////////////////////////////////
     // Read Images
     //////////////////////////////////////////////////////////////////////////////
     std::vector<std::string> usedModalities;
     for (std::size_t i = 0; i < modalities.size(); ++i)
     {
       usedModalities.push_back(modalities[i]);
     }
     usedModalities.push_back(trainMask);
     usedModalities.push_back(completeTrainMask);
     usedModalities.push_back(testMask);
     usedModalities.push_back(statisticGoldStandard);
     usedModalities.push_back(importanceWeightName);
 
     if (trainSingleDataset > 0)
     {
       trainPatients.clear();
       trainPatients.push_back(singleTrainDatasetName);
     }
 
     mitk::CollectionReader* colReader = new mitk::CollectionReader();
     colReader->AddDataElementIds(trainPatients);
     colReader->SetDataItemNames(usedModalities);
     //colReader->SetNames(usedModalities);
     mitk::DataCollection::Pointer trainCollection;
     if (doTraining)
     {
       trainCollection = colReader->LoadCollection(trainingCollectionPath);
     }
 
     if (testSingleDataset > 0)
     {
       testPatients.clear();
       testPatients.push_back(singleDatasetName);
     }
     colReader->ClearDataElementIds();
     colReader->AddDataElementIds(testPatients);
     mitk::DataCollection::Pointer testCollection = colReader->LoadCollection(testCollectionPath);
 
     std::time_t now;
     time(&now);
     double seconds =  std::difftime(now, lastTimePoint);
     timingFile << seconds << ";";
     time(&lastTimePoint);
 
     /*
     if (writePointsToFile)
     {
     MITK_INFO << "Use external weights...";
     mitk::ExternalWeighting weightReader;
     weightReader.SetModalities(modalities);
     weightReader.SetTestCollection(testCollection);
     weightReader.SetTrainCollection(trainCollection);
     weightReader.SetTestMask(testMask);
     weightReader.SetTrainMask(trainMask);
     weightReader.SetWeightsName("weights");
     weightReader.SetCorrectionFactor(1.0);
     weightReader.SetWeightFileName(writeDataFilePath);
     weightReader.WriteData();
     return 0;
     }*/
 
     //////////////////////////////////////////////////////////////////////////////
     // If required do Training....
     //////////////////////////////////////////////////////////////////////////////
     //mitk::DecisionForest forest;
 
     mitk::VigraRandomForestClassifier::Pointer forest = mitk::VigraRandomForestClassifier::New();
     forest->SetSamplesPerTree(samplesPerTree);
     forest->SetMinimumSplitNodeSize(minimumSplitNodeSize);
     forest->SetTreeCount(numberOfTrees);
     forest->UseSampleWithReplacement(sampleWithReplacement);
     forest->SetPrecision(trainPrecision);
     forest->SetMaximumTreeDepth(maximumTreeDepth);
     forest->SetWeightLambda(weightLambda);
 
     // TODO forest.UseRandomSplit(randomSplit);
 
     if (doTraining)
     {
       // 0 = LR-Estimation
       // 1 = KNN-Estimation
       // 2 = Kliep
       // 3 = Extern Image
       // 4 = Zadrozny
       // 5 = Spectral
       // 6 = uLSIF
       auto trainDataX = mitk::DCUtilities::DC3dDToMatrixXd(trainCollection, modalities, trainMask);
       auto trainDataY = mitk::DCUtilities::DC3dDToMatrixXi(trainCollection, trainMask, trainMask);
 
       if (useWeightedPoints)
       //if (false)
       {
         MITK_INFO << "Activated Point-based weighting...";
         //forest.UseWeightedPoints(true);
         forest->UsePointWiseWeight(true);
         //forest.SetWeightName("calculated_weight");
         /*if (importanceWeightAlgorithm == 1)
         {
         mitk::KNNDensityEstimation est;
         est.SetCollection(trainCollection);
         est.SetTrainMask(trainMask);
         est.SetTestMask(testMask);
         est.SetModalities(modalities);
         est.SetWeightName("calculated_weight");
         est.Update();
         } else if (importanceWeightAlgorithm == 2)
         {
         mitk::KliepDensityEstimation est;
         est.SetCollection(trainCollection);
         est.SetTrainMask(trainMask);
         est.SetTestMask(testMask);
         est.SetModalities(modalities);
         est.SetWeightName("calculated_weight");
         est.Update();
         } else if (importanceWeightAlgorithm == 3)
         {
         forest.SetWeightName(importanceWeightName);
         } else if (importanceWeightAlgorithm == 4)
         {
         mitk::ZadroznyWeighting est;
         est.SetCollection(trainCollection);
         est.SetTrainMask(trainMask);
         est.SetTestMask(testMask);
         est.SetModalities(modalities);
         est.SetWeightName("calculated_weight");
         est.Update();
         } else if (importanceWeightAlgorithm == 5)
         {
         mitk::SpectralDensityEstimation est;
         est.SetCollection(trainCollection);
         est.SetTrainMask(trainMask);
         est.SetTestMask(testMask);
         est.SetModalities(modalities);
         est.SetWeightName("calculated_weight");
         est.Update();
         } else if (importanceWeightAlgorithm == 6)
         {
         mitk::ULSIFDensityEstimation est;
         est.SetCollection(trainCollection);
         est.SetTrainMask(trainMask);
         est.SetTestMask(testMask);
         est.SetModalities(modalities);
         est.SetWeightName("calculated_weight");
         est.Update();
         } else*/
         {
           mitk::LRDensityEstimation est;
           est.SetCollection(trainCollection);
           est.SetTrainMask(trainMask);
           est.SetTestMask(testMask);
           est.SetModalities(modalities);
           est.SetWeightName("calculated_weight");
           est.Update();
         }
         auto trainDataW = mitk::DCUtilities::DC3dDToMatrixXd(trainCollection, "calculated_weight", trainMask);
         forest->SetPointWiseWeight(trainDataW);
         forest->UsePointWiseWeight(true);
       }
       MITK_INFO << "Start training the forest";
       forest->Train(trainDataX, trainDataY);
 
       MITK_INFO << "Save Forest";
       mitk::IOUtil::Save(forest, forestPath);
     } else
     {
       forest = dynamic_cast<mitk::VigraRandomForestClassifier*>(mitk::IOUtil::Load(forestPath)[0].GetPointer());// TODO forest.Load(forestPath);
     }
 
     time(&now);
     seconds =  std::difftime(now, lastTimePoint);
     MITK_INFO << "Duration for Training: " << seconds;
     timingFile << seconds << ";";
     time(&lastTimePoint);
     //////////////////////////////////////////////////////////////////////////////
     // If required do Save Forest....
     //////////////////////////////////////////////////////////////////////////////
 
     //writer.// (forest);
     /*
     auto w = forest->GetTreeWeights();
     w(0,0) = 10;
     forest->SetTreeWeights(w);*/
 
     //////////////////////////////////////////////////////////////////////////////
     // If required do test
     //////////////////////////////////////////////////////////////////////////////
     MITK_INFO << "Convert Test data";
     auto testDataX = mitk::DCUtilities::DC3dDToMatrixXd(testCollection,modalities, testMask);
 
     MITK_INFO << "Predict Test Data";
     auto testDataNewY = forest->Predict(testDataX);
     auto testDataNewProb = forest->GetPointWiseProbabilities();
     //MITK_INFO << testDataNewY;
 
     auto maxClassValue = testDataNewProb.cols();
     std::vector<std::string> names;
     for (int i = 0; i < maxClassValue; ++i)
     {
       std::string name = resultProb + std::to_string(i);
       MITK_INFO << name;
       names.push_back(name);
     }
     //names.push_back("prob-1");
     //names.push_back("prob-2");
 
     mitk::DCUtilities::MatrixToDC3d(testDataNewY, testCollection, resultMask, testMask);
     mitk::DCUtilities::MatrixToDC3d(testDataNewProb, testCollection, names, testMask);
     MITK_INFO << "Converted predicted data";
     //forest.SetMaskName(testMask);
     //forest.SetCollection(testCollection);
     //forest.Test();
     //forest.PrintTree(0);
 
     time(&now);
     seconds =  std::difftime(now, lastTimePoint);
     timingFile << seconds << ";";
     time(&lastTimePoint);
 
     //////////////////////////////////////////////////////////////////////////////
     // Cost-based analysis
     //////////////////////////////////////////////////////////////////////////////
 
     // TODO Reactivate
     //MITK_INFO << "Calculate Cost-based Statistic ";
     //mitk::CostingStatistic costStat;
     //costStat.SetCollection(testCollection);
     //costStat.SetCombinedA("combinedHealty");
     //costStat.SetCombinedB("combinedTumor");
     //costStat.SetCombinedLabel("combinedLabel");
     //costStat.SetMaskName(testMask);
     ////std::vector<std::string> labelHealthy;
     ////labelHealthy.push_back("result_prop_Class-0");
     ////labelHealthy.push_back("result_prop_Class-4");
     ////std::vector<std::string> labelTumor;
     ////labelTumor.push_back("result_prop_Class-1");
     ////labelTumor.push_back("result_prop_Class-2");
     ////labelTumor.push_back("result_prop_Class-3");
     //costStat.SetProbabilitiesA(labelGroupA);
     //costStat.SetProbabilitiesB(labelGroupB);
 
     //std::ofstream costStatisticFile;
     //costStatisticFile.open((statisticFilePath + ".cost").c_str(), std::ios::app);
     //std::ofstream lcostStatisticFile;
 
     //lcostStatisticFile.open((statisticFilePath + ".longcost").c_str(), std::ios::app);
     //costStat.WriteStatistic(lcostStatisticFile,costStatisticFile,2.5,statisticShortFileLabel);
     //costStatisticFile.close();
 
     //costStat.CalculateClass(50);
 
     //////////////////////////////////////////////////////////////////////////////
     // Save results to folder
     //////////////////////////////////////////////////////////////////////////////
     ////std::vector<std::string> outputFilter;
     //outputFilter.push_back(resultMask);
     //std::vector<std::string> propNames = forest.GetListOfProbabilityNames();
     //outputFilter.insert(outputFilter.begin(), propNames.begin(), propNames.end());
     MITK_INFO << "Write Result to HDD";
     mitk::CollectionWriter::ExportCollectionToFolder(testCollection,
       outputFolder + "/result_collection.xml",
       outputFilter);
 
     MITK_INFO << "Calculate Statistic...." ;
     //////////////////////////////////////////////////////////////////////////////
     // Calculate and Print Statistic
     //////////////////////////////////////////////////////////////////////////////
     std::ofstream statisticFile;
     statisticFile.open(statisticFilePath.c_str(), std::ios::app);
     std::ofstream sstatisticFile;
     sstatisticFile.open(statisticShortFilePath.c_str(), std::ios::app);
 
     mitk::CollectionStatistic stat;
     stat.SetCollection(testCollection);
     stat.SetClassCount(5);
     stat.SetGoldName(statisticGoldStandard);
     stat.SetTestName(resultMask);
     stat.SetMaskName(testMask);
     mitk::BinaryValueminusOneToIndexMapper* mapper = new mitk::BinaryValueminusOneToIndexMapper;
     stat.SetGroundTruthValueToIndexMapper(mapper);
     stat.SetTestValueToIndexMapper(mapper);
     stat.Update();
     //stat.Print(statisticFile,sstatisticFile,statisticWithHeader, statisticShortFileLabel);
     stat.Print(statisticFile,sstatisticFile,true, statisticShortFileLabel);
     statisticFile.close();
     delete mapper;
 
     time(&now);
     seconds =  std::difftime(now, lastTimePoint);
     timingFile << seconds << std::endl;
     time(&lastTimePoint);
     timingFile.close();
   }
   catch (std::string s)
   {
     MITK_INFO << s;
     return 0;
   }
   catch (char* s)
   {
     MITK_INFO << s;
   }
 
   return 0;
 }
 
 #endif
diff --git a/Modules/Classification/CLMiniApps/CLVoxelFeatures.cpp b/Modules/Classification/CLMiniApps/CLVoxelFeatures.cpp
index 55bd36b3c4..acae0547ec 100644
--- a/Modules/Classification/CLMiniApps/CLVoxelFeatures.cpp
+++ b/Modules/Classification/CLMiniApps/CLVoxelFeatures.cpp
@@ -1,335 +1,335 @@
 /*===================================================================
 
 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 mitkCLVoxeFeatures_cpp
 #define mitkCLVoxeFeatures_cpp
 
 #include "time.h"
 #include <sstream>
 #include <fstream>
 
 #include <mitkIOUtil.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkImageCast.h>
 #include "mitkCommandLineParser.h"
 
 #include <mitkGIFCooccurenceMatrix.h>
 #include <mitkGIFGrayLevelRunLength.h>
 
 #include "itkDiscreteGaussianImageFilter.h"
 #include <itkLaplacianRecursiveGaussianImageFilter.h>
 #include "itkHessianRecursiveGaussianImageFilter.h"
 #include "itkUnaryFunctorImageFilter.h"
 #include "vnl/algo/vnl_symmetric_eigensystem.h"
 #include <itkMultiHistogramFilter.h>
 #include <itkSubtractImageFilter.h>
 
 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 (std::getline(ss, tok, delimiter)) {
     std::stringstream s2(tok);
     s2 >> val;
     internal.push_back(val);
   }
 
   return internal;
 }
 
 namespace Functor
 {
   template <class TInput, class TOutput>
   class MatrixFirstEigenvalue
   {
   public:
     MatrixFirstEigenvalue() {}
     virtual ~MatrixFirstEigenvalue() {}
 
     int order;
 
     inline TOutput operator ()(const TInput& input)
     {
       double a,b,c;
       if (input[0] < 0.01 && input[1] < 0.01 &&input[2] < 0.01 &&input[3] < 0.01 &&input[4] < 0.01 &&input[5] < 0.01)
         return 0;
       vnl_symmetric_eigensystem_compute_eigenvals(input[0], input[1],input[2],input[3],input[4],input[5],a,b,c);
       switch (order)
       {
       case 0: return a;
       case 1: return b;
       case 2: return c;
       default: return a;
       }
     }
     bool operator !=(const MatrixFirstEigenvalue) const
     {
       return false;
     }
     bool operator ==(const MatrixFirstEigenvalue& other) const
     {
       return !(*this != other);
     }
   };
 }
 
 template<typename TPixel, unsigned int VImageDimension>
 void
   GaussianFilter(itk::Image<TPixel, VImageDimension>* itkImage, double variance, mitk::Image::Pointer &output)
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef itk::DiscreteGaussianImageFilter< ImageType, ImageType >  GaussFilterType;
 
   typename GaussFilterType::Pointer gaussianFilter = GaussFilterType::New();
   gaussianFilter->SetInput( itkImage );
   gaussianFilter->SetVariance(variance);
   gaussianFilter->Update();
   mitk::CastToMitkImage(gaussianFilter->GetOutput(), output);
 }
 
 template<typename TPixel, unsigned int VImageDimension>
 void
   DifferenceOfGaussFilter(itk::Image<TPixel, VImageDimension>* itkImage, double variance, mitk::Image::Pointer &output)
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef itk::DiscreteGaussianImageFilter< ImageType, ImageType >  GaussFilterType;
   typedef itk::SubtractImageFilter<ImageType, ImageType, ImageType> SubFilterType;
 
   typename GaussFilterType::Pointer gaussianFilter1 = GaussFilterType::New();
   gaussianFilter1->SetInput( itkImage );
   gaussianFilter1->SetVariance(variance);
   gaussianFilter1->Update();
   typename GaussFilterType::Pointer gaussianFilter2 = GaussFilterType::New();
   gaussianFilter2->SetInput( itkImage );
   gaussianFilter2->SetVariance(variance*0.66*0.66);
   gaussianFilter2->Update();
   typename SubFilterType::Pointer subFilter = SubFilterType::New();
   subFilter->SetInput1(gaussianFilter1->GetOutput());
   subFilter->SetInput2(gaussianFilter2->GetOutput());
   subFilter->Update();
   mitk::CastToMitkImage(subFilter->GetOutput(), output);
 }
 
 template<typename TPixel, unsigned int VImageDimension>
 void
   LaplacianOfGaussianFilter(itk::Image<TPixel, VImageDimension>* itkImage, double variance, mitk::Image::Pointer &output)
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef itk::DiscreteGaussianImageFilter< ImageType, ImageType >  GaussFilterType;
   typedef itk::LaplacianRecursiveGaussianImageFilter<ImageType, ImageType>    LaplacianFilter;
 
   typename GaussFilterType::Pointer gaussianFilter = GaussFilterType::New();
   gaussianFilter->SetInput( itkImage );
   gaussianFilter->SetVariance(variance);
   gaussianFilter->Update();
   typename LaplacianFilter::Pointer laplaceFilter = LaplacianFilter::New();
   laplaceFilter->SetInput(gaussianFilter->GetOutput());
   laplaceFilter->Update();
   mitk::CastToMitkImage(laplaceFilter->GetOutput(), output);
 }
 
 template<typename TPixel, unsigned int VImageDimension>
 void
   HessianOfGaussianFilter(itk::Image<TPixel, VImageDimension>* itkImage, double variance, std::vector<mitk::Image::Pointer> &out)
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef itk::Image<double, VImageDimension> FloatImageType;
   typedef itk::HessianRecursiveGaussianImageFilter <ImageType> HessianFilterType;
   typedef typename HessianFilterType::OutputImageType VectorImageType;
   typedef Functor::MatrixFirstEigenvalue<typename VectorImageType::PixelType, double> DeterminantFunctorType;
   typedef itk::UnaryFunctorImageFilter<VectorImageType, FloatImageType, DeterminantFunctorType> DetFilterType;
 
   typename HessianFilterType::Pointer hessianFilter = HessianFilterType::New();
   hessianFilter->SetInput(itkImage);
   hessianFilter->SetSigma(std::sqrt(variance));
   for (unsigned int i = 0; i < VImageDimension; ++i)
   {
     typename DetFilterType::Pointer detFilter = DetFilterType::New();
     detFilter->SetInput(hessianFilter->GetOutput());
     detFilter->GetFunctor().order = i;
     detFilter->Update();
     mitk::CastToMitkImage(detFilter->GetOutput(), out[i]);
   }
 }
 
 template<typename TPixel, unsigned int VImageDimension>
 void
   LocalHistograms(itk::Image<TPixel, VImageDimension>* itkImage, std::vector<mitk::Image::Pointer> &out, double offset, double delta)
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef itk::MultiHistogramFilter <ImageType,ImageType> MultiHistogramType;
 
   typename MultiHistogramType::Pointer filter = MultiHistogramType::New();
   filter->SetInput(itkImage);
   filter->SetOffset(offset);
   filter->SetDelta(delta);
   filter->Update();
   for (int i = 0; i < 11; ++i)
   {
     mitk::Image::Pointer img = mitk::Image::New();
     mitk::CastToMitkImage(filter->GetOutput(i), img);
     out.push_back(img);
   }
 }
 
 int main(int argc, char* argv[])
 {
   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("output", "o", mitkCommandLineParser::OutputFile, "Output text file", "Target file. The output statistic is appended to this file.", us::Any(), false);
   parser.addArgument("extension", "e", mitkCommandLineParser::OutputFile, "Extension", "File extension. Default is .nii.gz", us::Any(), true);
 
   parser.addArgument("gaussian","g",mitkCommandLineParser::String, "Gaussian Filtering of the input images", "Gaussian Filter. Followed by the used variances seperated by ';' ",us::Any());
   parser.addArgument("difference-of-gaussian","dog",mitkCommandLineParser::String, "Difference of Gaussian Filtering of the input images", "Difference of Gaussian Filter. Followed by the used variances seperated by ';' ",us::Any());
   parser.addArgument("laplace-of-gauss","log",mitkCommandLineParser::String, "Laplacian of Gaussian Filtering", "Laplacian of Gaussian Filter. Followed by the used variances seperated by ';' ",us::Any());
   parser.addArgument("hessian-of-gauss","hog",mitkCommandLineParser::String, "Hessian of Gaussian Filtering", "Hessian of Gaussian Filter. Followed by the used variances seperated by ';' ",us::Any());
   parser.addArgument("local-histogram", "lh", mitkCommandLineParser::String, "Local Histograms", "Calculate the local histogram based feature. Specify Offset and Delta, for exampel -3;0.6 ", us::Any());
   // Miniapp Infos
   parser.setCategory("Classification Tools");
   parser.setTitle("Global Image Feature calculator");
   parser.setDescription("Calculates different global statistics for a given segmentation / image combination");
   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::Image::Pointer image = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(parsedArgs["image"].ToString())[0].GetPointer());
   std::string filename=parsedArgs["output"].ToString();
 
   std::string extension = ".nii.gz";
   if (parsedArgs.count("extension"))
   {
     extension = parsedArgs["extension"].ToString();
   }
 
   ////////////////////////////////////////////////////////////////
   // CAlculate Gaussian Features
   ////////////////////////////////////////////////////////////////
   MITK_INFO << "Check for Local Histogram...";
   if (parsedArgs.count("local-histogram"))
   {
     std::vector<mitk::Image::Pointer> outs;
     auto ranges = splitDouble(parsedArgs["local-histogram"].ToString(), ';');
     if (ranges.size() < 2)
     {
       MITK_INFO << "Missing Delta and Offset for Local Histogram";
     }
     else
     {
       AccessByItk_3(image, LocalHistograms, outs, ranges[0], ranges[1]);
       for (std::size_t i = 0; i < outs.size(); ++i)
       {
         std::string name = filename + "-lh" + us::any_value_to_string<int>(i)+extension;
         mitk::IOUtil::Save(outs[i], name);
       }
     }
   }
 
   ////////////////////////////////////////////////////////////////
   // CAlculate Gaussian Features
   ////////////////////////////////////////////////////////////////
   MITK_INFO << "Check for Gaussian...";
   if (parsedArgs.count("gaussian"))
   {
     MITK_INFO << "Calculate Gaussian... " << parsedArgs["gaussian"].ToString();
     auto ranges = splitDouble(parsedArgs["gaussian"].ToString(),';');
 
     for (std::size_t i = 0; i < ranges.size(); ++i)
     {
       MITK_INFO << "Gaussian with sigma: " << ranges[i];
       mitk::Image::Pointer output;
       AccessByItk_2(image, GaussianFilter, ranges[i], output);
       MITK_INFO << "Write output:";
       std::string name = filename + "-gaussian-" + us::any_value_to_string(ranges[i]) + extension;
-      mitk::IOUtil::SaveImage(output, name);
+      mitk::IOUtil::Save(output, name);
     }
   }
 
   ////////////////////////////////////////////////////////////////
   // CAlculate Difference of Gaussian Features
   ////////////////////////////////////////////////////////////////
   MITK_INFO << "Check for DoG...";
   if (parsedArgs.count("difference-of-gaussian"))
   {
     MITK_INFO << "Calculate Difference of Gaussian... " << parsedArgs["difference-of-gaussian"].ToString();
     auto ranges = splitDouble(parsedArgs["difference-of-gaussian"].ToString(),';');
 
     for (std::size_t i = 0; i < ranges.size(); ++i)
     {
       mitk::Image::Pointer output;
       AccessByItk_2(image, DifferenceOfGaussFilter, ranges[i], output);
       std::string name = filename + "-dog-" + us::any_value_to_string(ranges[i]) + extension;
       mitk::IOUtil::Save(output, name);
     }
   }
 
   MITK_INFO << "Check for LoG...";
   ////////////////////////////////////////////////////////////////
   // CAlculate Laplacian Of Gauss Features
   ////////////////////////////////////////////////////////////////
   if (parsedArgs.count("laplace-of-gauss"))
   {
     MITK_INFO << "Calculate LoG... " << parsedArgs["laplace-of-gauss"].ToString();
     auto ranges = splitDouble(parsedArgs["laplace-of-gauss"].ToString(),';');
 
     for (std::size_t i = 0; i < ranges.size(); ++i)
     {
       mitk::Image::Pointer output;
       AccessByItk_2(image, LaplacianOfGaussianFilter, ranges[i], output);
       std::string name = filename + "-log-" + us::any_value_to_string(ranges[i]) + extension;
       mitk::IOUtil::Save(output, name);
     }
   }
 
   MITK_INFO << "Check for HoG...";
   ////////////////////////////////////////////////////////////////
   // CAlculate Hessian Of Gauss Features
   ////////////////////////////////////////////////////////////////
   if (parsedArgs.count("hessian-of-gauss"))
   {
     MITK_INFO << "Calculate HoG... " << parsedArgs["hessian-of-gauss"].ToString();
     auto ranges = splitDouble(parsedArgs["hessian-of-gauss"].ToString(),';');
 
     for (std::size_t i = 0; i < ranges.size(); ++i)
     {
       std::vector<mitk::Image::Pointer> outs;
       outs.push_back(mitk::Image::New());
       outs.push_back(mitk::Image::New());
       outs.push_back(mitk::Image::New());
       AccessByItk_2(image, HessianOfGaussianFilter, ranges[i], outs);
       std::string name = filename + "-hog0-" + us::any_value_to_string(ranges[i]) + extension;
       mitk::IOUtil::Save(outs[0], name);
       name = filename + "-hog1-" + us::any_value_to_string(ranges[i]) + extension;
       mitk::IOUtil::Save(outs[1], name);
       name = filename + "-hog2-" + us::any_value_to_string(ranges[i]) + extension;
       mitk::IOUtil::Save(outs[2], name);
     }
   }
 
   return 0;
 }
 
 #endif
diff --git a/Modules/Classification/CLMiniApps/CMakeLists.txt b/Modules/Classification/CLMiniApps/CMakeLists.txt
index 1978c241e3..af8f088c36 100644
--- a/Modules/Classification/CLMiniApps/CMakeLists.txt
+++ b/Modules/Classification/CLMiniApps/CMakeLists.txt
@@ -1,145 +1,135 @@
 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
         CLScreenshot^^MitkCore_MitkQtWidgetsExt_MitkCLUtilities
         CLDicom2Nrrd^^MitkCore
         CLImageTypeConverter^^MitkCore
         CLResampleImageToReference^^MitkCore
-        CLGlobalImageFeatures^^MitkCLUtilities
+        CLGlobalImageFeatures^^MitkCLUtilities_MitkQtWidgetsExt
         CLMRNormalization^^MitkCLUtilities_MitkCLMRUtilities
         CLStaple^^MitkCLUtilities
         CLVoxelFeatures^^MitkCLUtilities
         CLPolyToNrrd^^
         CLSimpleVoxelClassification^^MitkDataCollection_MitkCLVigraRandomForest
         CLVoxelClassification^^MitkDataCollection_MitkCLImportanceWeighting_MitkCLVigraRandomForest
         CLBrainMask^^MitkCLUtilities
         XRaxSimulationFromCT^^MitkCLUtilities
         CLRandomSampling^^MitkCore_MitkCLUtilities
         CLRemoveEmptyVoxels^^MitkCore
         CLN4^^MitkCore
         CLMultiForestPrediction^^MitkDataCollection_MitkCLVigraRandomForest
         CLNrrdToPoly^^MitkCore
         CL2Dto3DImage^^MitkCore
         CLWeighting^^MitkCore_MitkCLImportanceWeighting_MitkCLUtilities
         CLOverlayRoiCenterOfMass^^MitkCore_MitkCLUtilities_MitkQtWidgetsExt
         CLLungSegmentation^^MitkCore_MitkSegmentation_MitkMultilabel
     #    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 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
   #)
 
         # 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/CLMiniApps/XRaxSimulationFromCT.cpp b/Modules/Classification/CLMiniApps/XRaxSimulationFromCT.cpp
index c951097f72..2aaff7647e 100644
--- a/Modules/Classification/CLMiniApps/XRaxSimulationFromCT.cpp
+++ b/Modules/Classification/CLMiniApps/XRaxSimulationFromCT.cpp
@@ -1,198 +1,198 @@
 /*===================================================================
 
 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 "mitkDicomSeriesReader.h"
 #include "mitkProperties.h"
 
 #include "mitkCommandLineParser.h"
 #include "mitkIOUtil.h"
 
 #include "itkImageRegionIterator.h"
 // MITK
 #include <mitkITKImageImport.h>
 #include <mitkImageCast.h>
 #include <mitkImageAccessByItk.h>
 
 
 
 template<typename TPixel, unsigned int VImageDimension>
 void
 CreateXRay(itk::Image<TPixel, VImageDimension>* itkImage, mitk::Image::Pointer mask1, std::string output)
 {
   typedef itk::Image<TPixel, VImageDimension>         ImageType;
   typedef itk::Image<unsigned char, VImageDimension>  MaskType;
   typedef itk::Image<double, 2 >                      NewImageType;
 
   typename MaskType::Pointer itkMask = MaskType::New();
   mitk::CastToItkImage(mask1, itkMask);
 
   NewImageType::SpacingType newSpacing;
   auto spacing = itkImage->GetSpacing();
 
   NewImageType::RegionType region1,region2,region3,region1m,region2m,region3m;
   NewImageType::IndexType start;
   start[0] = 0; start[1] = 0;
 
   NewImageType::SizeType size1, size2, size3;
   size1[0] = mask1->GetDimensions()[0];
   size2[0] = mask1->GetDimensions()[0];
   size3[0] = mask1->GetDimensions()[1];
   size1[1] = mask1->GetDimensions()[1];
   size2[1] = mask1->GetDimensions()[2];
   size3[1] = mask1->GetDimensions()[2];
 
   region1.SetSize(size1);
   region1m.SetSize(size1);
   region2.SetSize(size2);
   region2m.SetSize(size2);
   region3.SetSize(size3);
   region3m.SetSize(size3);
   region1.SetIndex(start);
   region1m.SetIndex(start);
   region2.SetIndex(start);
   region2m.SetIndex(start);
   region3.SetIndex(start);
   region3m.SetIndex(start);
 
   NewImageType::Pointer image1 = NewImageType::New();
   image1->SetRegions(region1);
   image1->Allocate();
   image1->FillBuffer(0);
   newSpacing[0] = spacing[0]; newSpacing[1] = spacing[1];
   image1->SetSpacing(newSpacing);
   NewImageType::Pointer image2 = NewImageType::New();
   image2->SetRegions(region2);
   image2->Allocate();
   image2->FillBuffer(0);
   newSpacing[0] = spacing[0]; newSpacing[1] = spacing[2];
   image2->SetSpacing(newSpacing);
   NewImageType::Pointer image3 = NewImageType::New();
   image3->SetRegions(region3);
   image3->Allocate();
   image3->FillBuffer(0);
   newSpacing[0] = spacing[1]; newSpacing[1] = spacing[2];
   image3->SetSpacing(newSpacing);
   NewImageType::Pointer image1m = NewImageType::New();
   image1m->SetRegions(region1m);
   image1m->Allocate();
   image1m->FillBuffer(0);
   newSpacing[0] = spacing[0]; newSpacing[1] = spacing[1];
   image1m->SetSpacing(newSpacing);
   NewImageType::Pointer image2m = NewImageType::New();
   image2m->SetRegions(region2m);
   image2m->Allocate();
   image2m->FillBuffer(0);
   newSpacing[0] = spacing[0]; newSpacing[1] = spacing[2];
   image2m->SetSpacing(newSpacing);
   NewImageType::Pointer image3m = NewImageType::New();
   image3m->SetRegions(region3m);
   image3m->Allocate();
   image3m->FillBuffer(0);
   newSpacing[0] = spacing[1]; newSpacing[1] = spacing[2];
   image3m->SetSpacing(newSpacing);
 
-  for (int x = 0; x < mask1->GetDimensions()[0]; ++x)
+  for (unsigned int x = 0; x < mask1->GetDimensions()[0]; ++x)
   {
-    for (int y = 0; y < mask1->GetDimensions()[1]; ++y)
+    for (unsigned int y = 0; y < mask1->GetDimensions()[1]; ++y)
     {
-      for (int z = 0; z < mask1->GetDimensions()[2]; ++z)
+      for (unsigned int z = 0; z < mask1->GetDimensions()[2]; ++z)
       {
         NewImageType::IndexType newIndex;
         ImageType::IndexType index;
         index[0] = x; index[1] = y; index[2] = z;
         double pixel = itkImage->GetPixel(index)+1024;
         pixel = pixel / 1000.0;
         newIndex[0] = x; newIndex[1] = y;
         image1->SetPixel(newIndex, image1->GetPixel(newIndex) + pixel);
         newIndex[0] = x; newIndex[1] = z;
         image2->SetPixel(newIndex, image2->GetPixel(newIndex) + pixel);
         newIndex[0] = y; newIndex[1] = z;
         image3->SetPixel(newIndex, image3->GetPixel(newIndex) + pixel);
         if (itkMask->GetPixel(index) > 0)
         {
           pixel = -1000 + 1024;
           pixel = pixel / 1000.0;
         }
         newIndex[0] = x; newIndex[1] = y;
         image1m->SetPixel(newIndex, image1m->GetPixel(newIndex) + pixel);
         newIndex[0] = x; newIndex[1] = z;
         image2m->SetPixel(newIndex, image2m->GetPixel(newIndex) + pixel);
         newIndex[0] = y; newIndex[1] = z;
         image3m->SetPixel(newIndex, image3m->GetPixel(newIndex) + pixel);
       }
     }
   }
 
 
   mitk::Image::Pointer img = mitk::ImportItkImage(image1);
-  mitk::IOUtil::SaveImage(img, output + "1.nrrd");
+  mitk::IOUtil::Save(img, output + "1.nrrd");
   img = mitk::ImportItkImage(image2);
-  mitk::IOUtil::SaveImage(img, output + "2.nrrd");
+  mitk::IOUtil::Save(img, output + "2.nrrd");
   img = mitk::ImportItkImage(image3);
-  mitk::IOUtil::SaveImage(img, output + "3.nrrd");
+  mitk::IOUtil::Save(img, output + "3.nrrd");
   img = mitk::ImportItkImage(image1m);
-  mitk::IOUtil::SaveImage(img, output + "1m.nrrd");
+  mitk::IOUtil::Save(img, output + "1m.nrrd");
   img = mitk::ImportItkImage(image2m);
-  mitk::IOUtil::SaveImage(img, output + "2m.nrrd");
+  mitk::IOUtil::Save(img, output + "2m.nrrd");
   img = mitk::ImportItkImage(image3m);
-  mitk::IOUtil::SaveImage(img, output + "3m.nrrd");
+  mitk::IOUtil::Save(img, output + "3m.nrrd");
 }
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Dicom Loader");
   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 image:", "Input folder", us::Any(), false);
   parser.addArgument("mask", "m", mitkCommandLineParser::InputDirectory, "Input mask:", "Input folder", us::Any(), false);
   parser.addArgument("output", "o", mitkCommandLineParser::OutputFile, "Output file:", "Output file",us::Any(),false);
 
   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 inputImage = us::any_cast<std::string>(parsedArgs["input"]);
   MITK_INFO << inputImage;
   std::string inputMask = us::any_cast<std::string>(parsedArgs["mask"]);
   MITK_INFO << inputMask;
 
   mitk::Image::Pointer image = mitk::IOUtil::LoadImage(inputImage);
   mitk::Image::Pointer mask = mitk::IOUtil::LoadImage(inputMask);
 
   AccessByItk_2(image, CreateXRay, mask, parsedArgs["output"].ToString());
 
   //const mitk::Image::Pointer image = *imageIter;
   //mitk::IOUtil::SaveImage(image,outFileName);
 
 
 
   return EXIT_SUCCESS;
 }
diff --git a/Modules/Classification/CLUtilities/include/itkMultiHistogramFilter.cpp b/Modules/Classification/CLUtilities/include/itkMultiHistogramFilter.cpp
index 544ee43a67..efec31ece5 100644
--- a/Modules/Classification/CLUtilities/include/itkMultiHistogramFilter.cpp
+++ b/Modules/Classification/CLUtilities/include/itkMultiHistogramFilter.cpp
@@ -1,113 +1,112 @@
 #ifndef itkMultiHistogramFilter_cpp
 #define itkMultiHistogramFilter_cpp
 
 #include <itkMultiHistogramFilter.h>
 
 #include <itkNeighborhoodIterator.h>
 #include <itkImageRegionIterator.h>
 #include <itkImageIterator.h>
 #include "itkMinimumMaximumImageCalculator.h"
 
 template< class TInputImageType, class TOuputImageType>
 itk::MultiHistogramFilter<TInputImageType, TOuputImageType>::MultiHistogramFilter():
 m_Offset(-3.0), m_Delta(0.6), m_Bins(11), m_Size(5), m_UseImageIntensityRange(false)
 {
   this->SetNumberOfRequiredOutputs(m_Bins);
   this->SetNumberOfRequiredInputs(0);
 
   for (int i = 0; i < m_Bins; ++i)
   {
     this->SetNthOutput( i, this->MakeOutput(i) );
   }
 }
 
 template< class TInputImageType, class TOuputImageType>
 void
 itk::MultiHistogramFilter<TInputImageType, TOuputImageType>::BeforeThreadedGenerateData()
 {
   typedef itk::MinimumMaximumImageCalculator <TInputImageType>
     ImageCalculatorFilterType;
 
   if (m_UseImageIntensityRange)
   {
     ImageCalculatorFilterType::Pointer imageCalculatorFilter
       = ImageCalculatorFilterType::New();
     imageCalculatorFilter->SetImage(this->GetInput(0));
     imageCalculatorFilter->Compute();
 
-    offset = imageCalculatorFilter->GetMinimum();
-    delta = 1.0*(imageCalculatorFilter->GetMaximum() - imageCalculatorFilter->GetMinimum()) / (1.0*m_Bins);
+    m_Offset = imageCalculatorFilter->GetMinimum();
+    m_Delta = 1.0*(imageCalculatorFilter->GetMaximum() - imageCalculatorFilter->GetMinimum()) / (1.0*m_Bins);
   }
 
-  std::cout << "Offset: " << offset << " delta: " << delta << std::endl;
-
   InputImagePointer input = this->GetInput(0);
   for (int i = 0; i < m_Bins; ++i)
   {
     CreateOutputImage(input, this->GetOutput(i));
   }
 }
 template< class TInputImageType, class TOuputImageType>
 void
 itk::MultiHistogramFilter<TInputImageType, TOuputImageType>::ThreadedGenerateData(const OutputImageRegionType & outputRegionForThread, ThreadIdType threadId)
 {
   double offset = m_Offset;// -3.0;
   double delta = m_Delta;// 0.6;
 
   typedef itk::ImageRegionIterator<TInputImageType> IteratorType;
   typedef itk::ConstNeighborhoodIterator<TInputImageType> ConstIteratorType;
 
   typename TInputImageType::SizeType size; size.Fill(m_Size);
+  InputImagePointer input = this->GetInput(0);
 
 //  MITK_INFO << "Creating output iterator";
   std::vector<IteratorType> iterVector;
   for (int i = 0; i < m_Bins; ++i)
   {
     IteratorType iter(this->GetOutput(i), outputRegionForThread);
     iterVector.push_back(iter);
   }
 
   ConstIteratorType inputIter(size, input, outputRegionForThread);
   while (!inputIter.IsAtEnd())
   {
     for (int i = 0; i < m_Bins; ++i)
     {
       iterVector[i].Set(0);
     }
 
     for (unsigned int i = 0; i < inputIter.Size(); ++i)
     {
       double value = inputIter.GetPixel(i);
       value -=  offset;
       value /= delta;
       int pos = (int)(value);
       pos = std::max(0, std::min(m_Bins-1, pos));
       iterVector[pos].Value() += 1;// (iterVector[pos].GetCenterPixel() + 1);
     }
 
     for (int i = 0; i < m_Bins; ++i)
     {
       ++(iterVector[i]);
     }
     ++inputIter;
   }
 }
 
 template< class TInputImageType, class TOuputImageType>
 itk::ProcessObject::DataObjectPointer
   itk::MultiHistogramFilter<TInputImageType, TOuputImageType>::MakeOutput(itk::ProcessObject::DataObjectPointerArraySizeType /*idx*/)
 {
   itk::ProcessObject::DataObjectPointer output;
   output = ( TOuputImageType::New() ).GetPointer();
   return output;
 }
 
 template< class TInputImageType, class TOuputImageType>
 void
   itk::MultiHistogramFilter<TInputImageType, TOuputImageType>::CreateOutputImage(InputImagePointer input, OutputImagePointer output)
 {
   output->SetRegions(input->GetLargestPossibleRegion());
   output->Allocate();
 }
 
 #endif //itkMultiHistogramFilter_cpp