diff --git a/Modules/ImageStatistics/mitkIntensityProfile.cpp b/Modules/ImageStatistics/mitkIntensityProfile.cpp
index 07c140686a..f7e6d1491d 100644
--- a/Modules/ImageStatistics/mitkIntensityProfile.cpp
+++ b/Modules/ImageStatistics/mitkIntensityProfile.cpp
@@ -1,387 +1,387 @@
 /*===================================================================
 
 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 <itkLinearInterpolateImageFunction.h>
 #include <itkNearestNeighborInterpolateImageFunction.h>
 #include <itkPolyLineParametricPath.h>
 #include <itkWindowedSincInterpolateImageFunction.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkPixelTypeMultiplex.h>
 #include <mitkImageStatisticsContainer.h>
 #include "mitkIntensityProfile.h"
 
 using namespace mitk;
 
 template <class T>
-static void ReadPixel(const PixelType&, const Image* image, const itk::Index<3>& index, ScalarType* returnValue)
+static void ReadPixel(const PixelType&, Image::Pointer image, const itk::Index<3>& index, ScalarType* returnValue)
 {
   switch (image->GetDimension())
   {
   case 2:
     {
       ImagePixelReadAccessor<T, 2> readAccess(image, image->GetSliceData(0));
       *returnValue = readAccess.GetPixelByIndex(reinterpret_cast<const itk::Index<2>&>(index));
       break;
     }
 
   case 3:
     {
       ImagePixelReadAccessor<T, 3> readAccess(image, image->GetVolumeData(0));
       *returnValue = readAccess.GetPixelByIndex(index);
       break;
     }
 
   default:
     *returnValue = 0;
     break;
   }
 }
 
-static const IntensityProfile* ComputeIntensityProfile(const Image* image, const itk::PolyLineParametricPath<3>* path)
+static IntensityProfile::Pointer ComputeIntensityProfile(Image::Pointer image, itk::PolyLineParametricPath<3>::Pointer path)
 {
   if (image->GetDimension() == 4)
   {
     mitkThrow() << "computation of intensity profiles not supported for 4D images";
   }
 
   IntensityProfile::Pointer intensityProfile = IntensityProfile::New();
   itk::PolyLineParametricPath<3>::InputType input = path->StartOfInput();
   BaseGeometry* imageGeometry = image->GetGeometry();
   const PixelType pixelType = image->GetPixelType();
 
   IntensityProfile::MeasurementVectorType measurementVector;
   itk::PolyLineParametricPath<3>::OffsetType offset;
   Point3D worldPoint;
   itk::Index<3> index;
 
   do
   {
     imageGeometry->IndexToWorld(path->Evaluate(input), worldPoint);
     imageGeometry->WorldToIndex(worldPoint, index);
 
     mitkPixelTypeMultiplex3(ReadPixel, pixelType, image, index, measurementVector.GetDataPointer());
     intensityProfile->PushBack(measurementVector);
 
     offset = path->IncrementInput(input);
   } while ((offset[0] | offset[1] | offset[2]) != 0);
 
   return intensityProfile;
 }
 
 template <class TInputImage>
 static typename itk::InterpolateImageFunction<TInputImage>::Pointer CreateInterpolateImageFunction(InterpolateImageFunction::Enum interpolator)
 {
   switch (interpolator)
   {
   case InterpolateImageFunction::NearestNeighbor:
     return itk::NearestNeighborInterpolateImageFunction<TInputImage>::New().GetPointer();
 
   case InterpolateImageFunction::Linear:
     return itk::LinearInterpolateImageFunction<TInputImage>::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Blackman_3:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 3, itk::Function::BlackmanWindowFunction<3> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Blackman_4:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 4, itk::Function::BlackmanWindowFunction<4> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Blackman_5:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 5, itk::Function::BlackmanWindowFunction<5> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Cosine_3:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 3, itk::Function::CosineWindowFunction<3> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Cosine_4:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 4, itk::Function::CosineWindowFunction<4> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Cosine_5:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 5, itk::Function::CosineWindowFunction<5> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Hamming_3:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 3, itk::Function::HammingWindowFunction<3> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Hamming_4:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 4, itk::Function::HammingWindowFunction<4> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Hamming_5:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 5, itk::Function::HammingWindowFunction<5> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Lanczos_3:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 3, itk::Function::LanczosWindowFunction<3> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Lanczos_4:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 4, itk::Function::LanczosWindowFunction<4> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Lanczos_5:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 5, itk::Function::LanczosWindowFunction<5> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Welch_3:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 3, itk::Function::WelchWindowFunction<3> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Welch_4:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 4, itk::Function::WelchWindowFunction<4> >::New().GetPointer();
 
   case InterpolateImageFunction::WindowedSinc_Welch_5:
     return itk::WindowedSincInterpolateImageFunction<TInputImage, 5, itk::Function::WelchWindowFunction<5> >::New().GetPointer();
 
   default:
     return itk::NearestNeighborInterpolateImageFunction<TInputImage>::New().GetPointer();
   }
 }
 
 template <class TPixel, unsigned int VImageDimension>
-static void ComputeIntensityProfile(const itk::Image<TPixel, VImageDimension>* image, const itk::PolyLineParametricPath<3>* path, unsigned int numSamples, InterpolateImageFunction::Enum interpolator, IntensityProfile* intensityProfile)
+static void ComputeIntensityProfile(itk::Image<TPixel, VImageDimension>* image, itk::PolyLineParametricPath<3>::Pointer path, unsigned int numSamples, InterpolateImageFunction::Enum interpolator, IntensityProfile::Pointer intensityProfile)
 {
   typename itk::InterpolateImageFunction<itk::Image<TPixel, VImageDimension> >::Pointer interpolateImageFunction = CreateInterpolateImageFunction<itk::Image<TPixel, VImageDimension> >(interpolator);
   interpolateImageFunction->SetInputImage(image);
 
   const itk::PolyLineParametricPath<3>::InputType startOfInput = path->StartOfInput();
   const itk::PolyLineParametricPath<3>::InputType delta = 1.0 / (numSamples - 1);
 
   IntensityProfile::MeasurementVectorType measurementVector;
 
   for (unsigned int i = 0; i < numSamples; ++i)
   {
     measurementVector[0] = interpolateImageFunction->EvaluateAtContinuousIndex(path->Evaluate(startOfInput + i * delta));
     intensityProfile->PushBack(measurementVector);
   }
 }
 
-static const IntensityProfile* ComputeIntensityProfile(const Image* image, const itk::PolyLineParametricPath<3>* path, unsigned int numSamples, InterpolateImageFunction::Enum interpolator)
+static IntensityProfile::Pointer ComputeIntensityProfile(Image::Pointer image, itk::PolyLineParametricPath<3>::Pointer path, unsigned int numSamples, InterpolateImageFunction::Enum interpolator)
 {
   IntensityProfile::Pointer intensityProfile = IntensityProfile::New();
-  AccessFixedDimensionByItk_n(image, ComputeIntensityProfile, 3, (path, numSamples, interpolator, intensityProfile.GetPointer()));
-  return intensityProfile.GetPointer();
+  AccessFixedDimensionByItk_n(image, ComputeIntensityProfile, 3, (path, numSamples, interpolator, intensityProfile));
+  return intensityProfile;
 }
 
 class AddPolyLineElementToPath
 {
 public:
   AddPolyLineElementToPath(const PlaneGeometry* planarFigureGeometry, const BaseGeometry* imageGeometry, itk::PolyLineParametricPath<3>::Pointer path)
     : m_PlanarFigureGeometry(planarFigureGeometry),
       m_ImageGeometry(imageGeometry),
       m_Path(path)
   {
   }
 
   void operator()(const PlanarFigure::PolyLineElement& polyLineElement)
   {
     m_PlanarFigureGeometry->Map(polyLineElement, m_WorldPoint);
     m_ImageGeometry->WorldToIndex(m_WorldPoint, m_ContinuousIndexPoint);
     m_Vertex.CastFrom(m_ContinuousIndexPoint);
     m_Path->AddVertex(m_Vertex);
   }
 
 private:
   const PlaneGeometry* m_PlanarFigureGeometry;
   const BaseGeometry* m_ImageGeometry;
   itk::PolyLineParametricPath<3>::Pointer m_Path;
 
   Point3D m_WorldPoint;
   Point3D m_ContinuousIndexPoint;
   itk::PolyLineParametricPath<3>::ContinuousIndexType m_Vertex;
 };
 
-static const itk::PolyLineParametricPath<3>* CreatePathFromPlanarFigure(const BaseGeometry* imageGeometry, const PlanarFigure* planarFigure)
+static itk::PolyLineParametricPath<3>::Pointer CreatePathFromPlanarFigure(BaseGeometry* imageGeometry, PlanarFigure* planarFigure)
 {
   itk::PolyLineParametricPath<3>::Pointer path = itk::PolyLineParametricPath<3>::New();
   const PlanarFigure::PolyLineType polyLine = planarFigure->GetPolyLine(0);
 
   std::for_each(polyLine.begin(), polyLine.end(),
     AddPolyLineElementToPath(planarFigure->GetPlaneGeometry(), imageGeometry, path));
 
   return path;
 }
 
 static void AddPointToPath(const BaseGeometry* imageGeometry, const Point3D& point, itk::PolyLineParametricPath<3>::Pointer path)
 {
   Point3D continuousIndexPoint;
   imageGeometry->WorldToIndex(point, continuousIndexPoint);
 
   itk::PolyLineParametricPath<3>::ContinuousIndexType vertex;
   vertex.CastFrom(continuousIndexPoint);
 
   path->AddVertex(vertex);
 }
 
 static itk::PolyLineParametricPath<3>::Pointer CreatePathFromPoints(BaseGeometry* imageGeometry, const Point3D& startPoint, const Point3D& endPoint)
 {
   itk::PolyLineParametricPath<3>::Pointer path = itk::PolyLineParametricPath<3>::New();
 
   AddPointToPath(imageGeometry, startPoint, path);
   AddPointToPath(imageGeometry, endPoint, path);
 
   return path;
 }
 
-const IntensityProfile* mitk::ComputeIntensityProfile(const Image* image, const PlanarFigure* planarFigure)
+IntensityProfile::Pointer mitk::ComputeIntensityProfile(Image::Pointer image, PlanarFigure::Pointer planarFigure)
 {
   return ::ComputeIntensityProfile(image, CreatePathFromPlanarFigure(image->GetGeometry(), planarFigure));
 }
 
-const IntensityProfile* mitk::ComputeIntensityProfile(const Image* image, const PlanarLine* planarLine, unsigned int numSamples, InterpolateImageFunction::Enum interpolator)
+IntensityProfile::Pointer mitk::ComputeIntensityProfile(Image::Pointer image, PlanarLine::Pointer planarLine, unsigned int numSamples, InterpolateImageFunction::Enum interpolator)
 {
-  return ::ComputeIntensityProfile(image, CreatePathFromPlanarFigure(image->GetGeometry(), planarLine), numSamples, interpolator);
+  return ::ComputeIntensityProfile(image, CreatePathFromPlanarFigure(image->GetGeometry(), planarLine.GetPointer()), numSamples, interpolator);
 }
 
-const IntensityProfile* mitk::ComputeIntensityProfile(const Image* image, const Point3D& startPoint, const Point3D& endPoint, unsigned int numSamples, InterpolateImageFunction::Enum interpolator)
+IntensityProfile::Pointer mitk::ComputeIntensityProfile(Image::Pointer image, const Point3D& startPoint, const Point3D& endPoint, unsigned int numSamples, InterpolateImageFunction::Enum interpolator)
 {
   return ::ComputeIntensityProfile(image, CreatePathFromPoints(image->GetGeometry(), startPoint, endPoint), numSamples, interpolator);
 }
 
 IntensityProfile::InstanceIdentifier mitk::ComputeGlobalMaximum(IntensityProfile::ConstPointer intensityProfile, IntensityProfile::MeasurementType &max)
 {
   max = -vcl_numeric_limits<IntensityProfile::MeasurementType>::min();
   IntensityProfile::InstanceIdentifier maxIndex = 0;
 
   IntensityProfile::ConstIterator end = intensityProfile->End();
   IntensityProfile::MeasurementType measurement;
 
   for (IntensityProfile::ConstIterator it = intensityProfile->Begin(); it != end; ++it)
   {
     measurement = it.GetMeasurementVector()[0];
 
     if (measurement > max)
     {
       max = measurement;
       maxIndex = it.GetInstanceIdentifier();
     }
   }
 
   return maxIndex;
 }
 
 IntensityProfile::InstanceIdentifier mitk::ComputeGlobalMinimum(IntensityProfile::ConstPointer intensityProfile, IntensityProfile::MeasurementType &min)
 {
   min = vcl_numeric_limits<IntensityProfile::MeasurementType>::max();
   IntensityProfile::InstanceIdentifier minIndex = 0;
 
   IntensityProfile::ConstIterator end = intensityProfile->End();
   IntensityProfile::MeasurementType measurement;
 
   for (IntensityProfile::ConstIterator it = intensityProfile->Begin(); it != end; ++it)
   {
     measurement = it.GetMeasurementVector()[0];
 
     if (measurement < min)
     {
       min = measurement;
       minIndex = it.GetInstanceIdentifier();
     }
   }
 
   return minIndex;
 }
 
 IntensityProfile::InstanceIdentifier mitk::ComputeCenterOfMaximumArea(IntensityProfile::ConstPointer intensityProfile, IntensityProfile::InstanceIdentifier radius)
 {
   //const IntensityProfile::MeasurementType min = intensityProfile->GetMeasurementVector(ComputeGlobalMinimum(intensityProfile))[0];
   IntensityProfile::MeasurementType min;
   ComputeGlobalMinimum(intensityProfile, min);
   const IntensityProfile::InstanceIdentifier areaWidth = 1 + 2 * radius;
 
   IntensityProfile::MeasurementType maxArea = 0;
 
   for (IntensityProfile::InstanceIdentifier i = 0; i < areaWidth; ++i)
     maxArea += intensityProfile->GetMeasurementVector(i)[0] - min;
 
   const IntensityProfile::InstanceIdentifier lastIndex = intensityProfile->Size() - areaWidth;
   IntensityProfile::InstanceIdentifier centerOfMaxArea = radius;
   IntensityProfile::MeasurementType area = maxArea;
 
   for (IntensityProfile::InstanceIdentifier i = 1; i <= lastIndex; ++i)
   {
     area += intensityProfile->GetMeasurementVector(i + areaWidth - 1)[0] - min;
     area -= intensityProfile->GetMeasurementVector(i - 1)[0] - min;
 
     if (area > maxArea)
     {
       maxArea = area;
       centerOfMaxArea = i + radius; // TODO: If multiple areas in the neighborhood have the same intensity chose the middle one instead of the first one.
     }
   }
 
   return centerOfMaxArea;
 }
 
 std::vector<IntensityProfile::MeasurementType> mitk::CreateVectorFromIntensityProfile(IntensityProfile::ConstPointer intensityProfile)
 {
   std::vector<IntensityProfile::MeasurementType> result;
   result.reserve(intensityProfile->Size());
 
   IntensityProfile::ConstIterator end = intensityProfile->End();
 
   for (IntensityProfile::ConstIterator it = intensityProfile->Begin(); it != end; ++it)
     result.push_back(it.GetMeasurementVector()[0]);
 
   return result;
 }
 
 IntensityProfile::Pointer mitk::CreateIntensityProfileFromVector(const std::vector<IntensityProfile::MeasurementType>& vector)
 {
   const IntensityProfile::InstanceIdentifier size = vector.size();
 
   IntensityProfile::Pointer result = IntensityProfile::New();
   result->Resize(size);
 
   for (IntensityProfile::InstanceIdentifier i = 0; i < size; ++i)
     result->SetMeasurement(i, 0, vector[i]);
 
   return result;
 }
 
 void mitk::ComputeIntensityProfileStatistics(IntensityProfile::ConstPointer intensityProfile, ImageStatisticsContainer::ImageStatisticsObject& stats)
 {
   typedef std::vector<IntensityProfile::MeasurementType> StatsVecType;
 
   StatsVecType statsVec = mitk::CreateVectorFromIntensityProfile( intensityProfile );
 
   IntensityProfile::MeasurementType min;
   IntensityProfile::MeasurementType max;
   mitk::ComputeGlobalMinimum( intensityProfile, min );
   mitk::ComputeGlobalMaximum( intensityProfile, max );
   auto numSamples = static_cast<mitk::ImageStatisticsContainer::VoxelCountType>(statsVec.size());
 
   double mean = 0.0;
   double rms = 0.0;
   for ( StatsVecType::const_iterator it = statsVec.begin(); it != statsVec.end(); ++it )
   {
     double val = *it;
     mean += val;
     rms += val*val;
   }
   mean /= static_cast<double>(numSamples);
   rms /= static_cast<double>(numSamples);
 
   double var = 0.0;
   for ( StatsVecType::const_iterator it = statsVec.begin(); it != statsVec.end(); ++it )
   {
     double diff = *it - mean;
     var += diff*diff;
   }
   var /= (static_cast<double>(numSamples) - 1 );
 
   rms = sqrt( rms );
 
   stats.AddStatistic(mitk::ImageStatisticsConstants::MINIMUM(), min);
   stats.AddStatistic(mitk::ImageStatisticsConstants::MAXIMUM(), max);
   stats.AddStatistic(mitk::ImageStatisticsConstants::NUMBEROFVOXELS(), numSamples);
   stats.AddStatistic(mitk::ImageStatisticsConstants::MEAN(), mean);
   stats.AddStatistic(mitk::ImageStatisticsConstants::STANDARDDEVIATION(), sqrt(var));
   stats.AddStatistic(mitk::ImageStatisticsConstants::VARIANCE(), var);
   stats.AddStatistic(mitk::ImageStatisticsConstants::RMS(), rms);
 }
diff --git a/Modules/ImageStatistics/mitkIntensityProfile.h b/Modules/ImageStatistics/mitkIntensityProfile.h
index 421716195f..361ef34268 100644
--- a/Modules/ImageStatistics/mitkIntensityProfile.h
+++ b/Modules/ImageStatistics/mitkIntensityProfile.h
@@ -1,139 +1,139 @@
 /*===================================================================
 
 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 mitkIntensityProfile_h
 #define mitkIntensityProfile_h
 
 #include <itkListSample.h>
 #include <mitkImage.h>
 #include <mitkPlanarLine.h>
 #include <mitkImageStatisticsCalculator.h>
 #include <MitkImageStatisticsExports.h>
 
 namespace mitk
 {
   typedef itk::Statistics::ListSample<itk::Statistics::MeasurementVectorPixelTraits<ScalarType>::MeasurementVectorType> IntensityProfile;
 
   /** \brief Compute intensity profile of an image for each pixel along the first PolyLine of a given planar figure.
     *
     * \param[in] image A two or three-dimensional image which consists of single component pixels.
     * \param[in] planarFigure A planar figure from which the first PolyLine is used to evaluate the intensity profile.
     *
     * \return The computed intensity profile.
     */
-  MITKIMAGESTATISTICS_EXPORT const IntensityProfile* ComputeIntensityProfile(const Image* image, const PlanarFigure* planarFigure);
+  MITKIMAGESTATISTICS_EXPORT IntensityProfile::Pointer ComputeIntensityProfile(Image::Pointer image, PlanarFigure::Pointer planarFigure);
 
   namespace InterpolateImageFunction
   {
     enum Enum
     {
       NearestNeighbor,
       Linear,
       WindowedSinc_Blackman_3,
       WindowedSinc_Blackman_4,
       WindowedSinc_Blackman_5,
       WindowedSinc_Cosine_3,
       WindowedSinc_Cosine_4,
       WindowedSinc_Cosine_5,
       WindowedSinc_Hamming_3,
       WindowedSinc_Hamming_4,
       WindowedSinc_Hamming_5,
       WindowedSinc_Lanczos_3,
       WindowedSinc_Lanczos_4,
       WindowedSinc_Lanczos_5,
       WindowedSinc_Welch_3,
       WindowedSinc_Welch_4,
       WindowedSinc_Welch_5
     };
   }
 
   /** \brief Compute intensity profile of an image for each sample along a planar line.
     *
     * \param[in] image A three-dimensional image which consists of single component pixels.
     * \param[in] planarLine A planar line along which the intensity profile will be evaluated.
     * \param[in] numSamples Number of samples along the planar line (must be at least 2).
     * \param[in] interpolator Image interpolation function which is used to read each sample.
     * \throw if image is 4D
     *
     * \return The computed intensity profile.
     */
-  MITKIMAGESTATISTICS_EXPORT const IntensityProfile* ComputeIntensityProfile(const Image* image, const PlanarLine* planarLine, unsigned int numSamples, InterpolateImageFunction::Enum interpolator = InterpolateImageFunction::NearestNeighbor);
+  MITKIMAGESTATISTICS_EXPORT IntensityProfile::Pointer ComputeIntensityProfile(Image::Pointer image, PlanarLine::Pointer planarLine, unsigned int numSamples, InterpolateImageFunction::Enum interpolator = InterpolateImageFunction::NearestNeighbor);
 
   /** \brief Compute intensity profile of an image for each sample between two points.
     *
     * \param[in] image A three-dimensional image which consists of single component pixels.
     * \param[in] startPoint A point at which the first sample is to be read.
     * \param[in] endPoint A point at which the last sample is to be read.
     * \param[in] numSamples Number of samples between startPoint and endPoint (must be at least 2).
     * \param[in] interpolator Image interpolation function which is used to read each sample.
    * \throw if image is 4D
     *
     * \return The computed intensity profile.
     */
-  MITKIMAGESTATISTICS_EXPORT const IntensityProfile* ComputeIntensityProfile(const Image* image, const Point3D& startPoint, const Point3D& endPoint, unsigned int numSamples, InterpolateImageFunction::Enum interpolator = InterpolateImageFunction::NearestNeighbor);
+  MITKIMAGESTATISTICS_EXPORT IntensityProfile::Pointer ComputeIntensityProfile(Image::Pointer image, const Point3D& startPoint, const Point3D& endPoint, unsigned int numSamples, InterpolateImageFunction::Enum interpolator = InterpolateImageFunction::NearestNeighbor);
 
   /** \brief Compute global maximum of an intensity profile.
     *
     * \param[in] intensityProfile An intensity profile.
     *
     * \return Index of the global maximum.
     */
   MITKIMAGESTATISTICS_EXPORT IntensityProfile::InstanceIdentifier ComputeGlobalMaximum(IntensityProfile::ConstPointer intensityProfile, IntensityProfile::MeasurementType &max);
 
   /** \brief Compute global minimum of an intensity profile.
     *
     * \param[in] intensityProfile An intensity profile.
     *
     * \return Index of the global minimum.
     */
   MITKIMAGESTATISTICS_EXPORT IntensityProfile::InstanceIdentifier ComputeGlobalMinimum(IntensityProfile::ConstPointer intensityProfile, IntensityProfile::MeasurementType &min);
 
   /** \brief Compute statistics of an intensity profile.
     *
     * \param[in] intensityProfile An intensity profile.
     *
     * \param[in] stats An ImageStatisticsCalculator::Statistics object to hold the calculated statistics.
     *
     */
   MITKIMAGESTATISTICS_EXPORT void ComputeIntensityProfileStatistics(IntensityProfile::ConstPointer intensityProfile, ImageStatisticsContainer::ImageStatisticsObject& stats);
 
   /** \brief Compute center of maximum area under the curve of an intensity profile.
     *
     * \param[in] intensityProfile An intensity profile.
     * \param[in] radius Radius of the area (width of area equals 1 + 2 * radius).
     *
     * \return Index of the maximum area center.
     */
   MITKIMAGESTATISTICS_EXPORT IntensityProfile::InstanceIdentifier ComputeCenterOfMaximumArea(IntensityProfile::ConstPointer intensityProfile, IntensityProfile::InstanceIdentifier radius);
 
   /** \brief Convert an intensity profile to a standard library vector.
     *
     * \param[in] intensityProfile An intensity profile.
     *
     * \return Standard library vector which contains the input intensity profile measurements.
     */
   MITKIMAGESTATISTICS_EXPORT std::vector<IntensityProfile::MeasurementType> CreateVectorFromIntensityProfile(IntensityProfile::ConstPointer intensityProfile);
 
   /** \brief Convert a standard library vector to an intensity profile.
     *
     * \param[in] vector An standard library vector which contains intensity profile measurements.
     *
     * \return An intensity profile.
     */
   MITKIMAGESTATISTICS_EXPORT IntensityProfile::Pointer CreateIntensityProfileFromVector(const std::vector<IntensityProfile::MeasurementType>& vector);
 }
 
 #endif
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
index 28ba60406b..dd7c656621 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
@@ -1,551 +1,551 @@
 /*===================================================================
 
 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 "QmitkImageStatisticsView.h"
 
 #include <utility>
 
 // berry includes
 #include <berryIQtStyleManager.h>
 #include <berryWorkbenchPlugin.h>
 
 #include <QmitkChartWidget.h>
 #include <mitkImageStatisticsContainerNodeHelper.h>
 #include <mitkImageStatisticsPredicateHelper.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkIntensityProfile.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateGeometry.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkSliceNavigationController.h>
 #include <mitkStatisticsToImageRelationRule.h>
 #include <mitkStatisticsToMaskRelationRule.h>
 #include <mitkStatusBar.h>
 
 #include "mitkImageStatisticsContainerManager.h"
 #include <mitkPlanarFigureInteractor.h>
 
 const std::string QmitkImageStatisticsView::VIEW_ID = "org.mitk.views.imagestatistics";
 
 QmitkImageStatisticsView::QmitkImageStatisticsView(QObject * /*parent*/, const char * /*name*/)
 {
   this->m_CalculationJob = new QmitkImageStatisticsCalculationJob();
 }
 
 QmitkImageStatisticsView::~QmitkImageStatisticsView()
 {
   if (m_selectedPlanarFigure)
   {
     m_selectedPlanarFigure->RemoveObserver(m_PlanarFigureObserverTag);
   }
 
   if (!m_CalculationJob->isFinished())
   {
     m_CalculationJob->terminate();
     m_CalculationJob->wait();
   }
   this->m_CalculationJob->deleteLater();
 }
 
 void QmitkImageStatisticsView::CreateQtPartControl(QWidget *parent)
 {
   m_Controls.setupUi(parent);
   m_Controls.widget_histogram->SetTheme(this->GetColorTheme());
   m_Controls.widget_intensityProfile->SetTheme(this->GetColorTheme());
   m_Controls.groupBox_histogram->setVisible(true);
   m_Controls.groupBox_intensityProfile->setVisible(false);
   m_Controls.label_currentlyComputingStatistics->setVisible(false);
   m_Controls.sliderWidget_histogram->setPrefix("Time: ");
   m_Controls.sliderWidget_histogram->setDecimals(0);
   m_Controls.sliderWidget_histogram->setVisible(false);
   m_Controls.sliderWidget_intensityProfile->setPrefix("Time: ");
   m_Controls.sliderWidget_intensityProfile->setDecimals(0);
   m_Controls.sliderWidget_intensityProfile->setVisible(false);
   ResetGUI();
 
   PrepareDataStorageComboBoxes();
   m_Controls.widget_statistics->SetDataStorage(this->GetDataStorage());
   CreateConnections();
 }
 
 void QmitkImageStatisticsView::CreateConnections()
 {
   connect(this->m_CalculationJob,
           &QmitkImageStatisticsCalculationJob::finished,
           this,
           &QmitkImageStatisticsView::OnStatisticsCalculationEnds,
           Qt::QueuedConnection);
   connect(this->m_Controls.checkBox_ignoreZero,
           &QCheckBox::stateChanged,
           this,
           &QmitkImageStatisticsView::OnCheckBoxIgnoreZeroStateChanged);
   connect(this->m_Controls.sliderWidget_histogram,
           &ctkSliderWidget::valueChanged,
           this,
           &QmitkImageStatisticsView::OnSliderWidgetHistogramChanged);
   connect(this->m_Controls.sliderWidget_intensityProfile,
           &ctkSliderWidget::valueChanged,
           this,
           &QmitkImageStatisticsView::OnSliderWidgetIntensityProfileChanged);
   connect(this->m_Controls.imageSelector,
           static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
           this,
           &QmitkImageStatisticsView::OnImageSelectorChanged);
   connect(this->m_Controls.maskImageSelector,
           static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
           this,
           &QmitkImageStatisticsView::OnMaskSelectorChanged);
 }
 
 void QmitkImageStatisticsView::OnCheckBoxIgnoreZeroStateChanged(int state)
 {
   m_ForceRecompute = true;
   if (state != Qt::Unchecked)
   {
     this->m_CalculationJob->SetIgnoreZeroValueVoxel(true);
   }
   else
   {
     this->m_CalculationJob->SetIgnoreZeroValueVoxel(false);
   }
   CalculateOrGetStatistics();
 }
 
 void QmitkImageStatisticsView::OnSliderWidgetHistogramChanged(double value)
 {
   unsigned int timeStep = static_cast<unsigned int>(value);
   auto mask = m_selectedMaskNode ? m_selectedMaskNode->GetData() : nullptr;
   auto imageStatistics = mitk::ImageStatisticsContainerManager::GetImageStatistics(
     this->GetDataStorage(), m_selectedImageNode->GetData(), mask);
   HistogramType::ConstPointer histogram = imageStatistics->GetStatisticsForTimeStep(timeStep).m_Histogram;
 
   if (histogram.IsNotNull() && this->m_CalculationJob->GetStatisticsUpdateSuccessFlag())
   {
     this->FillHistogramWidget({histogram}, {m_selectedImageNode->GetName()});
   }
 }
 
 void QmitkImageStatisticsView::OnSliderWidgetIntensityProfileChanged()
 {
   // intensity profile is always computed on request, not stored as node in DataStorage
   auto image = dynamic_cast<mitk::Image *>(m_selectedImageNode->GetData());
   auto planarFigure = dynamic_cast<mitk::PlanarFigure *>(m_selectedMaskNode->GetData());
 
   if (image && planarFigure && this->m_CalculationJob->GetStatisticsUpdateSuccessFlag())
   {
     this->ComputeAndDisplayIntensityProfile(image, planarFigure);
   }
 }
 
 void QmitkImageStatisticsView::PartClosed(const berry::IWorkbenchPartReference::Pointer &) {}
 
 void QmitkImageStatisticsView::FillHistogramWidget(const std::vector<const HistogramType*> &histogram,
                                                    const std::vector<std::string> &dataLabels)
 {
   m_Controls.groupBox_histogram->setVisible(true);
   m_Controls.widget_histogram->SetTheme(this->GetColorTheme());
   m_Controls.widget_histogram->Reset();
   m_Controls.widget_histogram->SetHistogram(histogram.front(), dataLabels.front());
   connect(m_Controls.widget_histogram,
           &QmitkHistogramVisualizationWidget::RequestHistogramUpdate,
           this,
           &QmitkImageStatisticsView::OnRequestHistogramUpdate);
 }
 
 QmitkChartWidget::ColorTheme QmitkImageStatisticsView::GetColorTheme() const
 {
   ctkPluginContext *context = berry::WorkbenchPlugin::GetDefault()->GetPluginContext();
   ctkServiceReference styleManagerRef = context->getServiceReference<berry::IQtStyleManager>();
   if (styleManagerRef)
   {
     auto styleManager = context->getService<berry::IQtStyleManager>(styleManagerRef);
     if (styleManager->GetStyle().name == "Dark")
     {
       return QmitkChartWidget::ColorTheme::darkstyle;
     }
     else
     {
       return QmitkChartWidget::ColorTheme::lightstyle;
     }
   }
   return QmitkChartWidget::ColorTheme::darkstyle;
 }
 
 void QmitkImageStatisticsView::OnImageSelectorChanged()
 {
   auto selectedImageNode = m_Controls.imageSelector->GetSelectedNode();
   if (selectedImageNode != m_selectedImageNode)
   {
     m_selectedImageNode = selectedImageNode;
     if (m_selectedImageNode.IsNotNull())
     {
       ResetGUIDefault();
 
       auto isPlanarFigurePredicate = mitk::GetImageStatisticsPlanarFigurePredicate();
       auto isMaskPredicate = mitk::GetImageStatisticsMaskPredicate();
       auto hasSameGeometry = mitk::NodePredicateGeometry::New(m_selectedImageNode->GetData()->GetGeometry());
       hasSameGeometry->SetCheckPrecision(1e-10);
       auto isMaskWithGeometryPredicate = mitk::NodePredicateAnd::New(isMaskPredicate, hasSameGeometry);
       auto isMaskOrPlanarFigureWithGeometryPredicate =
         mitk::NodePredicateOr::New(isPlanarFigurePredicate, isMaskWithGeometryPredicate);
       // prevent triggering of computation as the predicate triggers a signalChanged event
       m_Controls.maskImageSelector->disconnect();
       m_Controls.maskImageSelector->SetPredicate(isMaskOrPlanarFigureWithGeometryPredicate);
       // reset mask to <none>
       m_Controls.maskImageSelector->SetZeroEntryText("<none>");
       m_Controls.checkBox_ignoreZero->setEnabled(true);
       m_selectedMaskNode = nullptr;
       m_Controls.widget_statistics->SetMaskNodes({});
       CalculateOrGetStatistics();
       m_Controls.widget_statistics->SetImageNodes({m_selectedImageNode});
       connect(this->m_Controls.maskImageSelector,
               static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
               this,
               &QmitkImageStatisticsView::OnMaskSelectorChanged);
     }
     else
     {
       m_Controls.widget_statistics->SetImageNodes({});
       m_Controls.widget_statistics->SetMaskNodes({});
       m_Controls.widget_statistics->Reset();
       m_Controls.widget_histogram->Reset();
       ResetGUI();
     }
   }
 }
 
 void QmitkImageStatisticsView::OnMaskSelectorChanged()
 {
   auto selectedMaskNode = m_Controls.maskImageSelector->GetSelectedNode();
   if (selectedMaskNode != m_selectedMaskNode)
   {
     m_selectedMaskNode = selectedMaskNode;
     if (m_selectedMaskNode.IsNotNull())
     {
       m_Controls.widget_statistics->SetMaskNodes({m_selectedMaskNode});
     }
     else
     {
       m_Controls.widget_statistics->SetMaskNodes({});
     }
     CalculateOrGetStatistics();
   }
 }
 
 void QmitkImageStatisticsView::CalculateOrGetStatistics()
 {
   if (this->m_selectedPlanarFigure)
   {
     this->m_selectedPlanarFigure->RemoveObserver(this->m_PlanarFigureObserverTag);
     this->m_selectedPlanarFigure = nullptr;
   }
 
   m_Controls.groupBox_intensityProfile->setVisible(false);
   m_Controls.widget_statistics->setEnabled(m_selectedImageNode.IsNotNull());
 
   if (m_selectedImageNode != nullptr)
   {
     auto image = dynamic_cast<mitk::Image *>(m_selectedImageNode->GetData());
     mitk::Image *mask = nullptr;
     mitk::PlanarFigure *maskPlanarFigure = nullptr;
 
     if (image->GetDimension() == 4)
     {
       m_Controls.sliderWidget_histogram->setVisible(true);
       unsigned int maxTimestep = image->GetTimeSteps();
       m_Controls.sliderWidget_histogram->setMaximum(maxTimestep - 1);
     }
     else
     {
       m_Controls.sliderWidget_histogram->setVisible(false);
     }
 
     if (m_selectedMaskNode != nullptr)
     {
       mask = dynamic_cast<mitk::Image *>(m_selectedMaskNode->GetData());
       if (mask == nullptr)
       {
         maskPlanarFigure = dynamic_cast<mitk::PlanarFigure *>(m_selectedMaskNode->GetData());
       }
     }
 
     mitk::ImageStatisticsContainer::ConstPointer imageStatistics;
     if (mask)
     {
       imageStatistics = mitk::ImageStatisticsContainerManager::GetImageStatistics(this->GetDataStorage(), image, mask);
     }
     else if (maskPlanarFigure)
     {
       m_selectedPlanarFigure = maskPlanarFigure;
       ITKCommandType::Pointer changeListener = ITKCommandType::New();
       changeListener->SetCallbackFunction(this, &QmitkImageStatisticsView::CalculateOrGetStatistics);
       this->m_PlanarFigureObserverTag =
         m_selectedPlanarFigure->AddObserver(mitk::EndInteractionPlanarFigureEvent(), changeListener);
       if (!maskPlanarFigure->IsClosed())
       {
         ComputeAndDisplayIntensityProfile(image, maskPlanarFigure);
       }
       imageStatistics =
         mitk::ImageStatisticsContainerManager::GetImageStatistics(this->GetDataStorage(), image, maskPlanarFigure);
     }
     else
     {
       imageStatistics = mitk::ImageStatisticsContainerManager::GetImageStatistics(this->GetDataStorage(), image);
     }
 
     bool imageStatisticsOlderThanInputs = false;
     if (imageStatistics &&
         (imageStatistics->GetMTime() < image->GetMTime() || (mask && imageStatistics->GetMTime() < mask->GetMTime()) ||
          (maskPlanarFigure && imageStatistics->GetMTime() < maskPlanarFigure->GetMTime())))
     {
       imageStatisticsOlderThanInputs = true;
     }
 
     if (imageStatistics)
     {
       // triggers recomputation when switched between images and the newest one has not 100 bins (default)
       auto calculatedBins = imageStatistics->GetStatisticsForTimeStep(0).m_Histogram.GetPointer()->Size();
       if (calculatedBins != 100)
       {
         OnRequestHistogramUpdate(m_Controls.widget_histogram->GetBins());
       }
     }
 
     // statistics need to be computed
     if (!imageStatistics || imageStatisticsOlderThanInputs || m_ForceRecompute)
     {
       CalculateStatistics(image, mask, maskPlanarFigure);
     }
     // statistics already computed
     else
     {
       // Not an open planar figure: show histogram (intensity profile already shown)
       if (!(maskPlanarFigure && !maskPlanarFigure->IsClosed()))
       {
         if (imageStatistics->TimeStepExists(0))
         {
           auto histogram = imageStatistics->GetStatisticsForTimeStep(0).m_Histogram.GetPointer();
           std::string imageNodeName = m_selectedImageNode->GetName();
           this->FillHistogramWidget({histogram}, {imageNodeName});
         }
       }
     }
   }
   else
   {
     ResetGUI();
   }
   m_ForceRecompute = false;
 }
 
 void QmitkImageStatisticsView::ComputeAndDisplayIntensityProfile(mitk::Image *image,
                                                                  mitk::PlanarFigure *maskPlanarFigure)
 {
-  const mitk::Image* inputImage;
+  mitk::Image::Pointer inputImage;
   if (image->GetDimension() == 4)
   {
     m_Controls.sliderWidget_intensityProfile->setVisible(true);
     unsigned int maxTimestep = image->GetTimeSteps();
     m_Controls.sliderWidget_intensityProfile->setMaximum(maxTimestep - 1);
     // Intensity profile can only be calculated on 3D, so extract if 4D
     mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
     int currentTimestep = static_cast<int>(m_Controls.sliderWidget_intensityProfile->value());
     timeSelector->SetInput(image);
     timeSelector->SetTimeNr(currentTimestep);
     timeSelector->Update();
 
     inputImage = timeSelector->GetOutput();
   }
   else
   {
     m_Controls.sliderWidget_intensityProfile->setVisible(false);
     inputImage = image;
   }
 
-  auto intensityProfile = mitk::ComputeIntensityProfile(inputImage, maskPlanarFigure);
+    auto intensityProfile = mitk::ComputeIntensityProfile(inputImage, maskPlanarFigure);
   // Don't show histogram for intensity profiles
   m_Controls.groupBox_histogram->setVisible(false);
   m_Controls.groupBox_intensityProfile->setVisible(true);
   m_Controls.widget_intensityProfile->Reset();
-  m_Controls.widget_intensityProfile->SetIntensityProfile(intensityProfile,
+  m_Controls.widget_intensityProfile->SetIntensityProfile(intensityProfile.GetPointer(),
                                                           "Intensity Profile of " + m_selectedImageNode->GetName());
 }
 
 void QmitkImageStatisticsView::ResetGUI()
 {
   m_Controls.widget_statistics->Reset();
   m_Controls.widget_statistics->setEnabled(false);
   m_Controls.widget_histogram->Reset();
   m_Controls.widget_histogram->setEnabled(false);
   m_Controls.checkBox_ignoreZero->setEnabled(false);
 }
 
 void QmitkImageStatisticsView::ResetGUIDefault()
 {
   m_Controls.widget_histogram->ResetDefault();
   m_Controls.checkBox_ignoreZero->setChecked(false);
 }
 
 void QmitkImageStatisticsView::OnStatisticsCalculationEnds()
 {
   mitk::StatusBar::GetInstance()->Clear();
 
   if (this->m_CalculationJob->GetStatisticsUpdateSuccessFlag())
   {
     auto statistic = m_CalculationJob->GetStatisticsData();
     auto image = m_CalculationJob->GetStatisticsImage();
     mitk::BaseData::ConstPointer mask = nullptr;
     auto imageRule = mitk::StatisticsToImageRelationRule::New();
     imageRule->Connect(statistic, image);
 
     if (m_CalculationJob->GetMaskImage())
     {
       auto maskRule = mitk::StatisticsToMaskRelationRule::New();
       mask = m_CalculationJob->GetMaskImage();
       maskRule->Connect(statistic, mask);
     }
     else if (m_CalculationJob->GetPlanarFigure())
     {
       auto planarFigureRule = mitk::StatisticsToMaskRelationRule::New();
       mask = m_CalculationJob->GetPlanarFigure();
       planarFigureRule->Connect(statistic, mask);
     }
 
     auto imageStatistics =
       mitk::ImageStatisticsContainerManager::GetImageStatistics(this->GetDataStorage(), image, mask);
 
     // if statistics base data already exist: add to existing node
     if (imageStatistics)
     {
       auto allDataNodes = this->GetDataStorage()->GetAll()->CastToSTLConstContainer();
       for (auto node : allDataNodes)
       {
         auto nodeData = node->GetData();
         if (nodeData && nodeData->GetUID() == imageStatistics->GetUID())
         {
           node->SetData(statistic);
         }
       }
     }
     // statistics base data does not exist: add new node
     else
     {
       auto statisticsNodeName = m_selectedImageNode->GetName();
       if (m_selectedMaskNode)
       {
         statisticsNodeName += "_" + m_selectedMaskNode->GetName();
       }
       statisticsNodeName += "_statistics";
       auto statisticsNode = mitk::CreateImageStatisticsNode(statistic, statisticsNodeName);
       this->GetDataStorage()->Add(statisticsNode);
     }
 
     if (!m_selectedPlanarFigure || m_selectedPlanarFigure->IsClosed())
     {
       this->FillHistogramWidget({m_CalculationJob->GetTimeStepHistogram()}, {m_selectedImageNode->GetName()});
     }
   }
   else
   {
     mitk::StatusBar::GetInstance()->DisplayErrorText(m_CalculationJob->GetLastErrorMessage().c_str());
     m_Controls.widget_histogram->setEnabled(false);
   }
   m_Controls.label_currentlyComputingStatistics->setVisible(false);
 }
 
 void QmitkImageStatisticsView::OnRequestHistogramUpdate(unsigned int nBins)
 {
   m_CalculationJob->SetHistogramNBins(nBins);
   m_CalculationJob->start();
 }
 
 void QmitkImageStatisticsView::CalculateStatistics(const mitk::Image *image,
                                                    const mitk::Image *mask,
                                                    const mitk::PlanarFigure *maskPlanarFigure)
 {
   this->m_CalculationJob->Initialize(image, mask, maskPlanarFigure);
 
   try
   {
     // Compute statistics
     this->m_CalculationJob->start();
     m_Controls.label_currentlyComputingStatistics->setVisible(true);
   }
   catch (const mitk::Exception &e)
   {
     mitk::StatusBar::GetInstance()->DisplayErrorText(e.GetDescription());
     m_Controls.label_currentlyComputingStatistics->setVisible(false);
   }
   catch (const std::runtime_error &e)
   {
     mitk::StatusBar::GetInstance()->DisplayErrorText(e.what());
     m_Controls.label_currentlyComputingStatistics->setVisible(false);
   }
   catch (const std::exception &e)
   {
     mitk::StatusBar::GetInstance()->DisplayErrorText(e.what());
     m_Controls.label_currentlyComputingStatistics->setVisible(false);
   }
 }
 
 void QmitkImageStatisticsView::OnSelectionChanged(berry::IWorkbenchPart::Pointer part,
                                                   const QList<mitk::DataNode::Pointer> &nodes)
 {
   Q_UNUSED(part);
   Q_UNUSED(nodes);
 }
 
 void QmitkImageStatisticsView::PrepareDataStorageComboBoxes()
 {
   auto isPlanarFigurePredicate = mitk::GetImageStatisticsPlanarFigurePredicate();
   auto isMaskPredicate = mitk::GetImageStatisticsMaskPredicate();
   auto isImagePredicate = mitk::GetImageStatisticsImagePredicate();
   auto isMaskOrPlanarFigurePredicate = mitk::NodePredicateOr::New(isPlanarFigurePredicate, isMaskPredicate);
 
   m_Controls.imageSelector->SetDataStorage(GetDataStorage());
   m_Controls.imageSelector->SetPredicate(isImagePredicate);
 
   m_Controls.maskImageSelector->SetDataStorage(GetDataStorage());
 
   m_Controls.maskImageSelector->SetPredicate(isMaskOrPlanarFigurePredicate);
   m_Controls.maskImageSelector->SetZeroEntryText("<none>");
 }
 
 void QmitkImageStatisticsView::Activated() {}
 
 void QmitkImageStatisticsView::Deactivated() {}
 
 void QmitkImageStatisticsView::Visible()
 {
   connect(this->m_Controls.imageSelector,
           static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
           this,
           &QmitkImageStatisticsView::OnImageSelectorChanged);
   connect(this->m_Controls.maskImageSelector,
           static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
           this,
           &QmitkImageStatisticsView::OnMaskSelectorChanged);
   OnImageSelectorChanged();
   OnMaskSelectorChanged();
 }
 
 void QmitkImageStatisticsView::Hidden()
 {
   m_Controls.imageSelector->disconnect();
   m_Controls.maskImageSelector->disconnect();
 }
 
 void QmitkImageStatisticsView::SetFocus() {}
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.h b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.h
index c857718620..aa950b04cc 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.h
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.h
@@ -1,117 +1,113 @@
 /*===================================================================
 
 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 QmitkImageStatisticsView_H__INCLUDED
 #define QmitkImageStatisticsView_H__INCLUDED
 
 #include "ui_QmitkImageStatisticsViewControls.h"
 
 // Qmitk includes
 #include <QmitkAbstractView.h>
 #include <QmitkImageStatisticsCalculationJob.h>
 #include <mitkImageStatisticsContainer.h>
 
 #include <mitkILifecycleAwarePart.h>
 #include <berryIPartListener.h>
 #include <mitkPropertyRelations.h>
 
 /*!
 \brief QmitkImageStatisticsView is a bundle that allows statistics calculation from images. Three modes
 are supported: 1. Statistics of one image, 2. Statistics of an image and a segmentation, 3. Statistics
 of an image and a Planar Figure. The statistics calculation is realized in a separate thread to keep the
 gui accessible during calculation.
 
 \ingroup Plugins/org.mitk.gui.qt.measurementtoolbox
 */
 class QmitkImageStatisticsView : public QmitkAbstractView, public mitk::ILifecycleAwarePart, public berry::IPartListener
 {
   Q_OBJECT
 
 public:
   /*!
   \brief default constructor */
   QmitkImageStatisticsView(QObject *parent = nullptr, const char *name = nullptr);
   /*!
   \brief default destructor */
   virtual ~QmitkImageStatisticsView();
   /*!
   \brief method for creating the widget containing the application   controls, like sliders, buttons etc. */
   virtual void CreateQtPartControl(QWidget *parent) override;
   /*!
   \brief  Is called from the selection mechanism once the data manager selection has changed*/
   void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer> &selectedNodes) override;
 
   static const std::string VIEW_ID;
+
 protected:
   using HistogramType = mitk::ImageStatisticsContainer::HistogramType;
 
   virtual void Activated() override;
   virtual void Deactivated() override;
   virtual void Visible() override;
   virtual void Hidden() override;
   virtual void SetFocus() override;
 
   /** \brief Is called right before the view closes (before the destructor) */
   virtual void PartClosed(const berry::IWorkbenchPartReference::Pointer&) override;
  
   /** \brief Required for berry::IPartListener */
   virtual Events::Types GetPartEventTypes() const override { return Events::CLOSED; }
 
-  void PrepareDataStorageComboBoxes();
-  void FillHistogramWidget(const std::vector<const HistogramType*> &histogram,
-                           const std::vector<std::string> &dataLabels);
-  QmitkChartWidget::ColorTheme GetColorTheme() const;
-
   void OnImageSelectorChanged();
   void OnMaskSelectorChanged();
 
   void CalculateOrGetStatistics();
   void CalculateStatistics(const mitk::Image* image,
                            const mitk::Image* mask = nullptr,
                            const mitk::PlanarFigure* maskPlanarFigure = nullptr);
 
   void ComputeAndDisplayIntensityProfile(mitk::Image * image, mitk::PlanarFigure* maskPlanarFigure);
   void FillHistogramWidget(const std::vector<const HistogramType*> &histogram,
                            const std::vector<std::string> &dataLabels);
   QmitkChartWidget::ColorTheme GetColorTheme() const;
 
   void ResetGUI();
   void ResetGUIDefault();
 
   void PrepareDataStorageComboBoxes();
   /*!
   \brief method for creating the connections of main and control widget */
   virtual void CreateConnections();
 
   void OnStatisticsCalculationEnds();
   void OnRequestHistogramUpdate(unsigned int nBins);
   void OnCheckBoxIgnoreZeroStateChanged(int state);
   void OnSliderWidgetHistogramChanged(double value);
   void OnSliderWidgetIntensityProfileChanged();
 
   // member variable
   Ui::QmitkImageStatisticsViewControls m_Controls;
 
 private:
   typedef itk::SimpleMemberCommand< QmitkImageStatisticsView > ITKCommandType;
   QmitkImageStatisticsCalculationJob * m_CalculationJob = nullptr;
   mitk::DataNode::ConstPointer m_selectedImageNode = nullptr, m_selectedMaskNode = nullptr;
 
   mitk::PlanarFigure::Pointer m_selectedPlanarFigure=nullptr;
   long m_PlanarFigureObserverTag;
   bool m_ForceRecompute = false;
 };
 #endif // QmitkImageStatisticsView_H__INCLUDED