diff --git a/Modules/ImageStatistics/mitkImageStatisticsCalculator.cpp b/Modules/ImageStatistics/mitkImageStatisticsCalculator.cpp
index 32eaec9440..6ae34e7543 100644
--- a/Modules/ImageStatistics/mitkImageStatisticsCalculator.cpp
+++ b/Modules/ImageStatistics/mitkImageStatisticsCalculator.cpp
@@ -1,536 +1,536 @@
 
 #include <limits>
 #include <cmath>
 
 #include <itkImageToHistogramFilter.h>
 #include <itkMaskedImageToHistogramFilter.h>
 #include <itkHistogram.h>
 #include <itkExtractImageFilter.h>
 #include <itkImageRegionConstIterator.h>
 #include <itkChangeInformationImageFilter.h>
 #include <itkMinimumMaximumImageCalculator.h>
 #include <itkMinimumMaximumImageFilter.h>
 #include <itkMaskImageFilter.h>
 #include <itkExceptionObject.h>
 
 #include <mitkImageStatisticsCalculator.h>
 #include <mitkImage.h>
 #include <mitkHistogramStatisticsCalculator.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkImageToItk.h>
 #include <mitkExtendedStatisticsImageFilter.h>
 #include <mitkExtendedLabelStatisticsImageFilter.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkMinMaxImageFilterWithIndex.h>
 #include <mitkMinMaxLabelmageFilterWithIndex.h>
 #include <mitkitkMaskImageFilter.h>
 #include <mitkImageCast.h>
 
 
 
 #include <mitkMaskUtilities.h>
 
 #include "itkImageFileWriter.h"
 
 namespace mitk
 {
 
     void ImageStatisticsCalculator::SetInputImage(mitk::Image::Pointer image)
     {
         if (image != m_Image)
         {
             m_Image = image;
             m_StatisticsUpdateTimePerTimeStep.resize(m_Image->GetTimeSteps());
             std::fill(m_StatisticsUpdateTimePerTimeStep.begin(), m_StatisticsUpdateTimePerTimeStep.end(), 0);
             this->Modified();
         }
     }
 
     void ImageStatisticsCalculator::SetMask(mitk::MaskGenerator::Pointer mask)
     {
 
         if (mask != m_MaskGenerator)
         {
             m_MaskGenerator = mask;
             this->Modified();
         }
 
     }
 
     void ImageStatisticsCalculator::SetSecondaryMask(mitk::MaskGenerator::Pointer mask)
     {
 
         if (mask != m_SecondaryMaskGenerator)
         {
             m_SecondaryMaskGenerator = mask;
             this->Modified();
         }
 
     }
 
 
     void ImageStatisticsCalculator::SetNBinsForHistogramStatistics(unsigned int nBins)
     {
         if (nBins != m_nBinsForHistogramStatistics)
         {
             m_nBinsForHistogramStatistics = nBins;
             this->Modified();
             this->m_UseBinSizeOverNBins = false;
         }
         if (m_UseBinSizeOverNBins)
         {
             this->Modified();
             this->m_UseBinSizeOverNBins = false;
         }
     }
 
     unsigned int ImageStatisticsCalculator::GetNBinsForHistogramStatistics() const
     {
         return m_nBinsForHistogramStatistics;
     }
 
     void ImageStatisticsCalculator::SetBinSizeForHistogramStatistics(double binSize)
     {
         if (binSize != m_binSizeForHistogramStatistics)
         {
             m_binSizeForHistogramStatistics = binSize;
             this->Modified();
             this->m_UseBinSizeOverNBins = true;
         }
         if (!m_UseBinSizeOverNBins)
         {
             this->Modified();
             this->m_UseBinSizeOverNBins = true;
         }
     }
 
     double ImageStatisticsCalculator::GetBinSizeForHistogramStatistics() const
     {
         return m_binSizeForHistogramStatistics;
     }
 
     mitk::StatisticsContainer::StatisticsObject ImageStatisticsCalculator::GetStatistics(unsigned int timeStep, unsigned int label)
     {
         if (!m_StatisticContainers.empty() && timeStep >= m_StatisticContainers.back()->GetTimeSteps())
         {
              mitkThrow() << "invalid timeStep in ImageStatisticsCalculator_v2::GetStatistics";
         }
 
         if (m_Image.IsNull())
         {
              mitkThrow() << "no image";
         }
 
         if (!m_Image->IsInitialized())
         {
           mitkThrow() << "Image not initialized!";
         }
 
         auto timeGeometry = m_Image->GetTimeGeometry();
         if (IsUpdateRequired(timeStep))
         {
             if (m_MaskGenerator.IsNotNull())
             {
                 m_MaskGenerator->SetTimeStep(timeStep);
                 m_InternalMask = m_MaskGenerator->GetMask();
                 if (m_MaskGenerator->GetReferenceImage().IsNotNull())
                 {
                     m_InternalImageForStatistics = m_MaskGenerator->GetReferenceImage();
                 }
                 else
                 {
                     m_InternalImageForStatistics = m_Image;
                 }
             }
             else
             {
                 m_InternalImageForStatistics = m_Image;
             }
 
             if (m_SecondaryMaskGenerator.IsNotNull())
             {
                 m_SecondaryMaskGenerator->SetTimeStep(timeStep);
                 m_SecondaryMask = m_SecondaryMaskGenerator->GetMask();
             }
 
             ImageTimeSelector::Pointer imgTimeSel = ImageTimeSelector::New();
             imgTimeSel->SetInput(m_InternalImageForStatistics);
             imgTimeSel->SetTimeNr(timeStep);
             imgTimeSel->UpdateLargestPossibleRegion();
             m_ImageTimeSlice = imgTimeSel->GetOutput();
 
 
             // Calculate statistics with/without mask
             if (m_MaskGenerator.IsNull() && m_SecondaryMaskGenerator.IsNull())
             {
                 // 1) calculate statistics unmasked:
                 AccessByItk_2(m_ImageTimeSlice, InternalCalculateStatisticsUnmasked, timeGeometry, timeStep)
 
             }
             else
             {
                 // 2) calculate statistics masked
                 AccessByItk_2(m_ImageTimeSlice, InternalCalculateStatisticsMasked, timeGeometry, timeStep)
             }
 
             //this->Modified();
         }
 
         m_StatisticsUpdateTimePerTimeStep[timeStep] = m_StatisticContainers[m_StatisticContainers.size() - 1]->GetMTime();
 
         for (auto it = m_StatisticContainers.begin(); it != m_StatisticContainers.end(); ++it)
         {
             StatisticsContainer::Pointer statCont = *it;
             StatisticsContainer::StatisticsObject statObject = statCont->GetStatisticsForTimeStep(timeStep);
             if (statObject.m_Label == label)
             {
               return statObject;
             }
         }
 
         // these lines will ony be executed if the requested label could not be found!
         MITK_WARN << "Invalid label: " << label << " in time step: " << timeStep;
         return StatisticsContainer::StatisticsObject();
     }
 
     template < typename TPixel, unsigned int VImageDimension > void ImageStatisticsCalculator::InternalCalculateStatisticsUnmasked(
             typename itk::Image< TPixel, VImageDimension >* image, TimeGeometry* timeGeometry, TimeStepType timeStep)
     {
         typedef typename itk::Image< TPixel, VImageDimension > ImageType;
         typedef typename itk::ExtendedStatisticsImageFilter<ImageType> ImageStatisticsFilterType;
         typedef typename itk::MinMaxImageFilterWithIndex<ImageType> MinMaxFilterType;
         
 
         // reset statistics container if queried time step exists
         if(m_StatisticContainers.empty() || m_StatisticContainers.back()->TimeStepExists(timeStep)) {
           m_StatisticContainers.clear();
           StatisticsContainer::Pointer statisticsResult = StatisticsContainer::New();
           statisticsResult->SetTimeGeometry(timeGeometry);
           m_StatisticContainers.push_back(statisticsResult);
         }
 
         //TODO for(timeStep)
         auto statObj = StatisticsContainer::StatisticsObject();
 
         typename ImageStatisticsFilterType::Pointer statisticsFilter = ImageStatisticsFilterType::New();
         statisticsFilter->SetInput(image);
         statisticsFilter->SetCoordinateTolerance(0.001);
         statisticsFilter->SetDirectionTolerance(0.001);
 
         // TODO: this is single threaded. Implement our own image filter that does this multi threaded
 //        typename itk::MinimumMaximumImageCalculator<ImageType>::Pointer imgMinMaxFilter = itk::MinimumMaximumImageCalculator<ImageType>::New();
 //        imgMinMaxFilter->SetImage(image);
 //        imgMinMaxFilter->Compute();
         vnl_vector<int> minIndex, maxIndex;
 
         typename MinMaxFilterType::Pointer minMaxFilter = MinMaxFilterType::New();
         minMaxFilter->SetInput(image);
         minMaxFilter->UpdateLargestPossibleRegion();
         typename ImageType::PixelType minval = minMaxFilter->GetMin();
         typename ImageType::PixelType maxval = minMaxFilter->GetMax();
 
         typename ImageType::IndexType tmpMinIndex = minMaxFilter->GetMinIndex();
         typename ImageType::IndexType tmpMaxIndex = minMaxFilter->GetMaxIndex();
 
 //        typename ImageType::IndexType tmpMinIndex = imgMinMaxFilter->GetIndexOfMinimum();
 //        typename ImageType::IndexType tmpMaxIndex = imgMinMaxFilter->GetIndexOfMaximum();
 
         minIndex.set_size(tmpMaxIndex.GetIndexDimension());
         maxIndex.set_size(tmpMaxIndex.GetIndexDimension());
 
         for (unsigned int i=0; i < tmpMaxIndex.GetIndexDimension(); i++)
         {
             minIndex[i] = tmpMinIndex[i];
             maxIndex[i] = tmpMaxIndex[i];
         }
 
         statObj.m_MinIndex = minIndex;
         statObj.m_MaxIndex = maxIndex;
 
         //convert m_binSize in m_nBins if necessary
         unsigned int nBinsForHistogram;
         if (m_UseBinSizeOverNBins)
         {
             nBinsForHistogram = std::max(static_cast<double>(std::ceil(maxval - minval)) / m_binSizeForHistogramStatistics, 10.); // do not allow less than 10 bins
         }
         else
         {
             nBinsForHistogram = m_nBinsForHistogramStatistics;
         }
 
         statisticsFilter->SetHistogramParameters(nBinsForHistogram, minval, maxval);
 
         try
         {
           statisticsFilter->Update();
         }
         catch (const itk::ExceptionObject& e)
         {
           mitkThrow() << "Image statistics calculation failed due to following ITK Exception: \n " << e.what();
         }
 
         auto voxelVolume = GetVoxelVolume<TPixel, VImageDimension>(image);
 
         // no mask, therefore just one label = the whole image
         statObj.m_Label = 1;
         statObj.m_N = image->GetLargestPossibleRegion().GetNumberOfPixels();
         statObj.m_Volume = statObj.m_N * voxelVolume;
         statObj.m_Mean = statisticsFilter->GetMean();
         statObj.m_Min = statisticsFilter->GetMinimum();
         statObj.m_Max = statisticsFilter->GetMaximum();
         statObj.m_Std = statisticsFilter->GetSigma();
         statObj.m_Skewness = statisticsFilter->GetSkewness();
         statObj.m_Kurtosis = statisticsFilter->GetKurtosis();
         statObj.m_RMS = std::sqrt(std::pow(statisticsFilter->GetMean(), 2.) + statisticsFilter->GetVariance()); // variance = sigma^2
         statObj.m_MPP = statisticsFilter->GetMPP();
 
         statObj.m_Entropy = statisticsFilter->GetEntropy();
         statObj.m_Median = statisticsFilter->GetMedian();
         statObj.m_Uniformity = statisticsFilter->GetUniformity();
         statObj.m_UPP = statisticsFilter->GetUPP();
         statObj.m_Histogram = statisticsFilter->GetHistogram();
 
         m_StatisticContainers.back()->SetStatisticsForTimeStep(timeStep, statObj);
     }
 
     template < typename TPixel, unsigned int VImageDimension >
     double ImageStatisticsCalculator::GetVoxelVolume(typename itk::Image<TPixel, VImageDimension>* image) const
     {
       auto spacing = image->GetSpacing();
       double voxelVolume = 1.;
       for (unsigned int i = 0; i < image->GetImageDimension(); i++) {
         voxelVolume *= spacing[i];
       }
       return voxelVolume;
     }
 
     template < typename TPixel, unsigned int VImageDimension > void ImageStatisticsCalculator::InternalCalculateStatisticsMasked(
             typename itk::Image< TPixel, VImageDimension >* image, TimeGeometry* timeGeometry,
             unsigned int timeStep)
     {
         typedef itk::Image< TPixel, VImageDimension > ImageType;
         typedef itk::Image< MaskPixelType, VImageDimension > MaskType;
         typedef typename MaskType::PixelType LabelPixelType;
         typedef itk::ExtendedLabelStatisticsImageFilter< ImageType, MaskType > ImageStatisticsFilterType;
         typedef MaskUtilities< TPixel, VImageDimension > MaskUtilType;
         typedef typename itk::MinMaxLabelImageFilterWithIndex<ImageType, MaskType> MinMaxLabelFilterType;
         typedef typename ImageType::PixelType InputImgPixelType;
 
         // workaround: if m_SecondaryMaskGenerator ist not null but m_MaskGenerator is! (this is the case if we request a 'ignore zuero valued pixels'
         // mask in the gui but do not define a primary mask)
         bool swapMasks = false;
         if (m_SecondaryMask.IsNotNull() && m_InternalMask.IsNull())
         {
             m_InternalMask = m_SecondaryMask;
             m_SecondaryMask = nullptr;
             swapMasks = true;
         }
 
         // maskImage has to have the same dimension as image
         typename MaskType::Pointer maskImage = MaskType::New();
         try {
             // try to access the pixel values directly (no copying or casting). Only works if mask pixels are of pixelType unsigned short
             maskImage = ImageToItkImage< MaskPixelType, VImageDimension >(m_InternalMask);
         }
         catch (const itk::ExceptionObject &)
 
         {
             // if the pixel type of the mask is not short, then we have to make a copy of m_InternalMask (and cast the values)
             CastToItkImage(m_InternalMask, maskImage);
         }
 
         // if we have a secondary mask (say a ignoreZeroPixelMask) we need to combine the masks (corresponds to AND)
         if (m_SecondaryMask.IsNotNull())
         {
             // dirty workaround for a bug when pf mask + any other mask is used in conjunction. We need a proper fix for this (Fabian Isensee is responsible and probably working on it!)
             if (m_InternalMask->GetDimension() == 2 && (m_SecondaryMask->GetDimension() == 3 || m_SecondaryMask->GetDimension() == 4))
             {
                 mitk::Image::Pointer old_img = m_SecondaryMaskGenerator->GetReferenceImage();
                 m_SecondaryMaskGenerator->SetInputImage(m_MaskGenerator->GetReferenceImage());
                 m_SecondaryMask = m_SecondaryMaskGenerator->GetMask();
                 m_SecondaryMaskGenerator->SetInputImage(old_img);
             }
             typename MaskType::Pointer secondaryMaskImage = MaskType::New();
             secondaryMaskImage = ImageToItkImage< MaskPixelType, VImageDimension >(m_SecondaryMask);
 
             // secondary mask should be a ignore zero value pixel mask derived from image. it has to be cropped to the mask region (which may be planar or simply smaller)
             typename MaskUtilities<MaskPixelType, VImageDimension>::Pointer secondaryMaskMaskUtil = MaskUtilities<MaskPixelType, VImageDimension>::New();
             secondaryMaskMaskUtil->SetImage(secondaryMaskImage.GetPointer());
             secondaryMaskMaskUtil->SetMask(maskImage.GetPointer());
             typename MaskType::Pointer adaptedSecondaryMaskImage = secondaryMaskMaskUtil->ExtractMaskImageRegion();
 
             typename itk::MaskImageFilter2<MaskType, MaskType, MaskType>::Pointer maskFilter = itk::MaskImageFilter2<MaskType, MaskType, MaskType>::New();
             maskFilter->SetInput1(maskImage);
             maskFilter->SetInput2(adaptedSecondaryMaskImage);
             maskFilter->SetMaskingValue(1); // all pixels of maskImage where secondaryMaskImage==1 will be kept, all the others are set to 0
             maskFilter->UpdateLargestPossibleRegion();
             maskImage = maskFilter->GetOutput();
         }
 
         typename MaskUtilType::Pointer maskUtil = MaskUtilType::New();
         maskUtil->SetImage(image);
         maskUtil->SetMask(maskImage.GetPointer());
 
         // if mask is smaller than image, extract the image region where the mask is
         typename ImageType::Pointer adaptedImage = ImageType::New();
 
         adaptedImage = maskUtil->ExtractMaskImageRegion(); // this also checks mask sanity
 
         // find min, max, minindex and maxindex
         typename MinMaxLabelFilterType::Pointer minMaxFilter = MinMaxLabelFilterType::New();
         minMaxFilter->SetInput(adaptedImage);
         minMaxFilter->SetLabelInput(maskImage);
         minMaxFilter->UpdateLargestPossibleRegion();
 
         // set histogram parameters for each label individually (min/max may be different for each label)
         typedef typename std::map<LabelPixelType, InputImgPixelType> MapType;
         typedef typename std::pair<LabelPixelType, InputImgPixelType> PairType;
 
         std::vector<LabelPixelType> relevantLabels = minMaxFilter->GetRelevantLabels();
         MapType minVals;
         MapType maxVals;
         std::map<LabelPixelType, unsigned int> nBins;
 
         for (LabelPixelType label:relevantLabels)
         {
             minVals.insert(PairType(label, minMaxFilter->GetMin(label)));
             maxVals.insert(PairType(label, minMaxFilter->GetMax(label)));
 
             unsigned int nBinsForHistogram;
             if (m_UseBinSizeOverNBins)
             {
                 nBinsForHistogram = std::max(static_cast<double>(std::ceil(minMaxFilter->GetMax(label) - minMaxFilter->GetMin(label))) / m_binSizeForHistogramStatistics, 10.); // do not allow less than 10 bins
             }
             else
             {
                 nBinsForHistogram = m_nBinsForHistogramStatistics;
             }
 
             nBins.insert(typename std::pair<LabelPixelType, unsigned int>(label, nBinsForHistogram));
         }
 
         typename ImageStatisticsFilterType::Pointer imageStatisticsFilter = ImageStatisticsFilterType::New();
         imageStatisticsFilter->SetDirectionTolerance(0.001);
         imageStatisticsFilter->SetCoordinateTolerance(0.001);
         imageStatisticsFilter->SetInput(adaptedImage);
         imageStatisticsFilter->SetLabelInput(maskImage);
         imageStatisticsFilter->SetHistogramParametersForLabels(nBins, minVals, maxVals);
         imageStatisticsFilter->Update();
 
         std::list<int> labels = imageStatisticsFilter->GetRelevantLabels();
         auto it = labels.begin();
 
         if (m_StatisticContainers.empty() || m_StatisticContainers.back()->TimeStepExists(timeStep)) {
           m_StatisticContainers.clear();
-          for (int i = 0; i < labels.size(); i++) {
+          for (size_t i = 0; i < labels.size(); i++) {
             StatisticsContainer::Pointer statisticsResult = StatisticsContainer::New();
             statisticsResult->SetTimeGeometry(timeGeometry);
             m_StatisticContainers.push_back(statisticsResult);
           }
         }
 
         //m_StatisticsByTimeStep[timeStep].resize(0);
 
         while(it != labels.end())
         {
             StatisticsContainer::StatisticsObject statObj = StatisticsContainer::StatisticsObject();
 
             // find min, max, minindex and maxindex
             // make sure to only look in the masked region, use a masker for this
 
             vnl_vector<int> minIndex, maxIndex;
             mitk::Point3D worldCoordinateMin;
             mitk::Point3D worldCoordinateMax;
             mitk::Point3D indexCoordinateMin;
             mitk::Point3D indexCoordinateMax;
             m_InternalImageForStatistics->GetGeometry()->IndexToWorld(minMaxFilter->GetMinIndex(*it), worldCoordinateMin);
             m_InternalImageForStatistics->GetGeometry()->IndexToWorld(minMaxFilter->GetMaxIndex(*it), worldCoordinateMax);
             m_Image->GetGeometry()->WorldToIndex(worldCoordinateMin, indexCoordinateMin);
             m_Image->GetGeometry()->WorldToIndex(worldCoordinateMax, indexCoordinateMax);
 
             minIndex.set_size(3);
             maxIndex.set_size(3);
 
             //for (unsigned int i=0; i < tmpMaxIndex.GetIndexDimension(); i++)
             for (unsigned int i=0; i < 3; i++)
             {
                 minIndex[i] = indexCoordinateMin[i];
                 maxIndex[i] = indexCoordinateMax[i];
             }
 
             statObj.m_MinIndex = minIndex;
             statObj.m_MaxIndex = maxIndex;
 
             assert(std::abs(minMaxFilter->GetMax(*it) - imageStatisticsFilter->GetMaximum(*it)) < mitk::eps);
             assert(std::abs(minMaxFilter->GetMin(*it) - imageStatisticsFilter->GetMinimum(*it)) < mitk::eps);
 
             auto voxelVolume = GetVoxelVolume<TPixel, VImageDimension>(image);
 
             statObj.m_N = imageStatisticsFilter->GetSum(*it) / (double) imageStatisticsFilter->GetMean(*it);
             statObj.m_Volume = statObj.m_N * voxelVolume;
             statObj.m_Mean = imageStatisticsFilter->GetMean(*it);
             statObj.m_Min = imageStatisticsFilter->GetMinimum(*it);
             statObj.m_Max = imageStatisticsFilter->GetMaximum(*it);
             statObj.m_Std = imageStatisticsFilter->GetSigma(*it);
             statObj.m_Skewness = imageStatisticsFilter->GetSkewness(*it);
             statObj.m_Kurtosis = imageStatisticsFilter->GetKurtosis(*it);
             statObj.m_RMS = std::sqrt(std::pow(imageStatisticsFilter->GetMean(*it), 2.) + imageStatisticsFilter->GetVariance(*it)); // variance = sigma^2
             statObj.m_MPP = imageStatisticsFilter->GetMPP(*it);
             statObj.m_Label = *it;
 
             statObj.m_Entropy = imageStatisticsFilter->GetEntropy(*it);
             statObj.m_Median = imageStatisticsFilter->GetMedian(*it);
             statObj.m_Uniformity = imageStatisticsFilter->GetUniformity(*it);
             statObj.m_UPP = imageStatisticsFilter->GetUPP(*it);
             statObj.m_Histogram = imageStatisticsFilter->GetHistogram(*it);
 
             m_StatisticContainers.at(*it)->SetStatisticsForTimeStep(timeStep, statObj);
             //m_StatisticsByTimeStep[timeStep].push_back(statisticsResult);
             ++it;
         }
 
         // swap maskGenerators back
         if (swapMasks)
         {
             m_SecondaryMask = m_InternalMask;
             m_InternalMask = nullptr;
         }
     }
 
     bool ImageStatisticsCalculator::IsUpdateRequired(unsigned int timeStep) const
     {
         unsigned long thisClassTimeStamp = this->GetMTime();
         unsigned long inputImageTimeStamp = m_Image->GetMTime();
         unsigned long statisticsTimeStamp = m_StatisticsUpdateTimePerTimeStep[timeStep];
 
         if (thisClassTimeStamp > statisticsTimeStamp) // inputs have changed
         {
             return true;
         }
 
         if (inputImageTimeStamp > statisticsTimeStamp) // image has changed
         {
             return true;
         }
 
         if (m_MaskGenerator.IsNotNull())
         {
             unsigned long maskGeneratorTimeStamp = m_MaskGenerator->GetMTime();
             if (maskGeneratorTimeStamp > statisticsTimeStamp) // there is a mask generator and it has changed
             {
                 return true;
             }
         }
 
         if (m_SecondaryMaskGenerator.IsNotNull())
         {
             unsigned long maskGeneratorTimeStamp = m_SecondaryMaskGenerator->GetMTime();
             if (maskGeneratorTimeStamp > statisticsTimeStamp) // there is a secondary mask generator and it has changed
             {
                 return true;
             }
         }
 
         return false;
     }
 }
diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationJob.cpp b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationJob.cpp
index 01283c5569..1142e81514 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationJob.cpp
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationJob.cpp
@@ -1,264 +1,264 @@
 /*===================================================================
 
 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 "QmitkImageStatisticsCalculationJob.h"
 
 //QT headers
 #include <QMessageBox>
 #include <QApplication>
 #include <mitkImageMaskGenerator.h>
 #include <mitkPlanarFigureMaskGenerator.h>
 #include <mitkIgnorePixelMaskGenerator.h>
 
 QmitkImageStatisticsCalculationJob::QmitkImageStatisticsCalculationJob()
   : QThread()
   , m_StatisticsImage(nullptr)
   , m_BinaryMask(nullptr)
   , m_PlanarFigureMask(nullptr)
   , m_TimeStep(0)
   , m_IgnoreZeros(false)
   , m_HistogramNBins(100)
   , m_StatisticChanged(false)
   , m_CalculationSuccessful(false)
 {
 }
 
 QmitkImageStatisticsCalculationJob::~QmitkImageStatisticsCalculationJob()
 {
 }
 
 void QmitkImageStatisticsCalculationJob::Initialize( mitk::Image::ConstPointer image, mitk::Image::ConstPointer binaryImage, mitk::PlanarFigure::ConstPointer planarFig )
 {
   // reset old values
   if( this->m_StatisticsImage.IsNotNull() )
     this->m_StatisticsImage = nullptr;
   if( this->m_BinaryMask.IsNotNull() )
     this->m_BinaryMask = nullptr;
   if( this->m_PlanarFigureMask.IsNotNull())
     this->m_PlanarFigureMask = nullptr;
 
   // set new values if passed in
   if(image.IsNotNull())
     this->m_StatisticsImage = image;
   if(binaryImage.IsNotNull())
     this->m_BinaryMask = binaryImage;
   if(planarFig.IsNotNull())
     this->m_PlanarFigureMask = planarFig;
 }
 
 void QmitkImageStatisticsCalculationJob::SetTimeStep( int times )
 {
   this->m_TimeStep = times;
 }
 
 int QmitkImageStatisticsCalculationJob::GetTimeStep() const
 {
   return this->m_TimeStep;
 }
 
 mitk::StatisticsContainer::ConstPointer QmitkImageStatisticsCalculationJob::GetStatisticsData() const
 {
-  mitk::StatisticsContainer::ConstPointer constContainer = this->m_StatisticsContainer;
+  mitk::StatisticsContainer::ConstPointer constContainer = this->m_StatisticsContainer.GetPointer();
   return constContainer;
 }
 
 mitk::Image::ConstPointer QmitkImageStatisticsCalculationJob::GetStatisticsImage() const
 {
   return this->m_StatisticsImage;
 }
 
 mitk::Image::ConstPointer QmitkImageStatisticsCalculationJob::GetMaskImage() const
 {
   return this->m_BinaryMask;
 }
 
 mitk::PlanarFigure::ConstPointer QmitkImageStatisticsCalculationJob::GetPlanarFigure() const
 {
   return this->m_PlanarFigureMask;
 }
 
 void QmitkImageStatisticsCalculationJob::SetIgnoreZeroValueVoxel(bool _arg)
 {
   this->m_IgnoreZeros = _arg;
 }
 
 bool QmitkImageStatisticsCalculationJob::GetIgnoreZeroValueVoxel() const
 {
   return this->m_IgnoreZeros;
 }
 
 void QmitkImageStatisticsCalculationJob::SetHistogramNBins(unsigned int nbins)
 {
   this->m_HistogramNBins = nbins;
 }
 
 unsigned int QmitkImageStatisticsCalculationJob::GetHistogramNBins() const
 {
   return this->m_HistogramNBins;
 }
 
 std::string QmitkImageStatisticsCalculationJob::GetLastErrorMessage() const
 {
   return m_message;
 }
 
 QmitkImageStatisticsCalculationJob::HistogramType::ConstPointer
 QmitkImageStatisticsCalculationJob::GetTimeStepHistogram(unsigned int t) const
 {
   if (t >= this->m_HistogramVector.size())
     return nullptr;
 
   return this->m_HistogramVector[t];
 }
 
 bool QmitkImageStatisticsCalculationJob::GetStatisticsChangedFlag() const
 {
   return m_StatisticChanged;
 }
 
 bool QmitkImageStatisticsCalculationJob::GetStatisticsUpdateSuccessFlag() const
 {
   return m_CalculationSuccessful;
 }
 
 void QmitkImageStatisticsCalculationJob::run()
 {
   bool statisticCalculationSuccessful = true;
   mitk::ImageStatisticsCalculator::Pointer calculator = mitk::ImageStatisticsCalculator::New();
 
   if(this->m_StatisticsImage.IsNotNull())
   {
     calculator->SetInputImage(m_StatisticsImage->Clone());
   }
   else
   {
     statisticCalculationSuccessful = false;
   }
 
   // Bug 13416 : The ImageStatistics::SetImageMask() method can throw exceptions, i.e. when the dimensionality
   // of the masked and input image differ, we need to catch them and mark the calculation as failed
   // the same holds for the ::SetPlanarFigure()
   try
   {
     if(this->m_BinaryMask.IsNotNull())
     {
       mitk::ImageMaskGenerator::Pointer imgMask = mitk::ImageMaskGenerator::New();
       imgMask->SetImageMask(m_BinaryMask->Clone());
       calculator->SetMask(imgMask.GetPointer());
     }
     if(this->m_PlanarFigureMask.IsNotNull())
     {
       mitk::PlanarFigureMaskGenerator::Pointer pfMaskGen = mitk::PlanarFigureMaskGenerator::New();
       pfMaskGen->SetInputImage(m_StatisticsImage->Clone());
       pfMaskGen->SetPlanarFigure(m_PlanarFigureMask->Clone());
       calculator->SetMask(pfMaskGen.GetPointer());
     }
   }
   catch (const mitk::Exception& e)
   {
     MITK_ERROR << "MITK Exception: " << e.what();
     m_message = e.what();
     statisticCalculationSuccessful = false;
   }
   catch( const itk::ExceptionObject& e)
   {
     MITK_ERROR << "ITK Exception:" << e.what();
     m_message = e.what();
     statisticCalculationSuccessful = false;
   }
   catch ( const std::runtime_error &e )
   {
     MITK_ERROR<< "Runtime Exception: " << e.what();
     m_message = e.what();
     statisticCalculationSuccessful = false;
   }
   catch ( const std::exception &e )
   {
     MITK_ERROR<< "Standard Exception: " << e.what();
     m_message = e.what();
     statisticCalculationSuccessful = false;
   }
 
   bool statisticChanged = false;
 
   if (this->m_IgnoreZeros)
   {
       mitk::IgnorePixelMaskGenerator::Pointer ignorePixelValueMaskGen = mitk::IgnorePixelMaskGenerator::New();
       ignorePixelValueMaskGen->SetIgnoredPixelValue(0);
       ignorePixelValueMaskGen->SetInputImage(m_StatisticsImage->Clone());
       calculator->SetSecondaryMask(ignorePixelValueMaskGen.GetPointer());
   }
   else
   {
       calculator->SetSecondaryMask(nullptr);
   }
 
   calculator->SetNBinsForHistogramStatistics(m_HistogramNBins);
 
   for (unsigned int i = 0; i < m_StatisticsImage->GetTimeSteps(); i++)
   {
     try
     {
       calculator->GetStatistics(i);
     }
     catch ( mitk::Exception& e)
     {
       m_message = e.GetDescription();
       MITK_ERROR<< "MITK Exception: " << e.what();
       statisticCalculationSuccessful = false;
     }
     catch ( const std::runtime_error &e )
     {
       m_message = "Failure: " + std::string(e.what());
       MITK_ERROR<< "Runtime Exception: " << e.what();
       statisticCalculationSuccessful = false;
     }
     catch ( const std::exception &e )
     {
       m_message = "Failure: " + std::string(e.what());
       MITK_ERROR<< "Standard Exception: " << e.what();
       statisticCalculationSuccessful = false;
     }
   }
 
   this->m_StatisticChanged = statisticChanged;
   this->m_CalculationSuccessful = statisticCalculationSuccessful;
 
   if(statisticCalculationSuccessful)
   {
     //this->m_StatisticsVector.clear();
     //this->m_HistogramVector.clear();
 
     //for (unsigned int i = 0; i < m_StatisticsImage->GetTimeSteps(); i++)
     //{
     //  this->m_StatisticsVector.push_back(calculator->GetStatistics(i).GetPointer());
     //  this->m_HistogramVector.push_back((HistogramType*)this->m_StatisticsVector[i]->GetHistogram().GetPointer());
     //}
 
     // maybe use reset if this line does not work
     m_StatisticsContainer = mitk::StatisticsContainer::New();
     this->m_HistogramVector.clear();
 
     mitk::TimeGeometry::Pointer tg = m_StatisticsImage->GetTimeGeometry()->Clone();
     m_StatisticsContainer->SetTimeGeometry(tg);
     for (unsigned int i = 0; i < m_StatisticsImage->GetTimeSteps(); i++)
     {
       this->m_StatisticsContainer->SetStatisticsForTimeStep(i, calculator->GetStatistics(i));
       this->m_HistogramVector.push_back((HistogramType*) calculator->GetStatistics(i).m_Histogram.GetPointer());
     }
 
   }
 }
diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTableModel.cpp b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTableModel.cpp
index b0891bc2e6..9910a69264 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTableModel.cpp
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTableModel.cpp
@@ -1,158 +1,158 @@
 /*===================================================================
 
 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 "QmitkImageStatisticsTableModel.h"
 #include <mitkProportionalTimeGeometry.h>
 
 QmitkImageStatisticsTableModel::QmitkImageStatisticsTableModel(QObject *parent) :
   QAbstractTableModel(parent)
 {}
 
 int QmitkImageStatisticsTableModel::rowCount(const QModelIndex &parent) const
 {
   if (parent.isValid())
   {
     return 0;
   }
   return m_statisticNames.size();
 }
 
 int QmitkImageStatisticsTableModel::columnCount(const QModelIndex &parent) const
 {
   if (parent.isValid() || m_statistics.IsNull())
     return 0;
 
   return static_cast<int>(m_statistics->GetNumberOfTimeSteps());
 }
 
 QVariant QmitkImageStatisticsTableModel::data(const QModelIndex &index, int role) const
 {
   if (!index.isValid())
     return QVariant();
 
   QVariant result;
   if (m_viewMode == viewMode::imageXStatistic) {
 
     if (m_statistics.IsNotNull() && index.row() < rowCount(QModelIndex()) && index.column() < columnCount(QModelIndex()))
     {
       if (Qt::DisplayRole == role)
       {
         auto statisticsVector = m_statistics->GetStatisticsAsOrderedVector(index.column());
         auto statisticsValueString = statisticsVector.at(index.row()).second;
         result = QVariant(QString::fromStdString(statisticsValueString));
       }
       else if (Qt::UserRole == role)
       {
         result = QVariant(index.row());
       }
 
     }
   }
 
   return result;
 }
 
 Qt::ItemFlags QmitkImageStatisticsTableModel::flags(const QModelIndex &index) const
 {
   Qt::ItemFlags flags = QAbstractItemModel::flags(index);
 
   return flags;
 }
 
 QVariant QmitkImageStatisticsTableModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
   if ((Qt::DisplayRole == role) && (Qt::Horizontal == orientation))
   {
     if (!m_imageNodes.empty()) {
       if (m_viewMode == viewMode::imageXStatistic) {
         std::string maskName;
         if (!m_maskNodes.empty() && m_maskNodes.size() == m_imageNodes.size()) {
           maskName = " / " + m_maskNodes.at(section)->GetName();
         }
         return QVariant((m_imageNodes.at(section)->GetName() + maskName + std::to_string(section)).c_str());
       }
     }
   }
   else if ((Qt::DisplayRole == role) && (Qt::Vertical == orientation)) {
     if (m_statistics.IsNotNull()) {
       if (m_viewMode == viewMode::imageXStatistic) {
         return QVariant(m_statisticNames.at(section).c_str());
       }
     }
   }
   return QVariant();
 }
 
 void QmitkImageStatisticsTableModel::SetStatistics(mitk::StatisticsContainer::ConstPointer statistics)
 {
   emit beginResetModel();
   m_statistics = statistics;
 
   if (m_statisticNames.empty() && m_statistics.IsNotNull() && m_statistics->TimeStepExists(0)) {
     auto firstStatisticAsMap = m_statistics->GetStatisticsAsOrderedVector(0);
     for (const auto& keyValue : firstStatisticAsMap) {
       m_statisticNames.push_back(keyValue.first);
     }
   }
   emit endResetModel();
 }
 
 void QmitkImageStatisticsTableModel::SetImageNodes(const std::vector<mitk::DataNode::ConstPointer>& nodes)
 {
   std::vector<mitk::DataNode::ConstPointer> tempNodes;
-  for (int i = 0; i < nodes.size(); i++)
+  for (size_t i = 0; i < nodes.size(); i++)
   {
     int timeSteps = nodes.at(i)->GetData()->GetTimeSteps();
     for (int j = 0; j < timeSteps; j++)
     {
       tempNodes.push_back(nodes.at(i));
     }
   }
   m_imageNodes = tempNodes;
 }
 
 void QmitkImageStatisticsTableModel::SetMaskNodes(const std::vector<mitk::DataNode::ConstPointer>& nodes)
 {
   m_maskNodes = nodes;
 }
 
 void QmitkImageStatisticsTableModel::SetViewMode(viewMode m)
 {
   m_viewMode = m;
 }
 
 void QmitkImageStatisticsTableModel::SetStatisticsToShow(const std::vector<std::string>& statisticNames)
 {
   m_statisticNamesToShow = statisticNames;
 }
 
 void QmitkImageStatisticsTableModel::SetStatisticsToIgnore(const std::vector<std::string>& statisticNames)
 {
   m_statisticNamesToIgnore = statisticNames;
 }
 
 void QmitkImageStatisticsTableModel::Clear()
 {
   emit beginResetModel();
   m_statistics = nullptr;
   m_imageNodes.clear();
   m_maskNodes.clear();
   m_statisticNamesToIgnore.clear();
   m_statisticNamesToShow.clear();
   m_statisticNames.clear();
   emit endResetModel();
 }