diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTableModel.cpp b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTableModel.cpp
index 435ff2869c..c4f963c8e0 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTableModel.cpp
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTableModel.cpp
@@ -1,155 +1,163 @@
-/*===================================================================
-
-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"
-
-QmitkImageStatisticsTableModel::QmitkImageStatisticsTableModel(QObject *parent) :
-QAbstractTableModel(parent)
-{}
-
-int QmitkImageStatisticsTableModel::rowCount(const QModelIndex &parent) const
-{
-    if (parent.isValid())
-    {
-        return 0;
-    }
-
-    if (!m_statistics.empty()){
-        return static_cast<int>(m_statistics.front()->GetStatisticsAsOrderedVector().size());
-    }
-    else
-    {
-        return 0;
-    }
-}
-
-int QmitkImageStatisticsTableModel::columnCount(const QModelIndex &parent) const
-{
-    if (parent.isValid())
-        return 0;
-
-    return static_cast<int>(m_statistics.size());
-}
-
-QVariant QmitkImageStatisticsTableModel::data(const QModelIndex &index, int role) const
-{
-    if (!index.isValid())
-        return QVariant();
-
-    QVariant result;
-    if (m_viewMode == viewMode::imageXStatistic) {
-      if (!m_statistics.empty() && index.row() < m_statistics.front()->GetStatisticsAsMap().size() && index.column() < m_statistics.size())
-      {
-        if (Qt::DisplayRole == role)
-        {
-          result = QVariant(m_statistics.at(index.column())->GetStatisticsAsOrderedVector().at(index.row()).second);
-        }
-        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).c_str());
-        }
-      }
-    }
-    else if ((Qt::DisplayRole == role) && (Qt::Vertical == orientation)){
-      if (!m_statistics.empty()) {
-        if (m_viewMode == viewMode::imageXStatistic) {
-          return QVariant(m_statisticNames.at(section).c_str());
-        }
-      }
-    }
-    return QVariant();
-}
-
-void QmitkImageStatisticsTableModel::SetStatistics(const std::vector<mitk::StatisticsContainer::ConstPointer>& statistics)
-{
-  emit beginResetModel();
-  m_statistics = statistics;
-
-  if (m_statisticNames.empty() && !statistics.empty()) {
-    auto firstStatisticAsMap = statistics.front()->GetStatisticsAsOrderedVector();
-    for (const auto& keyValue : firstStatisticAsMap) {
-      m_statisticNames.push_back(keyValue.first);
-    }
-  }
-  emit endResetModel();
-  emit dataChanged(QModelIndex(), QModelIndex());
-}
-
-void QmitkImageStatisticsTableModel::SetImageNodes(const std::vector<mitk::DataNode::ConstPointer>& nodes)
-{
-  m_imageNodes = nodes;
-}
-
-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.clear();
-  m_imageNodes.clear();
-  m_maskNodes.clear();
-  m_statisticNamesToIgnore.clear();
-  m_statisticNamesToShow.clear();
-  m_statisticNames.clear();
-  emit endResetModel();
-  emit dataChanged(QModelIndex(), QModelIndex());
-}
-
+/*===================================================================
+
+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"
+
+QmitkImageStatisticsTableModel::QmitkImageStatisticsTableModel(QObject *parent) :
+QAbstractTableModel(parent)
+{}
+
+int QmitkImageStatisticsTableModel::rowCount(const QModelIndex &parent) const
+{
+    if (parent.isValid())
+    {
+        return 0;
+    }
+
+    if (!m_statistics.empty()){
+        return static_cast<int>(m_statistics.front()->GetStatisticsAsOrderedVector().size());
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+int QmitkImageStatisticsTableModel::columnCount(const QModelIndex &parent) const
+{
+    if (parent.isValid())
+        return 0;
+
+    return static_cast<int>(m_statistics.size());
+}
+
+QVariant QmitkImageStatisticsTableModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid())
+        return QVariant();
+
+    QVariant result;
+    if (m_viewMode == viewMode::imageXStatistic) {
+      if (!m_statistics.empty() && index.row() < m_statistics.front()->GetStatisticsAsMap().size() && index.column() < m_statistics.size())
+      {
+        if (Qt::DisplayRole == role)
+        {
+          result = QVariant(m_statistics.at(index.column())->GetStatisticsAsOrderedVector().at(index.row()).second);
+        }
+        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.empty()) {
+        if (m_viewMode == viewMode::imageXStatistic) {
+          return QVariant(m_statisticNames.at(section).c_str());
+        }
+      }
+    }
+    return QVariant();
+}
+
+void QmitkImageStatisticsTableModel::SetStatistics(const std::vector<mitk::StatisticsContainer::ConstPointer>& statistics)
+{
+  emit beginResetModel();
+  m_statistics = statistics;
+
+  if (m_statisticNames.empty() && !statistics.empty()) {
+    auto firstStatisticAsMap = statistics.front()->GetStatisticsAsOrderedVector();
+    for (const auto& keyValue : firstStatisticAsMap) {
+      m_statisticNames.push_back(keyValue.first);
+    }
+  }
+  emit endResetModel();
+  emit dataChanged(QModelIndex(), QModelIndex());
+}
+
+void QmitkImageStatisticsTableModel::SetImageNodes(const std::vector<mitk::DataNode::ConstPointer>& nodes)
+{
+  std::vector<mitk::DataNode::ConstPointer> tempNodes;
+  for (int 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.clear();
+  m_imageNodes.clear();
+  m_maskNodes.clear();
+  m_statisticNamesToIgnore.clear();
+  m_statisticNamesToShow.clear();
+  m_statisticNames.clear();
+  emit endResetModel();
+  emit dataChanged(QModelIndex(), QModelIndex());
+}
+
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 195de154e2..70230b0008 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsReloadedView.cpp
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsReloadedView.cpp
@@ -1,301 +1,300 @@
 /*===================================================================
 
 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 <mitkNodePredicateOr.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkStatusBar.h>
 #include <mitkIntensityProfile.h>
 
 #include <mitkPlanarFigureInteractor.h>
 
 const std::string QmitkImageStatisticsReloadedView::VIEW_ID = "org.mitk.views.imagestatisticsReloaded";
 
 QmitkImageStatisticsReloadedView::QmitkImageStatisticsReloadedView(QObject* /*parent*/, const char* /*name*/)
 {
   this->m_CalculationThread = new QmitkImageStatisticsCalculationJob();
 }
 
 QmitkImageStatisticsReloadedView::~QmitkImageStatisticsReloadedView()
 {
   if (m_selectedPlanarFigure)
     m_selectedPlanarFigure->RemoveObserver(m_PlanarFigureObserverTag);
 }
 
 void QmitkImageStatisticsReloadedView::CreateQtPartControl(QWidget *parent)
 {
   m_Controls.setupUi(parent);
   m_Controls.widget_histogram->SetTheme(this->GetColorTheme());
   m_Controls.widget_intensityProfile->SetTheme(this->GetColorTheme());
   m_Controls.groupBox_histogram->setVisible(true);
   m_Controls.groupBox_intensityProfile->setVisible(false);
   PrepareDataStorageComboBoxes();
   CreateConnections();
 }
 
 void QmitkImageStatisticsReloadedView::CreateConnections()
 {
   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.groupBox_histogram->setVisible(true);
   m_Controls.widget_histogram->SetTheme(this->GetColorTheme());
   m_Controls.widget_histogram->Reset();
   m_Controls.widget_histogram->SetHistogram(histogram.front(), dataLabels.front());
   connect(m_Controls.widget_histogram, &QmitkHistogramVisualizationWidget::RequestHistogramUpdate, this, &QmitkImageStatisticsReloadedView::OnRequestHistogramUpdate);
 }
 
 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()
 {
   if (this->m_selectedPlanarFigure)
   {
     this->m_selectedPlanarFigure->RemoveObserver(this->m_PlanarFigureObserverTag);
     this->m_selectedPlanarFigure = nullptr;
   }
 
   m_selectedImageNode = m_Controls.imageSelector->GetSelectedNode();
   m_selectedMaskNode = m_Controls.maskImageSelector->GetSelectedNode();
 
   m_Controls.groupBox_intensityProfile->setVisible(false);
 
   if (m_selectedImageNode != nullptr) {
     auto image = dynamic_cast<mitk::Image*>(m_selectedImageNode->GetData());
     mitk::Image::Pointer mask = nullptr;
     mitk::PlanarFigure::Pointer maskPlanarFigure = nullptr;
     if (m_selectedMaskNode != nullptr) {
       mask = dynamic_cast<mitk::Image*>(m_selectedMaskNode->GetData());
       if (mask == nullptr) {
         maskPlanarFigure = dynamic_cast<mitk::PlanarFigure*>(m_selectedMaskNode->GetData());
       }
     }
     if (mask) {
       //compute statistics with given mask
       CalculateStatistics(image, mask);
     }
     else if (maskPlanarFigure) {
       m_selectedPlanarFigure = maskPlanarFigure;
       ITKCommandType::Pointer changeListener = ITKCommandType::New();
       changeListener->SetCallbackFunction(this, &QmitkImageStatisticsReloadedView::OnImageOrMaskSelectorChanged);
       this->m_PlanarFigureObserverTag =
         m_selectedPlanarFigure->AddObserver(mitk::EndInteractionPlanarFigureEvent(), changeListener);
       if (!maskPlanarFigure->IsClosed()) {
         //compute line profile and display statistics for voxels on line
         auto intensityProfile = mitk::ComputeIntensityProfile(image, maskPlanarFigure);
         //Don't show histogram for intensity profiles
         m_Controls.groupBox_histogram->setVisible(false);
         m_Controls.groupBox_intensityProfile->setVisible(true);
         m_Controls.widget_intensityProfile->Reset();
         m_Controls.widget_intensityProfile->SetIntensityProfile(intensityProfile.GetPointer(), "Intensity Profile of " + m_selectedImageNode->GetName());
       }
       //for all planar figures: compute statistics with planarFigure as mask
       CalculateStatistics(image, maskPlanarFigure);
     }
     else {
       //compute statistics with image only
       CalculateStatistics(image);
     }
   }
   else {
     ResetGUI();
   }
 }
 
 void QmitkImageStatisticsReloadedView::ResetGUI()
 {
   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());
     if (!m_selectedPlanarFigure || m_selectedPlanarFigure->IsClosed()) {
       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::OnRequestHistogramUpdate(unsigned int nBins)
 {
   m_CalculationThread->SetHistogramNBins(nBins);
   m_CalculationThread->start();
 }
 
 void QmitkImageStatisticsReloadedView::CalculateStatistics(mitk::Image::Pointer image, mitk::Image::Pointer mask)
 {
   CalculateStatisticsInternal(image, mask);
 
 }
 
 void QmitkImageStatisticsReloadedView::CalculateStatistics(mitk::Image::Pointer image, mitk::PlanarFigure::Pointer mask) {
   CalculateStatisticsInternal(image, nullptr, mask);
 }
 
 void QmitkImageStatisticsReloadedView::CalculateStatisticsInternal(mitk::Image::Pointer image, mitk::Image::Pointer mask, mitk::PlanarFigure::Pointer maskPlanarFigure)
 {
   this->m_StatisticsUpdatePending = true;
   this->m_CalculationThread->Initialize(image, mask, maskPlanarFigure);
-  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);
   auto isPlanarFigure = GetPlanarFigurePredicate();
   auto isBinaryImageOrPlanarFigure = mitk::NodePredicateOr::New(isBinaryImage, isPlanarFigure);
 
   m_Controls.imageSelector->SetDataStorage(GetDataStorage());
   m_Controls.imageSelector->SetPredicate(isNoBinaryImage);
 
   m_Controls.maskImageSelector->SetDataStorage(GetDataStorage());
   m_Controls.maskImageSelector->SetPredicate(isBinaryImageOrPlanarFigure);
   m_Controls.maskImageSelector->SetZeroEntryText("<none>");
 }
 
 mitk::NodePredicateBase::Pointer QmitkImageStatisticsReloadedView::GetPlanarFigurePredicate() const
 {
   auto isPlanarCircle = mitk::NodePredicateDataType::New("PlanarCircle");
   auto isPlanarRectangle = mitk::NodePredicateDataType::New("PlanarRectangle");
   auto isPlanarEllipse = mitk::NodePredicateDataType::New("PlanarEllipse");
   auto isPlanarDoubleEllipse = mitk::NodePredicateDataType::New("PlanarDoubleEllipse");
   auto isPlanarPolygon = mitk::NodePredicateDataType::New("PlanarPolygon");
   auto isPlanarSubdivisionPolygon = mitk::NodePredicateDataType::New("PlanarSubdivisionPolygon");
   auto isPlanarBezierCurve = mitk::NodePredicateDataType::New("PlanarBezierCurve");
   auto isPlanarLine = mitk::NodePredicateDataType::New("PlanarLine");
   auto isPlanarFigure = mitk::NodePredicateOr::New(isPlanarCircle, isPlanarEllipse);
   isPlanarFigure = mitk::NodePredicateOr::New(isPlanarFigure, isPlanarRectangle);
   isPlanarFigure = mitk::NodePredicateOr::New(isPlanarFigure, isPlanarDoubleEllipse);
   isPlanarFigure = mitk::NodePredicateOr::New(isPlanarFigure, isPlanarPolygon);
   isPlanarFigure = mitk::NodePredicateOr::New(isPlanarFigure, isPlanarSubdivisionPolygon);
   isPlanarFigure = mitk::NodePredicateOr::New(isPlanarFigure, isPlanarBezierCurve);
   isPlanarFigure = mitk::NodePredicateOr::New(isPlanarFigure, isPlanarLine);
   return isPlanarFigure.GetPointer();
 }
 
 void QmitkImageStatisticsReloadedView::Activated()
 {
 }
 
 void QmitkImageStatisticsReloadedView::Deactivated()
 {
 }
 
 void QmitkImageStatisticsReloadedView::Visible()
 {
   connect(m_Controls.imageSelector, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &QmitkImageStatisticsReloadedView::OnImageOrMaskSelectorChanged);
   connect(m_Controls.maskImageSelector, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &QmitkImageStatisticsReloadedView::OnImageOrMaskSelectorChanged);
   m_selectedImageNode = m_Controls.imageSelector->GetSelectedNode();
   if (m_selectedImageNode) {
     OnImageOrMaskSelectorChanged();
   }
   else {
     ResetGUI();
   }
 }
 
 void QmitkImageStatisticsReloadedView::Hidden()
 {
   m_Controls.imageSelector->disconnect();
   m_Controls.maskImageSelector->disconnect();
 }
 
 void QmitkImageStatisticsReloadedView::SetFocus()
 {
 }