diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeItem.cpp b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeItem.cpp
index 355cd148ad..7042b3210d 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeItem.cpp
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeItem.cpp
@@ -1,104 +1,104 @@
 /*===================================================================
 
 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 "QmitkImageStatisticsTreeItem.h"
 
 QmitkImageStatisticsTreeItem::QmitkImageStatisticsTreeItem(
   ImageStatisticsObject statisticsData,
   StatisticNameVector statisticNames,
   QVariant label,
   QmitkImageStatisticsTreeItem *parent)
   : m_statistics(statisticsData) , m_statisticNames(statisticNames), m_label(label), m_parentItem(parent)
 {
 }
 
  QmitkImageStatisticsTreeItem::QmitkImageStatisticsTreeItem(StatisticNameVector statisticNames,
                                                            QVariant label,
                                                            QmitkImageStatisticsTreeItem *parentItem)
   : QmitkImageStatisticsTreeItem(ImageStatisticsObject(), statisticNames, label, parentItem )
 {
 }
 
  QmitkImageStatisticsTreeItem::QmitkImageStatisticsTreeItem() : QmitkImageStatisticsTreeItem(StatisticNameVector(), QVariant(), nullptr ) {}
 
 QmitkImageStatisticsTreeItem::~QmitkImageStatisticsTreeItem()
 {
   qDeleteAll(m_childItems);
 }
 
 void QmitkImageStatisticsTreeItem::appendChild(QmitkImageStatisticsTreeItem *item)
 {
   m_childItems.append(item);
 }
 
 QmitkImageStatisticsTreeItem *QmitkImageStatisticsTreeItem::child(int row)
 {
   return m_childItems.value(row);
 }
 
 int QmitkImageStatisticsTreeItem::childCount() const
 {
   return m_childItems.count();
 }
 
 int QmitkImageStatisticsTreeItem::columnCount() const
 {
   return m_statisticNames.size() + 1;
 }
 
 QVariant QmitkImageStatisticsTreeItem::data(int column) const
 {
   QVariant result;
   if (column > 0 && !m_statisticNames.empty())
   {
-    if (column - 1 < m_statisticNames.size())
+    if (column - 1 < static_cast<int>(m_statisticNames.size()))
     {
       auto statisticKey = m_statisticNames.at(column - 1);
       std::stringstream ss;
       if (m_statistics.HasStatistic(statisticKey))
       {
         ss << m_statistics.GetValueNonConverted(statisticKey);
       }
       else
       {
         return QVariant();
       }
       result = QVariant(QString::fromStdString(ss.str()));
     }
     else
     {
       return QVariant();
     }
   }
   else if (column == 0)
   {
     result = m_label;
   }
   return result;
 }
 
 QmitkImageStatisticsTreeItem *QmitkImageStatisticsTreeItem::parentItem()
 {
   return m_parentItem;
 }
 
 int QmitkImageStatisticsTreeItem::row() const
 {
   if (m_parentItem)
     return m_parentItem->m_childItems.indexOf(const_cast<QmitkImageStatisticsTreeItem *>(this));
 
   return 0;
 }
diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeItem.h b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeItem.h
index a2d934abf0..f28ca97cf3 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeItem.h
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeItem.h
@@ -1,58 +1,58 @@
 /*===================================================================
 
 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 QmitkImageStatisticsTreeItem_h
 #define QmitkImageStatisticsTreeItem_h
 
 #include <QList>
 #include <QVariant>
 
 #include "mitkImageStatisticsContainer.h"
 
 /*!
 \class QmitkImageStatisticsTreeItem
 An item that represents an entry (usually ImageStatisticsObject) for the QmitkImageStatisticsTreeModel
 */
 class QmitkImageStatisticsTreeItem
 {
 public:
   using ImageStatisticsObject = mitk::ImageStatisticsContainer::ImageStatisticsObject;
   using StatisticNameVector = mitk::ImageStatisticsContainer::ImageStatisticsObject::StatisticNameVector;
   QmitkImageStatisticsTreeItem();
   explicit QmitkImageStatisticsTreeItem(ImageStatisticsObject statisticsData,
     StatisticNameVector statisticNames, QVariant label, QmitkImageStatisticsTreeItem *parentItem = nullptr);
   explicit QmitkImageStatisticsTreeItem(StatisticNameVector statisticNames,
     QVariant label, QmitkImageStatisticsTreeItem *parentItem = nullptr);
   ~QmitkImageStatisticsTreeItem();
 
   void appendChild(QmitkImageStatisticsTreeItem *child);
 
   QmitkImageStatisticsTreeItem *child(int row);
   int childCount() const;
   int columnCount() const;
   QVariant data(int column) const;
   int row() const;
   QmitkImageStatisticsTreeItem *parentItem();
 
 private:
-  QVariant m_label;
-  QList<QmitkImageStatisticsTreeItem *> m_childItems;
   ImageStatisticsObject m_statistics;
   StatisticNameVector m_statisticNames;
+  QVariant m_label;
   QmitkImageStatisticsTreeItem *m_parentItem = nullptr;
+  QList<QmitkImageStatisticsTreeItem *> m_childItems;
 };
 
 #endif // QmitkImageStatisticsTreeItem_h
diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeModel.cpp b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeModel.cpp
index 94c01ab29e..2598435e20 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeModel.cpp
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkImageStatisticsTreeModel.cpp
@@ -1,382 +1,382 @@
 /*===================================================================
 
 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 "QmitkImageStatisticsTreeModel.h"
 
 #include "QmitkImageStatisticsTreeItem.h"
 #include "itkMutexLockHolder.h"
 #include "mitkImageStatisticsContainerManager.h"
 #include "mitkProportionalTimeGeometry.h"
 #include "mitkStatisticsToImageRelationRule.h"
 #include "mitkStatisticsToMaskRelationRule.h"
 
 QmitkImageStatisticsTreeModel::QmitkImageStatisticsTreeModel(QObject *parent) : QmitkAbstractDataStorageModel(parent)
 {
   m_RootItem = new QmitkImageStatisticsTreeItem();
 }
 
 QmitkImageStatisticsTreeModel ::~QmitkImageStatisticsTreeModel()
 {
   // set data storage to nullptr so that the event listener gets removed
   this->SetDataStorage(nullptr);
   delete m_RootItem;
 };
 
 void QmitkImageStatisticsTreeModel::DataStorageChanged()
 {
   emit beginResetModel();
   UpdateByDataStorage();
   emit endResetModel();
   emit modelChanged();
 }
 
 void QmitkImageStatisticsTreeModel::NodePredicateChanged()
 {
   emit beginResetModel();
   UpdateByDataStorage();
   emit endResetModel();
   emit modelChanged();
 }
 
-int QmitkImageStatisticsTreeModel::columnCount(const QModelIndex &parent) const
+int QmitkImageStatisticsTreeModel::columnCount(const QModelIndex& /*parent*/) const
 {
   int columns = m_StatisticNames.size() + 1;
   return columns;
 }
 
 int QmitkImageStatisticsTreeModel::rowCount(const QModelIndex &parent) const
 {
   QmitkImageStatisticsTreeItem *parentItem;
   if (parent.column() > 0)
     return 0;
 
   if (!parent.isValid())
     parentItem = m_RootItem;
   else
     parentItem = static_cast<QmitkImageStatisticsTreeItem *>(parent.internalPointer());
 
   return parentItem->childCount();
 }
 
 QVariant QmitkImageStatisticsTreeModel::data(const QModelIndex &index, int role) const
 {
   if (!index.isValid())
     return QVariant();
 
   if (role != Qt::DisplayRole)
     return QVariant();
 
   QmitkImageStatisticsTreeItem *item = static_cast<QmitkImageStatisticsTreeItem *>(index.internalPointer());
 
   return item->data(index.column());
 }
 
 QModelIndex QmitkImageStatisticsTreeModel::index(int row, int column, const QModelIndex &parent) const
 {
   if (!hasIndex(row, column, parent))
     return QModelIndex();
 
   QmitkImageStatisticsTreeItem *parentItem;
 
   if (!parent.isValid())
     parentItem = m_RootItem;
   else
     parentItem = static_cast<QmitkImageStatisticsTreeItem *>(parent.internalPointer());
 
   QmitkImageStatisticsTreeItem *childItem = parentItem->child(row);
   if (childItem)
     return createIndex(row, column, childItem);
   else
     return QModelIndex();
 }
 
 QModelIndex QmitkImageStatisticsTreeModel::parent(const QModelIndex &child) const
 {
   if (!child.isValid())
     return QModelIndex();
 
   QmitkImageStatisticsTreeItem *childItem = static_cast<QmitkImageStatisticsTreeItem *>(child.internalPointer());
   QmitkImageStatisticsTreeItem *parentItem = childItem->parentItem();
 
   if (parentItem == m_RootItem)
     return QModelIndex();
 
   return createIndex(parentItem->row(), 0, parentItem);
 }
 
 Qt::ItemFlags QmitkImageStatisticsTreeModel::flags(const QModelIndex &index) const
 {
   if (!index.isValid())
     return 0;
 
   return QAbstractItemModel::flags(index);
 }
 
 QVariant QmitkImageStatisticsTreeModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
   if ((Qt::DisplayRole == role) && (Qt::Horizontal == orientation))
   {
     if (section == 0)
     {
       return m_HeaderFirstColumn;
     }
     else
     {
       return QVariant(m_StatisticNames.at(section - 1).c_str());
     }
   }
   return QVariant();
 }
 
 void QmitkImageStatisticsTreeModel::SetImageNodes(const std::vector<mitk::DataNode::ConstPointer> &nodes)
 {
   std::vector<std::pair<mitk::DataNode::ConstPointer, unsigned int>> tempNodes;
   for (const auto &node : nodes)
   {
     auto data = node->GetData();
     if (data)
     {
       auto timeSteps = data->GetTimeSteps();
       for (unsigned int i = 0; i < timeSteps; i++)
       {
         tempNodes.push_back(std::make_pair(node, i));
       }
     }
   }
 
   emit beginResetModel();
   m_TimeStepResolvedImageNodes = std::move(tempNodes);
   m_ImageNodes = nodes;
   UpdateByDataStorage();
   emit endResetModel();
   emit modelChanged();
 }
 
 void QmitkImageStatisticsTreeModel::SetMaskNodes(const std::vector<mitk::DataNode::ConstPointer> &nodes)
 {
   std::vector<std::pair<mitk::DataNode::ConstPointer, unsigned int>> tempNodes;
   for (const auto &node : nodes)
   {
     auto data = node->GetData();
     if (data)
     {
       auto timeSteps = data->GetTimeSteps();
       // special case: apply one mask to each timestep of an 4D image
       if (timeSteps == 1 && m_TimeStepResolvedImageNodes.size() > 1)
       {
         timeSteps = m_TimeStepResolvedImageNodes.size();
       }
       for (unsigned int i = 0; i < timeSteps; i++)
       {
         tempNodes.push_back(std::make_pair(node, i));
       }
     }
   }
 
   emit beginResetModel();
   m_TimeStepResolvedMaskNodes = std::move(tempNodes);
   m_MaskNodes = nodes;
   UpdateByDataStorage();
   emit endResetModel();
   emit modelChanged();
 }
 
 void QmitkImageStatisticsTreeModel::Clear()
 {
   emit beginResetModel();
   m_Statistics.clear();
   m_ImageNodes.clear();
   m_TimeStepResolvedImageNodes.clear();
   m_MaskNodes.clear();
   m_StatisticNames.clear();
   emit endResetModel();
   emit modelChanged();
 }
 
 void QmitkImageStatisticsTreeModel::UpdateByDataStorage()
 {
   StatisticsContainerVector newStatistics;
 
   auto datamanager = m_DataStorage.Lock();
 
   if (datamanager.IsNotNull())
   {
     for (const auto &image : m_ImageNodes)
     {
       if (m_MaskNodes.empty())
       {
         auto stats = mitk::ImageStatisticsContainerManager::GetImageStatistics(datamanager, image->GetData());
 
         if (stats.IsNotNull())
         {
           newStatistics.emplace_back(stats);
         }
       }
       else
       {
         for (const auto &mask : m_MaskNodes)
         {
           auto stats =
             mitk::ImageStatisticsContainerManager::GetImageStatistics(datamanager, image->GetData(), mask->GetData());
           if (stats.IsNotNull())
           {
             newStatistics.emplace_back(stats);
           }
         }
       }
     }
     if (!newStatistics.empty())
     {
       emit dataAvailable();
     }
   }
 
   {
     itk::MutexLockHolder<itk::SimpleFastMutexLock> locked(m_Mutex);
     m_Statistics = newStatistics;
   }
 
   m_StatisticNames = mitk::GetAllStatisticNames(m_Statistics);
   BuildHierarchicalModel();
 }
 
 void QmitkImageStatisticsTreeModel::BuildHierarchicalModel()
 {
   // reset old model
   delete m_RootItem;
   m_RootItem = new QmitkImageStatisticsTreeItem();
 
   bool hasMask = false;
   bool hasMultipleTimesteps = false;
 
   std::map<mitk::DataNode::Pointer, QmitkImageStatisticsTreeItem *> dataNodeToTreeItem;
 
   for (auto statistic : m_Statistics)
   {
     // get the connected image data node/mask data node
     auto imageRule = mitk::StatisticsToImageRelationRule::New();
     auto imageOfStatisticsPredicate = imageRule->GetDestinationsDetector(statistic);
     auto imageCandidates = this->GetDataStorage()->GetSubset(imageOfStatisticsPredicate);
 
     auto maskRule = mitk::StatisticsToMaskRelationRule::New();
     auto maskOfStatisticsPredicate = maskRule->GetDestinationsDetector(statistic);
     auto maskCandidates = this->GetDataStorage()->GetSubset(maskOfStatisticsPredicate);
 
     if (imageCandidates->empty())
     {
       mitkThrow() << "no image found connected to statistic" << statistic << " Aborting.";
     }
     auto image = imageCandidates->front();
     // image: 1. hierarchy level
     QmitkImageStatisticsTreeItem *imageItem;
     auto search = dataNodeToTreeItem.find(image);
     // the tree item was created previously
     if (search != dataNodeToTreeItem.end())
     {
       imageItem = search->second;
     }
     // create the tree item
     else
     {
       QString imageLabel = QString::fromStdString(image->GetName());
       if (statistic->GetTimeSteps() == 1 && maskCandidates->empty())
       {
         auto statisticsObject = statistic->GetStatisticsForTimeStep(0);
         imageItem = new QmitkImageStatisticsTreeItem(statisticsObject, m_StatisticNames, imageLabel, m_RootItem);
       }
       else
       {
         imageItem = new QmitkImageStatisticsTreeItem(m_StatisticNames, imageLabel, m_RootItem);
       }
       m_RootItem->appendChild(imageItem);
       dataNodeToTreeItem.emplace(image, imageItem);
     }
 
     // mask: 2. hierarchy level (optional, only if mask exists)
     QmitkImageStatisticsTreeItem *lastParent;
     if (!maskCandidates->empty())
     {
       auto mask = maskCandidates->front();
       QString maskLabel = QString::fromStdString(mask->GetName());
       QmitkImageStatisticsTreeItem *maskItem;
       // add statistical values directly in this hierarchy level
       if (statistic->GetTimeSteps() == 1)
       {
         auto statisticsObject = statistic->GetStatisticsForTimeStep(0);
         maskItem = new QmitkImageStatisticsTreeItem(statisticsObject, m_StatisticNames, maskLabel, imageItem);
       }
       else
       {
         maskItem = new QmitkImageStatisticsTreeItem(m_StatisticNames, maskLabel, imageItem);
       }
 
       imageItem->appendChild(maskItem);
       lastParent = maskItem;
       hasMask = true;
     }
     else
     {
       lastParent = imageItem;
     }
     // 3. hierarchy level (optional, only if >1 timestep)
     if (statistic->GetTimeSteps() > 1)
     {
       for (unsigned int i = 0; i < statistic->GetTimeSteps(); i++)
       {
         QString timeStepLabel = "[" + QString::number(i) + "] " +
                                 QString::number(statistic->GetTimeGeometry()->TimeStepToTimePoint(i)) + " ms";
         auto statisticsItem = new QmitkImageStatisticsTreeItem(
           statistic->GetStatisticsForTimeStep(i), m_StatisticNames, timeStepLabel, lastParent);
         lastParent->appendChild(statisticsItem);
       }
       hasMultipleTimesteps = true;
     }
   }
   QString headerString = "Images";
   if (hasMask)
   {
     headerString += "/Masks";
   }
   if (hasMultipleTimesteps)
   {
     headerString += "/Timesteps";
   }
   m_HeaderFirstColumn = headerString;
 }
 
 void QmitkImageStatisticsTreeModel::NodeRemoved(const mitk::DataNode *)
 {
   emit beginResetModel();
   UpdateByDataStorage();
   emit endResetModel();
   emit modelChanged();
 }
 
 void QmitkImageStatisticsTreeModel::NodeAdded(const mitk::DataNode *)
 {
   emit beginResetModel();
   UpdateByDataStorage();
   emit endResetModel();
   emit modelChanged();
 }
 
 void QmitkImageStatisticsTreeModel::NodeChanged(const mitk::DataNode *)
 {
   emit beginResetModel();
   UpdateByDataStorage();
   emit endResetModel();
   emit modelChanged();
 }
diff --git a/Modules/ImageStatisticsUI/Qmitk/QmitkStatisticsModelToStringConverter.cpp b/Modules/ImageStatisticsUI/Qmitk/QmitkStatisticsModelToStringConverter.cpp
index aa86e871d7..b9a49a52a7 100644
--- a/Modules/ImageStatisticsUI/Qmitk/QmitkStatisticsModelToStringConverter.cpp
+++ b/Modules/ImageStatisticsUI/Qmitk/QmitkStatisticsModelToStringConverter.cpp
@@ -1,111 +1,110 @@
 /*===================================================================
 
 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 "QmitkStatisticsModelToStringConverter.h"
 #include "mitkExceptionMacro.h"
 
 QmitkStatisticsModelToStringConverter::QmitkStatisticsModelToStringConverter() {}
 
 void QmitkStatisticsModelToStringConverter::SetTableModel(QAbstractItemModel *model)
 {
   m_statisticsModel = model;
 }
 
 void QmitkStatisticsModelToStringConverter::SetRootIndex(QModelIndex rootIndex)
 {
   m_rootIndex = rootIndex;
 }
 
 QString QmitkStatisticsModelToStringConverter::GetString() const
 {
   if (m_statisticsModel == nullptr)
   {
     mitkThrow() << "Cannot convert TableModel to String: TableModel is nullptr";
   }
 
   QString textData;
-  int rows = m_statisticsModel->rowCount();
   int columns = m_statisticsModel->columnCount();
 
   if (m_includeHeaderData)
   {
     for (int i = 0; i < columns; i++)
     {
       if (i > 0)
       {
         textData += m_columnDelimiterWithSpace;
       }
       textData += m_statisticsModel->headerData(i, Qt::Horizontal).toString();
     }
     textData += m_lineDelimiter;
   }
   textData += Iterate(m_rootIndex, m_statisticsModel);
 
   return textData;
 }
 
 void QmitkStatisticsModelToStringConverter::SetRowDelimiter(QChar lineDelimiter)
 {
   m_lineDelimiter = lineDelimiter;
 }
 
 void QmitkStatisticsModelToStringConverter::SetColumnDelimiter(QChar columnDelimiter)
 {
   m_columnDelimiterWithSpace = columnDelimiter + QString(" ");
 }
 
 void QmitkStatisticsModelToStringConverter::SetIncludeHeaderData(bool includeHeaderData)
 {
   m_includeHeaderData = includeHeaderData;
 }
 
 QString QmitkStatisticsModelToStringConverter::Iterate(const QModelIndex &index,
                                                        const QAbstractItemModel *model,
                                                        int depth) const
 {
   QString content;
   if (index.isValid())
   {
     content = index.data().toString();
   }
   if (!model->hasChildren(index) || (index.flags() & Qt::ItemNeverHasChildren))
   {
     return content;
   }
   else
   {
     content += m_lineDelimiter;
   }
 
   auto rows = model->rowCount(index);
   auto cols = model->columnCount(index);
   for (int i = 0; i < rows; ++i)
   {
     if (i > 0)
     {
       content += m_lineDelimiter;
     }
     for (int j = 0; j < cols; ++j)
     {
       if (j > 0)
       {
         content += m_columnDelimiterWithSpace;
       }
       content += Iterate(model->index(i, j, index), model, depth + 1);
     }
   }
   return content;
 }