diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter.hxx b/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter.hxx
index 7ac99c20ca..767a315238 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter.hxx
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter.hxx
@@ -1,339 +1,330 @@
 /*===================================================================
 
 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 __itkEnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter_hxx
 #define __itkEnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter_hxx
 
 #include "itkEnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter.h"
 
 #include "itkNumericTraits.h"
 #include "vnl/vnl_math.h"
 
 namespace itk {
 namespace Statistics {
 //constructor
 template<typename THistogram>
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter() :
   m_NumberOfVoxels(1)
 {
   this->ProcessObject::SetNumberOfRequiredInputs( 1 );
 
   // allocate the data objects for the outputs which are
   // just decorators real types
   for( unsigned int i = 0; i < 5; i++ )
   {
     this->ProcessObject::SetNthOutput( i, this->MakeOutput( i ) );
   }
 }
 
 template<typename THistogram>
 void
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter< THistogram>
 ::SetInput(const HistogramType *histogram )
 {
   this->ProcessObject::SetNthInput( 0, const_cast<HistogramType*>( histogram ) );
 }
 
 
 template<typename THistogram>
 const typename
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>::HistogramType *
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter< THistogram>
 ::GetInput() const
 {
   if ( this->GetNumberOfInputs() < 1 )
   {
     return ITK_NULLPTR;
   }
   return itkDynamicCastInDebugMode<const HistogramType *>(this->ProcessObject::GetInput(0) );
 }
 
 template<typename THistogram>
 typename
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>::DataObjectPointer
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::MakeOutput( DataObjectPointerArraySizeType itkNotUsed( idx ) )
 {
   return MeasurementObjectType::New().GetPointer();
 }
 
 template<typename THistogram>
 void
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter< THistogram>::
 GenerateData( void )
 {
   const HistogramType * inputHistogram = this->GetInput(); //The nis
 
   this->m_TotalNumberOfValidVoxels = static_cast<unsigned long>
       ( inputHistogram->GetTotalFrequency() );
 
   MeasurementType coarseness  = NumericTraits<MeasurementType>::ZeroValue();
   MeasurementType contrast    = NumericTraits<MeasurementType>::ZeroValue();
   MeasurementType busyness    = NumericTraits<MeasurementType>::ZeroValue();
   MeasurementType complexity  = NumericTraits<MeasurementType>::ZeroValue();
   MeasurementType strength    = NumericTraits<MeasurementType>::ZeroValue();
 
   typedef typename HistogramType::ConstIterator HistogramIterator;
 
   long unsigned int Ng = inputHistogram->GetSize(0);
   std::cout << "No of bins: " << Ng << "  total number of valid voxels: " << this->m_TotalNumberOfValidVoxels << std::endl;
 
   double sumPiSi    = 0.0;
   double sumSi      = 0.0;
   unsigned int Ngp  = 0;
   unsigned int Nv   = 0;
 
   //Calculate sum(pi*si).
   for ( HistogramIterator hit = inputHistogram->Begin();
         hit != inputHistogram->End(); ++hit )
   {
     IndexType index = hit.GetIndex();
 
     MeasurementType ni = hit.GetFrequency();
     double si = m_siMatrix[index[0]];
     if ( ni == 0 )
     {
       continue;
     }
     sumPiSi += ni*si;
     sumSi += si;
     Ngp++;
     Nv += ni;
   }
 
   sumPiSi /= Nv;
 
 
   //Calculate the other features
   //pi = ni / Nv, so we can simply calculate with ni instead of pi
 
   double pipj   = 0.0;
   double ipijpj = 0.0;
   double complexitySum = 0.0;
   double strengthSum = 0.0;
 
   for ( HistogramIterator hit = inputHistogram->Begin();
         hit != inputHistogram->End(); ++hit )
   {
     MeasurementVectorType measurement = hit.GetMeasurementVector();
     IndexType index = hit.GetIndex();
     //MITK_WARN << "current index " << index;
 
     MeasurementType ni = hit.GetFrequency();
     double si = m_siMatrix[index[0]];
 
     double i = measurement[0];
 
     for ( HistogramIterator hit2 = inputHistogram->Begin();
           hit2 != inputHistogram->End(); ++hit2 )
     {
       MeasurementVectorType measurement2 = hit2.GetMeasurementVector();
       IndexType index2 = hit2.GetIndex();
 
       MeasurementType nj= hit2.GetFrequency();
       double sj = m_siMatrix[index2[0]];
 
       double j = measurement2[0];
 
-      if(ni*nj != 0)
-      {
-      MITK_WARN << "===INFO===";
-      MITK_WARN << "At index " << index << "/" << index2;
-      MITK_WARN << " -> We have a greyvalue i = " << i << ", j = " << j;
-      MITK_WARN << " -> si = " << si << ", sj = " << sj;
-      MITK_WARN << " -> ni = " << ni << ", nj = " << nj;
-      }
-
       pipj += ni*nj*(i-j)*(i-j);
       ipijpj += std::abs(i*ni - j*nj);
 
       if(ni != 0 && nj != 0)
         complexitySum += std::abs(i-j) * (ni*si + nj*sj)/(ni+nj);
 
       strengthSum += (ni+nj)*(i-j)*(i-j);
     }
   }
 
 
   //Calculate Coarseness
   coarseness = (sumPiSi == 0) ? 1e6 : 1.0 / sumPiSi;
   contrast = (Ngp <= 1 || Nv == 0) ? 0 : (1.0/(Ngp * (Ngp - 1))*pipj / Nv / Nv) * (sumSi / Nv / Nv);
   busyness = (Ngp <= 1 || ipijpj == 0) ? 0 : sumPiSi / ipijpj / Nv;
   complexity = (Nv == 0) ? 0: complexitySum / Nv / Nv;
   strength = (sumSi == 0 || Nv == 0) ? 0 : strengthSum / Nv / sumSi;
 
   //Calculate the other features.
 
   MeasurementObjectType* CoarsenessOutputObject =
       static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 0 ) );
   CoarsenessOutputObject->Set( coarseness );
 
   MeasurementObjectType* ContrastOutputObject =
       static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 1 ) );
   ContrastOutputObject->Set( contrast );
 
   MeasurementObjectType* BusynessOutputObject =
       static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 2 ) );
   BusynessOutputObject->Set( busyness );
 
   MeasurementObjectType* ComplexityOutputObject =
       static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 3 ) );
   ComplexityOutputObject->Set( complexity );
 
   MeasurementObjectType* StrengthOutputObject =
       static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 4 ) );
   StrengthOutputObject->Set( strength );
 
 }
 
 template<typename THistogram>
 const
 typename EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>::MeasurementObjectType*
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::GetCoarsenessOutput() const
 {
   return itkDynamicCastInDebugMode<const MeasurementObjectType*>(this->ProcessObject::GetOutput( 0 ) );
 }
 
 template<typename THistogram>
 const
 typename EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>::MeasurementObjectType*
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::GetContrastOutput() const
 {
   return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 1 ) );
 }
 
 template<typename THistogram>
 const
 typename EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>::MeasurementObjectType*
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::GetBusynessOutput() const
 {
   return itkDynamicCastInDebugMode<const MeasurementObjectType*>(this->ProcessObject::GetOutput( 2 ) );
 }
 
 template<typename THistogram>
 const
 typename EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>::MeasurementObjectType*
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::GetComplexityOutput() const
 {
   return itkDynamicCastInDebugMode<const MeasurementObjectType*>(this->ProcessObject::GetOutput( 3 ) );
 }
 
 template<typename THistogram>
 const
 typename EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>::MeasurementObjectType*
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::GetStrengthOutput() const
 {
   return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 4 ) );
 }
 
 
 template<typename THistogram>
 typename EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>::MeasurementType
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::GetCoarseness() const
 {
   return this->GetCoarsenessOutput()->Get();
 }
 
 template<typename THistogram>
 typename EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>::MeasurementType
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::GetContrast() const
 {
   return this->GetContrastOutput()->Get();
 }
 
 template<typename THistogram>
 typename EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>::MeasurementType
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::GetBusyness() const
 {
   return this->GetBusynessOutput()->Get();
 }
 
 template<typename THistogram>
 typename EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>::MeasurementType
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::GetComplexity() const
 {
   return this->GetComplexityOutput()->Get();
 }
 
 template<typename THistogram>
 typename EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>::MeasurementType
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::GetStrength() const
 {
   return this->GetStrengthOutput()->Get();
 }
 
 
 template<typename THistogram>
 typename EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter< THistogram>::MeasurementType
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter<THistogram>
 ::GetFeature( NeighbourhoodGreyLevelDifferenceFeatureName feature )
 {
   switch( feature )
   {
   case Coarseness:
     return this->GetCoarseness();
   case Contrast:
     return this->GetContrast();
   case Busyness:
     return this->GetBusyness();
   case Complexity:
     return this->GetComplexity();
   case Strength:
     return this->GetStrength();
   default:
     return 0;
   }
 }
 
 template< typename THistogram>
 void
 EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter< THistogram>::
 PrintSelf(std::ostream& os, Indent indent) const
 {
   Superclass::PrintSelf( os,indent );
 }
 } // end of namespace Statistics
 } // end of namespace itk
 
 #endif
diff --git a/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToRunLengthFeaturesFilter.hxx b/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToRunLengthFeaturesFilter.hxx
index b405d40f8d..67d0cc5703 100644
--- a/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToRunLengthFeaturesFilter.hxx
+++ b/Modules/Classification/CLUtilities/include/itkEnhancedHistogramToRunLengthFeaturesFilter.hxx
@@ -1,602 +1,602 @@
 /*===================================================================
 
 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 __itkEnhancedHistogramToRunLengthFeaturesFilter_hxx
 #define __itkEnhancedHistogramToRunLengthFeaturesFilter_hxx
 
 #include "itkEnhancedHistogramToRunLengthFeaturesFilter.h"
 
 #include "itkNumericTraits.h"
 #include "vnl/vnl_math.h"
 
 namespace itk {
   namespace Statistics {
     //constructor
     template<typename THistogram>
     EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::EnhancedHistogramToRunLengthFeaturesFilter() :
     m_NumberOfVoxels(1)
     {
       this->ProcessObject::SetNumberOfRequiredInputs( 1 );
 
       // allocate the data objects for the outputs which are
       // just decorators real types
       for( unsigned int i = 0; i < 15; i++ )
       {
         this->ProcessObject::SetNthOutput( i, this->MakeOutput( i ) );
       }
     }
 
     template<typename THistogram>
     void
       EnhancedHistogramToRunLengthFeaturesFilter< THistogram>
       ::SetInput( const HistogramType *histogram )
     {
       this->ProcessObject::SetNthInput( 0, const_cast<HistogramType*>( histogram ) );
     }
 
     template<typename THistogram>
     const typename
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::HistogramType *
       EnhancedHistogramToRunLengthFeaturesFilter< THistogram>
       ::GetInput() const
     {
       if ( this->GetNumberOfInputs() < 1 )
       {
         return ITK_NULLPTR;
       }
       return itkDynamicCastInDebugMode<const HistogramType *>(this->ProcessObject::GetInput( 0 ) );
     }
 
     template<typename THistogram>
     typename
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::DataObjectPointer
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::MakeOutput( DataObjectPointerArraySizeType itkNotUsed( idx ) )
     {
       return MeasurementObjectType::New().GetPointer();
     }
 
     template<typename THistogram>
     void
       EnhancedHistogramToRunLengthFeaturesFilter< THistogram>::
       GenerateData( void )
     {
       const HistogramType * inputHistogram = this->GetInput();
 
       this->m_TotalNumberOfRuns = static_cast<unsigned long>
         ( inputHistogram->GetTotalFrequency() );
 
       MeasurementType shortRunEmphasis = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType longRunEmphasis = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType greyLevelNonuniformity = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType runLengthNonuniformity = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType lowGreyLevelRunEmphasis = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType highGreyLevelRunEmphasis = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType shortRunLowGreyLevelEmphasis = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType shortRunHighGreyLevelEmphasis = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType longRunLowGreyLevelEmphasis = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType longRunHighGreyLevelEmphasis = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType runPercentage = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType numberOfRuns = NumericTraits<MeasurementType>::ZeroValue();
       //Added 15.07.2016
       MeasurementType greyLevelVariance = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType runLengthVariance = NumericTraits<MeasurementType>::ZeroValue();
       MeasurementType runEntropy = NumericTraits<MeasurementType>::ZeroValue();
 
       vnl_vector<double> greyLevelNonuniformityVector(
         inputHistogram->GetSize()[0], 0.0 );
       vnl_vector<double> runLengthNonuniformityVector(
         inputHistogram->GetSize()[1], 0.0 );
 
       typedef typename HistogramType::ConstIterator HistogramIterator;
 
       double mu_i = 0.0;
       double mu_j = 0.0;
 
       //Calculate the means.
       for ( HistogramIterator hit = inputHistogram->Begin();
         hit != inputHistogram->End(); ++hit )
       {
         MeasurementType frequency = hit.GetFrequency();
         if ( frequency == 0 )
         {
           continue;
         }
         MeasurementVectorType measurement = hit.GetMeasurementVector();
         IndexType index = hit.GetIndex();
 
         double i = index[0] + 1;
         double j = index[1] + 1;
 
         double p_ij = frequency / m_TotalNumberOfRuns;
 
         mu_i += i * p_ij;
         mu_j += j * p_ij;
       }
 
       //Calculate the other features.
       const double log2 = std::log(2.0);
 
       for ( HistogramIterator hit = inputHistogram->Begin();
         hit != inputHistogram->End(); ++hit )
       {
         MeasurementType frequency = hit.GetFrequency();
         if ( frequency == 0 )
         {
           continue;
         }
         MeasurementVectorType measurement = hit.GetMeasurementVector();
         IndexType index = hit.GetIndex();
         //      inputHistogram->GetIndex( hit.GetInstanceIdentifier() );
 
         double i2 = static_cast<double>( ( index[0] + 1 ) * ( index[0] + 1 ) );
         double j2 = static_cast<double>( ( index[1] + 1 ) * ( index[1] + 1 ) );
 
         double i = index[0] + 1;
         double j = index[1] + 1;
 
         double p_ij = frequency / m_TotalNumberOfRuns;
 
         greyLevelVariance += ((i - mu_i) * (i - mu_i) * p_ij);
         runLengthVariance += ((j - mu_j) * (j - mu_j) * p_ij);
         runEntropy -= ( p_ij > 0.0001 ) ? p_ij *std::log(p_ij) / log2 : 0;
 
         // Traditional measures
         shortRunEmphasis += ( frequency / j2 );
         longRunEmphasis += ( frequency * j2 );
 
         greyLevelNonuniformityVector[index[0]] += frequency;
         runLengthNonuniformityVector[index[1]] += frequency;
 
         // measures from Chu et al.
-        lowGreyLevelRunEmphasis += ( frequency / i2 );
-        highGreyLevelRunEmphasis += ( frequency * i2 );
+        lowGreyLevelZoneEmphasis += (i2 > 0.0001) ? ( frequency / i2 ) : 0;
+        highGreyLevelZoneEmphasis += ( frequency * i2 );
 
         // measures from Dasarathy and Holder
-        shortRunLowGreyLevelEmphasis += ( frequency / ( i2 * j2 ) );
-        shortRunHighGreyLevelEmphasis += ( frequency * i2 / j2 );
-        longRunLowGreyLevelEmphasis += ( frequency * j2 / i2 );
-        longRunHighGreyLevelEmphasis += ( frequency * i2 * j2 );
+        SmallZoneLowGreyLevelEmphasis += ((i2 * j2) > 0.0001) ? ( frequency / ( i2 * j2 ) ) : 0;
+        SmallZoneHighGreyLevelEmphasis += (j2 > 0.0001) ? ( frequency * i2 / j2 ) : 0;
+        LargeZoneLowGreyLevelEmphasis += (i2 = 0.0001) ? ( frequency * j2 / i2 ) : 0;
+        LargeZoneHighGreyLevelEmphasis += ( frequency * i2 * j2 );
       }
       greyLevelNonuniformity =
         greyLevelNonuniformityVector.squared_magnitude();
       runLengthNonuniformity =
         runLengthNonuniformityVector.squared_magnitude();
 
       // Normalize all measures by the total number of runs
 
       if (this->m_TotalNumberOfRuns > 0)
       {
         shortRunEmphasis       /=
           static_cast<double>( this->m_TotalNumberOfRuns );
         longRunEmphasis        /=
           static_cast<double>( this->m_TotalNumberOfRuns );
         greyLevelNonuniformity /=
           static_cast<double>( this->m_TotalNumberOfRuns );
         runLengthNonuniformity /=
           static_cast<double>( this->m_TotalNumberOfRuns );
 
         lowGreyLevelRunEmphasis /=
           static_cast<double>( this->m_TotalNumberOfRuns );
         highGreyLevelRunEmphasis /=
           static_cast<double>( this->m_TotalNumberOfRuns );
 
         shortRunLowGreyLevelEmphasis /=
           static_cast<double>( this->m_TotalNumberOfRuns );
         shortRunHighGreyLevelEmphasis /=
           static_cast<double>( this->m_TotalNumberOfRuns );
         longRunLowGreyLevelEmphasis /=
           static_cast<double>( this->m_TotalNumberOfRuns );
         longRunHighGreyLevelEmphasis /=
           static_cast<double>( this->m_TotalNumberOfRuns );
         runPercentage = static_cast<double>( this->m_TotalNumberOfRuns ) / static_cast<double>( this->m_NumberOfVoxels );
         numberOfRuns = static_cast<double>( this->m_TotalNumberOfRuns ) ;
       } else {
         shortRunEmphasis        = 0;
         longRunEmphasis         = 0;
         greyLevelNonuniformity  = 0;
         runLengthNonuniformity= 0;
 
         lowGreyLevelRunEmphasis  = 0;
         highGreyLevelRunEmphasis = 0;
 
         shortRunLowGreyLevelEmphasis = 0;
         shortRunHighGreyLevelEmphasis= 0;
         longRunLowGreyLevelEmphasis  = 0;
         longRunHighGreyLevelEmphasis = 0;
         runPercentage = 0;
         numberOfRuns = static_cast<double>( this->m_TotalNumberOfRuns ) ;
       }
 
       MeasurementObjectType* shortRunEmphasisOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 0 ) );
       shortRunEmphasisOutputObject->Set( shortRunEmphasis );
 
       MeasurementObjectType* longRunEmphasisOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 1 ) );
       longRunEmphasisOutputObject->Set( longRunEmphasis );
 
       MeasurementObjectType* greyLevelNonuniformityOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 2 ) );
       greyLevelNonuniformityOutputObject->Set( greyLevelNonuniformity );
 
       MeasurementObjectType* runLengthNonuniformityOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 3 ) );
       runLengthNonuniformityOutputObject->Set( runLengthNonuniformity );
 
       MeasurementObjectType* lowGreyLevelRunEmphasisOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 4 ) );
       lowGreyLevelRunEmphasisOutputObject->Set( lowGreyLevelRunEmphasis );
 
       MeasurementObjectType* highGreyLevelRunEmphasisOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 5 ) );
       highGreyLevelRunEmphasisOutputObject->Set( highGreyLevelRunEmphasis );
 
       MeasurementObjectType* shortRunLowGreyLevelEmphasisOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 6 ) );
       shortRunLowGreyLevelEmphasisOutputObject->Set( shortRunLowGreyLevelEmphasis );
 
       MeasurementObjectType* shortRunHighGreyLevelEmphasisOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 7 ) );
       shortRunHighGreyLevelEmphasisOutputObject->Set(
         shortRunHighGreyLevelEmphasis );
 
       MeasurementObjectType* longRunLowGreyLevelEmphasisOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 8 ) );
       longRunLowGreyLevelEmphasisOutputObject->Set( longRunLowGreyLevelEmphasis );
 
       MeasurementObjectType* longRunHighGreyLevelEmphasisOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 9 ) );
       longRunHighGreyLevelEmphasisOutputObject->Set( longRunHighGreyLevelEmphasis );
 
       MeasurementObjectType* runPercentagesOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 10 ) );
       runPercentagesOutputObject->Set( runPercentage );
 
       MeasurementObjectType* numberOfRunsOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 11 ) );
       numberOfRunsOutputObject->Set( numberOfRuns );
 
       MeasurementObjectType* greyLevelVarianceOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 12 ) );
       greyLevelVarianceOutputObject->Set( greyLevelVariance );
 
       MeasurementObjectType* runLengthVarianceOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 13 ) );
       runLengthVarianceOutputObject->Set( runLengthVariance );
 
       MeasurementObjectType* runEntropyOutputObject =
         static_cast<MeasurementObjectType*>( this->ProcessObject::GetOutput( 14 ) );
       runEntropyOutputObject->Set( runEntropy );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetShortRunEmphasisOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>(this->ProcessObject::GetOutput( 0 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetLongRunEmphasisOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 1 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetGreyLevelNonuniformityOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>(this->ProcessObject::GetOutput( 2 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetRunLengthNonuniformityOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>(this->ProcessObject::GetOutput( 3 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetLowGreyLevelRunEmphasisOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 4 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetHighGreyLevelRunEmphasisOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 5 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetShortRunLowGreyLevelEmphasisOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 6 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetShortRunHighGreyLevelEmphasisOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 7 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetLongRunLowGreyLevelEmphasisOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 8 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetLongRunHighGreyLevelEmphasisOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 9 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetRunPercentageOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 10 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetNumberOfRunsOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 11 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetGreyLevelVarianceOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 12 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetRunLengthVarianceOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 13 ) );
     }
 
     template<typename THistogram>
     const
       typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementObjectType*
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetRunEntropyOutput() const
     {
       return itkDynamicCastInDebugMode<const MeasurementObjectType*>( this->ProcessObject::GetOutput( 14 ) );
     }
 
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetShortRunEmphasis() const
     {
       return this->GetShortRunEmphasisOutput()->Get();
     }
 
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetLongRunEmphasis() const
     {
       return this->GetLongRunEmphasisOutput()->Get();
     }
 
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetGreyLevelNonuniformity() const
     {
       return this->GetGreyLevelNonuniformityOutput()->Get();
     }
 
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetRunLengthNonuniformity() const
     {
       return this->GetRunLengthNonuniformityOutput()->Get();
     }
 
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetLowGreyLevelRunEmphasis() const
     {
       return this->GetLowGreyLevelRunEmphasisOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetHighGreyLevelRunEmphasis() const
     {
       return this->GetHighGreyLevelRunEmphasisOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetShortRunLowGreyLevelEmphasis() const
     {
       return this->GetShortRunLowGreyLevelEmphasisOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetShortRunHighGreyLevelEmphasis() const
     {
       return this->GetShortRunHighGreyLevelEmphasisOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetLongRunLowGreyLevelEmphasis() const
     {
       return this->GetLongRunLowGreyLevelEmphasisOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetLongRunHighGreyLevelEmphasis() const
     {
       return this->GetLongRunHighGreyLevelEmphasisOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetRunPercentage() const
     {
       return this->GetRunPercentageOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetNumberOfRuns() const
     {
       return this->GetNumberOfRunsOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetGreyLevelVariance() const
     {
       return this->GetGreyLevelVarianceOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetRunLengthVariance() const
     {
       return this->GetRunLengthVarianceOutput()->Get();
     }
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter<THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetRunEntropy() const
     {
       return this->GetRunEntropyOutput()->Get();
     }
 
 
     template<typename THistogram>
     typename EnhancedHistogramToRunLengthFeaturesFilter< THistogram>::MeasurementType
       EnhancedHistogramToRunLengthFeaturesFilter<THistogram>
       ::GetFeature( RunLengthFeatureName feature )
     {
       switch( feature )
       {
       case ShortRunEmphasis:
         return this->GetShortRunEmphasis();
       case LongRunEmphasis:
         return this->GetLongRunEmphasis();
       case GreyLevelNonuniformity:
         return this->GetGreyLevelNonuniformity();
       case RunLengthNonuniformity:
         return this->GetRunLengthNonuniformity();
       case LowGreyLevelRunEmphasis:
         return this->GetLowGreyLevelRunEmphasis();
       case HighGreyLevelRunEmphasis:
         return this->GetHighGreyLevelRunEmphasis();
       case ShortRunLowGreyLevelEmphasis:
         return this->GetShortRunLowGreyLevelEmphasis();
       case ShortRunHighGreyLevelEmphasis:
         return this->GetShortRunHighGreyLevelEmphasis();
       case LongRunLowGreyLevelEmphasis:
         return this->GetLongRunLowGreyLevelEmphasis();
       case LongRunHighGreyLevelEmphasis:
         return this->GetLongRunHighGreyLevelEmphasis();
       case RunPercentage:
         return this->GetRunPercentage();
       case NumberOfRuns:
         return this->GetNumberOfRuns();
       case GreyLevelVariance:
         return this->GetGreyLevelVariance();
       case RunLengthVariance:
         return this->GetRunLengthVariance();
       case RunEntropy:
         return this->GetRunEntropy();
       default:
         return 0;
       }
     }
 
     template< typename THistogram>
     void
       EnhancedHistogramToRunLengthFeaturesFilter< THistogram>::
       PrintSelf(std::ostream& os, Indent indent) const
     {
       Superclass::PrintSelf( os,indent );
     }
   } // end of namespace Statistics
 } // end of namespace itk
 
 #endif
diff --git a/Modules/Classification/CLUtilities/src/GlobalImageFeatures/mitkGIFVolumetricStatistics.cpp b/Modules/Classification/CLUtilities/src/GlobalImageFeatures/mitkGIFVolumetricStatistics.cpp
index e9d0d9debe..6a21303883 100644
--- a/Modules/Classification/CLUtilities/src/GlobalImageFeatures/mitkGIFVolumetricStatistics.cpp
+++ b/Modules/Classification/CLUtilities/src/GlobalImageFeatures/mitkGIFVolumetricStatistics.cpp
@@ -1,307 +1,307 @@
 /*===================================================================
 
 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::GIFVolumetricStatistics::FeatureListType & featureList)
 {
   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());
   std::vector<PointType> borderPoints;
   while(!iterator.IsAtEnd())
   {
     if (iterator.GetCenterPixel() == 0)
     {
       ++iterator;
       continue;
     }
 
     bool border = false;
     for (int i = 0; i < (int)(iterator.Size()); ++i)
     {
       if (iterator.GetPixel(i) == 0)
       {
         border = true;
         break;
       }
     }
     if (border)
     {
       auto centerIndex = iterator.GetIndex();
       PointType centerPoint;
       mask->TransformIndexToPhysicalPoint(centerIndex, centerPoint );
       borderPoints.push_back(centerPoint);
     }
     ++iterator;
   }
 
   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));
 }
 
 mitk::GIFVolumetricStatistics::GIFVolumetricStatistics()
 {
 }
 
 mitk::GIFVolumetricStatistics::FeatureListType mitk::GIFVolumetricStatistics::CalculateFeatures(const Image::Pointer & image, const Image::Pointer &mask)
 {
   FeatureListType featureList;
 
   AccessByItk_2(image, CalculateVolumeStatistic, mask, featureList);
   AccessByItk_1(mask, CalculateLargestDiameter, featureList);
 
   vtkSmartPointer<vtkImageMarchingCubes> mesher = vtkSmartPointer<vtkImageMarchingCubes>::New();
   vtkSmartPointer<vtkMassProperties> stats = vtkSmartPointer<vtkMassProperties>::New();
   mesher->SetInputData(mask->GetVtkImageData());
   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 compactness1 = pixelVolume / ( std::sqrt(pi) * std::pow(meshSurf, 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 compactness3 = pixelVolume / ( std::sqrt(pi) * std::pow(meshSurf, 3.0/2.0));
 
   double sphericity=std::pow(pi,1/3.0) *std::pow(6*pixelVolume, 2.0/3.0) / meshSurf;
   double surfaceToVolume = meshSurf / pixelVolume;
   double sphericalDisproportion = meshSurf / 4 / pi / std::pow(3.0 / 4.0 / pi * pixelVolume, 2.0 / 3.0);
   double asphericity = std::pow(compactness2,(-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];
 
   mitk::Point3D geom;
   mitk::Point3D weighted;
   unsigned int noOfPx = 0;
   double totalGrayValue = 0.0;
 
   std::vector<cv::Point3d> pointsForPCA;
 
   MITK_WARN << xx << "  " << yy << "  " << zz;
   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)
         {
           geom[0] += x;
           geom[1] += y;
           geom[2] += z;
 
           weighted[0] += pxImage*x;
           weighted[1] += pxImage*y;
           weighted[2] += pxImage*z;
 
           noOfPx++;
           totalGrayValue += pxImage;
 
           cv::Point3d tmp;
           tmp.x = x;
           tmp.y = y;
           tmp.z = z;
 
           pointsForPCA.push_back(tmp);
         }
 
       }
     }
   }
 
   geom[0] = geom[0] / noOfPx;
   geom[1] = geom[1] / noOfPx;
   geom[2] = geom[2] / noOfPx;
 
   weighted[0] = weighted[0] / totalGrayValue;
   weighted[1] = weighted[1] / totalGrayValue;
   weighted[2] = weighted[2] / totalGrayValue;
 
   double shift = std::sqrt(
         (geom[0] - weighted[0])*(geom[0] - weighted[0])
         + (geom[1] - weighted[1])*(geom[1] - weighted[1])
         + (geom[2] - weighted[2])*(geom[2] - weighted[2])
         );
 
   //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;
   }
 
   //Perform PCA analysis
   cv::PCA pca_analysis(data_pts, cv::Mat(), CV_PCA_DATA_AS_ROW);
 
   //Store the eigenvalues
   std::vector<double> eigen_val(3);
   for (int i = 0; i < 3; ++i)
   {
       eigen_val[i] = pca_analysis.eigenvalues.at<double>(0, i);
   }
 
   std::sort (eigen_val.begin(), eigen_val.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;
 
 
   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 Center of mass Shift",shift));
   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 Flatnes",flatness));
+  featureList.push_back(std::make_pair("Volumetric Features PCA Flatness",flatness));
 
 
   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;
 }