diff --git a/Modules/Classification/CLMRUtilities/include/mitkMRNormLinearStatisticBasedFilter.h b/Modules/Classification/CLMRUtilities/include/mitkMRNormLinearStatisticBasedFilter.h
index 7a72993503..4ad3d3f5ae 100644
--- a/Modules/Classification/CLMRUtilities/include/mitkMRNormLinearStatisticBasedFilter.h
+++ b/Modules/Classification/CLMRUtilities/include/mitkMRNormLinearStatisticBasedFilter.h
@@ -1,71 +1,75 @@
 /*===================================================================
 
 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 MRNORMLINEARSTATISTICBASEDFILTER_H
 #define MRNORMLINEARSTATISTICBASEDFILTER_H
 
 #include "mitkCommon.h"
 #include "MitkCLMRUtilitiesExports.h"
 #include "mitkImageToImageFilter.h"
 #include "mitkImageTimeSelector.h"
 
 #include "itkImage.h"
 
 namespace mitk {
   //##Documentation
   //## @brief
   //## @ingroup Process
   class MITKCLMRUTILITIES_EXPORT MRNormLinearStatisticBasedFilter : public ImageToImageFilter
   {
   public:
     mitkClassMacro(MRNormLinearStatisticBasedFilter, ImageToImageFilter);
 
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
     void SetMask( const mitk::Image* mask );
 
     const mitk::Image* GetMask() const;
 
     enum NormalizationBase
     {
       MEAN,
       MODE,
       MEDIAN
     };
 
     itkGetConstMacro(CenterMode, NormalizationBase);
     itkSetMacro(CenterMode, NormalizationBase);
 
+    itkGetConstMacro(IgnoreOutlier, bool);
+    itkSetMacro(IgnoreOutlier, bool);
+
   protected:
     MRNormLinearStatisticBasedFilter();
 
     ~MRNormLinearStatisticBasedFilter();
 
     virtual void GenerateInputRequestedRegion() override;
 
     virtual void GenerateOutputInformation() override;
 
     virtual void GenerateData() override;
 
     template < typename TPixel, unsigned int VImageDimension >
     void InternalComputeMask(itk::Image<TPixel, VImageDimension>* itkImage);
 
     NormalizationBase m_CenterMode;
+    bool m_IgnoreOutlier;
   };
 } // namespace mitk
 
 #endif /* MRNORMLINEARSTATISTICBASEDFILTER_H */
diff --git a/Modules/Classification/CLMRUtilities/src/MRNormalization/mitkMRNormLinearStatisticBasedFilter.cpp b/Modules/Classification/CLMRUtilities/src/MRNormalization/mitkMRNormLinearStatisticBasedFilter.cpp
index 7d4e7051da..a8dc779b22 100644
--- a/Modules/Classification/CLMRUtilities/src/MRNormalization/mitkMRNormLinearStatisticBasedFilter.cpp
+++ b/Modules/Classification/CLMRUtilities/src/MRNormalization/mitkMRNormLinearStatisticBasedFilter.cpp
@@ -1,147 +1,173 @@
 /*===================================================================
 
 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 "mitkMRNormLinearStatisticBasedFilter.h"
 
 #include "mitkImageToItk.h"
 #include "mitkImageAccessByItk.h"
 
 #include "itkImageRegionIterator.h"
 // MITK
 #include <mitkITKImageImport.h>
 #include <mitkImageCast.h>
 #include <mitkImageAccessByItk.h>
 // ITK
 #include <itkLabelStatisticsImageFilter.h>
 #include <itkMinimumMaximumImageCalculator.h>
 
 mitk::MRNormLinearStatisticBasedFilter::MRNormLinearStatisticBasedFilter() :
   m_CenterMode(MRNormLinearStatisticBasedFilter::MEDIAN)
 {
   this->SetNumberOfIndexedInputs(2);
   this->SetNumberOfRequiredInputs(1);
 }
 
 mitk::MRNormLinearStatisticBasedFilter::~MRNormLinearStatisticBasedFilter()
 {
 }
 
 void mitk::MRNormLinearStatisticBasedFilter::SetMask( const mitk::Image* mask )
 {
   // Process object is not const-correct so the const_cast is required here
   Image* nonconstMask = const_cast< mitk::Image * >( mask );
   this->SetNthInput(1, nonconstMask );
 }
 
 const mitk::Image* mitk::MRNormLinearStatisticBasedFilter::GetMask() const
 {
   return this->GetInput(1);
 }
 
 void mitk::MRNormLinearStatisticBasedFilter::GenerateInputRequestedRegion()
 {
   Superclass::GenerateInputRequestedRegion();
 
   mitk::Image* input = const_cast< mitk::Image * > ( this->GetInput() );
 
   input->SetRequestedRegionToLargestPossibleRegion();
 }
 
 void mitk::MRNormLinearStatisticBasedFilter::GenerateOutputInformation()
 {
   mitk::Image::ConstPointer input = this->GetInput();
   mitk::Image::Pointer output = this->GetOutput();
 
   itkDebugMacro(<< "GenerateOutputInformation()");
 
   output->Initialize(input->GetPixelType(), *input->GetTimeGeometry());
   output->SetPropertyList(input->GetPropertyList()->Clone());
 }
 
 template < typename TPixel, unsigned int VImageDimension >
 void mitk::MRNormLinearStatisticBasedFilter::InternalComputeMask(itk::Image<TPixel, VImageDimension>* itkImage)
 {
   // Define all necessary Types
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef itk::Image<int, VImageDimension> MaskType;
   typedef itk::LabelStatisticsImageFilter<ImageType, MaskType> FilterType;
   typedef itk::MinimumMaximumImageCalculator<ImageType> MinMaxComputerType;
 
   typename MaskType::Pointer itkMask0 = MaskType::New();
   mitk::CastToItkImage(this->GetMask(), itkMask0);
 
   typename ImageType::Pointer outImage = ImageType::New();
   mitk::CastToItkImage(this->GetOutput(0), outImage);
 
   typename MinMaxComputerType::Pointer minMaxComputer = MinMaxComputerType::New();
   minMaxComputer->SetImage(itkImage);
   minMaxComputer->Compute();
+  double min = minMaxComputer->GetMinimum();
+  double max = minMaxComputer->GetMaximum();
+
+  if (m_IgnoreOutlier)
+  {
+    typename FilterType::Pointer labelStatisticsImageFilter = FilterType::New();
+    labelStatisticsImageFilter->SetUseHistograms(true);
+    labelStatisticsImageFilter->SetHistogramParameters(2048, min, max);
+    labelStatisticsImageFilter->SetInput(itkImage);
+
+    labelStatisticsImageFilter->SetLabelInput(itkMask0);
+    labelStatisticsImageFilter->Update();
+    auto histo = labelStatisticsImageFilter->GetHistogram(1);
+    min = histo->Quantile(0, 0.02);
+    max = histo->Quantile(0, 0.98);
+  }
+
 
   typename FilterType::Pointer labelStatisticsImageFilter = FilterType::New();
   labelStatisticsImageFilter->SetUseHistograms(true);
-  labelStatisticsImageFilter->SetHistogramParameters(256, minMaxComputer->GetMinimum(),minMaxComputer->GetMaximum());
+  labelStatisticsImageFilter->SetHistogramParameters(256, min, max);
   labelStatisticsImageFilter->SetInput( itkImage );
 
   labelStatisticsImageFilter->SetLabelInput(itkMask0);
   labelStatisticsImageFilter->Update();
   double median0 = labelStatisticsImageFilter->GetMedian(1);
   double mean0 = labelStatisticsImageFilter->GetMean(1);
   double stddev = labelStatisticsImageFilter->GetSigma(1);
   double modulo0=0;
   {
     auto histo = labelStatisticsImageFilter->GetHistogram(1);
     double maxFrequency=0;
     for (auto hIter=histo->Begin();hIter!=histo->End();++hIter)
     {
       if (maxFrequency < hIter.GetFrequency())
       {
         maxFrequency = hIter.GetFrequency();
         modulo0 = (histo->GetBinMin(0,hIter.GetInstanceIdentifier()) + histo->GetBinMax(0,hIter.GetInstanceIdentifier())) / 2.0;
       }
     }
   }
 
   double value0=0;
   switch (m_CenterMode)
   {
   case MRNormLinearStatisticBasedFilter::MEAN:
     value0=mean0; break;
   case MRNormLinearStatisticBasedFilter::MEDIAN:
     value0=median0; break;
   case MRNormLinearStatisticBasedFilter::MODE:
     value0=modulo0; break;
   }
 
   double offset = value0;
   double scaling = stddev;
   if (scaling < 0.0001)
     return;
 
   itk::ImageRegionIterator<ImageType> inIter(itkImage, itkImage->GetLargestPossibleRegion());
   itk::ImageRegionIterator<ImageType> outIter(outImage, outImage->GetLargestPossibleRegion());
   while (! inIter.IsAtEnd())
   {
     TPixel value = inIter.Value();
+    if (m_IgnoreOutlier && (value < min))
+    {
+      value = min;
+    }
+    else if (m_IgnoreOutlier && (value > max))
+    {
+      value = max;
+    }
+
     outIter.Set((value - offset) / scaling);
     ++inIter;
     ++outIter;
   }
 }
 
 void mitk::MRNormLinearStatisticBasedFilter::GenerateData()
 {
   AccessByItk(GetInput(0),InternalComputeMask);
 }
\ No newline at end of file
diff --git a/Modules/Classification/CLMiniApps/CLImageTypeConverter.cpp b/Modules/Classification/CLMiniApps/CLImageTypeConverter.cpp
index 9f11ba3be7..2b94f4c168 100644
--- a/Modules/Classification/CLMiniApps/CLImageTypeConverter.cpp
+++ b/Modules/Classification/CLMiniApps/CLImageTypeConverter.cpp
@@ -1,103 +1,107 @@
 /*===================================================================
 
 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";
+  }
   else
   {
     CONVERT_IMAGE(double, 3);
   }
 
 
   mitk::IOUtil::SaveImage(outputImage, outputName);
 
   return EXIT_SUCCESS;
 }
\ No newline at end of file
diff --git a/Modules/Classification/CLMiniApps/CLMRNormalization.cpp b/Modules/Classification/CLMiniApps/CLMRNormalization.cpp
index 3dbcc57e48..81eb059bbe 100644
--- a/Modules/Classification/CLMiniApps/CLMRNormalization.cpp
+++ b/Modules/Classification/CLMiniApps/CLMRNormalization.cpp
@@ -1,134 +1,142 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #ifndef mitkCLPolyToNrrd_cpp
 #define mitkCLPolyToNrrd_cpp
 
 #include "time.h"
 #include <sstream>
 #include <fstream>
 
 #include <mitkIOUtil.h>
 #include "mitkCommandLineParser.h"
 
 #include "itkImageRegionIterator.h"
 // MITK
 #include <mitkITKImageImport.h>
 #include <mitkImageCast.h>
 #include <mitkImageAccessByItk.h>
 
 #include <mitkMRNormLinearStatisticBasedFilter.h>
 #include <mitkMRNormTwoRegionBasedFilter.h>
 // ITK
 #include <itkLabelStatisticsImageFilter.h>
 #include <itkMinimumMaximumImageCalculator.h>
 
 typedef itk::Image< double, 3 >                 FloatImageType;
 typedef itk::Image< unsigned char, 3 >          MaskImageType;
 
 int main(int argc, char* argv[])
 {
   MITK_INFO << "Start";
   mitkCommandLineParser parser;
   parser.setArgumentPrefix("--", "-");
   // required params
   parser.addArgument("image", "i", mitkCommandLineParser::InputImage, "Input Image", "Path to the input VTK polydata", us::Any(), false);
   parser.addArgument("mode", "mode", mitkCommandLineParser::InputImage, "Normalisation mode", "1,2,3: Single Area normalization to Mean, Median, Mode, 4,5,6: Mean, Median, Mode of two regions. ", us::Any(), false);
   parser.addArgument("mask0", "m0", mitkCommandLineParser::InputImage, "Input Mask", "The median of the area covered by this mask will be set to 0", us::Any(), false);
   parser.addArgument("mask1", "m1", mitkCommandLineParser::InputImage, "Input Mask", "The median of the area covered by this mask will be set to 1", us::Any(), true);
   parser.addArgument("output", "o", mitkCommandLineParser::OutputFile, "Output Image", "Target file. The output statistic is appended to this file.", us::Any(), false);
+  parser.addArgument("ignore-outlier", "outlier", mitkCommandLineParser::Bool, "Ignore Outlier", "Ignores the highest and lowest 2% during calculation. Only on single mask normalization.", us::Any(), true);
 
   // Miniapp Infos
   parser.setCategory("Classification Tools");
   parser.setTitle("MR Normalization Tool");
   parser.setDescription("Normalizes a MR image. Sets the Median of the tissue covered by mask 0 to 0 and the median of the area covered by mask 1 to 1.");
   parser.setContributor("MBI");
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
 
   if (parsedArgs.size()==0)
   {
     return EXIT_FAILURE;
   }
   if ( parsedArgs.count("help") || parsedArgs.count("h"))
   {
     return EXIT_SUCCESS;
   }
 
+  bool ignore_outlier = false;
+  if (parsedArgs.count("ignore-outlier"))
+  {
+    ignore_outlier = us::any_cast<bool>(parsedArgs["ignore-outlier"]);
+  }
+
   MITK_INFO << "Mode access";
   int mode =std::stoi(us::any_cast<std::string>(parsedArgs["mode"]));
   MITK_INFO << "Mode: " << mode;
 
   MITK_INFO << "Read images";
   mitk::Image::Pointer mask1;
   mitk::Image::Pointer image = mitk::IOUtil::LoadImage(parsedArgs["image"].ToString());
   mitk::Image::Pointer mask0 = mitk::IOUtil::LoadImage(parsedArgs["mask0"].ToString());
   if (mode > 3)
   {
     mask1 = mitk::IOUtil::LoadImage(parsedArgs["mask1"].ToString());
   }
   mitk::MRNormLinearStatisticBasedFilter::Pointer oneRegion = mitk::MRNormLinearStatisticBasedFilter::New();
   mitk::MRNormTwoRegionsBasedFilter::Pointer twoRegion = mitk::MRNormTwoRegionsBasedFilter::New();
   mitk::Image::Pointer output;
 
   oneRegion->SetInput(image);
   oneRegion->SetMask(mask0);
+  oneRegion->SetIgnoreOutlier(ignore_outlier);
   twoRegion->SetInput(image);
   twoRegion->SetMask1(mask0);
   twoRegion->SetMask2(mask1);
 
   switch (mode)
   {
   case 1:
     oneRegion->SetCenterMode(mitk::MRNormLinearStatisticBasedFilter::MEAN);
     oneRegion->Update();
     output=oneRegion->GetOutput();
     break;
   case 2:
     oneRegion->SetCenterMode(mitk::MRNormLinearStatisticBasedFilter::MEDIAN);
     oneRegion->Update();
     output=oneRegion->GetOutput();
     break;
   case 3:
     oneRegion->SetCenterMode(mitk::MRNormLinearStatisticBasedFilter::MODE);
     oneRegion->Update();
     output=oneRegion->GetOutput();
     break;
   case 4:
     twoRegion->SetArea1(mitk::MRNormTwoRegionsBasedFilter::MEAN);
     twoRegion->SetArea2(mitk::MRNormTwoRegionsBasedFilter::MEAN);
     twoRegion->Update();
     output=twoRegion->GetOutput();
     break;
   case 5:
     twoRegion->SetArea1(mitk::MRNormTwoRegionsBasedFilter::MEDIAN);
     twoRegion->SetArea2(mitk::MRNormTwoRegionsBasedFilter::MEDIAN);
     twoRegion->Update();
     output=twoRegion->GetOutput();
     break;
   case 6:
     twoRegion->SetArea1(mitk::MRNormTwoRegionsBasedFilter::MODE);
     twoRegion->SetArea2(mitk::MRNormTwoRegionsBasedFilter::MODE);
     twoRegion->Update();
     output=twoRegion->GetOutput();
     break;
   }
 
   mitk::IOUtil::SaveImage(output, parsedArgs["output"].ToString());
 
   return 0;
 }
 
 #endif
\ No newline at end of file
diff --git a/Modules/Classification/CLMiniApps/CMakeLists.txt b/Modules/Classification/CLMiniApps/CMakeLists.txt
index a8a26e1ad5..655c5f0fb6 100644
--- a/Modules/Classification/CLMiniApps/CMakeLists.txt
+++ b/Modules/Classification/CLMiniApps/CMakeLists.txt
@@ -1,137 +1,138 @@
 option(BUILD_ClassificationMiniApps "Build commandline tools for classification" OFF)
 
 if(BUILD_ClassificationMiniApps OR MITK_BUILD_ALL_APPS)
 
 
   include_directories(
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${CMAKE_CURRENT_BINARY_DIR}
     )
 
     # list of miniapps
     # if an app requires additional dependencies
     # they are added after a "^^" and separated by "_"
     set( classificationminiapps
         RandomForestTraining^^MitkCLVigraRandomForest
         NativeHeadCTSegmentation^^MitkCLVigraRandomForest
         ManualSegmentationEvaluation^^MitkCLVigraRandomForest
         CLGlobalImageFeatures^^MitkCore_MitkCLUtilities_MitkQtWidgetsExt
         CLMRNormalization^^MitkCore_MitkCLUtilities_MitkCLMRUtilities
         CLStaple^^MitkCore_MitkCLUtilities
         CLVoxelFeatures^^MitkCore_MitkCLUtilities
         CLDicom2Nrrd^^MitkCore
         CLPolyToNrrd^^MitkCore
         CLImageTypeConverter^^MitkCore
         CLResampleImageToReference^^MitkCore
         CLRandomSampling^^MitkCore_MitkCLUtilities
         CLRemoveEmptyVoxels^^MitkCore
         CLN4^^MitkCore
         CLMultiForestPrediction^^MitkDataCollection_MitkCLVigraRandomForest
         CLNrrdToPoly^^MitkCore
         CL2Dto3DImage^^MitkCore
+        CLWeighting^^MitkCore_MitkCLImportanceWeighting_MitkCLUtilities
     #    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/CLUtilities/include/itkEnhancedScalarImageToRunLengthFeaturesFilter.h b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthFeaturesFilter.h
index 7c0422872a..b65922d38a 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthFeaturesFilter.h
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthFeaturesFilter.h
@@ -1,245 +1,249 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 /*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
 #ifndef __itkEnhancedScalarImageToRunLengthFeaturesFilter_h
 #define __itkEnhancedScalarImageToRunLengthFeaturesFilter_h
 
 #include "itkDataObjectDecorator.h"
 
 #include "itkEnhancedHistogramToRunLengthFeaturesFilter.h"
 #include "itkEnhancedScalarImageToRunLengthMatrixFilter.h"
 
 namespace itk
 {
   namespace Statistics
   {
     /** \class EnhancedScalarImageToRunLengthFeaturesFilter
     *  \brief This class computes run length descriptions from an image.
     *
     * By default, run length features are computed for each spatial
     * direction and then averaged afterward, so it is possible to access the
     * standard deviations of the texture features. These values give a clue as
     * to texture anisotropy. However, doing this is much more work, because it
     * involved computing one for each offset given. To compute a single
     * matrix using the first offset, call FastCalculationsOn(). If this is called,
     * then the texture standard deviations will not be computed (and will be set
     * to zero), but texture computation will be much faster.
     *
     * This class is templated over the input image type.
     *
     * Template Parameters:
     * The image type, and the type of histogram frequency container. If you are
     * using a large number of bins per axis, a sparse frequency container may be
     * advisable.  The default is to use a dense frequency container.
     *
     * Inputs and parameters:
     * -# An image
     * -# A mask defining the region over which texture features will be
     *    calculated. (Optional)
     * -# The pixel value that defines the "inside" of the mask. (Optional, defaults
     *    to 1 if a mask is set.)
     * -# The set of features to be calculated. These features are defined
     *    in the HistogramToRunLengthFeaturesFilter class.
     * -# The number of intensity bins. (Optional, defaults to 256.)
     * -# The set of directions (offsets) to average across. (Optional, defaults to
     *    {(-1, 0), (-1, -1), (0, -1), (1, -1)} for 2D images and scales analogously
     *    for ND images.)
     * -# The pixel intensity range over which the features will be calculated.
     *    (Optional, defaults to the full dynamic range of the pixel type.)
     * -# The distance range over which the features will be calculated.
     *    (Optional, defaults to the full dynamic range of double type.)
     *
     * In general, the default parameter values should be sufficient.
     *
     * Outputs:
     * (1) The average value of each feature.
     * (2) The standard deviation in the values of each feature.
     *
     * Print references:
     * M. M. Galloway. Texture analysis using gray level run lengths. Computer
     * Graphics and Image Processing, 4:172-179, 1975.
     *
     * A. Chu, C. M. Sehgal, and J. F. Greenleaf. Use of gray value distribution of
     * run lengths for texture analysis.  Pattern Recognition Letters, 11:415-420,
     * 1990.
     *
     * B. R. Dasarathy and E. B. Holder. Image characterizations based on joint
     * gray-level run-length distributions. Pattern Recognition Letters, 12:490-502,
     * 1991.
     *
     * IJ article: http://hdl.handle.net/1926/1374
     *
     * \sa EnhancedScalarImageToRunLengthFeaturesFilter
     * \sa ScalarImageToRunLengthMatrixFilter
     * \sa HistogramToRunLengthFeaturesFilter
     *
     * \author: Nick Tustison
     * \ingroup ITKStatistics
     */
 
     template< typename TImageType,
       typename THistogramFrequencyContainer = DenseFrequencyContainer2 >
     class EnhancedScalarImageToRunLengthFeaturesFilter:public ProcessObject
     {
     public:
       /** Standard typedefs */
       typedef EnhancedScalarImageToRunLengthFeaturesFilter  Self;
       typedef ProcessObject                         Superclass;
       typedef SmartPointer< Self >                  Pointer;
       typedef SmartPointer< const Self >            ConstPointer;
 
       /** Run-time type information (and related methods). */
       itkTypeMacro(EnhancedScalarImageToRunLengthFeaturesFilter, ProcessObject);
 
       /** standard New() method support */
       itkNewMacro(Self);
 
       typedef THistogramFrequencyContainer FrequencyContainerType;
       typedef TImageType                   ImageType;
       typedef typename ImageType::Pointer  ImagePointer;
 
       typedef typename ImageType::PixelType                PixelType;
       typedef typename ImageType::OffsetType               OffsetType;
       typedef VectorContainer< unsigned char, OffsetType > OffsetVector;
       typedef typename OffsetVector::Pointer               OffsetVectorPointer;
       typedef typename OffsetVector::ConstPointer          OffsetVectorConstPointer;
 
       typedef EnhancedScalarImageToRunLengthMatrixFilter<
         ImageType, FrequencyContainerType >               RunLengthMatrixFilterType;
 
       typedef typename RunLengthMatrixFilterType::HistogramType
         HistogramType;
 
       typedef EnhancedHistogramToRunLengthFeaturesFilter< HistogramType >
         RunLengthFeaturesFilterType;
 
       typedef short                                    RunLengthFeatureName;
       typedef VectorContainer<unsigned char,
         RunLengthFeatureName>                          FeatureNameVector;
       typedef typename FeatureNameVector::Pointer      FeatureNameVectorPointer;
       typedef typename FeatureNameVector::ConstPointer FeatureNameVectorConstPointer;
       typedef VectorContainer< unsigned char, double > FeatureValueVector;
       typedef typename FeatureValueVector::Pointer     FeatureValueVectorPointer;
 
       /** Smart Pointer type to a DataObject. */
       typedef DataObject::Pointer DataObjectPointer;
 
       /** Type of DataObjects used for scalar outputs */
       typedef DataObjectDecorator< FeatureValueVector >
         FeatureValueVectorDataObjectType;
 
       const FeatureValueVectorDataObjectType * GetFeatureMeansOutput() const;
 
       const FeatureValueVectorDataObjectType * GetFeatureStandardDeviationsOutput()
         const;
 
       /** Connects the input image for which the features are going to be computed
       */
       using Superclass::SetInput;
       void SetInput(const ImageType *);
 
       const ImageType * GetInput() const;
 
       /** Return the feature means and deviations.  */
       itkGetConstReferenceObjectMacro(FeatureMeans, FeatureValueVector);
       itkGetConstReferenceObjectMacro(FeatureStandardDeviations, FeatureValueVector);
 
       /** Set the desired feature set. Optional, for default value see above. */
       itkSetConstObjectMacro(RequestedFeatures, FeatureNameVector);
       itkGetConstObjectMacro(RequestedFeatures, FeatureNameVector);
 
       /** Set the  offsets over which the co-occurrence pairs will be computed.
       Optional; for default value see above. */
       itkSetConstObjectMacro(Offsets, OffsetVector);
       itkGetConstObjectMacro(Offsets, OffsetVector);
 
       /** Set number of histogram bins along each axis.
       Optional; for default value see above. */
       void SetNumberOfBinsPerAxis(unsigned int);
 
       /** Set the min and max (inclusive) pixel value that will be used for
       feature calculations. Optional; for default value see above. */
       void SetPixelValueMinMax(PixelType min, PixelType max);
 
       /** Set the min and max (inclusive) pixel value that will be used for
       feature calculations. Optional; for default value see above. */
       void SetDistanceValueMinMax( double min, double max );
 
       /** Connects the mask image for which the histogram is going to be computed.
       Optional; for default value see above. */
       void SetMaskImage(const ImageType *);
 
       const ImageType * GetMaskImage() const;
 
       /** Set the pixel value of the mask that should be considered "inside" the
       object. Optional; for default value see above. */
       void SetInsidePixelValue(PixelType InsidePixelValue);
 
       itkGetConstMacro(FastCalculations, bool);
       itkSetMacro(FastCalculations, bool);
       itkBooleanMacro(FastCalculations);
+      itkGetConstMacro(CombinedFeatureCalculation, bool);
+      itkSetMacro(CombinedFeatureCalculation, bool);
+      itkBooleanMacro(CombinedFeatureCalculation);
 
     protected:
       EnhancedScalarImageToRunLengthFeaturesFilter();
       virtual ~EnhancedScalarImageToRunLengthFeaturesFilter() {}
       virtual void PrintSelf( std::ostream & os, Indent indent ) const ITK_OVERRIDE;
 
       void FastCompute();
 
       void FullCompute();
 
       /** This method causes the filter to generate its output. */
       virtual void GenerateData() ITK_OVERRIDE;
 
       /** Make a DataObject to be used for output output. */
       typedef ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType;
       using Superclass::MakeOutput;
       virtual DataObjectPointer MakeOutput(DataObjectPointerArraySizeType) ITK_OVERRIDE;
 
     private:
       typename RunLengthMatrixFilterType::Pointer m_RunLengthMatrixGenerator;
 
       FeatureValueVectorPointer     m_FeatureMeans;
       FeatureValueVectorPointer     m_FeatureStandardDeviations;
       FeatureNameVectorConstPointer m_RequestedFeatures;
       OffsetVectorConstPointer      m_Offsets;
       bool                          m_FastCalculations;
+      bool                          m_CombinedFeatureCalculation;
     };
   } // end of namespace Statistics
 } // end of namespace itk
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkEnhancedScalarImageToRunLengthFeaturesFilter.hxx"
 #endif
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthFeaturesFilter.hxx b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthFeaturesFilter.hxx
index b4de6e656c..c4d2029663 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthFeaturesFilter.hxx
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthFeaturesFilter.hxx
@@ -1,412 +1,435 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 /*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
 #ifndef __itkEnhancedScalarImageToRunLengthFeaturesFilter_hxx
 #define __itkEnhancedScalarImageToRunLengthFeaturesFilter_hxx
 
 #include "itkEnhancedScalarImageToRunLengthFeaturesFilter.h"
 #include "itkNeighborhood.h"
 #include <itkImageRegionConstIterator.h>
 #include "vnl/vnl_math.h"
 
 namespace itk
 {
   namespace Statistics
   {
     template<typename TImage, typename THistogramFrequencyContainer>
     EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
-      ::EnhancedScalarImageToRunLengthFeaturesFilter()
+      ::EnhancedScalarImageToRunLengthFeaturesFilter() :
+      m_CombinedFeatureCalculation(false)
     {
       this->SetNumberOfRequiredInputs( 1 );
       this->SetNumberOfRequiredOutputs( 1 );
 
       for( int i = 0; i < 2; ++i )
       {
         this->ProcessObject::SetNthOutput( i, this->MakeOutput( i ) );
       }
 
       this->m_RunLengthMatrixGenerator = RunLengthMatrixFilterType::New();
       this->m_FeatureMeans = FeatureValueVector::New();
       this->m_FeatureStandardDeviations = FeatureValueVector::New();
 
       // Set the requested features to the default value:
       // {Energy, Entropy, InverseDifferenceMoment, Inertia, ClusterShade,
       // ClusterProminence}
       FeatureNameVectorPointer requestedFeatures = FeatureNameVector::New();
       // can't directly set this->m_RequestedFeatures since it is const!
 
       requestedFeatures->push_back( RunLengthFeaturesFilterType::ShortRunEmphasis );
       requestedFeatures->push_back( RunLengthFeaturesFilterType::LongRunEmphasis );
       requestedFeatures->push_back( RunLengthFeaturesFilterType::GreyLevelNonuniformity );
       requestedFeatures->push_back( RunLengthFeaturesFilterType::GreyLevelNonuniformityNormalized );
       requestedFeatures->push_back( RunLengthFeaturesFilterType::RunLengthNonuniformity );
       requestedFeatures->push_back( RunLengthFeaturesFilterType::RunLengthNonuniformityNormalized );
       requestedFeatures->push_back( RunLengthFeaturesFilterType::LowGreyLevelRunEmphasis );
       requestedFeatures->push_back( RunLengthFeaturesFilterType::HighGreyLevelRunEmphasis );
       requestedFeatures->push_back( RunLengthFeaturesFilterType::ShortRunLowGreyLevelEmphasis );
       requestedFeatures->push_back( RunLengthFeaturesFilterType::ShortRunHighGreyLevelEmphasis );
       requestedFeatures->push_back( RunLengthFeaturesFilterType::LongRunLowGreyLevelEmphasis );
       requestedFeatures->push_back( RunLengthFeaturesFilterType::LongRunHighGreyLevelEmphasis );
       requestedFeatures->push_back( 20 );
 
       this->SetRequestedFeatures( requestedFeatures );
 
       // Set the offset directions to their defaults: half of all the possible
       // directions 1 pixel away. (The other half is included by symmetry.)
       // We use a neighborhood iterator to calculate the appropriate offsets.
       typedef Neighborhood<typename ImageType::PixelType,
         ImageType::ImageDimension> NeighborhoodType;
       NeighborhoodType hood;
       hood.SetRadius( 1 );
 
       // select all "previous" neighbors that are face+edge+vertex
       // connected to the current pixel. do not include the center pixel.
       unsigned int centerIndex = hood.GetCenterNeighborhoodIndex();
       OffsetVectorPointer offsets = OffsetVector::New();
       for( unsigned int d = 0; d < centerIndex; d++ )
       {
         OffsetType offset = hood.GetOffset( d );
         offsets->push_back( offset );
       }
       this->SetOffsets( offsets );
       this->m_FastCalculations = false;
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     typename
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::DataObjectPointer
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::MakeOutput( DataObjectPointerArraySizeType itkNotUsed(idx) )
     {
       return FeatureValueVectorDataObjectType::New().GetPointer();
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::GenerateData(void)
     {
       if ( this->m_FastCalculations )
       {
         this->FastCompute();
       }
       else
       {
         this->FullCompute();
       }
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::FullCompute()
     {
       int numOffsets = this->m_Offsets->size();
+      if (m_CombinedFeatureCalculation)
+      {
+        numOffsets = 1;
+      }
       int numFeatures = this->m_RequestedFeatures->size();
       double **features;
 
       features = new double *[numOffsets];
       for( int i = 0; i < numOffsets; i++ )
       {
         features[i] = new double[numFeatures];
       }
 
       unsigned long numberOfVoxels = 0;
       ImageRegionConstIterator<TImage> voxelCountIter(this->GetMaskImage(),this->GetMaskImage()->GetLargestPossibleRegion());
       while ( ! voxelCountIter.IsAtEnd() )
       {
         if (voxelCountIter.Get() > 0)
           ++numberOfVoxels;
         ++voxelCountIter;
       }
 
       // For each offset, calculate each feature
       typename OffsetVector::ConstIterator offsetIt;
       int offsetNum, featureNum;
       typedef typename RunLengthFeaturesFilterType::RunLengthFeatureName
         InternalRunLengthFeatureName;
 
+      OffsetVectorPointer offsets = OffsetVector::New();
+      if (m_CombinedFeatureCalculation)
+      {
+        for (int i = 0; i < this->m_Offsets->Size(); ++i)
+        {
+          offsets->push_back(m_Offsets->ElementAt(i));
+        }
+      }
+
+
       for( offsetIt = this->m_Offsets->Begin(), offsetNum = 0;
         offsetIt != this->m_Offsets->End(); offsetIt++, offsetNum++ )
       {
-        this->m_RunLengthMatrixGenerator->SetOffset( offsetIt.Value() );
+        this->m_RunLengthMatrixGenerator->SetOffset(offsetIt.Value());
+        if (m_CombinedFeatureCalculation)
+        {
+          this->m_RunLengthMatrixGenerator->SetOffsets(offsets);
+        }
         this->m_RunLengthMatrixGenerator->Update();
         typename RunLengthFeaturesFilterType::Pointer runLengthMatrixCalculator =
           RunLengthFeaturesFilterType::New();
         runLengthMatrixCalculator->SetInput(
           this->m_RunLengthMatrixGenerator->GetOutput() );
         runLengthMatrixCalculator->SetNumberOfVoxels(numberOfVoxels);
         runLengthMatrixCalculator->Update();
 
         typename FeatureNameVector::ConstIterator fnameIt;
         for( fnameIt = this->m_RequestedFeatures->Begin(), featureNum = 0;
           fnameIt != this->m_RequestedFeatures->End(); fnameIt++, featureNum++ )
         {
           features[offsetNum][featureNum] = runLengthMatrixCalculator->GetFeature(
             ( InternalRunLengthFeatureName )fnameIt.Value() );
         }
+        if (m_CombinedFeatureCalculation)
+        {
+          break;
+        }
       }
 
       // Now get the mean and deviaton of each feature across the offsets.
       this->m_FeatureMeans->clear();
       this->m_FeatureStandardDeviations->clear();
       double *tempFeatureMeans = new double[numFeatures];
       double *tempFeatureDevs = new double[numFeatures];
 
       /*Compute incremental mean and SD, a la Knuth, "The  Art of Computer
       Programming, Volume 2: Seminumerical Algorithms",  section 4.2.2.
       Compute mean and standard deviation using the recurrence relation:
       M(1) = x(1), M(k) = M(k-1) + (x(k) - M(k-1) ) / k
       S(1) = 0, S(k) = S(k-1) + (x(k) - M(k-1)) * (x(k) - M(k))
       for 2 <= k <= n, then
       sigma = std::sqrt(S(n) / n) (or divide by n-1 for sample SD instead of
       population SD).
       */
 
       // Set up the initial conditions (k = 1)
       for( featureNum = 0; featureNum < numFeatures; featureNum++ )
       {
         tempFeatureMeans[featureNum] = features[0][featureNum];
         tempFeatureDevs[featureNum] = 0;
       }
       // Run through the recurrence (k = 2 ... N)
       for( offsetNum = 1; offsetNum < numOffsets; offsetNum++ )
       {
         int k = offsetNum + 1;
         for( featureNum = 0; featureNum < numFeatures; featureNum++ )
         {
           double M_k_minus_1 = tempFeatureMeans[featureNum];
           double S_k_minus_1 = tempFeatureDevs[featureNum];
           double x_k = features[offsetNum][featureNum];
 
           double M_k = M_k_minus_1 + ( x_k - M_k_minus_1 ) / k;
           double S_k = S_k_minus_1 + ( x_k - M_k_minus_1 ) * ( x_k - M_k );
 
           tempFeatureMeans[featureNum] = M_k;
           tempFeatureDevs[featureNum] = S_k;
         }
       }
       for( featureNum = 0; featureNum < numFeatures; featureNum++ )
       {
         tempFeatureDevs[featureNum] = std::sqrt( tempFeatureDevs[featureNum] /
           numOffsets );
 
         this->m_FeatureMeans->push_back( tempFeatureMeans[featureNum] );
         this->m_FeatureStandardDeviations->push_back( tempFeatureDevs[featureNum] );
       }
 
       FeatureValueVectorDataObjectType *meanOutputObject =
         itkDynamicCastInDebugMode<FeatureValueVectorDataObjectType *>( this->ProcessObject::GetOutput( 0 ) );
       meanOutputObject->Set( this->m_FeatureMeans );
 
       FeatureValueVectorDataObjectType *standardDeviationOutputObject =
         itkDynamicCastInDebugMode<FeatureValueVectorDataObjectType *>( this->ProcessObject::GetOutput( 1 ) );
       standardDeviationOutputObject->Set( this->m_FeatureStandardDeviations );
 
       delete[] tempFeatureMeans;
       delete[] tempFeatureDevs;
       for( int i = 0; i < numOffsets; i++ )
       {
         delete[] features[i];
       }
       delete[] features;
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::FastCompute()
     {
       // Compute the feature for the first offset
       typename OffsetVector::ConstIterator offsetIt = this->m_Offsets->Begin();
       this->m_RunLengthMatrixGenerator->SetOffset( offsetIt.Value() );
 
       this->m_RunLengthMatrixGenerator->Update();
       typename RunLengthFeaturesFilterType::Pointer runLengthMatrixCalculator =
         RunLengthFeaturesFilterType::New();
       runLengthMatrixCalculator->SetInput(
         this->m_RunLengthMatrixGenerator->GetOutput() );
       runLengthMatrixCalculator->Update();
 
       typedef typename RunLengthFeaturesFilterType::RunLengthFeatureName
         InternalRunLengthFeatureName;
       this->m_FeatureMeans->clear();
       this->m_FeatureStandardDeviations->clear();
       typename FeatureNameVector::ConstIterator fnameIt;
       for( fnameIt = this->m_RequestedFeatures->Begin();
         fnameIt != this->m_RequestedFeatures->End(); fnameIt++ )
       {
         this->m_FeatureMeans->push_back( runLengthMatrixCalculator->GetFeature(
           ( InternalRunLengthFeatureName )fnameIt.Value() ) );
         this->m_FeatureStandardDeviations->push_back( 0.0 );
       }
 
       FeatureValueVectorDataObjectType *meanOutputObject =
         itkDynamicCastInDebugMode<FeatureValueVectorDataObjectType *>( this->ProcessObject::GetOutput( 0 ) );
       meanOutputObject->Set( this->m_FeatureMeans );
 
       FeatureValueVectorDataObjectType *standardDeviationOutputObject =
         itkDynamicCastInDebugMode<FeatureValueVectorDataObjectType *>( this->ProcessObject::GetOutput( 1 ) );
       standardDeviationOutputObject->Set( this->m_FeatureStandardDeviations );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::SetInput( const ImageType *image )
     {
       // Process object is not const-correct so the const_cast is required here
       this->ProcessObject::SetNthInput( 0,
         const_cast<ImageType *>( image ) );
 
       this->m_RunLengthMatrixGenerator->SetInput( image );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::SetNumberOfBinsPerAxis( unsigned int numberOfBins )
     {
       itkDebugMacro( "setting NumberOfBinsPerAxis to " << numberOfBins );
       this->m_RunLengthMatrixGenerator->SetNumberOfBinsPerAxis( numberOfBins );
       this->Modified();
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::SetPixelValueMinMax( PixelType min, PixelType max )
     {
       itkDebugMacro( "setting Min to " << min << "and Max to " << max );
       this->m_RunLengthMatrixGenerator->SetPixelValueMinMax( min, max );
       this->Modified();
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::SetDistanceValueMinMax( double min, double max )
     {
       itkDebugMacro( "setting Min to " << min << "and Max to " << max );
       this->m_RunLengthMatrixGenerator->SetDistanceValueMinMax( min, max );
       this->Modified();
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::SetMaskImage( const ImageType *image )
     {
       // Process object is not const-correct so the const_cast is required here
       this->ProcessObject::SetNthInput( 1,
         const_cast< ImageType * >( image ) );
 
       this->m_RunLengthMatrixGenerator->SetMaskImage( image );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     const TImage *
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::GetInput() const
     {
       if ( this->GetNumberOfInputs() < 1 )
       {
         return ITK_NULLPTR;
       }
       return static_cast<const ImageType *>( this->ProcessObject::GetInput( 0 ) );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     const typename
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::FeatureValueVectorDataObjectType *
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::GetFeatureMeansOutput() const
     {
       return itkDynamicCastInDebugMode<const FeatureValueVectorDataObjectType *>
         (this->ProcessObject::GetOutput( 0 ) );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     const typename
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::FeatureValueVectorDataObjectType *
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::GetFeatureStandardDeviationsOutput() const
     {
       return itkDynamicCastInDebugMode< const FeatureValueVectorDataObjectType * >
         ( this->ProcessObject::GetOutput( 1 ) );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     const TImage *
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::GetMaskImage() const
     {
       if ( this->GetNumberOfInputs() < 2 )
       {
         return ITK_NULLPTR;
       }
       return static_cast< const ImageType *>( this->ProcessObject::GetInput( 1 ) );
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::SetInsidePixelValue( PixelType insidePixelValue )
     {
       itkDebugMacro( "setting InsidePixelValue to " << insidePixelValue );
       this->m_RunLengthMatrixGenerator->SetInsidePixelValue( insidePixelValue );
       this->Modified();
     }
 
     template<typename TImage, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthFeaturesFilter<TImage, THistogramFrequencyContainer>
       ::PrintSelf(std::ostream & os, Indent indent) const
     {
       Superclass::PrintSelf(os, indent);
       os << indent << "RequestedFeatures: "
         << this->GetRequestedFeatures() << std::endl;
       os << indent << "FeatureStandardDeviations: "
         << this->GetFeatureStandardDeviations() << std::endl;
       os << indent << "FastCalculations: "
         << this->GetFastCalculations() << std::endl;
       os << indent << "Offsets: " << this->GetOffsets() << std::endl;
       os << indent << "FeatureMeans: " << this->GetFeatureMeans() << std::endl;
     }
   } // end of namespace Statistics
 } // end of namespace itk
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthMatrixFilter.hxx b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthMatrixFilter.hxx
index 4f6b26d98a..fc3d130ce4 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthMatrixFilter.hxx
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedScalarImageToRunLengthMatrixFilter.hxx
@@ -1,427 +1,429 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 /*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
 #ifndef __itkEnhancedScalarImageToRunLengthMatrixFilter_hxx
 #define __itkEnhancedScalarImageToRunLengthMatrixFilter_hxx
 
 #include "itkEnhancedScalarImageToRunLengthMatrixFilter.h"
 
 #include "itkConstNeighborhoodIterator.h"
 #include "itkNeighborhood.h"
 #include "vnl/vnl_math.h"
 #include "itkMacro.h"
 
 namespace itk
 {
   namespace Statistics
   {
     template<typename TImageType, typename THistogramFrequencyContainer>
     EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::EnhancedScalarImageToRunLengthMatrixFilter() :
     m_NumberOfBinsPerAxis( itkGetStaticConstMacro( DefaultBinsPerAxis ) ),
       m_Min( NumericTraits<PixelType>::NonpositiveMin() ),
       m_Max( NumericTraits<PixelType>::max() ),
       m_MinDistance( NumericTraits<RealType>::ZeroValue() ),
       m_MaxDistance( NumericTraits<RealType>::max() ),
       m_InsidePixelValue( NumericTraits<PixelType>::OneValue() )
     {
       this->SetNumberOfRequiredInputs( 1 );
       this->SetNumberOfRequiredOutputs( 1 );
 
       const unsigned int measurementVectorSize = 2;
 
       this->ProcessObject::SetNthOutput( 0, this->MakeOutput( 0 ) );
       HistogramType *output = const_cast<HistogramType *>( this->GetOutput() );
       output->SetMeasurementVectorSize( measurementVectorSize );
 
       this->m_LowerBound.SetSize( measurementVectorSize );
       this->m_UpperBound.SetSize( measurementVectorSize );
 
       this->m_LowerBound[0] = this->m_Min;
       this->m_LowerBound[1] = this->m_MinDistance;
       this->m_UpperBound[0] = this->m_Max;
       this->m_UpperBound[1] = this->m_MaxDistance;
     }
 
     template<typename TImageType, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::SetOffset( const OffsetType offset )
     {
       OffsetVectorPointer offsetVector = OffsetVector::New();
       offsetVector->push_back( offset );
       this->SetOffsets( offsetVector );
     }
 
     template<typename TImageType, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::SetInput( const ImageType *image )
     {
       // Process object is not const-correct so the const_cast is required here
       this->ProcessObject::SetNthInput( 0, const_cast<ImageType *>( image ) );
     }
 
     template<typename TImageType, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::SetMaskImage( const ImageType *image )
     {
       // Process object is not const-correct so the const_cast is required here
       this->ProcessObject::SetNthInput( 1, const_cast<ImageType *>( image ) );
     }
 
     template<typename TImageType, typename THistogramFrequencyContainer>
     const TImageType *
       EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::GetInput() const
     {
       if( this->GetNumberOfInputs() < 1 )
       {
         return ITK_NULLPTR;
       }
       return static_cast<const ImageType *>( this->ProcessObject::GetInput( 0 ) );
     }
 
     template<typename TImageType, typename THistogramFrequencyContainer>
     const TImageType *
       EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::GetMaskImage() const
     {
       if( this->GetNumberOfInputs() < 2 )
       {
         return ITK_NULLPTR;
       }
       return static_cast<const ImageType *>( this->ProcessObject::GetInput( 1 ) );
     }
 
     template<typename TImageType, typename THistogramFrequencyContainer>
     const typename EnhancedScalarImageToRunLengthMatrixFilter<TImageType,
       THistogramFrequencyContainer >::HistogramType *
       EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::GetOutput() const
     {
       const HistogramType *output =
         static_cast<const HistogramType *>( this->ProcessObject::GetOutput( 0 ) );
       return output;
     }
 
     template<typename TImageType, typename THistogramFrequencyContainer>
     typename EnhancedScalarImageToRunLengthMatrixFilter<TImageType,
       THistogramFrequencyContainer>::DataObjectPointer
       EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::MakeOutput( DataObjectPointerArraySizeType itkNotUsed( idx ) )
     {
       return HistogramType::New().GetPointer();
     }
 
     template<typename TImageType, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::GenerateData()
     {
       HistogramType *output =
         static_cast<HistogramType *>( this->ProcessObject::GetOutput( 0 ) );
 
       const ImageType * inputImage = this->GetInput();
 
       // First, create an appropriate histogram with the right number of bins
       // and mins and maxes correct for the image type.
       typename HistogramType::SizeType size( output->GetMeasurementVectorSize() );
 
       size.Fill( this->m_NumberOfBinsPerAxis );
       this->m_LowerBound[0] = this->m_Min;
       this->m_LowerBound[1] = this->m_MinDistance;
       this->m_UpperBound[0] = this->m_Max;
       this->m_UpperBound[1] = this->m_MaxDistance;
       output->Initialize( size, this->m_LowerBound, this->m_UpperBound );
 
       MeasurementVectorType run( output->GetMeasurementVectorSize() );
       typename HistogramType::IndexType hIndex;
 
       // Iterate over all of those pixels and offsets, adding each
       // distance/intensity pair to the histogram
 
       typedef ConstNeighborhoodIterator<ImageType> NeighborhoodIteratorType;
       typename NeighborhoodIteratorType::RadiusType radius;
       radius.Fill( 1 );
       NeighborhoodIteratorType neighborIt( radius,
         inputImage, inputImage->GetRequestedRegion() );
 
       // this temp image has the same dimension for each offset
       // moving the allocation out of loop of offsets
       // while keeping FillBuffer with boolean false in each loop
       typedef Image<bool, ImageDimension> BoolImageType;
       typename BoolImageType::Pointer alreadyVisitedImage = BoolImageType::New();
       alreadyVisitedImage->CopyInformation( inputImage );
       alreadyVisitedImage->SetRegions( inputImage->GetRequestedRegion() );
       alreadyVisitedImage->Allocate();
 
       typename OffsetVector::ConstIterator offsets;
       for( offsets = this->GetOffsets()->Begin();
         offsets != this->GetOffsets()->End(); offsets++ )
       {
         alreadyVisitedImage->FillBuffer( false );
 
         neighborIt.GoToBegin();
         OffsetType offset = offsets.Value();
 
         this->NormalizeOffsetDirection(offset);
 
         for( neighborIt.GoToBegin(); !neighborIt.IsAtEnd(); ++neighborIt )
         {
           const PixelType centerPixelIntensity = neighborIt.GetCenterPixel();
-          if (centerPixelIntensity != centerPixelIntensity)
+          if (centerPixelIntensity != centerPixelIntensity) // Check for invalid values
           {
             continue;
           }
           IndexType centerIndex = neighborIt.GetIndex();
           if( centerPixelIntensity < this->m_Min ||
             centerPixelIntensity > this->m_Max ||
             alreadyVisitedImage->GetPixel( centerIndex ) || ( this->GetMaskImage() &&
             this->GetMaskImage()->GetPixel( centerIndex ) !=
             this->m_InsidePixelValue ) )
           {
             continue; // don't put a pixel in the histogram if the value
             // is out-of-bounds or is outside the mask.
           }
 
           itkDebugMacro("===> offset = " << offset << std::endl);
 
           MeasurementType centerBinMin = this->GetOutput()->
             GetBinMinFromValue( 0, centerPixelIntensity );
           MeasurementType centerBinMax = this->GetOutput()->
             GetBinMaxFromValue( 0, centerPixelIntensity );
           MeasurementType lastBinMax = this->GetOutput()->
             GetDimensionMaxs( 0 )[ this->GetOutput()->GetSize( 0 ) - 1 ];
 
           PixelType pixelIntensity( NumericTraits<PixelType>::ZeroValue() );
           IndexType index;
 
           int steps = 0;
           index = centerIndex + offset;
           IndexType lastGoodIndex = centerIndex;
           bool runLengthSegmentAlreadyVisited = false;
 
           // Scan from the current pixel at index, following
           // the direction of offset. Run length is computed as the
           // length of continuous pixels whose pixel values are
           // in the same bin.
 
           while ( inputImage->GetRequestedRegion().IsInside(index) )
           {
             pixelIntensity = inputImage->GetPixel(index);
             // For the same offset, each run length segment can
             // only be visited once
             if (alreadyVisitedImage->GetPixel( index ) )
             {
               runLengthSegmentAlreadyVisited = true;
               break;
             }
             if (pixelIntensity != pixelIntensity)
             {
               break;
             }
 
 
             // Special attention paid to boundaries of bins.
             // For the last bin,
             // it is left close and right close (following the previous
             // gerrit patch).
             // For all
             // other bins,
             // the bin is left close and right open.
 
             if ( pixelIntensity >= centerBinMin
-              && ( pixelIntensity < centerBinMax || ( pixelIntensity == centerBinMax && centerBinMax == lastBinMax ) ) )
+              && ( pixelIntensity < centerBinMax || ( pixelIntensity == centerBinMax && centerBinMax == lastBinMax ) )
+              && (!this->GetMaskImage() || this->GetMaskImage()->GetPixel(index) == this->m_InsidePixelValue))
             {
               alreadyVisitedImage->SetPixel( index, true );
               lastGoodIndex = index;
               index += offset;
               steps++;
             }
             else
             {
               break;
             }
           }
 
           if ( runLengthSegmentAlreadyVisited )
           {
             MITK_INFO << "Already visited 1 " << index;
             continue;
           }
           IndexType lastGoodIndex2 = lastGoodIndex;
           index = centerIndex - offset;
           lastGoodIndex = centerIndex;
           while ( inputImage->GetRequestedRegion().IsInside(index) )
           {
             pixelIntensity = inputImage->GetPixel(index);
             if (pixelIntensity != pixelIntensity)
             {
               break;
             }
             if (alreadyVisitedImage->GetPixel( index ) )
             {
               if (pixelIntensity >= centerBinMin
                 && (pixelIntensity < centerBinMax || (pixelIntensity == centerBinMax && centerBinMax == lastBinMax)))
               {
                 runLengthSegmentAlreadyVisited = true;
               }
               break;
             }
 
             if ( pixelIntensity >= centerBinMin
-              && ( pixelIntensity < centerBinMax || ( pixelIntensity == centerBinMax && centerBinMax == lastBinMax ) ) )
+              && ( pixelIntensity < centerBinMax || ( pixelIntensity == centerBinMax && centerBinMax == lastBinMax ) )
+              && (!this->GetMaskImage() || this->GetMaskImage()->GetPixel(index) == this->m_InsidePixelValue))
             {
               alreadyVisitedImage->SetPixel( index, true );
               lastGoodIndex = index;
               steps++;
               index -= offset;
             }
             else
               break;
           }
           if (runLengthSegmentAlreadyVisited)
           {
             MITK_INFO << "Already visited 2 " << index;
             continue;
           }
           PointType centerPoint;
           inputImage->TransformIndexToPhysicalPoint(
             centerIndex, centerPoint );
           PointType point;
           inputImage->TransformIndexToPhysicalPoint( lastGoodIndex, point );
           PointType point2;
           inputImage->TransformIndexToPhysicalPoint( lastGoodIndex2, point2 );
 
           run[0] = centerPixelIntensity;
           run[1] = steps;
           //run[1] = point.EuclideanDistanceTo( point2 );
 
           if( run[1] >= this->m_MinDistance && run[1] <= this->m_MaxDistance )
           {
             output->GetIndex( run, hIndex );
             output->IncreaseFrequencyOfIndex( hIndex, 1 );
 
             itkDebugStatement(typename HistogramType::IndexType tempMeasurementIndex;)
               itkDebugStatement(output->GetIndex(run,tempMeasurementIndex);)
               itkDebugMacro( "centerIndex<->index: "
               << static_cast<int>( centerPixelIntensity )
               << "@"<< centerIndex
               << "<->" << static_cast<int>( pixelIntensity ) << "@" << index
               <<", Bin# " << tempMeasurementIndex
               << ", Measurement: (" << run[0] << ", " << run[1] << ")"
               << ", Center bin [" << this->GetOutput()->GetBinMinFromValue( 0, run[0] )
               << "," << this->GetOutput()->GetBinMaxFromValue( 0, run[0] ) << "]"
               << "~[" << this->GetOutput()->GetBinMinFromValue( 1, run[1] )
               << "," << this->GetOutput()->GetBinMaxFromValue( 1, run[1] ) << "]"
               << std::endl );
           }
         }
       }
     }
 
     template<typename TImageType, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::SetPixelValueMinMax( PixelType min, PixelType max )
     {
       if( this->m_Min != min || this->m_Max != max )
       {
         itkDebugMacro( "setting Min to " << min << "and Max to " << max );
         this->m_Min = min;
         this->m_Max = max;
         this->Modified();
       }
     }
 
     template<typename TImageType, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::SetDistanceValueMinMax( RealType min, RealType max )
     {
       if( this->m_MinDistance != min || this->m_MaxDistance != max )
       {
         itkDebugMacro( "setting MinDistance to " << min << "and MaxDistance to "
           << max );
         this->m_MinDistance = min;
         this->m_MaxDistance = max;
         this->Modified();
       }
     }
 
     template<typename TImageType, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::PrintSelf( std::ostream& os, Indent indent ) const
     {
       Superclass::PrintSelf( os,indent );
       os << indent << "Offsets: " << this->GetOffsets() << std::endl;
       os << indent << "Min: " << this->m_Min << std::endl;
       os << indent << "Max: " << this->m_Max << std::endl;
       os << indent << "Min distance: " << this->m_MinDistance << std::endl;
       os << indent << "Max distance: " << this->m_MaxDistance << std::endl;
       os << indent << "NumberOfBinsPerAxis: " << this->m_NumberOfBinsPerAxis
         << std::endl;
       os << indent << "InsidePixelValue: " << this->m_InsidePixelValue << std::endl;
     }
 
     template<typename TImageType, typename THistogramFrequencyContainer>
     void
       EnhancedScalarImageToRunLengthMatrixFilter<TImageType, THistogramFrequencyContainer>
       ::NormalizeOffsetDirection(OffsetType &offset)
     {
       itkDebugMacro("old offset = " << offset << std::endl);
       int sign = 1;
       bool metLastNonZero = false;
       for (int i = offset.GetOffsetDimension()-1; i>=0; i--)
       {
         if (metLastNonZero)
         {
           offset[i] *= sign;
         }
         else if (offset[i] != 0)
         {
           sign = (offset[i] > 0 ) ? 1 : -1;
           metLastNonZero = true;
           offset[i] *= sign;
         }
       }
 
       itkDebugMacro("new  offset = " << offset << std::endl);
     }
   } // end of namespace Statistics
 } // end of namespace itk
 
 #endif
\ No newline at end of file
diff --git a/Modules/Classification/CLUtilities/src/GlobalImageFeatures/mitkGIFGrayLevelRunLength.cpp b/Modules/Classification/CLUtilities/src/GlobalImageFeatures/mitkGIFGrayLevelRunLength.cpp
index b873741360..219a91f8bf 100644
--- a/Modules/Classification/CLUtilities/src/GlobalImageFeatures/mitkGIFGrayLevelRunLength.cpp
+++ b/Modules/Classification/CLUtilities/src/GlobalImageFeatures/mitkGIFGrayLevelRunLength.cpp
@@ -1,302 +1,341 @@
 /*===================================================================
 
 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 <mitkGIFGrayLevelRunLength.h>
 
 // MITK
 #include <mitkITKImageImport.h>
 #include <mitkImageCast.h>
 #include <mitkImageAccessByItk.h>
 
 // ITK
 #include <itkEnhancedScalarImageToRunLengthFeaturesFilter.h>
 #include <itkMinimumMaximumImageCalculator.h>
 
 // STL
 #include <sstream>
 
 template<typename TPixel, unsigned int VImageDimension>
 void
   CalculateGrayLevelRunLengthFeatures(itk::Image<TPixel, VImageDimension>* itkImage, mitk::Image::Pointer mask, mitk::GIFGrayLevelRunLength::FeatureListType & featureList, mitk::GIFGrayLevelRunLength::ParameterStruct params)
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef itk::Image<TPixel, VImageDimension> MaskType;
   typedef itk::Statistics::EnhancedScalarImageToRunLengthFeaturesFilter<ImageType> FilterType;
   typedef itk::MinimumMaximumImageCalculator<ImageType> MinMaxComputerType;
   typedef typename FilterType::RunLengthFeaturesFilterType TextureFilterType;
 
   typename MaskType::Pointer maskImage = MaskType::New();
   mitk::CastToItkImage(mask, maskImage);
 
   typename FilterType::Pointer filter = FilterType::New();
+  typename FilterType::Pointer filter2 = FilterType::New();
 
   typename FilterType::OffsetVector::Pointer newOffset = FilterType::OffsetVector::New();
   auto oldOffsets = filter->GetOffsets();
   auto oldOffsetsIterator = oldOffsets->Begin();
   while (oldOffsetsIterator != oldOffsets->End())
   {
     bool continueOuterLoop = false;
     typename FilterType::OffsetType offset = oldOffsetsIterator->Value();
     for (unsigned int i = 0; i < VImageDimension; ++i)
     {
       if (params.m_Direction == i + 2 && offset[i] != 0)
       {
         continueOuterLoop = true;
       }
     }
     if (params.m_Direction == 1)
     {
       offset[0] = 0;
       offset[1] = 0;
       offset[2] = 1;
       newOffset->push_back(offset);
       break;
     }
 
     oldOffsetsIterator++;
     if (continueOuterLoop)
       continue;
     newOffset->push_back(offset);
   }
   filter->SetOffsets(newOffset);
+  filter2->SetOffsets(newOffset);
 
 
   // All features are required
   typename FilterType::FeatureNameVectorPointer requestedFeatures = FilterType::FeatureNameVector::New();
   requestedFeatures->push_back(TextureFilterType::ShortRunEmphasis);
   requestedFeatures->push_back(TextureFilterType::LongRunEmphasis);
   requestedFeatures->push_back(TextureFilterType::GreyLevelNonuniformity);
   requestedFeatures->push_back(TextureFilterType::GreyLevelNonuniformityNormalized);
   requestedFeatures->push_back(TextureFilterType::RunLengthNonuniformity);
   requestedFeatures->push_back(TextureFilterType::RunLengthNonuniformityNormalized);
   requestedFeatures->push_back(TextureFilterType::LowGreyLevelRunEmphasis);
   requestedFeatures->push_back(TextureFilterType::HighGreyLevelRunEmphasis);
   requestedFeatures->push_back(TextureFilterType::ShortRunLowGreyLevelEmphasis);
   requestedFeatures->push_back(TextureFilterType::ShortRunHighGreyLevelEmphasis);
   requestedFeatures->push_back(TextureFilterType::LongRunLowGreyLevelEmphasis);
   requestedFeatures->push_back(TextureFilterType::LongRunHighGreyLevelEmphasis);
   requestedFeatures->push_back(TextureFilterType::RunPercentage);
   requestedFeatures->push_back(TextureFilterType::NumberOfRuns);
   requestedFeatures->push_back(TextureFilterType::GreyLevelVariance);
   requestedFeatures->push_back(TextureFilterType::RunLengthVariance);
   requestedFeatures->push_back(TextureFilterType::RunEntropy);
 
   typename MinMaxComputerType::Pointer minMaxComputer = MinMaxComputerType::New();
   minMaxComputer->SetImage(itkImage);
   minMaxComputer->Compute();
 
   filter->SetInput(itkImage);
   filter->SetMaskImage(maskImage);
   filter->SetRequestedFeatures(requestedFeatures);
+  filter2->SetInput(itkImage);
+  filter2->SetMaskImage(maskImage);
+  filter2->SetRequestedFeatures(requestedFeatures);
   int rangeOfPixels = params.Bins;
   if (rangeOfPixels < 2)
     rangeOfPixels = 256;
 
   if (params.m_UseCtRange)
   {
     filter->SetPixelValueMinMax((TPixel)(-1024.5),(TPixel)(3096.5));
-    filter->SetNumberOfBinsPerAxis(3096.5+1024.5);
+    filter->SetNumberOfBinsPerAxis(3096.5 + 1024.5);
+    filter2->SetPixelValueMinMax((TPixel)(-1024.5), (TPixel)(3096.5));
+    filter2->SetNumberOfBinsPerAxis(3096.5 + 1024.5);
   } else
   {
     double minRange = minMaxComputer->GetMinimum() - 0.5;
     double maxRange = minMaxComputer->GetMaximum() + 0.5;
 
     if (params.UseMinimumIntensity)
       minRange = params.MinimumIntensity;
     if (params.UseMaximumIntensity)
       maxRange = params.MaximumIntensity;
 
     filter->SetPixelValueMinMax(minRange, maxRange);
     filter->SetNumberOfBinsPerAxis(rangeOfPixels);
+    filter2->SetPixelValueMinMax(minRange, maxRange);
+    filter2->SetNumberOfBinsPerAxis(rangeOfPixels);
   }
 
-  filter->SetDistanceValueMinMax(0,rangeOfPixels);
+  filter->SetDistanceValueMinMax(0, rangeOfPixels);
+  filter2->SetDistanceValueMinMax(0, rangeOfPixels);
+
+  filter2->CombinedFeatureCalculationOn();
 
   filter->Update();
+  filter2->Update();
 
   auto featureMeans = filter->GetFeatureMeans ();
   auto featureStd = filter->GetFeatureStandardDeviations();
+  auto featureCombined = filter2->GetFeatureMeans();
 
   std::ostringstream  ss;
   ss << rangeOfPixels;
   std::string strRange = ss.str();
   for (std::size_t i = 0; i < featureMeans->size(); ++i)
   {
     switch (i)
     {
     case TextureFilterType::ShortRunEmphasis :
       featureList.push_back(std::make_pair("RunLength. ("+ strRange+") ShortRunEmphasis Means",featureMeans->ElementAt(i)));
-      featureList.push_back(std::make_pair("RunLength. ("+ strRange+") ShortRunEmphasis Std.",featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") ShortRunEmphasis Std.", featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") ShortRunEmphasis Comb.", featureCombined->ElementAt(i)));
       break;
     case TextureFilterType::LongRunEmphasis :
       featureList.push_back(std::make_pair("RunLength. ("+ strRange+") LongRunEmphasis Means",featureMeans->ElementAt(i)));
-      featureList.push_back(std::make_pair("RunLength. ("+ strRange+") LongRunEmphasis Std.",featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") LongRunEmphasis Std.", featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") LongRunEmphasis Comb.", featureCombined->ElementAt(i)));
       break;
     case TextureFilterType::GreyLevelNonuniformity :
       featureList.push_back(std::make_pair("RunLength. ("+ strRange+") GreyLevelNonuniformity Means",featureMeans->ElementAt(i)));
-      featureList.push_back(std::make_pair("RunLength. ("+ strRange+") GreyLevelNonuniformity Std.",featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") GreyLevelNonuniformity Std.", featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") GreyLevelNonuniformity Comb.", featureCombined->ElementAt(i)));
       break;
     case TextureFilterType::GreyLevelNonuniformityNormalized :
       featureList.push_back(std::make_pair("RunLength. ("+ strRange+") GreyLevelNonuniformityNormalized Means",featureMeans->ElementAt(i)));
-      featureList.push_back(std::make_pair("RunLength. ("+ strRange+") GreyLevelNonuniformityNormalized Std.",featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") GreyLevelNonuniformityNormalized Std.", featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") GreyLevelNonuniformityNormalized Comb.", featureCombined->ElementAt(i)));
       break;
     case TextureFilterType::RunLengthNonuniformity :
       featureList.push_back(std::make_pair("RunLength. ("+ strRange+") RunLengthNonuniformity Means",featureMeans->ElementAt(i)));
-      featureList.push_back(std::make_pair("RunLength. ("+ strRange+") RunLengthNonuniformity Std.",featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") RunLengthNonuniformity Std.", featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") RunLengthNonuniformity Comb.", featureCombined->ElementAt(i)));
       break;
     case TextureFilterType::RunLengthNonuniformityNormalized :
       featureList.push_back(std::make_pair("RunLength. ("+ strRange+") RunLengthNonuniformityNormalized Means",featureMeans->ElementAt(i)));
-      featureList.push_back(std::make_pair("RunLength. ("+ strRange+") RunLengthNonuniformityNormalized Std.",featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") RunLengthNonuniformityNormalized Std.", featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") RunLengthNonuniformityNormalized Comb.", featureCombined->ElementAt(i)));
       break;
     case TextureFilterType::LowGreyLevelRunEmphasis :
       featureList.push_back(std::make_pair("RunLength. ("+ strRange+") LowGreyLevelRunEmphasis Means",featureMeans->ElementAt(i)));
-      featureList.push_back(std::make_pair("RunLength. ("+ strRange+") LowGreyLevelRunEmphasis Std.",featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") LowGreyLevelRunEmphasis Std.", featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") LowGreyLevelRunEmphasis Comb.", featureCombined->ElementAt(i)));
       break;
     case TextureFilterType::HighGreyLevelRunEmphasis :
       featureList.push_back(std::make_pair("RunLength. ("+ strRange+") HighGreyLevelRunEmphasis Means",featureMeans->ElementAt(i)));
-      featureList.push_back(std::make_pair("RunLength. ("+ strRange+") HighGreyLevelRunEmphasis Std.",featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") HighGreyLevelRunEmphasis Std.", featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") HighGreyLevelRunEmphasis Comb.", featureCombined->ElementAt(i)));
       break;
     case TextureFilterType::ShortRunLowGreyLevelEmphasis :
       featureList.push_back(std::make_pair("RunLength. ("+ strRange+") ShortRunLowGreyLevelEmphasis Means",featureMeans->ElementAt(i)));
-      featureList.push_back(std::make_pair("RunLength. ("+ strRange+") ShortRunLowGreyLevelEmphasis Std.",featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") ShortRunLowGreyLevelEmphasis Std.", featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") ShortRunLowGreyLevelEmphasis Comb.", featureCombined->ElementAt(i)));
       break;
     case TextureFilterType::ShortRunHighGreyLevelEmphasis :
       featureList.push_back(std::make_pair("RunLength. ("+ strRange+") ShortRunHighGreyLevelEmphasis Means",featureMeans->ElementAt(i)));
-      featureList.push_back(std::make_pair("RunLength. ("+ strRange+") ShortRunHighGreyLevelEmphasis Std.",featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") ShortRunHighGreyLevelEmphasis Std.", featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") ShortRunHighGreyLevelEmphasis Comb.", featureCombined->ElementAt(i)));
       break;
     case TextureFilterType::LongRunLowGreyLevelEmphasis :
       featureList.push_back(std::make_pair("RunLength. ("+ strRange+") LongRunLowGreyLevelEmphasis Means",featureMeans->ElementAt(i)));
-      featureList.push_back(std::make_pair("RunLength. ("+ strRange+") LongRunLowGreyLevelEmphasis Std.",featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") LongRunLowGreyLevelEmphasis Std.", featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") LongRunLowGreyLevelEmphasis Comb.", featureStd->ElementAt(i)));
       break;
     case TextureFilterType::LongRunHighGreyLevelEmphasis :
       featureList.push_back(std::make_pair("RunLength. ("+ strRange+") LongRunHighGreyLevelEmphasis Means",featureMeans->ElementAt(i)));
-      featureList.push_back(std::make_pair("RunLength. ("+ strRange+") LongRunHighGreyLevelEmphasis Std.",featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") LongRunHighGreyLevelEmphasis Std.", featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") LongRunHighGreyLevelEmphasis Comb.", featureStd->ElementAt(i)));
       break;
     case TextureFilterType::RunPercentage :
       featureList.push_back(std::make_pair("RunLength. ("+ strRange+") RunPercentage Means",featureMeans->ElementAt(i)));
-      featureList.push_back(std::make_pair("RunLength. ("+ strRange+") RunPercentage Std.",featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") RunPercentage Std.", featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") RunPercentage Comb.", featureStd->ElementAt(i)));
       break;
     case TextureFilterType::NumberOfRuns :
       featureList.push_back(std::make_pair("RunLength. ("+ strRange+") NumberOfRuns Means",featureMeans->ElementAt(i)));
-      featureList.push_back(std::make_pair("RunLength. ("+ strRange+") NumberOfRuns Std.",featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") NumberOfRuns Std.", featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") NumberOfRuns Comb.", featureStd->ElementAt(i)));
       break;
     case TextureFilterType::GreyLevelVariance :
       featureList.push_back(std::make_pair("RunLength. ("+ strRange+") GreyLevelVariance Means",featureMeans->ElementAt(i)));
-      featureList.push_back(std::make_pair("RunLength. ("+ strRange+") GreyLevelVariance Std.",featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") GreyLevelVariance Std.", featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") GreyLevelVariance Comb.", featureStd->ElementAt(i)));
       break;
     case TextureFilterType::RunLengthVariance :
       featureList.push_back(std::make_pair("RunLength. ("+ strRange+") RunLengthVariance Means",featureMeans->ElementAt(i)));
-      featureList.push_back(std::make_pair("RunLength. ("+ strRange+") RunLengthVariance Std.",featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") RunLengthVariance Std.", featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") RunLengthVariance Comb.", featureStd->ElementAt(i)));
       break;
     case TextureFilterType::RunEntropy :
       featureList.push_back(std::make_pair("RunLength. ("+ strRange+") RunEntropy Means",featureMeans->ElementAt(i)));
-      featureList.push_back(std::make_pair("RunLength. ("+ strRange+") RunEntropy Std.",featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") RunEntropy Std.", featureStd->ElementAt(i)));
+      featureList.push_back(std::make_pair("RunLength. (" + strRange + ") RunEntropy Comb.", featureStd->ElementAt(i)));
       break;
     default:
       break;
     }
   }
 }
 
 mitk::GIFGrayLevelRunLength::GIFGrayLevelRunLength():
 m_Range(1.0), m_UseCtRange(false)
 {
   SetShortName("rl");
   SetLongName("run-length");
 }
 
 mitk::GIFGrayLevelRunLength::FeatureListType mitk::GIFGrayLevelRunLength::CalculateFeatures(const Image::Pointer & image, const Image::Pointer &mask)
 {
   FeatureListType featureList;
 
   ParameterStruct params;
   params.m_UseCtRange=m_UseCtRange;
   params.m_Range = m_Range;
   params.m_Direction = GetDirection();
 
   params.MinimumIntensity = GetMinimumIntensity();
   params.MaximumIntensity = GetMaximumIntensity();
   params.UseMinimumIntensity = GetUseMinimumIntensity();
   params.UseMaximumIntensity = GetUseMaximumIntensity();
   params.Bins = GetBins();
 
+  MITK_INFO << params.MinimumIntensity;
+  MITK_INFO << params.MaximumIntensity;
+  MITK_INFO << params.m_UseCtRange;
+  MITK_INFO << params.m_Direction;
+  MITK_INFO << params.Bins;
+  MITK_INFO<<params.m_Range;
+
+
   AccessByItk_3(image, CalculateGrayLevelRunLengthFeatures, mask, featureList,params);
 
   return featureList;
 }
 
 mitk::GIFGrayLevelRunLength::FeatureNameListType mitk::GIFGrayLevelRunLength::GetFeatureNames()
 {
   FeatureNameListType featureList;
   featureList.push_back("RunLength. ShortRunEmphasis Means");
   featureList.push_back("RunLength. ShortRunEmphasis Std.");
   featureList.push_back("RunLength. LongRunEmphasis Means");
   featureList.push_back("RunLength. LongRunEmphasis Std.");
   featureList.push_back("RunLength. GreyLevelNonuniformity Means");
   featureList.push_back("RunLength. GreyLevelNonuniformity Std.");
   featureList.push_back("RunLength. RunLengthNonuniformity Means");
   featureList.push_back("RunLength. RunLengthNonuniformity Std.");
   featureList.push_back("RunLength. LowGreyLevelRunEmphasis Means");
   featureList.push_back("RunLength. LowGreyLevelRunEmphasis Std.");
   featureList.push_back("RunLength. HighGreyLevelRunEmphasis Means");
   featureList.push_back("RunLength. HighGreyLevelRunEmphasis Std.");
   featureList.push_back("RunLength. ShortRunLowGreyLevelEmphasis Means");
   featureList.push_back("RunLength. ShortRunLowGreyLevelEmphasis Std.");
   featureList.push_back("RunLength. ShortRunHighGreyLevelEmphasis Means");
   featureList.push_back("RunLength. ShortRunHighGreyLevelEmphasis Std.");
   featureList.push_back("RunLength. LongRunHighGreyLevelEmphasis Means");
   featureList.push_back("RunLength. LongRunHighGreyLevelEmphasis Std.");
   return featureList;
 }
 
 
 void mitk::GIFGrayLevelRunLength::AddArguments(mitkCommandLineParser &parser)
 {
   std::string name = GetOptionPrefix();
 
   parser.addArgument(GetLongName(), name, mitkCommandLineParser::String, "Use Co-occurence matrix", "calculates Co-occurence based features (new implementation)", us::Any());
   parser.addArgument(name + "::bins", name + "::bins", mitkCommandLineParser::String, "RL Bins", "Define the number of bins that is used (Semicolon-separated)", us::Any());
 }
 
 void
 mitk::GIFGrayLevelRunLength::CalculateFeaturesUsingParameters(const Image::Pointer & feature, const Image::Pointer &, const Image::Pointer &maskNoNAN, FeatureListType &featureList)
 {
   auto parsedArgs = GetParameter();
   std::string name = GetOptionPrefix();
 
   if (parsedArgs.count(GetLongName()))
   {
     std::vector<double> bins;
     if (parsedArgs.count(name + "::bins"))
     {
       bins = SplitDouble(parsedArgs[name + "::bins"].ToString(), ';');
     }
     else
     {
       bins.push_back(1);
     }
 
     for (std::size_t i = 0; i < bins.size(); ++i)
     {
       MITK_INFO << "Start calculating Run-length with range " << bins[i] << "....";
       this->SetBins(bins[i]);
       auto localResults = this->CalculateFeatures(feature, maskNoNAN);
       featureList.insert(featureList.end(), localResults.begin(), localResults.end());
       MITK_INFO << "Finished calculating Run-length with range " << bins[i] << "....";
     }
   }
 
 }
diff --git a/Modules/Classification/CLUtilities/src/GlobalImageFeatures/mitkGIFVolumetricStatistics.cpp b/Modules/Classification/CLUtilities/src/GlobalImageFeatures/mitkGIFVolumetricStatistics.cpp
index 0734a02c5e..80b47d5fef 100644
--- a/Modules/Classification/CLUtilities/src/GlobalImageFeatures/mitkGIFVolumetricStatistics.cpp
+++ b/Modules/Classification/CLUtilities/src/GlobalImageFeatures/mitkGIFVolumetricStatistics.cpp
@@ -1,431 +1,432 @@
 /*===================================================================
 
 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 <mitkGIFVolumetricStatistics.h>
 
 // MITK
 #include <mitkITKImageImport.h>
 #include <mitkImageCast.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkPixelTypeMultiplex.h>
 #include <mitkImagePixelReadAccessor.h>
 
 // ITK
 #include <itkLabelStatisticsImageFilter.h>
 #include <itkNeighborhoodIterator.h>
 
 // VTK
 #include <vtkSmartPointer.h>
 #include <vtkImageMarchingCubes.h>
 #include <vtkMassProperties.h>
 
 // STL
 #include <sstream>
 #include <vnl/vnl_math.h>
 
 // OpenCV
 #include <opencv2/opencv.hpp>
 
 template<typename TPixel, unsigned int VImageDimension>
 void
   CalculateVolumeStatistic(itk::Image<TPixel, VImageDimension>* itkImage, mitk::Image::Pointer mask, mitk::GIFVolumetricStatistics::FeatureListType & featureList)
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef itk::Image<int, VImageDimension> MaskType;
   typedef itk::LabelStatisticsImageFilter<ImageType, MaskType> FilterType;
 
   typename MaskType::Pointer maskImage = MaskType::New();
   mitk::CastToItkImage(mask, maskImage);
 
   typename FilterType::Pointer labelStatisticsImageFilter = FilterType::New();
   labelStatisticsImageFilter->SetInput( itkImage );
   labelStatisticsImageFilter->SetLabelInput(maskImage);
   labelStatisticsImageFilter->Update();
 
   double volume = labelStatisticsImageFilter->GetCount(1);
   double voxelVolume = 1;
   for (int i = 0; i < (int)(VImageDimension); ++i)
   {
     volume *= itkImage->GetSpacing()[i];
     voxelVolume *= itkImage->GetSpacing()[i];
   }
 
   featureList.push_back(std::make_pair("Volumetric Features Volume (pixel based)", volume));
   featureList.push_back(std::make_pair("Volumetric Features Voxel Volume", voxelVolume));
 }
 
 template<typename TPixel, unsigned int VImageDimension>
 void
   CalculateLargestDiameter(itk::Image<TPixel, VImageDimension>* mask, mitk::Image::Pointer valueImage, mitk::GIFVolumetricStatistics::FeatureListType & featureList)
 {
   typedef itk::Image<double, VImageDimension> ValueImageType;
 
   typename ValueImageType::Pointer itkValueImage = ValueImageType::New();
   mitk::CastToItkImage(valueImage, itkValueImage);
 
 
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef typename ImageType::PointType PointType;
   typename ImageType::SizeType radius;
   for (int i=0; i < (int)VImageDimension; ++i)
     radius[i] = 1;
   itk::NeighborhoodIterator<ImageType> iterator(radius, mask, mask->GetRequestedRegion());
   itk::NeighborhoodIterator<ValueImageType> valueIter(radius, itkValueImage, itkValueImage->GetRequestedRegion());
   std::vector<PointType> borderPoints;
 
   //
   //  Calculate surface in different directions
   //
   double surface = 0;
   std::vector<double> directionSurface;
   for (int i = 0; i < (int)(iterator.Size()); ++i)
   {
     auto offset = iterator.GetOffset(i);
     double deltaS = 1;
     int nonZeros = 0;
     for (unsigned int j = 0; j < VImageDimension; ++j)
     {
       if (offset[j] != 0 && nonZeros == 0)
       {
         for (unsigned int k = 0; k < VImageDimension; ++k)
         {
           if (k != j)
             deltaS *= mask->GetSpacing()[k];
         }
         nonZeros++;
       }
       else if (offset[j] != 0)
       {
         deltaS = 0;
       }
     }
     if (nonZeros < 1)
       deltaS = 0;
     directionSurface.push_back(deltaS);
   }
 
   //
   // Prepare calulation of Centre of mass shift
   //
   PointType normalCenter(0);
   PointType normalCenterUncorrected(0);
   PointType weightedCenter(0);
   PointType currentPoint;
   int numberOfPoints = 0;
   int numberOfPointsUncorrected = 0;
   double sumOfPoints = 0;
 
   while(!iterator.IsAtEnd())
   {
     if (iterator.GetCenterPixel() == 0)
     {
       ++iterator;
       ++valueIter;
       continue;
     }
 
     mask->TransformIndexToPhysicalPoint(iterator.GetIndex(), currentPoint);
 
     normalCenterUncorrected += currentPoint.GetVectorFromOrigin();
     ++numberOfPointsUncorrected;
 
     double intensityValue = valueIter.GetCenterPixel();
     if (intensityValue == intensityValue)
     {
       normalCenter += currentPoint.GetVectorFromOrigin();
       weightedCenter += currentPoint.GetVectorFromOrigin() * intensityValue;
       sumOfPoints += intensityValue;
       ++numberOfPoints;
     }
 
     bool border = false;
     for (int i = 0; i < (int)(iterator.Size()); ++i)
     {
       if (iterator.GetPixel(i) == 0 || ( ! iterator.IndexInBounds(i)))
       {
         border = true;
         surface += directionSurface[i];
         //break;
       }
     }
     if (border)
     {
       auto centerIndex = iterator.GetIndex();
       PointType centerPoint;
       mask->TransformIndexToPhysicalPoint(centerIndex, centerPoint );
       borderPoints.push_back(centerPoint);
     }
     ++iterator;
     ++valueIter;
   }
 
   auto normalCenterVector = normalCenter.GetVectorFromOrigin() / numberOfPoints;
   auto normalCenterVectorUncorrected = normalCenter.GetVectorFromOrigin() / numberOfPointsUncorrected;
   auto weightedCenterVector = weightedCenter.GetVectorFromOrigin() / sumOfPoints;
   auto differenceOfCentersUncorrected = (normalCenterVectorUncorrected - weightedCenterVector).GetNorm();
   auto differenceOfCenters = (normalCenterVector - weightedCenterVector).GetNorm();
 
   double longestDiameter = 0;
   unsigned long numberOfBorderPoints = borderPoints.size();
   for (int i = 0; i < (int)numberOfBorderPoints; ++i)
   {
     auto point = borderPoints[i];
     for (int j = i; j < (int)numberOfBorderPoints; ++j)
     {
       double newDiameter=point.EuclideanDistanceTo(borderPoints[j]);
       if (newDiameter > longestDiameter)
         longestDiameter = newDiameter;
     }
   }
 
   featureList.push_back(std::make_pair("Volumetric Features Maximum 3D diameter", longestDiameter));
   featureList.push_back(std::make_pair("Volumetric Features Surface (Voxel based)", surface));
   featureList.push_back(std::make_pair("Volumetric Features Centre of mass shift", differenceOfCenters));
   featureList.push_back(std::make_pair("Volumetric Features Centre of mass shift (Uncorrected)", differenceOfCentersUncorrected));
 }
 
 mitk::GIFVolumetricStatistics::GIFVolumetricStatistics()
 {
   SetLongName("volume");
   SetShortName("vol");
 }
 
 mitk::GIFVolumetricStatistics::FeatureListType mitk::GIFVolumetricStatistics::CalculateFeatures(const Image::Pointer & image, const Image::Pointer &mask)
 {
   FeatureListType featureList;
   if (image->GetDimension() < 3)
   {
     return featureList;
   }
 
 
   AccessByItk_2(image, CalculateVolumeStatistic, mask, featureList);
   AccessByItk_2(mask, CalculateLargestDiameter, image, featureList);
 
   vtkSmartPointer<vtkImageMarchingCubes> mesher = vtkSmartPointer<vtkImageMarchingCubes>::New();
   vtkSmartPointer<vtkMassProperties> stats = vtkSmartPointer<vtkMassProperties>::New();
   mesher->SetInputData(mask->GetVtkImageData());
+  mesher->SetValue(0, 0.5);
   stats->SetInputConnection(mesher->GetOutputPort());
   stats->Update();
 
   double pi = vnl_math::pi;
 
   double meshVolume = stats->GetVolume();
   double meshSurf = stats->GetSurfaceArea();
   double pixelVolume = featureList[0].second;
   double pixelSurface = featureList[3].second;
 
   MITK_INFO << "Surf: " << pixelSurface << " Vol " << pixelVolume;
 
   double compactness1 = pixelVolume / (std::sqrt(pi) * std::pow(meshSurf, 2.0 / 3.0));
   double compactness1Pixel = pixelVolume / (std::sqrt(pi) * std::pow(pixelSurface, 2.0 / 3.0));
   //This is the definition used by Aertz. However, due to 2/3 this feature is not demensionless. Use compactness3 instead.
 
   double compactness2 = 36 * pi*pixelVolume*pixelVolume / meshSurf / meshSurf / meshSurf;
   double compactness2Pixel = 36 * pi*pixelVolume*pixelVolume / pixelSurface / pixelSurface / pixelSurface;
   double compactness3 = pixelVolume / (std::sqrt(pi) * std::pow(meshSurf, 3.0 / 2.0));
   double compactness3Pixel = pixelVolume / (std::sqrt(pi) * std::pow(pixelSurface, 3.0 / 2.0));
 
   double sphericity = std::pow(pi, 1 / 3.0) *std::pow(6 * pixelVolume, 2.0 / 3.0) / meshSurf;
   double sphericityPixel = std::pow(pi, 1 / 3.0) *std::pow(6 * pixelVolume, 2.0 / 3.0) / pixelSurface;
   double surfaceToVolume = meshSurf / pixelVolume;
   double surfaceToVolumePixel = pixelSurface / pixelVolume;
   double sphericalDisproportion = meshSurf / 4 / pi / std::pow(3.0 / 4.0 / pi * pixelVolume, 2.0 / 3.0);
   double sphericalDisproportionPixel = pixelSurface / 4 / pi / std::pow(3.0 / 4.0 / pi * pixelVolume, 2.0 / 3.0);
   double asphericity = std::pow(1.0/compactness2, (1.0 / 3.0)) - 1;
   double asphericityPixel = std::pow(1.0/compactness2Pixel, (1.0 / 3.0)) - 1;
 
   //Calculate center of mass shift
   int xx = mask->GetDimensions()[0];
   int yy = mask->GetDimensions()[1];
   int zz = mask->GetDimensions()[2];
 
   double xd = mask->GetGeometry()->GetSpacing()[0];
   double yd = mask->GetGeometry()->GetSpacing()[1];
   double zd = mask->GetGeometry()->GetSpacing()[2];
 
 
   std::vector<cv::Point3d> pointsForPCA;
   std::vector<cv::Point3d> pointsForPCAUncorrected;
 
   for (int x = 0; x < xx; x++)
   {
     for (int y = 0; y < yy; y++)
     {
       for (int z = 0; z < zz; z++)
       {
         itk::Image<int,3>::IndexType index;
 
         index[0] = x;
         index[1] = y;
         index[2] = z;
 
         mitk::ScalarType pxImage;
         mitk::ScalarType pxMask;
 
         mitkPixelTypeMultiplex5(
               mitk::FastSinglePixelAccess,
               image->GetChannelDescriptor().GetPixelType(),
               image,
               image->GetVolumeData(),
               index,
               pxImage,
               0);
 
         mitkPixelTypeMultiplex5(
               mitk::FastSinglePixelAccess,
               mask->GetChannelDescriptor().GetPixelType(),
               mask,
               mask->GetVolumeData(),
               index,
               pxMask,
               0);
 
         //Check if voxel is contained in segmentation
         if (pxMask > 0)
         {
           cv::Point3d tmp;
           tmp.x = x * xd;
           tmp.y = y * yd;
           tmp.z = z * zd;
           pointsForPCAUncorrected.push_back(tmp);
 
           if (pxImage == pxImage)
           {
             pointsForPCA.push_back(tmp);
           }
         }
       }
     }
   }
 
 
   //Calculate PCA Features
   int sz = pointsForPCA.size();
   cv::Mat data_pts = cv::Mat(sz, 3, CV_64FC1);
   for (int i = 0; i < data_pts.rows; ++i)
   {
       data_pts.at<double>(i, 0) = pointsForPCA[i].x;
       data_pts.at<double>(i, 1) = pointsForPCA[i].y;
       data_pts.at<double>(i, 2) = pointsForPCA[i].z;
   }
 
   //Calculate PCA Features
   int szUC = pointsForPCAUncorrected.size();
   cv::Mat data_ptsUC = cv::Mat(szUC, 3, CV_64FC1);
   for (int i = 0; i < data_ptsUC.rows; ++i)
   {
     data_ptsUC.at<double>(i, 0) = pointsForPCAUncorrected[i].x;
     data_ptsUC.at<double>(i, 1) = pointsForPCAUncorrected[i].y;
     data_ptsUC.at<double>(i, 2) = pointsForPCAUncorrected[i].z;
   }
 
   //Perform PCA analysis
   cv::PCA pca_analysis(data_pts, cv::Mat(), CV_PCA_DATA_AS_ROW);
   cv::PCA pca_analysisUC(data_ptsUC, cv::Mat(), CV_PCA_DATA_AS_ROW);
 
   //Store the eigenvalues
   std::vector<double> eigen_val(3);
   std::vector<double> eigen_valUC(3);
   for (int i = 0; i < 3; ++i)
   {
     eigen_val[i] = pca_analysis.eigenvalues.at<double>(0, i);
     eigen_valUC[i] = pca_analysisUC.eigenvalues.at<double>(0, i);
   }
 
   std::sort(eigen_val.begin(), eigen_val.end());
   std::sort(eigen_valUC.begin(), eigen_valUC.end());
   double major = eigen_val[2];
   double minor = eigen_val[1];
   double least = eigen_val[0];
   double elongation = major == 0 ? 0 : minor/major;
   double flatness = major == 0 ? 0 : least / major;
   double majorUC = eigen_valUC[2];
   double minorUC = eigen_valUC[1];
   double leastUC = eigen_valUC[0];
   double elongationUC = majorUC == 0 ? 0 : minorUC / majorUC;
   double flatnessUC = majorUC == 0 ? 0 : leastUC / majorUC;
 
 
   featureList.push_back(std::make_pair("Volumetric Features Volume (mesh based)",meshVolume));
   featureList.push_back(std::make_pair("Volumetric Features Surface area",meshSurf));
   featureList.push_back(std::make_pair("Volumetric Features Surface to volume ratio",surfaceToVolume));
   featureList.push_back(std::make_pair("Volumetric Features Sphericity",sphericity));
   featureList.push_back(std::make_pair("Volumetric Features Asphericity",asphericity));
   featureList.push_back(std::make_pair("Volumetric Features Compactness 1",compactness1));
   featureList.push_back(std::make_pair("Volumetric Features Compactness 2",compactness2));
   featureList.push_back(std::make_pair("Volumetric Features Compactness 3",compactness3));
   featureList.push_back(std::make_pair("Volumetric Features Spherical disproportion", sphericalDisproportion));
   featureList.push_back(std::make_pair("Volumetric Features Surface to volume ratio (Voxel based)", surfaceToVolumePixel));
   featureList.push_back(std::make_pair("Volumetric Features Sphericity (Voxel based)", sphericityPixel));
   featureList.push_back(std::make_pair("Volumetric Features Asphericity (Voxel based)", asphericityPixel));
   featureList.push_back(std::make_pair("Volumetric Features Compactness 1 (Voxel based)", compactness1Pixel));
   featureList.push_back(std::make_pair("Volumetric Features Compactness 2 (Voxel based)", compactness2Pixel));
   featureList.push_back(std::make_pair("Volumetric Features Compactness 3 (Voxel based)", compactness3Pixel));
   featureList.push_back(std::make_pair("Volumetric Features Spherical disproportion (Voxel based)", sphericalDisproportionPixel));
   featureList.push_back(std::make_pair("Volumetric Features PCA Major Axis",major));
   featureList.push_back(std::make_pair("Volumetric Features PCA Minor Axis",minor));
   featureList.push_back(std::make_pair("Volumetric Features PCA Least Axis",least));
   featureList.push_back(std::make_pair("Volumetric Features PCA Elongation",elongation));
   featureList.push_back(std::make_pair("Volumetric Features PCA Flatness",flatness));
   featureList.push_back(std::make_pair("Volumetric Features PCA Major Axis (Uncorrected)", majorUC));
   featureList.push_back(std::make_pair("Volumetric Features PCA Minor Axis (Uncorrected)", minorUC));
   featureList.push_back(std::make_pair("Volumetric Features PCA Least Axis (Uncorrected)", leastUC));
   featureList.push_back(std::make_pair("Volumetric Features PCA Elongation (Uncorrected)", elongationUC));
   featureList.push_back(std::make_pair("Volumetric Features PCA Flatness (Uncorrected)", flatnessUC));
 
 
   return featureList;
 }
 
 mitk::GIFVolumetricStatistics::FeatureNameListType mitk::GIFVolumetricStatistics::GetFeatureNames()
 {
   FeatureNameListType featureList;
   featureList.push_back("Volumetric Features Compactness 1");
   featureList.push_back("Volumetric Features Compactness 2");
   featureList.push_back("Volumetric Features Compactness 3");
   featureList.push_back("Volumetric Features Sphericity");
   featureList.push_back("Volumetric Features Asphericity");
   featureList.push_back("Volumetric Features Surface to volume ratio");
   featureList.push_back("Volumetric Features Surface area");
   featureList.push_back("Volumetric Features Volume (mesh based)");
   featureList.push_back("Volumetric Features Volume (pixel based)");
   featureList.push_back("Volumetric Features Spherical disproportion");
   featureList.push_back("Volumetric Features Maximum 3D diameter");
   return featureList;
 }
 
 
 void mitk::GIFVolumetricStatistics::AddArguments(mitkCommandLineParser &parser)
 {
   std::string name = GetOptionPrefix();
 
   parser.addArgument(GetLongName(), name, mitkCommandLineParser::String, "Use Volume-Statistic", "calculates volume based features", us::Any());
 }
 
 void
 mitk::GIFVolumetricStatistics::CalculateFeaturesUsingParameters(const Image::Pointer & feature, const Image::Pointer &mask, const Image::Pointer &, FeatureListType &featureList)
 {
   auto parsedArgs = GetParameter();
   if (parsedArgs.count(GetLongName()))
   {
     MITK_INFO << "Start calculating volumetric features ....";
     auto localResults = this->CalculateFeatures(feature, mask);
     featureList.insert(featureList.end(), localResults.begin(), localResults.end());
     MITK_INFO << "Finished calculating volumetric features....";
   }
 }