diff --git a/Modules/Classification/CLUtilities/src/GlobalImageFeatures/mitkGIFLocalIntensity.cpp b/Modules/Classification/CLUtilities/src/GlobalImageFeatures/mitkGIFLocalIntensity.cpp
index 541d8dc82b..0690a13369 100644
--- a/Modules/Classification/CLUtilities/src/GlobalImageFeatures/mitkGIFLocalIntensity.cpp
+++ b/Modules/Classification/CLUtilities/src/GlobalImageFeatures/mitkGIFLocalIntensity.cpp
@@ -1,201 +1,201 @@
 /*===================================================================
 
 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 <mitkGIFLocalIntensity.h>
 
 // MITK
 #include <mitkITKImageImport.h>
 #include <mitkImageCast.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkPixelTypeMultiplex.h>
 #include <mitkImagePixelReadAccessor.h>
 
 // ITK
 #include <itkImageRegionIteratorWithIndex.h>
 #include <itkNeighborhoodIterator.h>
 #include <itkLocalIntensityFilter.h>
 
 // STL
 #include <limits>
 
 struct GIFLocalIntensityParameter
 {
   double range;
   std::string prefix;
 };
 
 
 template<typename TPixel, unsigned int VImageDimension>
 static void
 CalculateIntensityPeak(itk::Image<TPixel, VImageDimension>* itkImage, mitk::Image::Pointer mask, mitk::GIFLocalIntensity::FeatureListType & featureList, GIFLocalIntensityParameter params)
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef itk::Image<unsigned short, VImageDimension> MaskType;
 
   typename MaskType::Pointer itkMask = MaskType::New();
   mitk::CastToItkImage(mask, itkMask);
 
   double range = params.range;
   //double minimumSpacing = 1;
   //typename ImageType::SizeType regionSize;
   //int offset = std::ceil(range / minimumSpacing);
   //regionSize.Fill(1);
   //for (unsigned int i = 0; i < VImageDimension; ++i)
   //{
   //  minimumSpacing = itkImage->GetSpacing()[i];
   //  offset = std::ceil(range / minimumSpacing);
   //  regionSize[i] = offset;
   //}
 
   //itk::NeighborhoodIterator<ImageType> iter(regionSize, itkImage, itkImage->GetLargestPossibleRegion());
   //itk::NeighborhoodIterator<MaskType> iterMask(regionSize, itkMask, itkMask->GetLargestPossibleRegion());
 
   //typename ImageType::PointType origin;
   //typename ImageType::PointType localPoint;
   //itk::Index<VImageDimension> index;
 
   //double tmpPeakValue;
   //double globalPeakValue = 0;
   //double localPeakValue = 0;
   //TPixel localMaximum = 0;
 
   //std::vector<bool> vectorIsInRange;
   //index = iter.GetIndex();
   //itkImage->TransformIndexToPhysicalPoint(index, origin);
   //for (itk::SizeValueType i = 0; i < iter.Size(); ++i)
   //{
   //  itkImage->TransformIndexToPhysicalPoint(iter.GetIndex(i), localPoint);
   //  double dist = origin.EuclideanDistanceTo(localPoint);
   //  vectorIsInRange.push_back((dist < params.range));
   //}
 
   //int count = 0;
   //bool inbounds = true;
 
   //iter.NeedToUseBoundaryConditionOff();
   //iterMask.NeedToUseBoundaryConditionOff();
 
   //while (!iter.IsAtEnd())
   //{
   //  if (iterMask.GetCenterPixel() > 0)
   //  {
   //    tmpPeakValue = 0;
   //    count = 0;
   //    for (itk::SizeValueType i = 0; i < iter.Size(); ++i)
   //    {
   //      if (vectorIsInRange[i] )
   //      {
   //        if (iter.IndexInBounds(i))
   //        {
   //          tmpPeakValue += iter.GetPixel(i);
   //          ++count;
   //        }
   //      }
   //    }
   //    tmpPeakValue /= count;
   //    globalPeakValue = std::max<double>(tmpPeakValue, globalPeakValue);
   //    auto currentCenterPixelValue = iter.GetCenterPixel();
   //    if (localMaximum == currentCenterPixelValue)
   //    {
   //      localPeakValue = std::max<double>(tmpPeakValue,localPeakValue);
   //    }
   //    else if (localMaximum < currentCenterPixelValue)
   //    {
   //      localMaximum = currentCenterPixelValue;
   //      localPeakValue = tmpPeakValue;
   //    }
   //  }
   //  ++iterMask;
   //  ++iter;
   //}
 
-  itk::LocalIntensityFilter<ImageType>::Pointer filter = itk::LocalIntensityFilter<ImageType>::New();
+  typename itk::LocalIntensityFilter<ImageType>::Pointer filter = itk::LocalIntensityFilter<ImageType>::New();
   filter->SetInput(itkImage);
   filter->SetMask(itkMask);
   filter->SetRange(range);
   filter->Update();
 
   featureList.push_back(std::make_pair(params.prefix + "2. Local Intensity Peak", filter->GetLocalPeak()));
   featureList.push_back(std::make_pair(params.prefix + "2. Global Intensity Peak", filter->GetGlobalPeak()));
 }
 
 
 mitk::GIFLocalIntensity::GIFLocalIntensity() :
 m_Range(6.2)
 {
   SetLongName("local-intensity");
   SetShortName("loci");
   SetFeatureClassName("Local Intensity");
 }
 
 mitk::GIFLocalIntensity::FeatureListType mitk::GIFLocalIntensity::CalculateFeatures(const Image::Pointer & image, const Image::Pointer &mask)
 {
   FeatureListType featureList;
   if (image->GetDimension() < 3)
   {
     return featureList;
   }
   GIFLocalIntensityParameter params;
   params.range = GetRange();
   params.prefix = FeatureDescriptionPrefix();
   AccessByItk_3(image, CalculateIntensityPeak, mask, featureList, params);
   return featureList;
 }
 
 mitk::GIFLocalIntensity::FeatureNameListType mitk::GIFLocalIntensity::GetFeatureNames()
 {
   FeatureNameListType featureList;
   return featureList;
 }
 
 
 void mitk::GIFLocalIntensity::AddArguments(mitkCommandLineParser &parser)
 {
   std::string name = GetOptionPrefix();
 
   parser.addArgument(GetLongName(), name, mitkCommandLineParser::Bool, "Use Local Intensity", "calculates local intensity based features", us::Any());
   parser.addArgument(name + "::range", name+"::range", mitkCommandLineParser::Float, "Range for the local intensity", "Give the range that should be used for the local intensity in mm", us::Any());
 }
 
 void
 mitk::GIFLocalIntensity::CalculateFeaturesUsingParameters(const Image::Pointer & feature, const Image::Pointer &mask, const Image::Pointer &, FeatureListType &featureList)
 {
   std::string name = GetOptionPrefix();
   auto parsedArgs = GetParameter();
   if (parsedArgs.count(GetLongName()))
   {
     if (parsedArgs.count(name + "::range"))
     {
       double range = us::any_cast<float>(parsedArgs[name + "::range"]);
       this->SetRange(range);
     }
     MITK_INFO << "Start calculating local intensity features ....";
     auto localResults = this->CalculateFeatures(feature, mask);
     featureList.insert(featureList.end(), localResults.begin(), localResults.end());
     MITK_INFO << "Finished calculating local intensity features....";
   }
 }
 
 std::string mitk::GIFLocalIntensity::GetCurrentFeatureEncoding()
 {
   std::ostringstream  ss;
   ss << m_Range;
   std::string strRange = ss.str();
   return "Range-" + ss.str();
 }