diff --git a/Modules/ImageStatistics/mitkImageStatisticsCalculator.h b/Modules/ImageStatistics/mitkImageStatisticsCalculator.h
index 105b135366..c1743253c1 100644
--- a/Modules/ImageStatistics/mitkImageStatisticsCalculator.h
+++ b/Modules/ImageStatistics/mitkImageStatisticsCalculator.h
@@ -1,114 +1,114 @@
 #ifndef MITKIMAGESTATISTICSCALCULATOR
 #define MITKIMAGESTATISTICSCALCULATOR
 
 #include <MitkImageStatisticsExports.h>
 #include <mitkImage.h>
 #include <mitkMaskGenerator.h>
 #include <mitkImageStatisticsContainer.h>
 #include <itkImage.h>
 #include <limits>
 #include <itkObject.h>
 #include <itkSmartPointer.h>
 
 namespace mitk
 {
     class MITKIMAGESTATISTICS_EXPORT ImageStatisticsCalculator: public itk::Object
     {
     public:
         /** Standard Self typedef */
         typedef ImageStatisticsCalculator        Self;
         typedef itk::Object                         Superclass;
         typedef itk::SmartPointer< Self >           Pointer;
         typedef itk::SmartPointer< const Self >     ConstPointer;
 
         /** Method for creation through the object factory. */
         itkNewMacro(Self)
 
         /** Runtime information support. */
         itkTypeMacro(ImageStatisticsCalculator_v2, itk::Object)
 
         typedef double statisticsValueType;
         typedef std::map<std::string, statisticsValueType> statisticsMapType;
         typedef itk::Statistics::Histogram<double> HistogramType;
         typedef unsigned short MaskPixelType;
 
         /**Documentation
         @brief Set the image for which the statistics are to be computed.*/
         void SetInputImage(mitk::Image::Pointer image);
 
         /**Documentation
         @brief Set the mask generator that creates the mask which is to be used to calculate statistics. If no more mask is desired simply set @param mask to nullptr*/
         void SetMask(mitk::MaskGenerator::Pointer mask);
 
         /**Documentation
         @brief Set this if more than one mask should be applied (for instance if a IgnorePixelValueMask were to be used alongside with a segmentation).
         Both masks are combined using pixel wise AND operation. The secondary mask does not have to be the same size than the primary but they need to have some overlap*/
         void SetSecondaryMask(mitk::MaskGenerator::Pointer mask);
 
         /**Documentation
         @brief Set number of bins to be used for histogram statistics. If Bin size is set after number of bins, bin size will be used instead!*/
         void SetNBinsForHistogramStatistics(unsigned int nBins);
 
         /**Documentation
         @brief Retrieve the number of bins used for histogram statistics. Careful: The return value does not indicate whether NBins or BinSize is used.
         That solely depends on which parameter has been set last.*/
         unsigned int GetNBinsForHistogramStatistics() const;
 
         /**Documentation
         @brief Set bin size to be used for histogram statistics. If nbins is set after bin size, nbins will be used instead!*/
         void SetBinSizeForHistogramStatistics(double binSize);
 
         /**Documentation
         @brief Retrieve the bin size for histogram statistics. Careful: The return value does not indicate whether NBins or BinSize is used.
         That solely depends on which parameter has been set last.*/
         double GetBinSizeForHistogramStatistics() const;
 
         /**Documentation
         @brief Returns the statistics for label @a label and timeStep @a timeStep. If these requested statistics are not computed yet the computation is done as well.
         For performance reasons, statistics for all labels in the image are computed at once.
          */
         StatisticsContainer::Pointer GetStatistics(unsigned int timeStep=0, unsigned int label=1);
 
     protected:
         ImageStatisticsCalculator(){
             m_nBinsForHistogramStatistics = 100;
             m_binSizeForHistogramStatistics = 10;
             m_UseBinSizeOverNBins = false;
         };
 
 
     private:
         template < typename TPixel, unsigned int VImageDimension > void InternalCalculateStatisticsUnmasked(
                 typename itk::Image< TPixel, VImageDimension >* image,
                 unsigned int timeStep);
 
         template < typename TPixel, unsigned int VImageDimension > void InternalCalculateStatisticsMasked(
                 typename itk::Image< TPixel, VImageDimension >* image,
                 unsigned int timeStep);
 
         template < typename TPixel, unsigned int VImageDimension >
         double GetVoxelVolume(typename itk::Image<TPixel, VImageDimension>* image) const;
-        bool IsUpdateRequired(unsigned int timeStep) const;
 
+        bool IsUpdateRequired(unsigned int timeStep) const;
 
         mitk::Image::Pointer m_Image;
         mitk::Image::Pointer m_ImageTimeSlice;
         mitk::Image::Pointer m_InternalImageForStatistics;
 
         mitk::MaskGenerator::Pointer m_MaskGenerator;
         mitk::Image::Pointer m_InternalMask;
 
         mitk::MaskGenerator::Pointer m_SecondaryMaskGenerator;
         mitk::Image::Pointer m_SecondaryMask;
 
         unsigned int m_nBinsForHistogramStatistics;
         double m_binSizeForHistogramStatistics;
         bool m_UseBinSizeOverNBins;
 
         std::vector<std::vector<StatisticsContainer::Pointer>> m_StatisticsByTimeStep;
         std::vector<unsigned long> m_StatisticsUpdateTimePerTimeStep;
     };
 
 }
 #endif // MITKIMAGESTATISTICSCALCULATOR
 
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsCalculationThread.cpp b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationJob.cpp
similarity index 80%
rename from Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsCalculationThread.cpp
rename to Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationJob.cpp
index d91a37e768..abdac7b3d9 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsCalculationThread.cpp
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationJob.cpp
@@ -1,240 +1,240 @@
 /*===================================================================
 
 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 "QmitkImageStatisticsCalculationThread.h"
+#include "QmitkImageStatisticsCalculationJob.h"
 
 //QT headers
 #include <QMessageBox>
 #include <QApplication>
 #include <mitkImageMaskGenerator.h>
 #include <mitkPlanarFigureMaskGenerator.h>
 #include <mitkIgnorePixelMaskGenerator.h>
 
-QmitkImageStatisticsCalculationThread::QmitkImageStatisticsCalculationThread()
+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)
 {
 }
 
-QmitkImageStatisticsCalculationThread::~QmitkImageStatisticsCalculationThread()
+QmitkImageStatisticsCalculationJob::~QmitkImageStatisticsCalculationJob()
 {
 }
 
-void QmitkImageStatisticsCalculationThread::Initialize( mitk::Image::Pointer image, mitk::Image::Pointer binaryImage, mitk::PlanarFigure::Pointer planarFig )
+void QmitkImageStatisticsCalculationJob::Initialize( mitk::Image::Pointer image, mitk::Image::Pointer binaryImage, mitk::PlanarFigure::Pointer 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->Clone();
   if(binaryImage.IsNotNull())
     this->m_BinaryMask = binaryImage->Clone();
   if(planarFig.IsNotNull())
     this->m_PlanarFigureMask = planarFig->Clone();
 }
 
-void QmitkImageStatisticsCalculationThread::SetTimeStep( int times )
+void QmitkImageStatisticsCalculationJob::SetTimeStep( int times )
 {
   this->m_TimeStep = times;
 }
 
-int QmitkImageStatisticsCalculationThread::GetTimeStep()
+int QmitkImageStatisticsCalculationJob::GetTimeStep()
 {
   return this->m_TimeStep;
 }
 
-std::vector<mitk::StatisticsContainer::ConstPointer> QmitkImageStatisticsCalculationThread::GetStatisticsData()
+std::vector<mitk::StatisticsContainer::ConstPointer> QmitkImageStatisticsCalculationJob::GetStatisticsData()
 {
   return this->m_StatisticsVector;
 }
 
-mitk::Image::Pointer QmitkImageStatisticsCalculationThread::GetStatisticsImage()
+mitk::Image::Pointer QmitkImageStatisticsCalculationJob::GetStatisticsImage()
 {
   return this->m_StatisticsImage;
 }
 
-void QmitkImageStatisticsCalculationThread::SetIgnoreZeroValueVoxel(bool _arg)
+void QmitkImageStatisticsCalculationJob::SetIgnoreZeroValueVoxel(bool _arg)
 {
   this->m_IgnoreZeros = _arg;
 }
 
-bool QmitkImageStatisticsCalculationThread::GetIgnoreZeroValueVoxel()
+bool QmitkImageStatisticsCalculationJob::GetIgnoreZeroValueVoxel()
 {
   return this->m_IgnoreZeros;
 }
 
-void QmitkImageStatisticsCalculationThread::SetHistogramNBins(unsigned int nbins)
+void QmitkImageStatisticsCalculationJob::SetHistogramNBins(unsigned int nbins)
 {
   this->m_HistogramNBins = nbins;
 }
 
-unsigned int QmitkImageStatisticsCalculationThread::GetHistogramNBins() const
+unsigned int QmitkImageStatisticsCalculationJob::GetHistogramNBins() const
 {
   return this->m_HistogramNBins;
 }
 
-std::string QmitkImageStatisticsCalculationThread::GetLastErrorMessage()
+std::string QmitkImageStatisticsCalculationJob::GetLastErrorMessage()
 {
   return m_message;
 }
 
-QmitkImageStatisticsCalculationThread::HistogramType::ConstPointer
-QmitkImageStatisticsCalculationThread::GetTimeStepHistogram(unsigned int t)
+QmitkImageStatisticsCalculationJob::HistogramType::ConstPointer
+QmitkImageStatisticsCalculationJob::GetTimeStepHistogram(unsigned int t)
 {
   if (t >= this->m_HistogramVector.size())
     return nullptr;
 
   return this->m_HistogramVector[t];
 }
 
-bool QmitkImageStatisticsCalculationThread::GetStatisticsChangedFlag()
+bool QmitkImageStatisticsCalculationJob::GetStatisticsChangedFlag()
 {
   return m_StatisticChanged;
 }
 
-bool QmitkImageStatisticsCalculationThread::GetStatisticsUpdateSuccessFlag()
+bool QmitkImageStatisticsCalculationJob::GetStatisticsUpdateSuccessFlag()
 {
   return m_CalculationSuccessful;
 }
 
-void QmitkImageStatisticsCalculationThread::run()
+void QmitkImageStatisticsCalculationJob::run()
 {
   bool statisticCalculationSuccessful = true;
   mitk::ImageStatisticsCalculator::Pointer calculator = mitk::ImageStatisticsCalculator::New();
 
   if(this->m_StatisticsImage.IsNotNull())
   {
     calculator->SetInputImage(m_StatisticsImage);
   }
   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);
       calculator->SetMask(imgMask.GetPointer());
     }
     if(this->m_PlanarFigureMask.IsNotNull())
     {
       mitk::PlanarFigureMaskGenerator::Pointer pfMaskGen = mitk::PlanarFigureMaskGenerator::New();
       pfMaskGen->SetInputImage(m_StatisticsImage);
       pfMaskGen->SetPlanarFigure(m_PlanarFigureMask);
       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);
       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());
     }
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsCalculationThread.h b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationJob.h
similarity index 95%
rename from Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsCalculationThread.h
rename to Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationJob.h
index 1f63ab1ec2..898e311af1 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsCalculationThread.h
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsCalculationJob.h
@@ -1,112 +1,112 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #ifndef QMITKIMAGESTATISTICSCALCULATIONTHREAD_H_INCLUDED
 #define QMITKIMAGESTATISTICSCALCULATIONTHREAD_H_INCLUDED
 
 //QT headers
 #include <QThread>
 #include <QEvent>
 
 //mitk headers
 #include "mitkImage.h"
 #include "mitkPlanarFigure.h"
 #include "mitkImageStatisticsCalculator.h"
+#include <MitkImageStatisticsUIExports.h>
 
 // itk headers
 #ifndef __itkHistogram_h
 #include <itkHistogram.h>
 #endif
 
 
 /** /brief This class is executed as background thread for image statistics calculation.
   * Documentation: This class is derived from QThread and is intended to be used by QmitkImageStatisticsView
                    to run the image statistics calculation in a background thread keepung the gui usable.
-  *   \ingroup Plugins/MeasurementToolbox
   */
 
-class  QmitkImageStatisticsCalculationThread : public QThread
+class MITKIMAGESTATISTICSUI_EXPORT QmitkImageStatisticsCalculationJob : public QThread
 {
   Q_OBJECT
 
 public:
 
   typedef itk::Statistics::Histogram<double> HistogramType;
 
   /*!
   /brief standard constructor. */
-  QmitkImageStatisticsCalculationThread();
+  QmitkImageStatisticsCalculationJob();
   /*!
   /brief standard destructor. */
-  ~QmitkImageStatisticsCalculationThread();
+  ~QmitkImageStatisticsCalculationJob();
 
   /*!
   /brief Initializes the object with necessary data. */
   void Initialize( mitk::Image::Pointer image, mitk::Image::Pointer binaryImage, mitk::PlanarFigure::Pointer planarFig );
   /*!
   /brief returns the calculated image statistics. */
   std::vector<mitk::StatisticsContainer::ConstPointer> GetStatisticsData();
   /*!
   /brief */
   mitk::Image::Pointer GetStatisticsImage();
   /*!
   /brief Set the time step of the image you want to process. */
   void SetTimeStep( int times );
   /*!
   /brief Get the time step of the image you want to process. */
   int GetTimeStep();
   /*!
   /brief Set flag to ignore zero valued voxels */
   void SetIgnoreZeroValueVoxel( bool _arg );
   /*!
   /brief Get status of zero value voxel ignoring. */
   bool GetIgnoreZeroValueVoxel();
   /*!
   /brief Set bin size for histogram resolution.*/
   void SetHistogramNBins( unsigned int nbins);
   /*!
   /brief Get bin size for histogram resolution.*/
   unsigned int GetHistogramNBins() const;
   /*!
   /brief Returns the histogram of the currently selected time step. */
   HistogramType::ConstPointer GetTimeStepHistogram(unsigned int t = 0);
   /*!
   /brief Returns a flag indicating if the statistics have changed during calculation */
   bool GetStatisticsChangedFlag();
   /*!
   /brief Returns a flag the indicates if the statistics are updated successfully */
   bool GetStatisticsUpdateSuccessFlag();
   /*!
   /brief Method called once the thread is executed. */
   void run() override;
 
   std::string GetLastErrorMessage();
 
 private:
   //member declaration
 
   mitk::Image::Pointer m_StatisticsImage;                         ///< member variable holds the input image for which the statistics need to be calculated.
   mitk::Image::Pointer m_BinaryMask;                              ///< member variable holds the binary mask image for segmentation image statistics calculation.
   mitk::PlanarFigure::Pointer m_PlanarFigureMask;                 ///< member variable holds the planar figure for segmentation image statistics calculation.
   std::vector<mitk::StatisticsContainer::ConstPointer> m_StatisticsVector; ///< member variable holds the result structs.
   int m_TimeStep;                                                 ///< member variable holds the time step for statistics calculation
   bool m_IgnoreZeros;                                             ///< member variable holds flag to indicate if zero valued voxel should be suppressed
   unsigned int m_HistogramNBins;                                      ///< member variable holds the bin size for histogram resolution.
   bool m_StatisticChanged;                                        ///< flag set if statistics have changed
   bool m_CalculationSuccessful;                                   ///< flag set if statistics calculation was successful
   std::vector<HistogramType::ConstPointer> m_HistogramVector;          ///< member holds the histograms of all time steps.
   std::string m_message;
 };
 #endif // QMITKIMAGESTATISTICSCALCULATIONTHREAD_H_INCLUDED
diff --git a/Modules/ImageStatisticsUI/files.cmake b/Modules/ImageStatisticsUI/files.cmake
index 41f22d4226..e7f5a52732 100644
--- a/Modules/ImageStatisticsUI/files.cmake
+++ b/Modules/ImageStatisticsUI/files.cmake
@@ -1,22 +1,24 @@
 set(CPP_FILES
   Qmitk/QmitkHistogramVisualizationWidget.cpp
   Qmitk/QmitkIntensityProfileVisualizationWidget.cpp
   Qmitk/QmitkImageStatisticsTableModel.cpp
+  Qmitk/QmitkImageStatisticsCalculationJob.cpp
 )
 
 set(H_FILES
 )
 
 set(TPP_FILES
 )
 
 set(UI_FILES
   Qmitk/QmitkHistogramVisualizationWidget.ui
   Qmitk/QmitkIntensityProfileVisualizationWidget.ui
 )
 
 set(MOC_H_FILES
   Qmitk/QmitkHistogramVisualizationWidget.h
   Qmitk/QmitkIntensityProfileVisualizationWidget.h
   Qmitk/QmitkImageStatisticsTableModel.h
+  Qmitk/QmitkImageStatisticsCalculationJob.h
 )
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/files.cmake b/Plugins/org.mitk.gui.qt.measurementtoolbox/files.cmake
index c6920059f2..e9d7bcb1e9 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/files.cmake
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/files.cmake
@@ -1,58 +1,56 @@
 set(SRC_CPP_FILES
 
 )
 
 set(INTERNAL_CPP_FILES
   QmitkMeasurementView.cpp
   QmitkImageStatisticsView.cpp
   QmitkImageStatisticsReloadedView.cpp
-  QmitkImageStatisticsCalculationThread.cpp
   mitkPluginActivator.cpp
 )
 
 set(UI_FILES
   src/internal/QmitkImageStatisticsViewControls.ui
   src/internal/QmitkImageStatisticsReloadedViewControls.ui
 )
 
 set(MOC_H_FILES
   src/internal/QmitkMeasurementView.h
   src/internal/QmitkImageStatisticsView.h
   src/internal/QmitkImageStatisticsReloadedView.h
-  src/internal/QmitkImageStatisticsCalculationThread.h
   src/internal/mitkPluginActivator.h
 
 )
 
 set(CACHED_RESOURCE_FILES
   resources/angle.png
   resources/arrow.png
   resources/circle.png
   resources/four-point-angle.png
   resources/lena.xpm
   resources/line.png
   resources/measurement.svg
   resources/path.png
   resources/polygon.png
   resources/rectangle.png
   resources/stats.png
   resources/text.png
   resources/bar-chart.svg
   plugin.xml
 )
 
 set(QRC_FILES
   resources/measurement.qrc
   resources/QmitkImageStatisticsView.qrc
 )
 
 
 set(CPP_FILES )
 
 foreach(file ${SRC_CPP_FILES})
   set(CPP_FILES ${CPP_FILES} src/${file})
 endforeach(file ${SRC_CPP_FILES})
 
 foreach(file ${INTERNAL_CPP_FILES})
   set(CPP_FILES ${CPP_FILES} src/internal/${file})
 endforeach(file ${INTERNAL_CPP_FILES})
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsReloadedView.cpp b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsReloadedView.cpp
index 2f5ada08c2..256640edb9 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsReloadedView.cpp
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsReloadedView.cpp
@@ -1,205 +1,205 @@
 /*===================================================================
 
 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 "QmitkImageStatisticsReloadedView.h"
 
 // berry includes
 #include <berryWorkbenchPlugin.h>
 #include <berryIQtStyleManager.h>
 
 #include <QmitkChartWidget.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkStatusBar.h>
 
 const std::string QmitkImageStatisticsReloadedView::VIEW_ID = "org.mitk.views.imagestatisticsReloaded";
 
 QmitkImageStatisticsReloadedView::QmitkImageStatisticsReloadedView(QObject* /*parent*/, const char* /*name*/)
 {
-  this->m_CalculationThread = new QmitkImageStatisticsCalculationThread;
+  this->m_CalculationThread = new QmitkImageStatisticsCalculationJob();
 }
 
 QmitkImageStatisticsReloadedView::~QmitkImageStatisticsReloadedView()
 {
 }
 
 void QmitkImageStatisticsReloadedView::CreateQtPartControl(QWidget *parent)
 {
   m_Controls.setupUi(parent);
   m_Controls.widget_histogram->SetTheme(this->GetColorTheme());
   PrepareDataStorageComboBoxes();
   CreateConnections();
 }
 
 void QmitkImageStatisticsReloadedView::CreateConnections()
 {
   connect(m_Controls.imageSelector, QOverload<int>::of(&QComboBox::currentIndexChanged), [=](int index) { OnImageOrMaskSelectorChanged(); });
   connect(m_Controls.maskImageSelector, QOverload<int>::of(&QComboBox::currentIndexChanged), [=](int index) { OnImageOrMaskSelectorChanged(); });
-  connect(this->m_CalculationThread, &QmitkImageStatisticsCalculationThread::finished, this, &QmitkImageStatisticsReloadedView::OnStatisticsCalculationEnds, Qt::QueuedConnection);
+  connect(this->m_CalculationThread, &QmitkImageStatisticsCalculationJob::finished, this, &QmitkImageStatisticsReloadedView::OnStatisticsCalculationEnds, Qt::QueuedConnection);
 }
 
 void QmitkImageStatisticsReloadedView::PartClosed(const berry::IWorkbenchPartReference::Pointer& )
 {
 }
 
 void QmitkImageStatisticsReloadedView::FillStatisticsWidget(const std::vector<mitk::StatisticsContainer::ConstPointer>& statistics)
 {
   m_Controls.widget_statistics->Reset();
   m_Controls.widget_statistics->SetStatistics(statistics);
   m_Controls.widget_statistics->SetImageNodes({ m_selectedImageNode });
   if (m_selectedMaskNode) {
     m_Controls.widget_statistics->SetMaskNodes({ m_selectedMaskNode });
   }
   m_Controls.widget_statistics->setEnabled(true);
 }
 
 void QmitkImageStatisticsReloadedView::FillHistogramWidget(const std::vector<HistogramType::ConstPointer>& histogram, const std::vector<std::string>& dataLabels)
 {
   m_Controls.widget_histogram->SetTheme(this->GetColorTheme());
   m_Controls.widget_histogram->Reset();
   m_Controls.widget_histogram->SetHistogram(histogram.front(), dataLabels.front());
 
 }
 
 QmitkChartWidget::ChartStyle QmitkImageStatisticsReloadedView::GetColorTheme() const
 {
   ctkPluginContext* context = berry::WorkbenchPlugin::GetDefault()->GetPluginContext();
   ctkServiceReference styleManagerRef = context->getServiceReference<berry::IQtStyleManager>();
   if (styleManagerRef)
   {
     auto styleManager = context->getService<berry::IQtStyleManager>(styleManagerRef);
     if (styleManager->GetStyle().name == "Dark") {
       return QmitkChartWidget::ChartStyle::darkstyle;
     }
     else {
       return QmitkChartWidget::ChartStyle::lightstyle;
     }
   }
   return QmitkChartWidget::ChartStyle::darkstyle;
 }
 
 void QmitkImageStatisticsReloadedView::OnImageOrMaskSelectorChanged()
 {
   m_selectedImageNode = m_Controls.imageSelector->GetSelectedNode();
   m_selectedMaskNode = m_Controls.maskImageSelector->GetSelectedNode();
 
   if (m_selectedImageNode != nullptr) {
     auto image = dynamic_cast<mitk::Image*>(m_selectedImageNode->GetData());
     mitk::Image::Pointer mask = nullptr;
     if (m_selectedMaskNode != nullptr) {
       mask = dynamic_cast<mitk::Image*>(m_selectedMaskNode->GetData());
     }
 
     CalculateStatistics(image, mask);
   }
   else {
     m_Controls.widget_statistics->Reset();
     m_Controls.widget_statistics->setEnabled(false);
     m_Controls.widget_histogram->Reset();
     m_Controls.widget_histogram->setEnabled(false);
   }
 }
 
 void QmitkImageStatisticsReloadedView::OnStatisticsCalculationEnds()
 {
   mitk::StatusBar::GetInstance()->Clear();
 
   if (this->m_CalculationThread->GetStatisticsUpdateSuccessFlag()) {
     this->FillStatisticsWidget(m_CalculationThread->GetStatisticsData());
     this->FillHistogramWidget({ m_CalculationThread->GetTimeStepHistogram() }, {m_selectedImageNode->GetName()});
   }
   else {
     mitk::StatusBar::GetInstance()->DisplayErrorText(m_CalculationThread->GetLastErrorMessage().c_str());
     m_Controls.widget_histogram->setEnabled(false);
     m_Controls.widget_statistics->setEnabled(false);
   }
 }
 
 void QmitkImageStatisticsReloadedView::CalculateStatistics(mitk::Image::Pointer image, mitk::Image::Pointer mask)
 {
   this->m_StatisticsUpdatePending = true;
   this->m_CalculationThread->Initialize(image, mask, nullptr);
   this->m_CalculationThread->SetTimeStep(0);
 
   try
   {
     // Compute statistics
     this->m_CalculationThread->start();
   }
   catch (const mitk::Exception& e)
   {
     mitk::StatusBar::GetInstance()->DisplayErrorText(e.GetDescription());
     this->m_StatisticsUpdatePending = false;
   }
   catch (const std::runtime_error &e)
   {
     mitk::StatusBar::GetInstance()->DisplayErrorText(e.what());
     this->m_StatisticsUpdatePending = false;
   }
   catch (const std::exception &e)
   {
     mitk::StatusBar::GetInstance()->DisplayErrorText(e.what());
     this->m_StatisticsUpdatePending = false;
   }
 }
 
 void QmitkImageStatisticsReloadedView::OnSelectionChanged( berry::IWorkbenchPart::Pointer /*part*/,
     const QList<mitk::DataNode::Pointer> &nodes )
 {
   
 }
 
 void QmitkImageStatisticsReloadedView::PrepareDataStorageComboBoxes()
 {
 
   auto isImage = mitk::NodePredicateDataType::New("Image");
   auto isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
   auto isNoBinary = mitk::NodePredicateNot::New(isBinary);
   auto isBinaryImage = mitk::NodePredicateAnd::New(isImage, isBinary);
   auto isNoBinaryImage = mitk::NodePredicateAnd::New(isImage, isNoBinary);
 
   m_Controls.imageSelector->SetDataStorage(GetDataStorage());
   m_Controls.imageSelector->SetPredicate(isNoBinaryImage);
 
   m_Controls.maskImageSelector->SetDataStorage(GetDataStorage());
   m_Controls.maskImageSelector->SetPredicate(isBinaryImage);
   m_Controls.maskImageSelector->SetZeroEntryText("<none>");
 }
 
 void QmitkImageStatisticsReloadedView::Activated()
 {
 }
 
 void QmitkImageStatisticsReloadedView::Deactivated()
 {
 }
 
 void QmitkImageStatisticsReloadedView::Visible()
 {
  
 }
 
 void QmitkImageStatisticsReloadedView::Hidden()
 {
   m_Controls.imageSelector->disconnect();
   m_Controls.maskImageSelector->disconnect();
 }
 
 void QmitkImageStatisticsReloadedView::SetFocus()
 {
 }
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsReloadedView.h b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsReloadedView.h
index e9d2683823..56c1f68a9f 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsReloadedView.h
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsReloadedView.h
@@ -1,95 +1,95 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef QmitkImageStatisticsReloadedView_H__INCLUDED
 #define QmitkImageStatisticsReloadedView_H__INCLUDED
 
 #include "ui_QmitkImageStatisticsReloadedViewControls.h"
 
 // Qmitk includes
 #include <QmitkAbstractView.h>
-#include "QmitkImageStatisticsCalculationThread.h"
+#include <QmitkImageStatisticsCalculationJob.h>
 #include <mitkImageStatisticsContainer.h>
 
 #include <mitkILifecycleAwarePart.h>
 #include <berryIPartListener.h>
 
 /*!
 \brief QmitkImageStatisticsView is a bundle that allows statistics calculation from images. Three modes
 are supported: 1. Statistics of one image, 2. Statistics of an image and a segmentation, 3. Statistics
 of an image and a Planar Figure. The statistics calculation is realized in a separate thread to keep the
 gui accessible during calculation.
 
 \ingroup Plugins/org.mitk.gui.qt.measurementtoolbox
 */
 class QmitkImageStatisticsReloadedView : public QmitkAbstractView, public mitk::ILifecycleAwarePart, public berry::IPartListener
 {
   Q_OBJECT
 
 public:
   using HistogramType = mitk::StatisticsContainer::HistogramType;
   /*!
   \brief default constructor */
   QmitkImageStatisticsReloadedView(QObject *parent = nullptr, const char *name = nullptr);
   /*!
   \brief default destructor */
   virtual ~QmitkImageStatisticsReloadedView();
   /*!
   \brief method for creating the widget containing the application   controls, like sliders, buttons etc. */
   virtual void CreateQtPartControl(QWidget *parent) override;
   /*!
   \brief method for creating the connections of main and control widget */
   virtual void CreateConnections();
   /*!
   \brief  Is called from the selection mechanism once the data manager selection has changed*/
   void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer> &selectedNodes) override;
 
   void PrepareDataStorageComboBoxes();
 
   static const std::string VIEW_ID;
 
   void FillStatisticsWidget(const std::vector<mitk::StatisticsContainer::ConstPointer>& statistics);
   void FillHistogramWidget(const std::vector<HistogramType::ConstPointer>& histogram, const std::vector<std::string>& dataLabels);
   QmitkChartWidget::ChartStyle GetColorTheme() const;
 protected:
   virtual void Activated() override;
   virtual void Deactivated() override;
   virtual void Visible() override;
   virtual void Hidden() override;
 
   virtual void SetFocus() override;
 
   /** \brief Is called right before the view closes (before the destructor) */
   virtual void PartClosed(const berry::IWorkbenchPartReference::Pointer&) override;
  
   /** \brief Required for berry::IPartListener */
   virtual Events::Types GetPartEventTypes() const override { return Events::CLOSED; }
 
   void OnImageOrMaskSelectorChanged();
   void OnStatisticsCalculationEnds();
 
   void CalculateStatistics(mitk::Image::Pointer image, mitk::Image::Pointer mask);
 
   // member variables
   Ui::QmitkImageStatisticsReloadedViewControls m_Controls;
 
 private:
-  QmitkImageStatisticsCalculationThread * m_CalculationThread;
+  QmitkImageStatisticsCalculationJob * m_CalculationThread;
   bool m_StatisticsUpdatePending=false;
   mitk::DataNode::ConstPointer m_selectedImageNode, m_selectedMaskNode;
  
 };
 #endif // QmitkImageStatisticsView_H__INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
index dce04e71b5..5f884875e0 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
@@ -1,1295 +1,1295 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkImageStatisticsView.h"
 
 // Qt includes
 #include <QClipboard>
 #include <QScrollBar>
 #include <QVector>
 
 // berry includes
 #include <berryIWorkbenchPage.h>
 
 // mitk includes
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkImageTimeSelector.h>
 #include <QmitkRenderWindow.h>
 #include <QmitkChartWidget.h>
 #include <mitkImageCast.h>
 #include <mitkImageStatisticsHolder.h>
 
 // itk includes
 #include "itksys/SystemTools.hxx"
 #include "itkImageRegionConstIteratorWithIndex.h"
 
 #include <limits>
 
 //blueberry includes
 #include <berryWorkbenchPlugin.h>
 #include <berryQtPreferences.h>
 
 const std::string QmitkImageStatisticsView::VIEW_ID = "org.mitk.views.imagestatistics";
 const int QmitkImageStatisticsView::STAT_TABLE_BASE_HEIGHT = 180;
 
 QmitkImageStatisticsView::QmitkImageStatisticsView(QObject* /*parent*/, const char* /*name*/)
 : m_Controls( nullptr ),
   m_SelectedImage( nullptr ),
   m_SelectedImageMask( nullptr ),
   m_SelectedPlanarFigure( nullptr ),
   m_ImageObserverTag( -1 ),
   m_ImageMaskObserverTag( -1 ),
   m_PlanarFigureObserverTag( -1 ),
   m_TimeObserverTag( -1 ),
   m_CurrentStatisticsValid( false ),
   m_StatisticsUpdatePending( false ),
   m_DataNodeSelectionChanged ( false ),
   m_Visible(false)
 {
-  this->m_CalculationThread = new QmitkImageStatisticsCalculationThread;
+  this->m_CalculationThread = new QmitkImageStatisticsCalculationJob;
 }
 
 QmitkImageStatisticsView::~QmitkImageStatisticsView()
 {
   if ( m_SelectedImage != nullptr )
     m_SelectedImage->RemoveObserver( m_ImageObserverTag );
   if ( m_SelectedImageMask != nullptr )
     m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
   if ( m_SelectedPlanarFigure != nullptr )
     m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
 
   while(this->m_CalculationThread->isRunning()) // wait until thread has finished
   {
     itksys::SystemTools::Delay(100);
   }
   delete this->m_CalculationThread;
 }
 
 
 void QmitkImageStatisticsView::CreateQtPartControl(QWidget *parent)
 {
   if (m_Controls == nullptr)
   {
     m_Controls = new Ui::QmitkImageStatisticsViewControls;
     m_Controls->setupUi(parent);
     CreateConnections();
 
     m_Controls->m_ErrorMessageLabel->hide();
     m_Controls->m_StatisticsWidgetStack->setCurrentIndex(0);
     m_Controls->m_BinSizeFrame->setEnabled(false);
     #if QT_VERSION < QT_VERSION_CHECK(5, 10, 0)
       m_Controls->m_StatisticsWidgetStack->setVisible(false);
       m_Controls->label_HistogramIsInvisibleWarning->setEnabled(true);
       m_Controls->label_HistogramIsInvisibleWarning->setVisible(true);
       m_Controls->label_HistogramIsInvisibleWarning->setText("<font color='red'>Histogram is not visible because Qt 5.10 is required. You can use the button <i>Copy to Clipboard</i> below to retrieve values.</font>");
       m_Controls->groupBox_plot->setVisible(false);
     #else
       m_Controls->label_HistogramIsInvisibleWarning->setVisible(false);
     #endif
 
   }
 }
 
 void QmitkImageStatisticsView::OnPageSuccessfullyLoaded()
 {
   berry::IPreferencesService* prefService = berry::WorkbenchPlugin::GetDefault()->GetPreferencesService();
   m_StylePref = prefService->GetSystemPreferences()->Node(berry::QtPreferences::QT_STYLES_NODE);
 
   QString styleName = m_StylePref->Get(berry::QtPreferences::QT_STYLE_NAME, "");
 
   if (styleName == ":/org.blueberry.ui.qt/darkstyle.qss")
   {
     this->m_Controls->m_JSHistogram->SetTheme(QmitkChartWidget::ChartStyle::darkstyle);
   }
   else
   {
     this->m_Controls->m_JSHistogram->SetTheme(QmitkChartWidget::ChartStyle::lightstyle);
   }
 }
 
 void QmitkImageStatisticsView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(this->m_Controls->m_ButtonCopyHistogramToClipboard), SIGNAL(clicked()),(QObject*) this, SLOT(OnClipboardHistogramButtonClicked()) );
     connect( (QObject*)(this->m_Controls->m_ButtonCopyStatisticsToClipboard), SIGNAL(clicked()),(QObject*) this, SLOT(OnClipboardStatisticsButtonClicked()) );
     connect( (QObject*)(this->m_Controls->m_IgnoreZerosCheckbox), SIGNAL(clicked()),(QObject*) this, SLOT(OnIgnoreZerosCheckboxClicked()) );
     connect( (QObject*) this->m_CalculationThread, SIGNAL(finished()),this, SLOT( OnThreadedStatisticsCalculationEnds()),Qt::QueuedConnection);
     connect( (QObject*) this, SIGNAL(StatisticsUpdate()),this, SLOT( RequestStatisticsUpdate()), Qt::QueuedConnection);
     connect( (QObject*) this->m_Controls->m_StatisticsTable, SIGNAL(cellDoubleClicked(int,int)),this, SLOT( JumpToCoordinates(int,int)) );
     connect((QObject*)(this->m_Controls->m_barRadioButton), SIGNAL(clicked()), (QObject*)(this), SLOT(OnBarRadioButtonSelected()));
     connect((QObject*)(this->m_Controls->m_lineRadioButton), SIGNAL(clicked()), (QObject*)(this), SLOT(OnLineRadioButtonSelected()));
     connect( (QObject*) (this->m_Controls->m_HistogramNBinsSpinbox), SIGNAL(editingFinished()), this, SLOT(OnHistogramNBinsCheckBoxValueChanged()));
     connect((QObject*)(this->m_Controls->m_UseDefaultNBinsCheckBox), SIGNAL(clicked()), (QObject*) this, SLOT(OnDefaultNBinsSpinBoxChanged()));
     connect((QObject*)(this->m_Controls->m_ShowSubchartCheckBox), SIGNAL(clicked()), (QObject*) this, SLOT(OnShowSubchartBoxChanged()));
     connect((QObject*)(this->m_Controls->m_JSHistogram), SIGNAL(PageSuccessfullyLoaded()), (QObject*) this, SLOT(OnPageSuccessfullyLoaded()));
   }
 }
 
 void QmitkImageStatisticsView::OnDefaultNBinsSpinBoxChanged()
 {
   if (this->m_Controls->m_UseDefaultNBinsCheckBox->isChecked()) {
     m_Controls->m_HistogramNBinsSpinbox->setValue(100);
     this->m_CalculationThread->SetHistogramNBins(m_Controls->m_HistogramNBinsSpinbox->value());
     m_HistogramNBins = m_Controls->m_HistogramNBinsSpinbox->value();
   }
   m_Controls->m_BinSizeFrame->setEnabled(!m_Controls->m_UseDefaultNBinsCheckBox->isChecked());
 
   this->UpdateStatistics();
 
 }
 
 void QmitkImageStatisticsView::OnShowSubchartBoxChanged()
 {
   bool showSubchart = this->m_Controls->m_ShowSubchartCheckBox->isChecked();
   this->m_Controls->m_JSHistogram->Reload(showSubchart);
 }
 
 
 void QmitkImageStatisticsView::OnBarRadioButtonSelected()
 {
   this->m_Controls->m_JSHistogram->SetChartTypeForAllDataAndReload(QmitkChartWidget::ChartType::bar);
 }
 
 void QmitkImageStatisticsView::OnLineRadioButtonSelected()
 {
   this->m_Controls->m_JSHistogram->SetChartTypeForAllDataAndReload(QmitkChartWidget::ChartType::line);
 }
 
 void QmitkImageStatisticsView::PartClosed(const berry::IWorkbenchPartReference::Pointer& )
 {
 }
 
 void QmitkImageStatisticsView::OnTimeChanged(const itk::EventObject& e)
 {
   if (this->m_SelectedDataNodes.isEmpty() || this->m_SelectedImage == nullptr)
     return;
 
   const mitk::SliceNavigationController::GeometryTimeEvent* timeEvent =
       dynamic_cast<const mitk::SliceNavigationController::GeometryTimeEvent*>(&e);
   assert(timeEvent != nullptr);
   int timestep = timeEvent->GetPos();
 
   if (this->m_SelectedImage->GetTimeSteps() > 1)
   {
     for (int x = 0; x < this->m_Controls->m_StatisticsTable->columnCount(); x++)
     {
       for (int y = 0; y < this->m_Controls->m_StatisticsTable->rowCount(); y++)
       {
         QTableWidgetItem* item = this->m_Controls->m_StatisticsTable->item(y, x);
         if (item == nullptr)
           break;
 
         if (x == timestep)
         {
           item->setBackgroundColor(Qt::yellow);
         }
         else
         {
           if (y % 2 == 0)
             item->setBackground(this->m_Controls->m_StatisticsTable->palette().base());
           else
             item->setBackground(this->m_Controls->m_StatisticsTable->palette().alternateBase());
         }
       }
     }
 
     this->m_Controls->m_StatisticsTable->viewport()->update();
   }
 
   if ((this->m_SelectedImage->GetTimeSteps() == 1 && timestep == 0) ||
       this->m_SelectedImage->GetTimeSteps() > 1)
   {
     // display histogram for selected timestep
     //bug in Qt thats leads to crash in debug builds. Fixed in Qt 5.10
     #if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
       m_Controls->m_JSHistogram->Clear();
     #endif
-    QmitkImageStatisticsCalculationThread::HistogramType::ConstPointer histogram =
-        (QmitkImageStatisticsCalculationThread::HistogramType::ConstPointer)this->m_CalculationThread->GetTimeStepHistogram(timestep);
+    QmitkImageStatisticsCalculationJob::HistogramType::ConstPointer histogram =
+        (QmitkImageStatisticsCalculationJob::HistogramType::ConstPointer)this->m_CalculationThread->GetTimeStepHistogram(timestep);
 
     if (histogram.IsNotNull())
     {
       bool statisticsUpdateSuccessful = this->m_CalculationThread->GetStatisticsUpdateSuccessFlag();
 
       if (statisticsUpdateSuccessful)
       {
 
         auto imageNameLabel = m_Controls->m_SelectedFeatureImageLabel->text().toStdString();
         this->m_Controls->m_JSHistogram->AddData2D(ConvertHistogramToMap(histogram), imageNameLabel);
         if (this->m_Controls->m_lineRadioButton->isChecked())
         {
           this->m_Controls->m_JSHistogram->SetChartType(imageNameLabel, QmitkChartWidget::ChartType::line);
         }
         else
         {
           this->m_Controls->m_JSHistogram->SetChartType(imageNameLabel, QmitkChartWidget::ChartType::bar);
         }
         this->m_Controls->m_JSHistogram->SetXAxisLabel("Grey value");
         this->m_Controls->m_JSHistogram->SetYAxisLabel("Frequency");
         this->m_Controls->m_JSHistogram->Show(this->m_Controls->m_ShowSubchartCheckBox->isChecked());
       }
     }
   }
 }
 
 void QmitkImageStatisticsView::JumpToCoordinates(int row ,int col)
 {
   if(m_SelectedDataNodes.isEmpty())
   {
     MITK_WARN("QmitkImageStatisticsView") << "No data node selected for statistics calculation." ;
     return;
   }
 
   mitk::Point3D world;
   if (row==5 && !m_WorldMinList.empty())
     world = m_WorldMinList[col];
   else if (row==4 && !m_WorldMaxList.empty())
     world = m_WorldMaxList[col];
   else
     return;
 
   mitk::IRenderWindowPart* part = this->GetRenderWindowPart();
   if (part)
   {
     part->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SelectSliceByPoint(world);
     part->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SelectSliceByPoint(world);
     part->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SelectSliceByPoint(world);
 
     mitk::SliceNavigationController::GeometryTimeEvent timeEvent(this->m_SelectedImage->GetTimeGeometry(), col);
     part->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SetGeometryTime(timeEvent);
   }
 }
 
 void QmitkImageStatisticsView::OnIgnoreZerosCheckboxClicked()
 {
   emit StatisticsUpdate();
 }
 
 void QmitkImageStatisticsView::OnClipboardHistogramButtonClicked()
 {
   if (!m_CurrentStatisticsValid)
   {
     QApplication::clipboard()->clear();
   }
 
   if (m_SelectedPlanarFigure == nullptr)
   {
     const unsigned int t = this->GetRenderWindowPart()->GetTimeNavigationController()->GetTime()->GetPos();
 
     typedef mitk::ImageStatisticsCalculator::HistogramType HistogramType;
     const HistogramType *histogram = this->m_CalculationThread->GetTimeStepHistogram(t).GetPointer();
 
     QString clipboard("Measurement \t Frequency\n");
     for (HistogramType::ConstIterator it = histogram->Begin();
       it != histogram->End();
       ++it)
     {
       clipboard = clipboard.append("%L1 \t %L2\n")
         .arg(it.GetMeasurementVector()[0], 0, 'f', 2)
         .arg(it.GetFrequency());
     }
 
     QApplication::clipboard()->setText(
       clipboard, QClipboard::Clipboard);
   }
   //If a (non-closed) PlanarFigure is selected, display a line profile widget
   else if (m_SelectedPlanarFigure != nullptr)
   {
     QString clipboard("Pixel \t Intensity\n");
     for (unsigned int i = 0; i < m_IntensityProfileList.size(); i++)
     {
       clipboard =
         clipboard.append("%L1 \t %L2\n").arg(QString::number(i)).arg(QString::number(m_IntensityProfileList.at(i)));
     }
     QApplication::clipboard()->setText(clipboard, QClipboard::Clipboard);
   }
 }
 
 void QmitkImageStatisticsView::OnClipboardStatisticsButtonClicked()
 {
   QLocale tempLocal;
   QLocale::setDefault(QLocale(QLocale::English, QLocale::UnitedStates));
   if ( m_CurrentStatisticsValid && !( m_SelectedPlanarFigure != nullptr))
    {
     auto &statistics =
       this->m_CalculationThread->GetStatisticsData();
 
     // Set time borders for for loop ;)
     unsigned int startT, endT;
     if(this->m_Controls->m_CheckBox4dCompleteTable->checkState()==Qt::CheckState::Unchecked)
     {
         startT = this->GetRenderWindowPart()->GetTimeNavigationController()->GetTime()->
           GetPos();
         endT = startT+1;
     }
     else
     {
         startT = 0;
         endT = statistics.size();
     }
     QVector< QVector<QString> > statisticsTable;
     QStringList headline{ "Timestep", "Mean", "Median", "StdDev", "RMS", "Max", "Min", "NumberOfVoxels", "Skewness", "Kurtosis", "Uniformity", "Entropy", "MPP", "UPP", "V [mm³]" };
 
     for(int i=0;i<headline.size();i++)
     {
         QVector<QString> row;
         row.append(headline.at(i));
         statisticsTable.append(row);
     }
 
     // Fill Table
     for(unsigned int t=startT;t<endT;t++)
     {
         // Copy statistics to clipboard ("%Ln" will use the default locale for
         // number formatting)
         QStringList value;
         value << QString::number(t)
               << QString::number(statistics[t]->GetMean())
               << QString::number(statistics[t]->GetMedian())
               << QString::number(statistics[t]->GetStd())
               << QString::number(statistics[t]->GetRMS())
               << QString::number(statistics[t]->GetMax())
               << QString::number(statistics[t]->GetMin())
               << QString::number(statistics[t]->GetN())
               << QString::number(statistics[t]->GetSkewness())
               << QString::number(statistics[t]->GetKurtosis())
               << QString::number(statistics[t]->GetUniformity())
               << QString::number(statistics[t]->GetEntropy())
               << QString::number(statistics[t]->GetMPP())
               << QString::number(statistics[t]->GetUPP())
               << QString::number(m_Controls->m_StatisticsTable->item(7, 0)->data(Qt::DisplayRole).toDouble());
 
          for(int z=0;z<value.size();z++)
          {
              statisticsTable[z].append(value.at(z));
          }
     }
 
     // Create output string
     QString clipboard;
     for(int i=0;i<statisticsTable.size();i++)
     {
         for(int t=0;t<statisticsTable.at(i).size();t++)
         {
             clipboard.append(statisticsTable.at(i).at(t));
             clipboard.append("\t");
         }
         clipboard.append("\n");
     }
     QApplication::clipboard()->setText(clipboard, QClipboard::Clipboard);
   }
   else
   {
     QApplication::clipboard()->clear();
   }
   QLocale::setDefault(tempLocal);
 }
 
 void QmitkImageStatisticsView::OnSelectionChanged( berry::IWorkbenchPart::Pointer /*part*/,
     const QList<mitk::DataNode::Pointer> &nodes )
 {
   if (this->m_Visible)
   {
     this->SelectionChanged( nodes );
   }
   else
   {
     this->m_DataNodeSelectionChanged = true;
   }
 }
 
 void QmitkImageStatisticsView::SelectionChanged(const QList<mitk::DataNode::Pointer> &selectedNodes)
 {
   //Clear Histogram if data node is deselected
   //bug in Qt thats leads to crash in debug builds. Fixed in Qt 5.10
   #if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
   m_Controls->m_JSHistogram->Clear();
   #endif
 
   if( this->m_StatisticsUpdatePending )
   {
     this->m_DataNodeSelectionChanged = true;
     return; // not ready for new data now!
   }
 
   if (selectedNodes.size() == this->m_SelectedDataNodes.size())
   {
     int i = 0;
     for (; i < selectedNodes.size(); ++i)
     {
       if (selectedNodes.at(i) != this->m_SelectedDataNodes.at(i))
       {
         break;
       }
     }
     // node selection did not change
     if (i == selectedNodes.size()) return;
   }
 
   //reset the feature image and image mask field
   m_Controls->m_SelectedFeatureImageLabel->setText("None");
   m_Controls->m_SelectedMaskLabel->setText("None");
 
   this->ReinitData();
   if (selectedNodes.isEmpty())
   {
     DisableHistogramGUIElements();
   }
   else
   {
     EnableHistogramGUIElements();
     ResetHistogramGUIElementsToDefault();
   }
   if(selectedNodes.size() == 1 || selectedNodes.size() == 2)
   {
     bool isBinary = false;
     selectedNodes.value(0)->GetBoolProperty("binary",isBinary);
     mitk::NodePredicateDataType::Pointer isLabelSet = mitk::NodePredicateDataType::New("LabelSetImage");
     isBinary |= isLabelSet->CheckNode(selectedNodes.value(0));
     if(isBinary)
     {
       EnableHistogramGUIElements();
       m_Controls->m_InfoLabel->setText("");
     }
     for (int i= 0; i< selectedNodes.size(); ++i)
     {
       this->m_SelectedDataNodes.push_back(selectedNodes.at(i));
     }
     this->m_DataNodeSelectionChanged = false;
     this->m_Controls->m_ErrorMessageLabel->setText( "" );
     this->m_Controls->m_ErrorMessageLabel->hide();
     emit StatisticsUpdate();
   }
   else
   {
     this->m_DataNodeSelectionChanged = false;
   }
 }
 
 void QmitkImageStatisticsView::DisableHistogramGUIElements()
 {
   m_Controls->m_InfoLabel->setText("");
   m_Controls->groupBox_histogram->setEnabled(false);
   m_Controls->groupBox_statistics->setEnabled(false);
 }
 
 void QmitkImageStatisticsView::ResetHistogramGUIElementsToDefault()
 {
   m_Controls->m_barRadioButton->setChecked(true);
   m_Controls->m_HistogramNBinsSpinbox->setValue(100);
   m_HistogramNBins = m_Controls->m_HistogramNBinsSpinbox->value();
   m_Controls->m_UseDefaultNBinsCheckBox->setChecked(true);
   m_Controls->m_ShowSubchartCheckBox->setChecked(true);
   m_Controls->m_BinSizeFrame->setEnabled(false);
   m_Controls->m_barRadioButton->setEnabled(true);
   m_Controls->m_lineRadioButton->setEnabled(true);
   m_Controls->m_HistogramNBinsSpinbox->setEnabled(true);
   this->m_CalculationThread->SetHistogramNBins(m_Controls->m_HistogramNBinsSpinbox->value());
 }
 
 void QmitkImageStatisticsView::EnableHistogramGUIElements()
 {
   m_Controls->groupBox_histogram->setEnabled(true);
   m_Controls->groupBox_plot->setEnabled(true);
   m_Controls->groupBox_statistics->setEnabled(true);
 }
 
 void QmitkImageStatisticsView::ReinitData()
 {
   while( this->m_CalculationThread->isRunning()) // wait until thread has finished
   {
     itksys::SystemTools::Delay(100);
   }
 
   if(this->m_SelectedImage != nullptr)
   {
     this->m_SelectedImage->RemoveObserver( this->m_ImageObserverTag);
     this->m_SelectedImage = nullptr;
   }
   if(this->m_SelectedImageMask != nullptr)
   {
     this->m_SelectedImageMask->RemoveObserver( this->m_ImageMaskObserverTag);
     this->m_SelectedImageMask = nullptr;
   }
   if(this->m_SelectedPlanarFigure != nullptr)
   {
     this->m_SelectedPlanarFigure->RemoveObserver( this->m_PlanarFigureObserverTag);
     this->m_SelectedPlanarFigure = nullptr;
   }
   this->m_SelectedDataNodes.clear();
   this->m_StatisticsUpdatePending = false;
 
   m_Controls->m_ErrorMessageLabel->setText( "" );
   m_Controls->m_ErrorMessageLabel->hide();
   this->InvalidateStatisticsTableView();
   m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
 }
 
 void QmitkImageStatisticsView::OnThreadedStatisticsCalculationEnds()
 {
   m_Controls->m_ErrorMessageLabel->setText("");
   m_Controls->m_ErrorMessageLabel->hide();
   this->WriteStatisticsToGUI();
 }
 
 void QmitkImageStatisticsView::UpdateStatistics()
 {
   mitk::IRenderWindowPart* renderPart = this->GetRenderWindowPart();
   if ( renderPart == nullptr )
   {
     this->m_StatisticsUpdatePending =  false;
     return;
   }
   m_WorldMinList.clear();
   m_WorldMaxList.clear();
 
   // classify selected nodes
   mitk::NodePredicateDataType::Pointer isImage = mitk::NodePredicateDataType::New("Image");
   mitk::NodePredicateDataType::Pointer isLabelSet = mitk::NodePredicateDataType::New("LabelSetImage");
   mitk::NodePredicateOr::Pointer imagePredicate = mitk::NodePredicateOr::New(isImage, isLabelSet);
 
   std::string maskName;
   std::string maskType;
   std::string featureImageName;
   unsigned int maskDimension = 0;
 
   // reset data from last run
   ITKCommandType::Pointer changeListener = ITKCommandType::New();
   changeListener->SetCallbackFunction( this, &QmitkImageStatisticsView::SelectedDataModified );
 
   mitk::DataNode::Pointer planarFigureNode;
   for( int i= 0 ; i < this->m_SelectedDataNodes.size(); ++i)
   {
     mitk::PlanarFigure::Pointer planarFig = dynamic_cast<mitk::PlanarFigure*>(this->m_SelectedDataNodes.at(i)->GetData());
     if( imagePredicate->CheckNode(this->m_SelectedDataNodes.at(i)) )
     {
       bool isMask = false;
       this->m_SelectedDataNodes.at(i)->GetPropertyValue("binary", isMask);
       isMask |= isLabelSet->CheckNode(this->m_SelectedDataNodes.at(i));
 
       if( this->m_SelectedImageMask == nullptr && isMask)
       {
         this->m_SelectedImageMask = dynamic_cast<mitk::Image*>(this->m_SelectedDataNodes.at(i)->GetData());
         this->m_ImageMaskObserverTag = this->m_SelectedImageMask->AddObserver(itk::ModifiedEvent(), changeListener);
 
         maskName = this->m_SelectedDataNodes.at(i)->GetName();
         maskType = m_SelectedImageMask->GetNameOfClass();
         maskDimension = 3;
       }
       else if( !isMask )
       {
         if(this->m_SelectedImage == nullptr)
         {
           this->m_SelectedImage = static_cast<mitk::Image*>(this->m_SelectedDataNodes.at(i)->GetData());
           this->m_ImageObserverTag = this->m_SelectedImage->AddObserver(itk::ModifiedEvent(), changeListener);
         }
         featureImageName = this->m_SelectedDataNodes.at(i)->GetName();
       }
     }
     else if (planarFig.IsNotNull())
     {
       if(this->m_SelectedPlanarFigure == nullptr)
       {
         this->m_SelectedPlanarFigure = planarFig;
         this->m_PlanarFigureObserverTag  =
             this->m_SelectedPlanarFigure->AddObserver(mitk::EndInteractionPlanarFigureEvent(), changeListener);
         maskName = this->m_SelectedDataNodes.at(i)->GetName();
         maskType = this->m_SelectedPlanarFigure->GetNameOfClass();
         maskDimension = 2;
         planarFigureNode = m_SelectedDataNodes.at(i);
       }
     }
     else
     {
       m_Controls->m_ErrorMessageLabel->setText("<font color='red'>Invalid data node type!</font>");
       m_Controls->m_ErrorMessageLabel->show();
     }
   }
 
   if(maskName == "")
   {
     maskName = "None";
     maskType = "";
     maskDimension = 0;
   }
 
   if(featureImageName == "")
   {
     featureImageName = "None";
   }
 
   if (m_SelectedPlanarFigure != nullptr && m_SelectedImage == nullptr)
   {
     mitk::DataStorage::SetOfObjects::ConstPointer parentSet = this->GetDataStorage()->GetSources(planarFigureNode);
     for (unsigned int i=0; i<parentSet->Size(); i++)
     {
       mitk::DataNode::Pointer node = parentSet->ElementAt(i);
       if( imagePredicate->CheckNode(node) )
       {
         bool isMask = false;
         node->GetPropertyValue("binary", isMask);
         isMask |= isLabelSet->CheckNode(node);
 
         if( !isMask )
         {
           if(this->m_SelectedImage == nullptr)
           {
             this->m_SelectedImage = static_cast<mitk::Image*>(node->GetData());
             this->m_ImageObserverTag = this->m_SelectedImage->AddObserver(itk::ModifiedEvent(), changeListener);
           }
         }
       }
     }
   }
 
   unsigned int timeStep = renderPart->GetTimeNavigationController()->GetTime()->GetPos();
 
   if ( m_SelectedImage != nullptr && m_SelectedImage->IsInitialized())
   {
     // Check if a the selected image is a multi-channel image. If yes, statistics
     // cannot be calculated currently.
     if ( m_SelectedImage->GetPixelType().GetNumberOfComponents() > 1 )
     {
       m_Controls->m_ErrorMessageLabel->setText( "<font color='red'>Multi-component images not supported.</font>" );
       m_Controls->m_ErrorMessageLabel->show();
 
       this->InvalidateStatisticsTableView();
       m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 0 );
       m_CurrentStatisticsValid = false;
       this->m_StatisticsUpdatePending = false;
       this->DisableHistogramGUIElements();
       m_Controls->m_InfoLabel->setText("");
       return;
     }
 
     std::stringstream maskLabel;
     maskLabel << maskName;
     if ( maskDimension > 0 )
     {
       maskLabel << "  [" << maskDimension << "D " << maskType << "]";
     }
     m_Controls->m_SelectedMaskLabel->setText( maskLabel.str().c_str() );
     m_Controls->m_SelectedFeatureImageLabel->setText(featureImageName.c_str());
 
     // check time step validity
     if(m_SelectedImage->GetDimension() <= 3 && timeStep > m_SelectedImage->GetDimension(3)-1)
     {
       timeStep = m_SelectedImage->GetDimension(3)-1;
     }
 
     // Add the used mask time step to the mask label so the user knows which mask time step was used
     // if the image time step is bigger than the total number of mask time steps (see
     // ImageStatisticsCalculator::ExtractImageAndMask)
     if (m_SelectedImageMask != nullptr)
     {
       unsigned int maskTimeStep = timeStep;
 
       if (maskTimeStep >= m_SelectedImageMask->GetTimeSteps())
       {
         maskTimeStep = m_SelectedImageMask->GetTimeSteps() - 1;
       }
 
       m_Controls->m_SelectedMaskLabel->setText(m_Controls->m_SelectedMaskLabel->text() +
           QString(" (t=") +
           QString::number(maskTimeStep) +
           QString(")"));
     }
 
     // check if the segmentation mask is empty
     if (m_SelectedImageMask != nullptr)
     {
       auto maskStatistics = m_SelectedImageMask->GetStatistics();
       mitk::ScalarType maskMaxValue = maskStatistics->GetScalarValueMax(0);
       if (m_SelectedImageMask->GetDimension() == 4) {
         for (unsigned int curTimestep = 1; curTimestep < m_SelectedImageMask->GetTimeSteps(); curTimestep++) {
           maskMaxValue = std::max(maskStatistics->GetScalarValueMax(curTimestep), maskMaxValue);
         }
       }
 
       bool segmentationIsEmpty = maskMaxValue == 0;
 
       if (segmentationIsEmpty)
       {
         m_Controls->m_ErrorMessageLabel->setText( "<font color='red'>Empty segmentation mask selected...</font>" );
         m_Controls->m_ErrorMessageLabel->show();
         this->m_StatisticsUpdatePending = false;
         return;
       }
     }
 
     //// initialize thread and trigger it
     this->m_CalculationThread->SetIgnoreZeroValueVoxel( m_Controls->m_IgnoreZerosCheckbox->isChecked() );
     this->m_CalculationThread->Initialize( m_SelectedImage, m_SelectedImageMask, m_SelectedPlanarFigure );
     this->m_CalculationThread->SetTimeStep( timeStep );
 
     m_Controls->m_ErrorMessageLabel->setText("<font color='red'>Calculating statistics...</font>");
     m_Controls->m_ErrorMessageLabel->show();
 
     try
     {
       // Compute statistics
       this->m_CalculationThread->start();
     }
     catch ( const mitk::Exception& e)
     {
       m_Controls->m_ErrorMessageLabel->setText("<font color='red'>" + QString(e.GetDescription()) + "</font>");
       m_Controls->m_ErrorMessageLabel->show();
       this->m_StatisticsUpdatePending = false;
     }
     catch ( const std::runtime_error &e )
     {
       // In case of exception, print error message on GUI
       m_Controls->m_ErrorMessageLabel->setText("<font color='red'>" + QString(e.what()) + "</font>");
       m_Controls->m_ErrorMessageLabel->show();
       this->m_StatisticsUpdatePending = false;
     }
     catch ( const std::exception &e )
     {
       MITK_ERROR << "Caught exception: " << e.what();
 
       // In case of exception, print error message on GUI
       m_Controls->m_ErrorMessageLabel->setText("<font color='red'>" + QString(e.what()) + "</font>");
       m_Controls->m_ErrorMessageLabel->show();
       this->m_StatisticsUpdatePending = false;
     }
   }
   else
   {
     this->m_StatisticsUpdatePending = false;
   }
 }
 
 void QmitkImageStatisticsView::SelectedDataModified()
 {
   if( !m_StatisticsUpdatePending )
   {
     emit StatisticsUpdate();
   }
 }
 
 void QmitkImageStatisticsView::NodeRemoved(const mitk::DataNode *node)
 {
   while(this->m_CalculationThread->isRunning()) // wait until thread has finished
   {
     itksys::SystemTools::Delay(100);
   }
 
   if (node->GetData() == m_SelectedImage)
   {
     m_SelectedImage = nullptr;
   }
 }
 
 void QmitkImageStatisticsView::RequestStatisticsUpdate()
 {
   if ( !m_StatisticsUpdatePending )
   {
     if(this->m_DataNodeSelectionChanged)
     {
       this->SelectionChanged(this->GetCurrentSelection());
     }
     else
     {
       this->m_StatisticsUpdatePending = true;
       this->UpdateStatistics();
     }
   }
   if (this->GetRenderWindowPart())
     this->GetRenderWindowPart()->RequestUpdate();
 }
 
 void QmitkImageStatisticsView::OnHistogramNBinsCheckBoxValueChanged()
 {
     if (static_cast<unsigned int>(m_Controls->m_HistogramNBinsSpinbox->value()) != m_HistogramNBins)
     {
       m_HistogramNBins = m_Controls->m_HistogramNBinsSpinbox->value();
         this->m_CalculationThread->SetHistogramNBins(m_Controls->m_HistogramNBinsSpinbox->value());
         this->UpdateStatistics();
     }
 }
 
 void QmitkImageStatisticsView::WriteStatisticsToGUI()
 {
   //bug in Qt thats leads to crash in debug builds. Fixed in Qt 5.10
   #if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
   m_Controls->m_JSHistogram->Clear();
   #endif
   m_IntensityProfileList.clear();
 
   //Disconnect OnLineRadioButtonSelected() to prevent reloading chart when radiobutton is checked programmatically
   disconnect((QObject*)(this->m_Controls->m_JSHistogram), SIGNAL(PageSuccessfullyLoaded()), 0, 0);
   connect((QObject*)(this->m_Controls->m_JSHistogram), SIGNAL(PageSuccessfullyLoaded()), (QObject*) this, SLOT(OnPageSuccessfullyLoaded()));
   m_Controls->m_InfoLabel->setText("");
 
   if (m_DataNodeSelectionChanged)
   {
     this->m_StatisticsUpdatePending = false;
     this->RequestStatisticsUpdate();
     return;    // stop visualization of results and calculate statistics of new selection
   }
 
   if (this->m_CalculationThread->GetStatisticsUpdateSuccessFlag())
   {
     if (this->m_CalculationThread->GetStatisticsChangedFlag())
     {
       // Do not show any error messages
       m_Controls->m_ErrorMessageLabel->hide();
       m_CurrentStatisticsValid = true;
     }
 
     if (m_SelectedImage != nullptr) {
       //all statistics are now computed also on planar figures (lines, paths...)!
     // If a (non-closed) PlanarFigure is selected, display a line profile widget
       if (m_SelectedPlanarFigure != nullptr && !m_SelectedPlanarFigure->IsClosed()) {
 
         // check whether PlanarFigure is initialized
         const mitk::PlaneGeometry *planarFigurePlaneGeometry = m_SelectedPlanarFigure->GetPlaneGeometry();
 
         if (planarFigurePlaneGeometry != nullptr)
         {
           unsigned int timeStep = this->GetRenderWindowPart()->GetTimeNavigationController()->GetTime()->GetPos();
 
           mitk::Image::Pointer image;
 
           if (this->m_CalculationThread->GetStatisticsImage()->GetDimension() == 4)
           {
             mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
             timeSelector->SetInput(this->m_CalculationThread->GetStatisticsImage());
             timeSelector->SetTimeNr(timeStep);
             timeSelector->Update();
 
             image = timeSelector->GetOutput();
           }
           else
           {
             image = this->m_CalculationThread->GetStatisticsImage();
           }
 
           mitk::IntensityProfile::ConstPointer intensityProfile = (mitk::IntensityProfile::ConstPointer)mitk::ComputeIntensityProfile(image, m_SelectedPlanarFigure);
 
           m_IntensityProfileList = ConvertIntensityProfileToVector(intensityProfile);
           auto lineDataLabel = "Intensity profile " + m_Controls->m_SelectedMaskLabel->text().toStdString();
           m_Controls->m_JSHistogram->SetChartType(lineDataLabel, QmitkChartWidget::ChartType::line);
           m_Controls->m_JSHistogram->AddData1D(m_IntensityProfileList, lineDataLabel);
           m_Controls->m_JSHistogram->SetXAxisLabel("Distance");
           m_Controls->m_JSHistogram->SetYAxisLabel("Intensity");
           m_Controls->m_JSHistogram->Show(m_Controls->m_ShowSubchartCheckBox->isChecked());
 
           m_Controls->m_lineRadioButton->setChecked(true);
           m_Controls->m_lineRadioButton->setEnabled(false);
           m_Controls->m_barRadioButton->setEnabled(false);
           m_Controls->m_HistogramNBinsSpinbox->setEnabled(false);
           m_Controls->m_BinSizeFrame->setEnabled(false);
           m_Controls->m_UseDefaultNBinsCheckBox->setEnabled(false);
 
           //Reconnect OnLineRadioButtonSelected()
           connect((QObject*)(this->m_Controls->m_JSHistogram), SIGNAL(PageSuccessfullyLoaded()), (QObject*) this, SLOT(OnLineRadioButtonSelected()));
           auto statisticsVector = this->m_CalculationThread->GetStatisticsData();
           //only one entry (current timestep)
           this->FillLinearProfileStatisticsTableView(statisticsVector.front().GetPointer(), this->m_CalculationThread->GetStatisticsImage());
 
           QString message("<font color='red'>Only linegraph available for an intensity profile!");
           if (this->m_CalculationThread->GetStatisticsImage()->GetDimension() == 4) {
             message += "Only current timestep displayed!";
           }
           message += "</font>";
           m_Controls->m_InfoLabel->setText(message);
           m_CurrentStatisticsValid = true;
         }
         else
         {
           // Clear statistics, histogram, and GUI
           this->InvalidateStatisticsTableView();
           m_Controls->m_StatisticsWidgetStack->setCurrentIndex(0);
           m_CurrentStatisticsValid = false;
           m_Controls->m_ErrorMessageLabel->hide();
           m_Controls->m_SelectedMaskLabel->setText("None");
           this->m_StatisticsUpdatePending = false;
           m_Controls->m_InfoLabel->setText("");
           return;
         }
       }
       else
       {
         m_Controls->m_StatisticsWidgetStack->setCurrentIndex(0);
 
         auto histogram = this->m_CalculationThread->GetTimeStepHistogram(this->m_CalculationThread->GetTimeStep()).GetPointer();
 
         auto imageLabelName = m_Controls->m_SelectedFeatureImageLabel->text().toStdString();
         m_Controls->m_JSHistogram->AddData2D(ConvertHistogramToMap(histogram), imageLabelName);
         m_Controls->m_JSHistogram->SetChartType(imageLabelName, QmitkChartWidget::ChartType::bar);
         this->m_Controls->m_JSHistogram->SetXAxisLabel("Gray value");
         this->m_Controls->m_JSHistogram->SetYAxisLabel("Frequency");
         m_Controls->m_UseDefaultNBinsCheckBox->setEnabled(true);
         m_Controls->m_JSHistogram->Show(this->m_Controls->m_ShowSubchartCheckBox->isChecked());
         this->FillStatisticsTableView(this->m_CalculationThread->GetStatisticsData(), this->m_CalculationThread->GetStatisticsImage());
 
         for (const auto& aStatistic: this->m_CalculationThread->GetStatisticsData()) {
           auto statisticsNode = mitk::DataNode::New();
           statisticsNode->SetName(m_Controls->m_SelectedFeatureImageLabel->text().toStdString());
           statisticsNode->SetData(aStatistic->Clone());
           statisticsNode->SetProperty("helper object", mitk::BoolProperty::New(true));
           this->GetDataStorage()->Add(statisticsNode);
         }
       }
       m_CurrentStatisticsValid = true;
     }
   }
   else
   {
     m_Controls->m_SelectedMaskLabel->setText("None");
     m_Controls->m_ErrorMessageLabel->setText(m_CalculationThread->GetLastErrorMessage().c_str());
     m_Controls->m_ErrorMessageLabel->show();
 
     // Clear statistics and histogram
     this->InvalidateStatisticsTableView();
     m_Controls->m_StatisticsWidgetStack->setCurrentIndex(0);
     m_CurrentStatisticsValid = false;
 
   }
   berry::IPreferencesService* prefService = berry::WorkbenchPlugin::GetDefault()->GetPreferencesService();
   m_StylePref = prefService->GetSystemPreferences()->Node(berry::QtPreferences::QT_STYLES_NODE);
 
   this->m_StatisticsUpdatePending = false;
 }
 
 void QmitkImageStatisticsView::FillStatisticsTableView(
     const std::vector<mitk::StatisticsContainer::ConstPointer> &statistics,
     const mitk::Image *image )
 {
   this->m_Controls->m_StatisticsTable->setColumnCount(image->GetTimeSteps());
   this->m_Controls->m_StatisticsTable->horizontalHeader()->setVisible(image->GetTimeSteps() > 1);
 
   // Set Checkbox for complete copy of statistic table
   if(image->GetTimeSteps()>1)
   {
     this->m_Controls->m_CheckBox4dCompleteTable->setEnabled(true);
   }
   else
   {
     this->m_Controls->m_CheckBox4dCompleteTable->setEnabled(false);
     this->m_Controls->m_CheckBox4dCompleteTable->setChecked(false);
   }
 
 
   for (unsigned int t = 0; t < image->GetTimeSteps(); t++)
   {
     this->m_Controls->m_StatisticsTable->setHorizontalHeaderItem(t,
         new QTableWidgetItem(QString::number(t)));
 
     if (statistics.at(t)->GetMaxIndex().size()==3)
     {
       mitk::Point3D index, max, min;
       index[0] = statistics.at(t)->GetMaxIndex()[0];
       index[1] = statistics.at(t)->GetMaxIndex()[1];
       index[2] = statistics.at(t)->GetMaxIndex()[2];
       m_SelectedImage->GetGeometry()->IndexToWorld(index, max);
       this->m_WorldMaxList.push_back(max);
       index[0] = statistics.at(t)->GetMinIndex()[0];
       index[1] = statistics.at(t)->GetMinIndex()[1];
       index[2] = statistics.at(t)->GetMinIndex()[2];
       m_SelectedImage->GetGeometry()->IndexToWorld(index, min);
       this->m_WorldMinList.push_back(min);
     }
 
     auto statisticsVector = AssembleStatisticsIntoVector(statistics.at(t).GetPointer(), image);
 
     unsigned int count = 0;
     for (const auto& entry : statisticsVector) {
       auto item = new QTableWidgetItem(entry);
       this->m_Controls->m_StatisticsTable->setItem(count, t, item);
       count++;
     }
 
     }
 
 
   this->m_Controls->m_StatisticsTable->resizeColumnsToContents();
   int height = STAT_TABLE_BASE_HEIGHT;
 
   if (this->m_Controls->m_StatisticsTable->horizontalHeader()->isVisible())
     height += this->m_Controls->m_StatisticsTable->horizontalHeader()->height();
 
   if (this->m_Controls->m_StatisticsTable->horizontalScrollBar()->isVisible())
     height += this->m_Controls->m_StatisticsTable->horizontalScrollBar()->height();
 
   this->m_Controls->m_StatisticsTable->setMinimumHeight(height);
 
   // make sure the current timestep's column is highlighted (and the correct histogram is displayed)
   unsigned int t = this->GetRenderWindowPart()->GetTimeNavigationController()->GetTime()->
       GetPos();
   mitk::SliceNavigationController::GeometryTimeEvent timeEvent(this->m_SelectedImage->GetTimeGeometry(),
       t);
   this->OnTimeChanged(timeEvent);
 
   t = std::min(image->GetTimeSteps() - 1, t);
 
   // See bug 18340
   /*QString hotspotMean; hotspotMean.append(QString("%1").arg(s[t].GetHotspotStatistics().GetMean(), 0, 'f', decimals));
   hotspotMean += " (";
   for (int i=0; i<s[t].GetHotspotIndex().size(); i++)
   {
   hotspotMean += QString::number(s[t].GetHotspotIndex()[i]);
   if (i<s[t].GetHotspotIndex().size()-1)
   hotspotMean += ",";
   }
   hotspotMean += ")";
 
   this->m_Controls->m_StatisticsTable->setItem( 7, t, new QTableWidgetItem( hotspotMean ) );
 
   QString hotspotMax; hotspotMax.append(QString("%1").arg(s[t].GetHotspotStatistics().GetMax(), 0, 'f', decimals));
   hotspotMax += " (";
   for (int i=0; i<s[t].GetHotspotStatistics().GetMaxIndex().size(); i++)
   {
   hotspotMax += QString::number(s[t].GetHotspotStatistics().GetMaxIndex()[i]);
   if (i<s[t].GetHotspotStatistics().GetMaxIndex().size()-1)
   hotspotMax += ",";
   }
   hotspotMax += ")";
 
   this->m_Controls->m_StatisticsTable->setItem( 8, t, new QTableWidgetItem( hotspotMax ) );
 
   QString hotspotMin; hotspotMin.append(QString("%1").arg(s[t].GetHotspotStatistics().GetMin(), 0, 'f', decimals));
   hotspotMin += " (";
   for (int i=0; i<s[t].GetHotspotStatistics().GetMinIndex().size(); i++)
   {
   hotspotMin += QString::number(s[t].GetHotspotStatistics().GetMinIndex()[i]);
   if (i<s[t].GetHotspotStatistics().GetMinIndex().size()-1)
   hotspotMin += ",";
   }
   hotspotMin += ")";
 
   this->m_Controls->m_StatisticsTable->setItem( 9, t, new QTableWidgetItem( hotspotMin ) );*/
 }
 
 std::vector<QString> QmitkImageStatisticsView::AssembleStatisticsIntoVector(mitk::StatisticsContainer::ConstPointer statistics, mitk::Image::ConstPointer image, bool noVolumeDefined) const
 {
   std::vector<QString> result;
 
   unsigned int decimals = 2;
 
   //statistics of higher order should have 5 decimal places because they used to be very small
   unsigned int decimalsHigherOrderStatistics = 5;
 
   if (image->GetPixelType().GetComponentType() == itk::ImageIOBase::DOUBLE || image->GetPixelType().GetComponentType() == itk::ImageIOBase::FLOAT)
   {
     decimals = 5;
   }
 
   result.push_back(GetFormattedString(statistics->GetMean(), decimals));
   result.push_back(GetFormattedString(statistics->GetMedian(), decimals));
   result.push_back(GetFormattedString(statistics->GetStd(), decimals));
   result.push_back(GetFormattedString(statistics->GetRMS(), decimals));
   result.push_back(GetFormattedString(statistics->GetMax(), decimals) + " " + GetFormattedIndex(statistics->GetMaxIndex()));
   result.push_back(GetFormattedString(statistics->GetMin(), decimals) + " " + GetFormattedIndex(statistics->GetMinIndex()));
   //to prevent large negative values of empty image statistics
   if (statistics->GetN() != std::numeric_limits<long>::min()) {
     result.push_back(GetFormattedString(statistics->GetN(), 0));
 
     const mitk::BaseGeometry *geometry = image->GetGeometry();
     if (geometry != NULL && !noVolumeDefined)
   {
       const mitk::Vector3D &spacing = image->GetGeometry()->GetSpacing();
       double volume = spacing[0] * spacing[1] * spacing[2] * static_cast<double>(statistics->GetN());
       result.push_back(GetFormattedString(volume, decimals));
   }
     else {
       result.push_back("NA");
   }
   }
   else {
     result.push_back("NA");
     result.push_back("NA");
   }
 
   result.push_back(GetFormattedString(statistics->GetSkewness(), decimalsHigherOrderStatistics));
   result.push_back(GetFormattedString(statistics->GetKurtosis(), decimalsHigherOrderStatistics));
   result.push_back(GetFormattedString(statistics->GetUniformity(), decimalsHigherOrderStatistics));
   result.push_back(GetFormattedString(statistics->GetEntropy(), decimalsHigherOrderStatistics));
   result.push_back(GetFormattedString(statistics->GetMPP(), decimals));
   result.push_back(GetFormattedString(statistics->GetUPP(), decimalsHigherOrderStatistics));
 
   return result;
 }
 
 void QmitkImageStatisticsView::FillLinearProfileStatisticsTableView(mitk::StatisticsContainer::ConstPointer statistics,
   const mitk::Image *image)
 {
   this->m_Controls->m_StatisticsTable->setColumnCount(1);
   this->m_Controls->m_StatisticsTable->horizontalHeader()->setVisible(false);
 
   m_PlanarFigureStatistics = this->AssembleStatisticsIntoVector(statistics, image, true);
 
   for (unsigned int i = 0; i< m_PlanarFigureStatistics.size(); i++)
   {
     this->m_Controls->m_StatisticsTable->setItem( i, 0, new QTableWidgetItem(m_PlanarFigureStatistics[i] ));
   }
 
   this->m_Controls->m_StatisticsTable->resizeColumnsToContents();
   int height = STAT_TABLE_BASE_HEIGHT;
 
   if (this->m_Controls->m_StatisticsTable->horizontalHeader()->isVisible())
     height += this->m_Controls->m_StatisticsTable->horizontalHeader()->height();
 
   if (this->m_Controls->m_StatisticsTable->horizontalScrollBar()->isVisible())
     height += this->m_Controls->m_StatisticsTable->horizontalScrollBar()->height();
 
   this->m_Controls->m_StatisticsTable->setMinimumHeight(height);
 }
 
 void QmitkImageStatisticsView::InvalidateStatisticsTableView()
 {
   this->m_Controls->m_StatisticsTable->horizontalHeader()->setVisible(false);
   this->m_Controls->m_StatisticsTable->setColumnCount(1);
 
   for ( int i = 0; i < this->m_Controls->m_StatisticsTable->rowCount(); ++i )
   {
     {
       this->m_Controls->m_StatisticsTable->setItem( i, 0, new QTableWidgetItem( "NA" ) );
     }
   }
 
   this->m_Controls->m_StatisticsTable->setMinimumHeight(STAT_TABLE_BASE_HEIGHT);
 }
 
 void QmitkImageStatisticsView::Activated()
 {
 }
 
 void QmitkImageStatisticsView::Deactivated()
 {
 }
 
 void QmitkImageStatisticsView::Visible()
 {
   m_Visible = true;
 
   mitk::IRenderWindowPart* renderWindow = GetRenderWindowPart();
 
   if (renderWindow)
   {
     itk::ReceptorMemberCommand<QmitkImageStatisticsView>::Pointer cmdTimeEvent =
         itk::ReceptorMemberCommand<QmitkImageStatisticsView>::New();
     cmdTimeEvent->SetCallbackFunction(this, &QmitkImageStatisticsView::OnTimeChanged);
 
     // It is sufficient to add the observer to the axial render window since the GeometryTimeEvent
     // is always triggered by all views.
     m_TimeObserverTag = renderWindow->GetQmitkRenderWindow("axial")->
         GetSliceNavigationController()->
         AddObserver(mitk::SliceNavigationController::GeometryTimeEvent(nullptr, 0), cmdTimeEvent);
   }
 
   if (m_DataNodeSelectionChanged)
   {
     if (this->IsCurrentSelectionValid())
     {
       this->SelectionChanged(this->GetCurrentSelection());
     }
     else
     {
       this->SelectionChanged(this->GetDataManagerSelection());
     }
     m_DataNodeSelectionChanged = false;
   }
 }
 
 void QmitkImageStatisticsView::Hidden()
 {
   m_Visible = false;
 
   // The slice navigation controller observer is removed here instead of in the destructor.
   // If it was called in the destructor, the application would freeze because the view's
   // destructor gets called after the render windows have been destructed.
   if ( m_TimeObserverTag != 0 )
   {
     mitk::IRenderWindowPart* renderWindow = GetRenderWindowPart();
 
     if (renderWindow)
     {
       renderWindow->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->
           RemoveObserver( m_TimeObserverTag );
     }
     m_TimeObserverTag = 0;
   }
 }
 
 void QmitkImageStatisticsView::SetFocus()
 {
 }
 
 std::map<double, double> QmitkImageStatisticsView::ConvertHistogramToMap(itk::Statistics::Histogram<double>::ConstPointer histogram) const
 {
   std::map<double, double> histogramMap;
 
   auto endIt = histogram->End();
   auto it = histogram->Begin();
 
   // generating Lists of measurement and frequencies
   for (; it != endIt; ++it)
   {
     double frequency = it.GetFrequency();
     double measurement = it.GetMeasurementVector()[0];
     histogramMap.emplace(measurement, frequency);
   }
 
   return histogramMap;
 }
 
 std::vector<double> QmitkImageStatisticsView::ConvertIntensityProfileToVector(mitk::IntensityProfile::ConstPointer intensityProfile) const
 {
   std::vector<double> intensityProfileList;
   auto end = intensityProfile->End();
 
   for (auto it = intensityProfile->Begin(); it != end; ++it)
   {
     intensityProfileList.push_back(it.GetMeasurementVector()[0]);
   }
   return intensityProfileList;
 }
 
 QString QmitkImageStatisticsView::GetFormattedString(double value, unsigned int decimals) const
 {
   typedef mitk::StatisticsContainer::RealType RealType;
   RealType maxVal = std::numeric_limits<RealType>::max();
 
   if (value == maxVal)
   {
     return QString("NA");
   }
   else
   {
     return QString("%1").arg(value, 0, 'f', decimals);
   }
 }
 
 QString QmitkImageStatisticsView::GetFormattedIndex(const vnl_vector<int>& vector) const
 {
   if (vector.empty()) {
     return QString();
   }
   QString formattedIndex("(");
   for (const auto& entry : vector)
   {
     formattedIndex += QString::number(entry);
     formattedIndex += ",";
   }
   formattedIndex.chop(1);
   formattedIndex += ")";
   return formattedIndex;
 }
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.h b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.h
index c25ea27220..a1e305ddd9 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.h
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.h
@@ -1,191 +1,191 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef QmitkImageStatisticsView_H__INCLUDED
 #define QmitkImageStatisticsView_H__INCLUDED
 
 #include "ui_QmitkImageStatisticsViewControls.h"
 
 // Qmitk includes
 #include <QmitkAbstractView.h>
 #include <QmitkStepperAdapter.h>
-#include "QmitkImageStatisticsCalculationThread.h"
+#include <QmitkImageStatisticsCalculationJob.h>
 #include <berryIPartListener.h>
 
 // mitk includes
 #include <mitkILifecycleAwarePart.h>
 #include <mitkPlanarLine.h>
 #include <mitkIntensityProfile.h>
 
 #include <berryIPreferences.h>
 
 /*!
 \brief QmitkImageStatisticsView is a bundle that allows statistics calculation from images. Three modes
 are supported: 1. Statistics of one image, 2. Statistics of an image and a segmentation, 3. Statistics
 of an image and a Planar Figure. The statistics calculation is realized in a separate thread to keep the
 gui accessible during calculation.
 
 \ingroup Plugins/org.mitk.gui.qt.measurementtoolbox
 */
 class QmitkImageStatisticsView : public QmitkAbstractView, public mitk::ILifecycleAwarePart, public berry::IPartListener
 {
   Q_OBJECT
 
 private:
   /*!
   \  Convenient typedefs */
   typedef QList<mitk::DataNode*> SelectedDataNodeVectorType;
   typedef itk::SimpleMemberCommand< QmitkImageStatisticsView > ITKCommandType;
 
   std::map<double, double> ConvertHistogramToMap(itk::Statistics::Histogram<double>::ConstPointer histogram) const;
   std::vector<double> ConvertIntensityProfileToVector(mitk::IntensityProfile::ConstPointer intensityProfile) const;
   std::vector<QString> AssembleStatisticsIntoVector(mitk::StatisticsContainer::ConstPointer statistics, mitk::Image::ConstPointer image, bool noVolumeDefined=false) const;
 
   QString GetFormattedIndex(const vnl_vector<int>& vector) const;
   QString GetFormattedString(double value, unsigned int decimals) const;
 public:
 
   /*!
   \brief default constructor */
   QmitkImageStatisticsView(QObject *parent = nullptr, const char *name = nullptr);
   /*!
   \brief default destructor */
   virtual ~QmitkImageStatisticsView();
   /*!
   \brief method for creating the widget containing the application   controls, like sliders, buttons etc. */
   virtual void CreateQtPartControl(QWidget *parent) override;
   /*!
   \brief method for creating the connections of main and control widget */
   virtual void CreateConnections();
   /*!
   \brief  Is called from the selection mechanism once the data manager selection has changed*/
   void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer> &selectedNodes) override;
 
   static const std::string VIEW_ID;
   static const int STAT_TABLE_BASE_HEIGHT;
 
   public slots:
   /** \brief  Called when the statistics update is finished, sets the results to GUI.*/
   void OnThreadedStatisticsCalculationEnds();
 
   /** \brief Update bin size for histogram resolution. */
   void OnHistogramNBinsCheckBoxValueChanged();
 
   protected slots:
   /** \brief  Saves the histogram to the clipboard */
   void OnClipboardHistogramButtonClicked();
   /** \brief  Saves the statistics to the clipboard */
   void OnClipboardStatisticsButtonClicked();
   /** \brief  Indicates if zeros should be excluded from statistics calculation */
   void OnIgnoreZerosCheckboxClicked();
   /** \brief Checks if update is possible and calls StatisticsUpdate() possible */
   void RequestStatisticsUpdate();
   /** \brief Jump to coordinates stored in the double clicked cell */
   void JumpToCoordinates(int row, int col);
   /** \brief Toogle GUI elements if histogram default bin size checkbox value changed. */
   void OnDefaultNBinsSpinBoxChanged();
 
   void OnShowSubchartBoxChanged();
 
   void OnBarRadioButtonSelected();
 
   void OnLineRadioButtonSelected();
 
   void OnPageSuccessfullyLoaded();
 
 signals:
   /** \brief Method to set the data to the member and start the threaded statistics update */
   void StatisticsUpdate();
 
 protected:
   /** \brief  Writes the calculated statistics to the GUI */
   void FillStatisticsTableView(const std::vector<mitk::StatisticsContainer::ConstPointer> &statistics,
     const mitk::Image *image);
 
   void FillLinearProfileStatisticsTableView(mitk::StatisticsContainer::ConstPointer statistics, const mitk::Image *image);
 
   /** \brief  Removes statistics from the GUI */
   void InvalidateStatisticsTableView();
 
   /** \brief Recalculate statistics for currently selected image and mask and
   * update the GUI. */
   void UpdateStatistics();
 
   virtual void Activated() override;
   virtual void Deactivated() override;
   virtual void Visible() override;
   virtual void Hidden() override;
 
   virtual void SetFocus() override;
 
   /** \brief Method called when itkModifiedEvent is called by selected data. */
   void SelectedDataModified();
   /** \brief  Method called when the data manager selection changes */
   void SelectionChanged(const QList<mitk::DataNode::Pointer> &selectedNodes);
 
   void DisableHistogramGUIElements();
 
   void ResetHistogramGUIElementsToDefault();
 
   void EnableHistogramGUIElements();
 
   /** \brief  Method called to remove old selection when a new selection is present */
   void ReinitData();
   /** \brief  writes the statistics to the gui*/
   void WriteStatisticsToGUI();
 
   void NodeRemoved(const mitk::DataNode *node) override;
 
   /** \brief Is called right before the view closes (before the destructor) */
   virtual void PartClosed(const berry::IWorkbenchPartReference::Pointer&) override;
   /** \brief Is called from the image navigator once the time step has changed */
   void OnTimeChanged(const itk::EventObject&);
   /** \brief Required for berry::IPartListener */
   virtual Events::Types GetPartEventTypes() const override { return Events::CLOSED; }
 
   // member variables
   Ui::QmitkImageStatisticsViewControls *m_Controls;
   // if you have a planar figure selected, the statistics values will be saved in this one.
   std::vector<QString> m_PlanarFigureStatistics;
-  QmitkImageStatisticsCalculationThread* m_CalculationThread;
+  QmitkImageStatisticsCalculationJob* m_CalculationThread;
 
   // Image and mask data
   mitk::Image* m_SelectedImage;
   mitk::Image* m_SelectedImageMask;
   mitk::PlanarFigure* m_SelectedPlanarFigure;
 
   // observer tags
   long m_ImageObserverTag;
   long m_ImageMaskObserverTag;
   long m_PlanarFigureObserverTag;
   long m_TimeObserverTag;
 
   SelectedDataNodeVectorType m_SelectedDataNodes;
 
   bool m_CurrentStatisticsValid;
   bool m_StatisticsUpdatePending;
   bool m_DataNodeSelectionChanged;
   bool m_Visible;
 
   unsigned int m_HistogramNBins;
 
   std::vector<mitk::Point3D>     m_WorldMinList;
   std::vector<mitk::Point3D>     m_WorldMaxList;
 
   std::vector<double> m_IntensityProfileList;
   berry::IPreferences::Pointer m_StylePref;
 };
 #endif // QmitkImageStatisticsView_H__INCLUDED