diff --git a/Modules/ImageStatistics/mitkImageStatisticsContainer.cpp b/Modules/ImageStatistics/mitkImageStatisticsContainer.cpp
index 03bd820022..90213a565c 100644
--- a/Modules/ImageStatistics/mitkImageStatisticsContainer.cpp
+++ b/Modules/ImageStatistics/mitkImageStatisticsContainer.cpp
@@ -1,285 +1,306 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 #include <mitkImageStatisticsContainer.h>
 
+#include <mitkImageStatisticsContainerManager.h>
+#include <mitkProperties.h>
+
 #include <algorithm>
 
 namespace mitk
 {
   ImageStatisticsContainer::ImageStatisticsContainer() { this->Reset(); }
 
   // The order is derived from the old (<2018) image statistics plugin.
   const ImageStatisticsContainer::ImageStatisticsObject::StatisticNameVector
     ImageStatisticsContainer::ImageStatisticsObject::m_DefaultNames = {ImageStatisticsConstants::MEAN(),
                                                                   ImageStatisticsConstants::MEDIAN(),
                                                                   ImageStatisticsConstants::STANDARDDEVIATION(),
                                                                   ImageStatisticsConstants::RMS(),
                                                                   ImageStatisticsConstants::MAXIMUM(),
                                                                   ImageStatisticsConstants::MAXIMUMPOSITION(),
                                                                   ImageStatisticsConstants::MINIMUM(),
                                                                   ImageStatisticsConstants::MINIMUMPOSITION(),
                                                                   ImageStatisticsConstants::NUMBEROFVOXELS(),
                                                                   ImageStatisticsConstants::VOLUME(),
                                                                   ImageStatisticsConstants::SKEWNESS(),
                                                                   ImageStatisticsConstants::KURTOSIS(),
                                                                   ImageStatisticsConstants::UNIFORMITY(),
                                                                   ImageStatisticsConstants::ENTROPY(),
                                                                   ImageStatisticsConstants::MPP(),
                                                                   ImageStatisticsConstants::UPP()};
 
   ImageStatisticsContainer::ImageStatisticsObject::ImageStatisticsObject() { Reset(); }
 
   void ImageStatisticsContainer::ImageStatisticsObject::AddStatistic(const std::string_view key, StatisticsVariantType value)
   {
     m_Statistics.emplace(key, value);
 
     if (std::find(m_DefaultNames.cbegin(), m_DefaultNames.cend(), key) == m_DefaultNames.cend())
     {
       if (std::find(m_CustomNames.cbegin(), m_CustomNames.cend(), key) == m_CustomNames.cend())
       {
         m_CustomNames.emplace_back(key);
       }
     }
   }
 
   const ImageStatisticsContainer::ImageStatisticsObject::StatisticNameVector &
     ImageStatisticsContainer::ImageStatisticsObject::GetDefaultStatisticNames()
   {
     return m_DefaultNames;
   }
 
   const ImageStatisticsContainer::ImageStatisticsObject::StatisticNameVector &
     ImageStatisticsContainer::ImageStatisticsObject::GetCustomStatisticNames() const
   {
     return m_CustomNames;
   }
 
   ImageStatisticsContainer::ImageStatisticsObject::StatisticNameVector
     ImageStatisticsContainer::ImageStatisticsObject::GetAllStatisticNames() const
   {
     StatisticNameVector names = GetDefaultStatisticNames();
 
       names.insert(names.cend(), m_CustomNames.cbegin(), m_CustomNames.cend());
 
     return names;
   }
 
     ImageStatisticsContainer::ImageStatisticsObject::StatisticNameVector
     ImageStatisticsContainer::ImageStatisticsObject::GetExistingStatisticNames() const
   {
     StatisticNameVector names;
 
       std::transform(m_Statistics.begin(), m_Statistics.end(), std::back_inserter(names), [](const auto &pair) {
         return pair.first;
       });
 
     return names;
   }
 
   bool ImageStatisticsContainer::ImageStatisticsObject::HasStatistic(const std::string_view name) const
   {
     return m_Statistics.find(name) != m_Statistics.cend();
   }
 
   ImageStatisticsContainer::StatisticsVariantType ImageStatisticsContainer::ImageStatisticsObject::GetValueNonConverted(
     const std::string_view name) const
   {
     if (HasStatistic(name))
     {
       return m_Statistics.find(name)->second;
     }
     else
     {
       mitkThrow() << "invalid statistic key, could not find";
     }
   }
 
   void ImageStatisticsContainer::ImageStatisticsObject::Reset()
   {
     m_Statistics.clear();
     m_CustomNames.clear();
   }
 
   const static ImageStatisticsContainer::LabelValueType NO_MASK_LABEL_VALUE = 1;
 
   bool ImageStatisticsContainer::StatisticsExist(LabelValueType labelValue, TimeStepType timeStep) const
   {
     auto labelFinding = m_LabelTimeStep2StatisticsMap.find(labelValue);
     if (labelFinding == m_LabelTimeStep2StatisticsMap.end()) return false;
 
     auto timeFinding = labelFinding->second.find(timeStep);
 
     return timeFinding != labelFinding->second.end();
   }
 
   const ImageStatisticsContainer::HistogramType*
     ImageStatisticsContainer::GetHistogram(LabelValueType labelValue, TimeStepType timeStep) const
   {
     return this->GetStatistics(labelValue, timeStep).m_Histogram;
   }
 
+  bool ImageStatisticsContainer::IgnoresZeroVoxel() const
+  {
+    const auto prop = this->GetProperty(mitk::STATS_IGNORE_ZERO_VOXEL_PROPERTY_NAME.c_str());
+    const auto boolProp = dynamic_cast<const mitk::BoolProperty*>(prop.GetPointer());
+
+    if (nullptr != boolProp)
+    {
+      return boolProp->GetValue();
+    }
+
+    return false;
+  }
+
+  bool ImageStatisticsContainer::IsWIP() const
+  {
+    return this->GetProperty(mitk::STATS_GENERATION_STATUS_PROPERTY_NAME.c_str()).IsNotNull();
+  }
+
   const ImageStatisticsContainer::ImageStatisticsObject &ImageStatisticsContainer::GetStatistics(LabelValueType labelValue,
     TimeStepType timeStep) const
   {
     auto labelFinding = m_LabelTimeStep2StatisticsMap.find(labelValue);
     if (labelFinding == m_LabelTimeStep2StatisticsMap.end()) mitkThrow() << "Cannot get statistics. Requested label value does not exist. Invalid label:" <<labelValue;
 
     auto timeFinding = labelFinding->second.find(timeStep);
     if (timeFinding == labelFinding->second.end()) mitkThrow() << "Cannot get statistics. Requested time step does not exist. Invalid time step:" << timeStep;
 
     return timeFinding->second;
   }
 
   void ImageStatisticsContainer::SetStatistics(LabelValueType labelValue, TimeStepType timeStep, const ImageStatisticsObject& statistics)
   {
     
     if (!this->GetTimeGeometry()->IsValidTimeStep(timeStep)) mitkThrow() << "Given timeStep " << timeStep
       << " out of TimeGeometry bounds of the object. TimeSteps in geometry: " << this->GetTimeSteps();
 
     m_LabelTimeStep2StatisticsMap[labelValue][timeStep] = statistics;
     this->Modified();
   }
 
   void ImageStatisticsContainer::PrintSelf(std::ostream &os, itk::Indent indent) const
   {
     Superclass::PrintSelf(os, indent);
     for (const auto& [labelValue, timeMap] : m_LabelTimeStep2StatisticsMap)
     {
       for (const auto& [timeStep, container] : timeMap)
       {
         os << std::endl << indent << "Statistics instance (Label "<< labelValue << ", TimeStep "<< timeStep << "):";
         auto statisticsValues = GetStatistics(labelValue,timeStep);
 
         auto statisticKeys = statisticsValues.GetExistingStatisticNames();
         os << std::endl << indent << "Number of entries: " << statisticKeys.size();
         for (const auto& aKey : statisticKeys)
         {
           os << std::endl << indent.GetNextIndent() << aKey << ": " << statisticsValues.GetValueNonConverted(aKey);
         }
       }
     }
   }
 
 
   ImageStatisticsContainer::LabelValueVectorType ImageStatisticsContainer::GetExistingLabelValues(bool ignoreUnlabeled) const
   {
     LabelValueVectorType result;
     for (const auto& [labelValue, timeMap] : m_LabelTimeStep2StatisticsMap)
     {
       if (!ignoreUnlabeled || labelValue != NO_MASK_LABEL_VALUE)
       {
         result.push_back(labelValue);
       }
     }
     return result;
   }
 
   ImageStatisticsContainer::TimeStepVectorType ImageStatisticsContainer::GetExistingTimeSteps(LabelValueType labelValue) const
   {
     TimeStepVectorType result;
 
     auto labelFinding = m_LabelTimeStep2StatisticsMap.find(labelValue);
     if (labelFinding == m_LabelTimeStep2StatisticsMap.end()) mitkThrow() << "Cannot get existing time steps. Requested label value does not exist. Invalid label:" << labelValue;
 
     for (const auto& [timestep, stats] : labelFinding->second)
     {
       result.push_back(timestep);
     }
     return result;
   }
 
   void ImageStatisticsContainer::Reset()
   {
     m_LabelTimeStep2StatisticsMap.clear();
     this->Modified();
   }
 
   itk::LightObject::Pointer ImageStatisticsContainer::InternalClone() const
   {
     itk::LightObject::Pointer ioPtr = Superclass::InternalClone();
     Self::Pointer rval = dynamic_cast<Self *>(ioPtr.GetPointer());
     if (rval.IsNull())
     {
       itkExceptionMacro(<< "downcast to type "
                         << "StatisticsContainer"
                         << " failed.");
     }
 
     rval->m_LabelTimeStep2StatisticsMap = m_LabelTimeStep2StatisticsMap;
     rval->SetTimeGeometry(this->GetTimeGeometry()->Clone());
 
     return ioPtr;
   }
 
   ImageStatisticsContainer::ImageStatisticsObject::StatisticNameVector GetAllStatisticNames(
     const ImageStatisticsContainer *container)
   {
     ImageStatisticsContainer::ImageStatisticsObject::StatisticNameVector names =
       ImageStatisticsContainer::ImageStatisticsObject::GetDefaultStatisticNames();
 
     if (container)
     {
       std::set<std::string> customKeys;
 
       auto labelValues = container->GetExistingLabelValues(false);
 
       for (const auto labelValue : labelValues)
       {
         auto timeSteps = container->GetExistingTimeSteps(labelValue);
 
         for (const auto timeStep : timeSteps)
         {
           auto statisticKeys = container->GetStatistics(labelValue, timeStep).GetCustomStatisticNames();
           customKeys.insert(statisticKeys.cbegin(), statisticKeys.cend());
         }
       }
 
       names.insert(names.cend(), customKeys.cbegin(), customKeys.cend());
     }
 
     return names;
   }
 
   ImageStatisticsContainer::ImageStatisticsObject::StatisticNameVector GetAllStatisticNames(
     std::vector<ImageStatisticsContainer::ConstPointer> containers)
   {
     ImageStatisticsContainer::ImageStatisticsObject::StatisticNameVector names =
       ImageStatisticsContainer::ImageStatisticsObject::GetDefaultStatisticNames();
 
     std::set<std::string> customKeys;
 
     for (const auto &container : containers)
     {
       std::set<std::string> customKeys;
 
       auto labelValues = container->GetExistingLabelValues(false);
 
       for (const auto labelValue : labelValues)
       {
         auto timeSteps = container->GetExistingTimeSteps(labelValue);
 
         for (const auto timeStep : timeSteps)
         {
           auto statisticKeys = container->GetStatistics(labelValue, timeStep).GetCustomStatisticNames();
           customKeys.insert(statisticKeys.cbegin(), statisticKeys.cend());
         }
       }
 
       names.insert(names.cend(), customKeys.cbegin(), customKeys.cend());
     }
 
     names.insert(names.end(), customKeys.begin(), customKeys.end());
 
     return names;
   };
 
 } // namespace mitk
diff --git a/Modules/ImageStatistics/mitkImageStatisticsContainer.h b/Modules/ImageStatistics/mitkImageStatisticsContainer.h
index d0a18bee7a..db315f8460 100644
--- a/Modules/ImageStatistics/mitkImageStatisticsContainer.h
+++ b/Modules/ImageStatistics/mitkImageStatisticsContainer.h
@@ -1,178 +1,182 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef mitkImageStatisticsContainer_h
 #define mitkImageStatisticsContainer_h
 
 #include <MitkImageStatisticsExports.h>
 #include <mitkBaseData.h>
 #include <itkHistogram.h>
 #include <mitkLabelSetImage.h>
 #include <mitkImageStatisticsConstants.h>
 
 #include <boost/variant.hpp>
 
 namespace mitk
 {
 
   /**
    @brief Container class for storing a StatisticsObject for each time step.
 
    Stored statistics are:
    - for the defined statistics, see GetAllStatisticNames
    - Histogram of Pixel Values
   */
   class MITKIMAGESTATISTICS_EXPORT ImageStatisticsContainer : public mitk::BaseData
   {
   public:
     mitkClassMacro(ImageStatisticsContainer, mitk::BaseData);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
     using HistogramType = itk::Statistics::Histogram<double>;
     using LabelValueType = LabelSetImage::LabelValueType;
 
     void SetRequestedRegionToLargestPossibleRegion() override {}
 
     bool RequestedRegionIsOutsideOfTheBufferedRegion() override { return false; }
 
     bool VerifyRequestedRegion() override { return true; }
 
     void SetRequestedRegion(const itk::DataObject*) override {}
 
     /**
     @brief Container class for storing the computed image statistics.
     @details The statistics are stored in a map <name,value> with value as boost::variant<RealType, VoxelCountType, IndexType >.
     The type used to create the boost::variant is important as only this type can be recovered later on.
     */
     class MITKIMAGESTATISTICS_EXPORT ImageStatisticsObject {
     public:
       ImageStatisticsObject();
 
       using RealType = double;
       using IndexType = vnl_vector<int>;
       using VoxelCountType = unsigned long;
 
       using StatisticsVariantType = boost::variant<RealType, VoxelCountType, IndexType >;
 
       /**
       @brief Adds a statistic to the statistics object
       @details if already a statistic with that name is included, it is overwritten
       */
       void AddStatistic(const std::string_view key, StatisticsVariantType value);
 
       using StatisticNameVector = std::vector<std::string>;
 
       /**
       @brief Returns the names of the default statistics
       @details The order is derived from the image statistics plugin.
       */
       static const StatisticNameVector& GetDefaultStatisticNames();
 
       /**
       @brief Returns the names of all custom statistics (defined at runtime and no default names).
       */
       const StatisticNameVector& GetCustomStatisticNames() const;
 
       /**
       @brief Returns the names of all statistics (default and custom defined)
       Additional custom keys are added at the end in a sorted order.
       */
       StatisticNameVector GetAllStatisticNames() const;
 
       StatisticNameVector GetExistingStatisticNames() const;
 
       bool HasStatistic(const std::string_view name) const;
 
       /**
       @brief Converts the requested value to the defined type
       @param name defined string on creation (AddStatistic)
       @exception if no statistics with key name was found.
       */
       template <typename TType>
       TType GetValueConverted(const std::string_view name) const
       {
         auto value = GetValueNonConverted(name);
         return boost::get<TType>(value);
       }
 
       /**
       @brief Returns the requested value
       @exception if no statistics with key name was found.
       */
       StatisticsVariantType GetValueNonConverted(const std::string_view name) const;
 
       void Reset();
 
       HistogramType::ConstPointer m_Histogram=nullptr;
     private:
 
       using StatisticsMapType = std::map < std::string, StatisticsVariantType, std::less<>>;
 
       StatisticsMapType m_Statistics;
       StatisticNameVector m_CustomNames;
       static const StatisticNameVector m_DefaultNames;
     };
 
     using StatisticsVariantType = ImageStatisticsObject::StatisticsVariantType;
     using RealType = ImageStatisticsObject::RealType;
     using IndexType = ImageStatisticsObject::IndexType;
     using VoxelCountType = ImageStatisticsObject::VoxelCountType;
 
     using TimeStepVectorType = std::vector<TimeStepType>;
     TimeStepVectorType GetExistingTimeSteps(LabelValueType labelValue) const;
 
     /** Value that can be used to query for the statistic if no mask was provided.*/
     const static LabelValueType NO_MASK_LABEL_VALUE = Label::UNLABELED_VALUE;
     using LabelValueVectorType = LabelSetImage::LabelValueVectorType;
     LabelValueVectorType GetExistingLabelValues(bool ignoreUnlabeled) const;
 
     /**
     @brief Deletes all stored values*/
     void Reset();
 
     const ImageStatisticsObject& GetStatistics(LabelValueType labelValue, TimeStepType timeStep) const;
 
     /**
     @brief Sets the statisticObject for the given Timestep
     @pre timeStep must be valid
     */
     void SetStatistics(LabelValueType labelValue, TimeStepType timeStep, const ImageStatisticsObject& statistics);
 
     /**
     @brief Checks if the Time step exists
     @pre timeStep must be valid
     */
     bool StatisticsExist(LabelValueType labelValue, TimeStepType timeStep) const;
 
     /**
     /brief Returns the histogram of the passed time step.
     @pre timeStep must be valid*/
     const HistogramType* GetHistogram(LabelValueType labelValue, TimeStepType timeStep) const;
 
+    bool IgnoresZeroVoxel() const;
+
+    bool IsWIP() const;
+
   protected:
     ImageStatisticsContainer();
     void PrintSelf(std::ostream &os, itk::Indent indent) const override;
 
   private:
     itk::LightObject::Pointer InternalClone() const override;
 
     using TimeStepMapType = std::map<TimeStepType, ImageStatisticsObject>;
     using LabelMapType = std::map<LabelValueType, TimeStepMapType>;
 
     LabelMapType m_LabelTimeStep2StatisticsMap;
   };
 
   MITKIMAGESTATISTICS_EXPORT ImageStatisticsContainer::ImageStatisticsObject::StatisticNameVector GetAllStatisticNames(const ImageStatisticsContainer* container);
   MITKIMAGESTATISTICS_EXPORT ImageStatisticsContainer::ImageStatisticsObject::StatisticNameVector GetAllStatisticNames(std::vector<ImageStatisticsContainer::ConstPointer> containers);
 }
 #endif
diff --git a/Modules/ImageStatistics/mitkIntensityProfile.cpp b/Modules/ImageStatistics/mitkIntensityProfile.cpp
index 6523ef049a..914fb96c76 100644
--- a/Modules/ImageStatistics/mitkIntensityProfile.cpp
+++ b/Modules/ImageStatistics/mitkIntensityProfile.cpp
@@ -1,383 +1,383 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #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&, 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 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(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 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));
   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 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;
 }
 
 IntensityProfile::Pointer mitk::ComputeIntensityProfile(Image::Pointer image, PlanarFigure::Pointer planarFigure)
 {
   return ::ComputeIntensityProfile(image, CreatePathFromPlanarFigure(image->GetGeometry(), planarFigure));
 }
 
 IntensityProfile::Pointer mitk::ComputeIntensityProfile(Image::Pointer image, PlanarLine::Pointer planarLine, unsigned int numSamples, InterpolateImageFunction::Enum interpolator)
 {
   return ::ComputeIntensityProfile(image, CreatePathFromPlanarFigure(image->GetGeometry(), planarLine.GetPointer()), numSamples, 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());
+  auto numSamples = static_cast<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/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeItem.cpp b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeItem.cpp
index 87c477439b..52100ea1f7 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeItem.cpp
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeItem.cpp
@@ -1,132 +1,132 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkImageStatisticsTreeItem.h"
 
 QmitkImageStatisticsTreeItem::QmitkImageStatisticsTreeItem(
-  ImageStatisticsObject statisticsData,
-  StatisticNameVector statisticNames,
+  const ImageStatisticsObject& statisticsData,
+  const StatisticNameVector& statisticNames,
   QVariant label, bool isWIP,
   QmitkImageStatisticsTreeItem *parent)
   : m_statistics(statisticsData) , m_statisticNames(statisticNames), m_label(label), m_parentItem(parent), m_IsWIP(isWIP)
 {
 }
 
  QmitkImageStatisticsTreeItem::QmitkImageStatisticsTreeItem(const StatisticNameVector& statisticNames,
                                                            QVariant label,
                                                            bool isWIP,
                                                            QmitkImageStatisticsTreeItem *parentItem)
   : QmitkImageStatisticsTreeItem(ImageStatisticsObject(), statisticNames, label, isWIP, parentItem )
 {
 }
 
  QmitkImageStatisticsTreeItem::QmitkImageStatisticsTreeItem() : QmitkImageStatisticsTreeItem(StatisticNameVector(), QVariant(), false, nullptr ) {}
 
 QmitkImageStatisticsTreeItem::~QmitkImageStatisticsTreeItem()
 {
   qDeleteAll(m_childItems);
 }
 
 void QmitkImageStatisticsTreeItem::appendChild(QmitkImageStatisticsTreeItem *item)
 {
   m_childItems.append(item);
 }
 
 QmitkImageStatisticsTreeItem *QmitkImageStatisticsTreeItem::child(int row)
 {
   return m_childItems.value(row);
 }
 
 int QmitkImageStatisticsTreeItem::childCount() const
 {
   return m_childItems.count();
 }
 
 int QmitkImageStatisticsTreeItem::columnCount() const
 {
   return m_statisticNames.size() + 1;
 }
 
 struct StatValueVisitor : boost::static_visitor<QVariant>
 {
   QVariant operator()(const mitk::ImageStatisticsContainer::RealType& val) const
   {
     return QVariant(val);
   }
 
   QVariant operator()(const mitk::ImageStatisticsContainer::VoxelCountType& val) const
   {
     return QVariant::fromValue<mitk::ImageStatisticsContainer::VoxelCountType>(val);
   }
 
   QVariant operator()(const mitk::ImageStatisticsContainer::IndexType& val) const
   {
     std::stringstream ss;
     ss << val;
     return QVariant(QString::fromStdString(ss.str()));
   }
 
 };
 
 QVariant QmitkImageStatisticsTreeItem::data(int column) const
 {
   QVariant result;
   if (column > 0 && !m_statisticNames.empty())
   {
     if (column - 1 < static_cast<int>(m_statisticNames.size()))
     {
       if (m_IsWIP)
       {
         result = QVariant(QString("..."));
       }
       else
       {
         auto statisticKey = m_statisticNames.at(column - 1);
         if (m_statistics.HasStatistic(statisticKey))
         {
           return boost::apply_visitor(StatValueVisitor(), m_statistics.GetValueNonConverted(statisticKey));
         }
         else
         {
           return QVariant();
         }
       }
     }
     else
     {
       return QVariant();
     }
   }
   else if (column == 0)
   {
     result = m_label;
   }
   return result;
 }
 
 QmitkImageStatisticsTreeItem *QmitkImageStatisticsTreeItem::parentItem()
 {
   return m_parentItem;
 }
 
 int QmitkImageStatisticsTreeItem::row() const
 {
   if (m_parentItem)
     return m_parentItem->m_childItems.indexOf(const_cast<QmitkImageStatisticsTreeItem *>(this));
 
   return 0;
 }
 
 bool QmitkImageStatisticsTreeItem::isWIP() const
 {
   return m_IsWIP;
 }
diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeItem.h b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeItem.h
index 40e0ca3b87..9bb312f239 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeItem.h
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeItem.h
@@ -1,59 +1,59 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef QmitkImageStatisticsTreeItem_h
 #define QmitkImageStatisticsTreeItem_h
 
 #include <QList>
 #include <QVariant>
 
 #include "mitkImageStatisticsContainer.h"
 
 /*!
 \class QmitkImageStatisticsTreeItem
 An item that represents an entry (usually ImageStatisticsObject) for the QmitkImageStatisticsTreeModel
 */
 class QmitkImageStatisticsTreeItem
 {
 public:
   using ImageStatisticsObject = mitk::ImageStatisticsContainer::ImageStatisticsObject;
   using StatisticNameVector = mitk::ImageStatisticsContainer::ImageStatisticsObject::StatisticNameVector;
   QmitkImageStatisticsTreeItem();
-  explicit QmitkImageStatisticsTreeItem(ImageStatisticsObject statisticsData,
-    StatisticNameVector statisticNames, QVariant label, bool isWIP, QmitkImageStatisticsTreeItem *parentItem = nullptr);
+  explicit QmitkImageStatisticsTreeItem(const ImageStatisticsObject& statisticsData,
+    const StatisticNameVector& statisticNames, QVariant label, bool isWIP, QmitkImageStatisticsTreeItem *parentItem = nullptr);
   explicit QmitkImageStatisticsTreeItem(const StatisticNameVector& statisticNames,
     QVariant label, bool isWIP, QmitkImageStatisticsTreeItem *parentItem = nullptr);
   ~QmitkImageStatisticsTreeItem();
 
   void appendChild(QmitkImageStatisticsTreeItem *child);
 
   QmitkImageStatisticsTreeItem *child(int row);
   int childCount() const;
   int columnCount() const;
   QVariant data(int column) const;
   int row() const;
   QmitkImageStatisticsTreeItem *parentItem();
 
   /**indicates that the statistic container owned by this instance is only a dummy
   WIP container and the calculation of the up-to-date statistic is not yet finished.**/
   bool isWIP() const;
 
 private:
   ImageStatisticsObject m_statistics;
   StatisticNameVector m_statisticNames;
   QVariant m_label;
   QmitkImageStatisticsTreeItem *m_parentItem = nullptr;
   QList<QmitkImageStatisticsTreeItem *> m_childItems;
   bool m_IsWIP;
 };
 
 #endif
diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeModel.cpp b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeModel.cpp
index 82dbe49401..b9078ac9ba 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeModel.cpp
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeModel.cpp
@@ -1,497 +1,507 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkImageStatisticsTreeModel.h"
 
 #include "QmitkImageStatisticsTreeItem.h"
 #include "mitkImageStatisticsContainerManager.h"
 #include "mitkProportionalTimeGeometry.h"
 #include "mitkStatisticsToImageRelationRule.h"
 #include "mitkStatisticsToMaskRelationRule.h"
 
 #include "QmitkStyleManager.h"
 
 QmitkImageStatisticsTreeModel::QmitkImageStatisticsTreeModel(QObject *parent) : QmitkAbstractDataStorageModel(parent)
 {
   m_RootItem = std::make_unique<QmitkImageStatisticsTreeItem>();
 }
 
 QmitkImageStatisticsTreeModel ::~QmitkImageStatisticsTreeModel()
 {
   // set data storage to nullptr so that the event listener gets removed
   this->SetDataStorage(nullptr);
 };
 
 void QmitkImageStatisticsTreeModel::DataStorageChanged()
 {
   emit beginResetModel();
   UpdateByDataStorage();
   emit endResetModel();
   emit modelChanged();
 }
 
 void QmitkImageStatisticsTreeModel::NodePredicateChanged()
 {
   emit beginResetModel();
   UpdateByDataStorage();
   emit endResetModel();
   emit modelChanged();
 }
 
 int QmitkImageStatisticsTreeModel::columnCount(const QModelIndex& /*parent*/) const
 {
   int columns = m_StatisticNames.size() + 1;
   return columns;
 }
 
 int QmitkImageStatisticsTreeModel::rowCount(const QModelIndex &parent) const
 {
   QmitkImageStatisticsTreeItem *parentItem;
   if (parent.column() > 0)
     return 0;
 
   if (!parent.isValid())
     parentItem = m_RootItem.get();
   else
     parentItem = static_cast<QmitkImageStatisticsTreeItem *>(parent.internalPointer());
 
   return parentItem->childCount();
 }
 
 QVariant QmitkImageStatisticsTreeModel::data(const QModelIndex &index, int role) const
 {
   if (!index.isValid())
     return QVariant();
 
   QmitkImageStatisticsTreeItem* item = static_cast<QmitkImageStatisticsTreeItem*>(index.internalPointer());
 
   if (role == Qt::DisplayRole)
   {
     return item->data(index.column());
   }
   else if (role == Qt::DecorationRole && index.column() == 0 && item->isWIP() && item->childCount()==0)
   {
     return QVariant(QmitkStyleManager::ThemeIcon(QStringLiteral(":/Qmitk/hourglass-half-solid.svg")));
   }
   return QVariant();
 }
 
 QModelIndex QmitkImageStatisticsTreeModel::index(int row, int column, const QModelIndex &parent) const
 {
   if (!hasIndex(row, column, parent))
     return QModelIndex();
 
   QmitkImageStatisticsTreeItem *parentItem;
 
   if (!parent.isValid())
     parentItem = m_RootItem.get();
   else
     parentItem = static_cast<QmitkImageStatisticsTreeItem *>(parent.internalPointer());
 
   QmitkImageStatisticsTreeItem *childItem = parentItem->child(row);
   if (childItem)
     return createIndex(row, column, childItem);
   else
     return QModelIndex();
 }
 
 QModelIndex QmitkImageStatisticsTreeModel::parent(const QModelIndex &child) const
 {
   if (!child.isValid())
     return QModelIndex();
 
   QmitkImageStatisticsTreeItem *childItem = static_cast<QmitkImageStatisticsTreeItem *>(child.internalPointer());
   QmitkImageStatisticsTreeItem *parentItem = childItem->parentItem();
 
   if (parentItem == m_RootItem.get())
     return QModelIndex();
 
   return createIndex(parentItem->row(), 0, parentItem);
 }
 
 Qt::ItemFlags QmitkImageStatisticsTreeModel::flags(const QModelIndex &index) const
 {
   if (!index.isValid())
     return {};
 
   return QAbstractItemModel::flags(index);
 }
 
 QVariant QmitkImageStatisticsTreeModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
   if ((Qt::DisplayRole == role) && (Qt::Horizontal == orientation))
   {
     if (section == 0)
     {
       return m_HeaderFirstColumn;
     }
     else
     {
       return QVariant(m_StatisticNames.at(section - 1).c_str());
     }
   }
   return QVariant();
 }
 
 void QmitkImageStatisticsTreeModel::SetImageNodes(const std::vector<mitk::DataNode::ConstPointer> &nodes)
 {
   std::vector<std::pair<mitk::DataNode::ConstPointer, unsigned int>> tempNodes;
   for (const auto &node : nodes)
   {
     auto data = node->GetData();
     if (data)
     {
       auto timeSteps = data->GetTimeSteps();
       for (unsigned int i = 0; i < timeSteps; i++)
       {
         tempNodes.push_back(std::make_pair(node, i));
       }
     }
   }
 
   emit beginResetModel();
   m_TimeStepResolvedImageNodes = std::move(tempNodes);
   m_ImageNodes = nodes;
   UpdateByDataStorage();
   emit endResetModel();
   emit modelChanged();
 }
 
 void QmitkImageStatisticsTreeModel::SetMaskNodes(const std::vector<mitk::DataNode::ConstPointer> &nodes)
 {
   std::vector<std::pair<mitk::DataNode::ConstPointer, unsigned int>> tempNodes;
   for (const auto &node : nodes)
   {
     auto data = node->GetData();
     if (data)
     {
       auto timeSteps = data->GetTimeSteps();
       // special case: apply one mask to each time step of an 4D image
       if (timeSteps == 1 && m_TimeStepResolvedImageNodes.size() > 1)
       {
         timeSteps = m_TimeStepResolvedImageNodes.size();
       }
       for (unsigned int i = 0; i < timeSteps; i++)
       {
         tempNodes.push_back(std::make_pair(node, i));
       }
     }
   }
 
   emit beginResetModel();
   m_TimeStepResolvedMaskNodes = std::move(tempNodes);
   m_MaskNodes = nodes;
   UpdateByDataStorage();
   emit endResetModel();
   emit modelChanged();
 }
 
 void QmitkImageStatisticsTreeModel::Clear()
 {
   emit beginResetModel();
   m_Statistics.clear();
   m_ImageNodes.clear();
   m_TimeStepResolvedImageNodes.clear();
   m_MaskNodes.clear();
   m_StatisticNames.clear();
   emit endResetModel();
   emit modelChanged();
 }
 
 void QmitkImageStatisticsTreeModel::SetIgnoreZeroValueVoxel(bool _arg)
 {
   if (m_IgnoreZeroValueVoxel != _arg)
   {
     emit beginResetModel();
     m_IgnoreZeroValueVoxel = _arg;
     UpdateByDataStorage();
     emit endResetModel();
     emit modelChanged();
   }
 }
 
 bool QmitkImageStatisticsTreeModel::GetIgnoreZeroValueVoxel() const
 {
   return this->m_IgnoreZeroValueVoxel;
 }
 
 void QmitkImageStatisticsTreeModel::SetHistogramNBins(unsigned int nbins)
 {
   if (m_HistogramNBins != nbins)
   {
     emit beginResetModel();
     m_HistogramNBins = nbins;
     UpdateByDataStorage();
     emit endResetModel();
     emit modelChanged();
   }
 }
 
 unsigned int QmitkImageStatisticsTreeModel::GetHistogramNBins() const
 {
   return this->m_HistogramNBins;
 }
 
 void QmitkImageStatisticsTreeModel::UpdateByDataStorage()
 {
   StatisticsContainerVector newStatistics;
 
   auto datamanager = m_DataStorage.Lock();
 
   if (datamanager.IsNotNull())
   {
     for (const auto &image : m_ImageNodes)
     {
       if (m_MaskNodes.empty())
       {
         auto stats = mitk::ImageStatisticsContainerManager::GetImageStatistics(datamanager, image->GetData(), nullptr, m_IgnoreZeroValueVoxel, m_HistogramNBins, true, false);
 
         if (stats.IsNotNull())
         {
           newStatistics.emplace_back(stats);
         }
       }
       else
       {
         for (const auto &mask : m_MaskNodes)
         {
           auto stats =
             mitk::ImageStatisticsContainerManager::GetImageStatistics(datamanager, image->GetData(), mask->GetData(), m_IgnoreZeroValueVoxel, m_HistogramNBins, true, false);
           if (stats.IsNotNull())
           {
             newStatistics.emplace_back(stats);
           }
         }
       }
     }
     if (!newStatistics.empty())
     {
       emit dataAvailable();
     }
   }
 
   {
     std::lock_guard<std::mutex> locked(m_Mutex);
     m_Statistics = newStatistics;
 
     m_StatisticNames = mitk::GetAllStatisticNames(m_Statistics);
     BuildHierarchicalModel();
     m_BuildTime.Modified();
   }
 }
 
 void AddTimeStepTreeItems(const mitk::ImageStatisticsContainer* statistic, mitk::ImageStatisticsContainer::LabelValueType labelValue, const std::vector<std::string>& statisticNames, bool isWIP, QmitkImageStatisticsTreeItem* parentItem, bool& hasMultipleTimesteps)
 {
   // 4. hierarchy level: time steps (optional, only if >1 time step)
   if (statistic->GetTimeSteps() > 1)
   {
     for (unsigned int i = 0; i < statistic->GetTimeSteps(); i++)
     {
       QString timeStepLabel = "[" + QString::number(i) + "] " +
         QString::number(statistic->GetTimeGeometry()->TimeStepToTimePoint(i)) + " ms";
       if (statistic->StatisticsExist(labelValue, i))
       {
         auto statisticsItem = new QmitkImageStatisticsTreeItem(
           statistic->GetStatistics(labelValue,i), statisticNames, timeStepLabel, isWIP, parentItem);
         parentItem->appendChild(statisticsItem);
       }
       else
       {
         auto statisticsItem = new QmitkImageStatisticsTreeItem(statisticNames, QStringLiteral("N/A"), isWIP, parentItem);
       }
     }
   }
   hasMultipleTimesteps = hasMultipleTimesteps || (statistic->GetTimeSteps() > 1);
 }
 
 void AddLabelTreeItems(const mitk::ImageStatisticsContainer* statistic, const mitk::DataNode* maskNode, mitk::ImageStatisticsContainer::LabelValueVectorType labelValues, const std::vector<std::string>& statisticNames, bool isWIP, QmitkImageStatisticsTreeItem* parentItem, bool& hasMultipleTimesteps)
 {
   // 3. hierarchy level: labels (optional, only if labels >1)
   for (const auto labelValue : labelValues)
   {
     if (labelValue != mitk::ImageStatisticsContainer::NO_MASK_LABEL_VALUE)
     {
       //currently we only show statistics of the labeled pixel if a mask is provided
       QString labelLabel = QStringLiteral("unnamed label");
       const auto multiLabelSeg = dynamic_cast<mitk::LabelSetImage*>(maskNode->GetData());
       if (nullptr != multiLabelSeg)
       {
         auto labelInstance = multiLabelSeg->GetLabel(labelValue);
         labelLabel = QString::fromStdString(labelInstance->GetName() + " (" + labelInstance->GetTrackingID() + ")");
       }
       QmitkImageStatisticsTreeItem* labelItem = nullptr;
 
       if (statistic->GetTimeSteps() == 1)
       {
         // add statistical values directly in this hierarchy level
         auto statisticsObject = statistic->GetStatistics(labelValue, 0);
         labelItem = new QmitkImageStatisticsTreeItem(statisticsObject, statisticNames, labelLabel, isWIP, parentItem);
       }
       else
       {
         labelItem = new QmitkImageStatisticsTreeItem(statisticNames, labelLabel, isWIP, parentItem);
         AddTimeStepTreeItems(statistic, labelValue, statisticNames, isWIP, labelItem, hasMultipleTimesteps);
       }
 
       parentItem->appendChild(labelItem);
     }
   }
 }
 
 void QmitkImageStatisticsTreeModel::BuildHierarchicalModel()
 {
   // reset old model
   m_RootItem.reset(new QmitkImageStatisticsTreeItem());
 
   bool hasMask = false;
   bool hasMultipleTimesteps = false;
 
   std::map<mitk::DataNode::ConstPointer, QmitkImageStatisticsTreeItem *> dataNodeToTreeItem;
 
   for (const auto &statistic : m_Statistics)
   {
-    bool isWIP = statistic->GetProperty(mitk::STATS_GENERATION_STATUS_PROPERTY_NAME.c_str()).IsNotNull();
+    bool isWIP = statistic->IsWIP();
     // get the connected image data node/mask data node
     auto imageRule = mitk::StatisticsToImageRelationRule::New();
     auto imageOfStatisticsPredicate = imageRule->GetDestinationsDetector(statistic);
     auto imageFinding = std::find_if(m_ImageNodes.begin(), m_ImageNodes.end(), [&imageOfStatisticsPredicate](const mitk::DataNode::ConstPointer& testNode) { return imageOfStatisticsPredicate->CheckNode(testNode); });
 
     auto maskRule = mitk::StatisticsToMaskRelationRule::New();
     auto maskOfStatisticsPredicate = maskRule->GetDestinationsDetector(statistic);
     auto maskFinding = std::find_if(m_MaskNodes.begin(), m_MaskNodes.end(), [&maskOfStatisticsPredicate](const mitk::DataNode::ConstPointer& testNode) { return maskOfStatisticsPredicate->CheckNode(testNode); });
 
     if (imageFinding == m_ImageNodes.end())
     {
       mitkThrow() << "no image found connected to statistic" << statistic << " Aborting.";
     }
 
     auto& image = *imageFinding;
 
     // image: 1. hierarchy level
     QmitkImageStatisticsTreeItem *imageItem = nullptr;
     auto search = dataNodeToTreeItem.find(image);
     if (search != dataNodeToTreeItem.end())
     {
       // the tree item was created previously
       imageItem = search->second;
     }
     else
     {
       QString imageLabel = QString::fromStdString(image->GetName());
       if (statistic->GetTimeSteps() == 1 && maskFinding == m_MaskNodes.end())
       {
+        bool noZero = statistic->IgnoresZeroVoxel();
+        //we have to check if statistics are calculated with no zero voxels, because then
+        //we have a label/mask (no zero mask), even if no mask is officially defined.
+        auto labelValue = (!isWIP && noZero) ? statistic->GetExistingLabelValues(true).front() : mitk::ImageStatisticsContainer::NO_MASK_LABEL_VALUE;
+
+        auto statisticsObject = isWIP ? mitk::ImageStatisticsContainer::ImageStatisticsObject() : statistic->GetStatistics(labelValue, 0);
         // create the final statistics tree item
-        auto statisticsObject = isWIP ? mitk::ImageStatisticsContainer::ImageStatisticsObject() : statistic->GetStatistics(mitk::ImageStatisticsContainer::NO_MASK_LABEL_VALUE, 0);
         imageItem = new QmitkImageStatisticsTreeItem(statisticsObject, m_StatisticNames, imageLabel, isWIP, m_RootItem.get());
       }
       else
       {
         imageItem = new QmitkImageStatisticsTreeItem(m_StatisticNames, imageLabel, isWIP, m_RootItem.get());
       }
       m_RootItem->appendChild(imageItem);
       dataNodeToTreeItem.emplace(image, imageItem);
     }
 
     const auto labelValues = statistic->GetExistingLabelValues(true); //currently we not support showing the statistics for unlabeled pixels if a mask exist
     if (maskFinding != m_MaskNodes.end())
     {
       // mask: 2. hierarchy level exists
       auto& mask = *maskFinding;
       QString maskLabel = QString::fromStdString(mask->GetName());
       QmitkImageStatisticsTreeItem* maskItem;
 
       if (statistic->GetTimeSteps() == 1 && labelValues.size() == 1)
       {
         // add statistical values directly in this hierarchy level
         auto statisticsObject = isWIP ? mitk::ImageStatisticsContainer::ImageStatisticsObject() : statistic->GetStatistics(labelValues.front(), 0);
         maskItem = new QmitkImageStatisticsTreeItem(statisticsObject, m_StatisticNames, maskLabel, isWIP, imageItem);
       }
       else
       {
         maskItem = new QmitkImageStatisticsTreeItem(m_StatisticNames, maskLabel, isWIP, imageItem);
       }
 
       imageItem->appendChild(maskItem);
       hasMask = true;
 
       // 3. hierarchy level: labels (optional, only if more then one label in statistic)
       if (labelValues.size() > 1)
       {
         AddLabelTreeItems(statistic, mask, labelValues, m_StatisticNames, isWIP, maskItem, hasMultipleTimesteps);
       }
       else
       {
         mitk::Label::PixelType labelValue = isWIP ? 0 : labelValues.front();
         AddTimeStepTreeItems(statistic, labelValue, m_StatisticNames, isWIP, maskItem, hasMultipleTimesteps);
       }
     }
     else
     {
       //no mask -> but multi time step
-      AddTimeStepTreeItems(statistic, mitk::ImageStatisticsContainer::NO_MASK_LABEL_VALUE, m_StatisticNames, isWIP, imageItem, hasMultipleTimesteps);
+      bool noZero = statistic->IgnoresZeroVoxel();
+      //we have to check if statistics are calculated with no zero voxels, because then
+      //we have a label/mask (no zero mask), even if no mask is officially defined.
+      auto labelValue = (!isWIP && noZero) ? statistic->GetExistingLabelValues(true).front() : mitk::ImageStatisticsContainer::NO_MASK_LABEL_VALUE;
+
+      AddTimeStepTreeItems(statistic, labelValue, m_StatisticNames, isWIP, imageItem, hasMultipleTimesteps);
     }
   }
   QString headerString = "Images";
   if (hasMask)
   {
     headerString += "/Masks";
   }
   if (hasMultipleTimesteps)
   {
     headerString += "/Timesteps";
   }
   m_HeaderFirstColumn = headerString;
 }
 
 void QmitkImageStatisticsTreeModel::NodeRemoved(const mitk::DataNode* changedNode)
 {
   bool isRelevantNode = (nullptr != dynamic_cast<const mitk::ImageStatisticsContainer*>(changedNode->GetData()));
 
   if (isRelevantNode)
   {
     emit beginResetModel();
     UpdateByDataStorage();
     emit endResetModel();
     emit modelChanged();
   }
 }
 
 void QmitkImageStatisticsTreeModel::NodeAdded(const mitk::DataNode * changedNode)
 {
   bool isRelevantNode = (nullptr != dynamic_cast<const mitk::ImageStatisticsContainer*>(changedNode->GetData()));
 
   if (isRelevantNode)
   {
       emit beginResetModel();
       UpdateByDataStorage();
       emit endResetModel();
       emit modelChanged();
   }
 }
 
 void QmitkImageStatisticsTreeModel::NodeChanged(const mitk::DataNode * changedNode)
 {
   bool isRelevantNode = m_ImageNodes.end() != std::find(m_ImageNodes.begin(), m_ImageNodes.end(), changedNode);
   isRelevantNode = isRelevantNode || (m_MaskNodes.end() != std::find(m_MaskNodes.begin(), m_MaskNodes.end(), changedNode));
   isRelevantNode = isRelevantNode || (nullptr != dynamic_cast<const mitk::ImageStatisticsContainer*>(changedNode->GetData()));
 
   if (isRelevantNode)
   {
     if (m_BuildTime.GetMTime() < changedNode->GetData()->GetMTime())
     {
       emit beginResetModel();
       UpdateByDataStorage();
       emit endResetModel();
       emit modelChanged();
     }
   }
 }
diff --git a/Modules/Segmentation/Algorithms/mitkFeatureBasedEdgeDetectionFilter.cpp b/Modules/Segmentation/Algorithms/mitkFeatureBasedEdgeDetectionFilter.cpp
index 7c724274d0..eeded96c06 100644
--- a/Modules/Segmentation/Algorithms/mitkFeatureBasedEdgeDetectionFilter.cpp
+++ b/Modules/Segmentation/Algorithms/mitkFeatureBasedEdgeDetectionFilter.cpp
@@ -1,195 +1,195 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkFeatureBasedEdgeDetectionFilter.h"
 
 #include <SegmentationUtilities/MorphologicalOperations/mitkMorphologicalOperations.h>
 #include <mitkITKImageImport.h>
 #include <mitkImage.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkImageStatisticsCalculator.h>
 #include <mitkImageToUnstructuredGridFilter.h>
 #include <mitkProgressBar.h>
 #include <mitkUnstructuredGrid.h>
 #include <mitkImageMaskGenerator.h>
 #include <mitkImageStatisticsConstants.h>
 
 #include <itkBinaryBallStructuringElement.h>
 #include <itkBinaryContourImageFilter.h>
 #include <itkBinaryThresholdImageFilter.h>
 #include <itkDilateObjectMorphologyImageFilter.h>
 #include <itkErodeObjectMorphologyImageFilter.h>
 #include <itkImage.h>
 
 mitk::FeatureBasedEdgeDetectionFilter::FeatureBasedEdgeDetectionFilter()
 {
   this->SetNumberOfRequiredInputs(1);
 
   this->SetNumberOfIndexedOutputs(1);
 }
 
 mitk::FeatureBasedEdgeDetectionFilter::~FeatureBasedEdgeDetectionFilter()
 {
 }
 
 void mitk::FeatureBasedEdgeDetectionFilter::GenerateData()
 {
   mitk::Image::ConstPointer image = ImageToUnstructuredGridFilter::GetInput();
 
   if (m_SegmentationMask.IsNull())
   {
     MITK_WARN << "Please set a segmentation mask first" << std::endl;
     return;
   }
   // First create a threshold segmentation of the image. The threshold is determined
   // by the mean +/- stddev of the pixel values that are covered by the segmentation mask
 
   // Compute mean and stdDev based on the current segmentation
   mitk::ImageStatisticsCalculator::Pointer statCalc = mitk::ImageStatisticsCalculator::New();
   statCalc->SetInputImage(image);
 
   mitk::ImageMaskGenerator::Pointer imgMask = mitk::ImageMaskGenerator::New();
   imgMask->SetInputImage(image);
   imgMask->SetImageMask(m_SegmentationMask);
 
-  auto stats = statCalc->GetStatistics()->GetStatisticsForTimeStep(0);
+  auto stats = statCalc->GetStatistics()->GetStatistics(ImageStatisticsContainer::NO_MASK_LABEL_VALUE,0);
   double mean = stats.GetValueConverted<double>(mitk::ImageStatisticsConstants::MEAN());
   double stdDev = stats.GetValueConverted<double>(mitk::ImageStatisticsConstants::STANDARDDEVIATION());
 
   double upperThreshold = mean + stdDev;
   double lowerThreshold = mean - stdDev;
 
   // Perform thresholding
   mitk::Image::Pointer thresholdImage = mitk::Image::New();
   AccessByItk_3(image.GetPointer(), ITKThresholding, lowerThreshold, upperThreshold, thresholdImage)
 
     mitk::ProgressBar::GetInstance()
       ->Progress(2);
 
   // Postprocess threshold segmentation
   // First a closing will be executed
   mitk::Image::Pointer closedImage = mitk::Image::New();
   AccessByItk_1(thresholdImage, ThreadedClosing, closedImage);
 
   // Then we will holes that might exist
   mitk::MorphologicalOperations::FillHoles(closedImage);
 
   mitk::ProgressBar::GetInstance()->Progress();
 
   // Extract the binary edges of the resulting segmentation
   mitk::Image::Pointer edgeImage = mitk::Image::New();
   AccessByItk_1(closedImage, ContourSearch, edgeImage);
 
   // Convert the edge image into an unstructured grid
   mitk::ImageToUnstructuredGridFilter::Pointer i2UFilter = mitk::ImageToUnstructuredGridFilter::New();
   i2UFilter->SetInput(edgeImage);
   i2UFilter->SetThreshold(1.0);
   i2UFilter->Update();
 
   m_PointGrid = this->GetOutput();
   if (m_PointGrid.IsNull())
     m_PointGrid = mitk::UnstructuredGrid::New();
 
   m_PointGrid->SetVtkUnstructuredGrid(i2UFilter->GetOutput()->GetVtkUnstructuredGrid());
 
   mitk::ProgressBar::GetInstance()->Progress();
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void mitk::FeatureBasedEdgeDetectionFilter::ThreadedClosing(itk::Image<TPixel, VImageDimension> *originalImage,
                                                             mitk::Image::Pointer &result)
 {
   typedef itk::BinaryBallStructuringElement<TPixel, VImageDimension> myKernelType;
 
   myKernelType ball;
   ball.SetRadius(1);
   ball.CreateStructuringElement();
 
   typedef typename itk::Image<TPixel, VImageDimension> ImageType;
 
   typename itk::DilateObjectMorphologyImageFilter<ImageType, ImageType, myKernelType>::Pointer dilationFilter =
     itk::DilateObjectMorphologyImageFilter<ImageType, ImageType, myKernelType>::New();
   dilationFilter->SetInput(originalImage);
   dilationFilter->SetKernel(ball);
   dilationFilter->Update();
 
   typename itk::Image<TPixel, VImageDimension>::Pointer dilatedImage = dilationFilter->GetOutput();
 
   typename itk::ErodeObjectMorphologyImageFilter<ImageType, ImageType, myKernelType>::Pointer erodeFilter =
     itk::ErodeObjectMorphologyImageFilter<ImageType, ImageType, myKernelType>::New();
   erodeFilter->SetInput(dilatedImage);
   erodeFilter->SetKernel(ball);
   erodeFilter->Update();
 
   mitk::GrabItkImageMemory(erodeFilter->GetOutput(), result);
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void mitk::FeatureBasedEdgeDetectionFilter::ContourSearch(itk::Image<TPixel, VImageDimension> *originalImage,
                                                           mitk::Image::Pointer &result)
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef itk::BinaryContourImageFilter<ImageType, ImageType> binaryContourImageFilterType;
 
   typename binaryContourImageFilterType::Pointer binaryContourFilter = binaryContourImageFilterType::New();
   binaryContourFilter->SetInput(originalImage);
   binaryContourFilter->SetForegroundValue(1);
   binaryContourFilter->SetBackgroundValue(0);
   binaryContourFilter->Update();
 
   typename itk::Image<TPixel, VImageDimension>::Pointer itkImage = itk::Image<TPixel, VImageDimension>::New();
   itkImage->Graft(binaryContourFilter->GetOutput());
 
   mitk::GrabItkImageMemory(itkImage, result);
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void mitk::FeatureBasedEdgeDetectionFilter::ITKThresholding(const itk::Image<TPixel, VImageDimension> *originalImage,
                                                             double lower,
                                                             double upper,
                                                             mitk::Image::Pointer &result)
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef itk::Image<unsigned short, VImageDimension> SegmentationType;
   typedef itk::BinaryThresholdImageFilter<ImageType, SegmentationType> ThresholdFilterType;
 
   if (typeid(TPixel) != typeid(float) && typeid(TPixel) != typeid(double))
   {
     // round the thresholds if we have nor a float or double image
     lower = std::floor(lower + 0.5);
     upper = std::floor(upper - 0.5);
   }
   if (lower >= upper)
   {
     upper = lower;
   }
 
   typename ThresholdFilterType::Pointer filter = ThresholdFilterType::New();
   filter->SetInput(originalImage);
   filter->SetLowerThreshold(lower);
   filter->SetUpperThreshold(upper);
   filter->SetInsideValue(1);
   filter->SetOutsideValue(0);
   filter->Update();
 
   mitk::GrabItkImageMemory(filter->GetOutput(), result);
 }
 
 void mitk::FeatureBasedEdgeDetectionFilter::SetSegmentationMask(mitk::Image::Pointer segmentation)
 {
   this->m_SegmentationMask = segmentation;
 }
 
 void mitk::FeatureBasedEdgeDetectionFilter::GenerateOutputInformation()
 {
   Superclass::GenerateOutputInformation();
 }
diff --git a/Modules/SurfaceInterpolation/mitkImageToPointCloudFilter.cpp b/Modules/SurfaceInterpolation/mitkImageToPointCloudFilter.cpp
index 8304b6d820..4d9ea351c8 100644
--- a/Modules/SurfaceInterpolation/mitkImageToPointCloudFilter.cpp
+++ b/Modules/SurfaceInterpolation/mitkImageToPointCloudFilter.cpp
@@ -1,163 +1,163 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkImageToPointCloudFilter.h"
 
 #include <itkImageRegionIterator.h>
 #include <itkLaplacianImageFilter.h>
 
 #include <vtkPolyVertex.h>
 #include <vtkUnstructuredGrid.h>
 #include <vtkSmartPointer.h>
 
 #include <mitkITKImageImport.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkImageStatisticsCalculator.h>
 #include <mitkUnstructuredGrid.h>
 #include <mitkImageStatisticsConstants.h>
 
 mitk::ImageToPointCloudFilter::ImageToPointCloudFilter() : m_Geometry(nullptr)
 {
   m_Method = DetectionMethod(0);
 
   this->SetNumberOfRequiredInputs(1);
 
   this->SetNumberOfIndexedOutputs(1);
 }
 
 mitk::ImageToPointCloudFilter::~ImageToPointCloudFilter()
 {
 }
 
 void mitk::ImageToPointCloudFilter::GenerateData()
 {
   mitk::Image::ConstPointer image = ImageToUnstructuredGridFilter::GetInput();
   m_Geometry = image->GetGeometry();
 
   if (image.IsNull())
   {
     MITK_ERROR << "mitk::ImageToContourFilter: No input available. "
                   "Please set the input!"
                << std::endl;
     return;
   }
 
   mitk::Image::Pointer notConstImage = const_cast<mitk::Image *>(image.GetPointer());
 
   switch (m_Method)
   {
     case 0:
       AccessByItk_1(notConstImage.GetPointer(), StdDeviations, 2) break;
 
     case 1:
       AccessByItk_1(notConstImage.GetPointer(), StdDeviations, 3) break;
 
     case 2:
       AccessByItk_1(notConstImage.GetPointer(), StdDeviations, 4) break;
 
     default:
       AccessByItk_1(notConstImage.GetPointer(), StdDeviations, 2) break;
   }
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void mitk::ImageToPointCloudFilter::StdDeviations(itk::Image<TPixel, VImageDimension> *image, int amount)
 {
   typedef itk::Image<TPixel, VImageDimension> InputImageType;
   typedef itk::CastImageFilter<InputImageType, FloatImageType> ImagePTypeToFloatPTypeCasterType;
   typedef itk::LaplacianImageFilter<FloatImageType, FloatImageType> LaplacianFilterType;
   typename LaplacianFilterType::Pointer lapFilter = LaplacianFilterType::New();
 
   typename ImagePTypeToFloatPTypeCasterType::Pointer caster = ImagePTypeToFloatPTypeCasterType::New();
   caster->SetInput(image);
   caster->Update();
   FloatImageType::Pointer fImage = caster->GetOutput();
 
   lapFilter->SetInput(fImage);
   lapFilter->UpdateLargestPossibleRegion();
   auto edgeImage = mitk::ImportItkImage(lapFilter->GetOutput());
 
   mitk::ImageStatisticsCalculator::Pointer statCalc =
                                          mitk::ImageStatisticsCalculator::New();
   statCalc->SetInputImage(edgeImage.GetPointer());
-  auto stats = statCalc->GetStatistics()->GetStatisticsForTimeStep(0);
+  auto stats = statCalc->GetStatistics()->GetStatistics(ImageStatisticsContainer::NO_MASK_LABEL_VALUE, 0);
   auto mean = stats.GetValueConverted<double>(mitk::ImageStatisticsConstants::MEAN());
   auto stdDev = stats.GetValueConverted<double>(mitk::ImageStatisticsConstants::STANDARDDEVIATION());
 
   double upperThreshold = mean + stdDev * amount;
   double lowerThreshold = mean - stdDev * amount;
 
   typename itk::ImageRegionIterator<FloatImageType> it(lapFilter->GetOutput(),
                                                        lapFilter->GetOutput()->GetRequestedRegion());
 
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
 
   double greatX = 0, greatY = 0, greatZ = 0;
 
   it.GoToBegin();
   while (!it.IsAtEnd())
   {
     if (it.Get() > lowerThreshold && it.Get() < upperThreshold)
     {
       it.Set(0);
     }
     else
     {
       it.Set(1);
 
       mitk::Point3D imagePoint;
       mitk::Point3D worldPoint;
 
       imagePoint[0] = it.GetIndex()[0];
       imagePoint[1] = it.GetIndex()[1];
       imagePoint[2] = it.GetIndex()[2];
 
       m_Geometry->IndexToWorld(imagePoint, worldPoint);
 
       if (worldPoint[0] > greatX)
         greatX = worldPoint[0];
       if (worldPoint[1] > greatY)
         greatY = worldPoint[1];
       if (worldPoint[2] > greatZ)
         greatZ = worldPoint[2];
 
       points->InsertNextPoint(worldPoint[0], worldPoint[1], worldPoint[2]);
       m_NumberOfExtractedPoints++;
     }
     ++it;
   }
 
   /*need to build the UnstructuredGrid with at least one vertex otherwise its
   not visible*/
   vtkSmartPointer<vtkPolyVertex> verts = vtkSmartPointer<vtkPolyVertex>::New();
 
   verts->GetPointIds()->SetNumberOfIds(m_NumberOfExtractedPoints);
   for (int i = 0; i < m_NumberOfExtractedPoints; i++)
   {
     verts->GetPointIds()->SetId(i, i);
   }
 
   vtkSmartPointer<vtkUnstructuredGrid> uGrid = vtkSmartPointer<vtkUnstructuredGrid>::New();
   uGrid->Allocate(1);
 
   uGrid->InsertNextCell(verts->GetCellType(), verts->GetPointIds());
   uGrid->SetPoints(points);
 
   mitk::UnstructuredGrid::Pointer outputGrid = mitk::UnstructuredGrid::New();
   outputGrid->SetVtkUnstructuredGrid(uGrid);
   this->SetNthOutput(0, outputGrid);
 }
 
 void mitk::ImageToPointCloudFilter::GenerateOutputInformation()
 {
   Superclass::GenerateOutputInformation();
 }