diff --git a/Plugins/org.mitk.gui.qt.fit.inspector/CMakeLists.txt b/Plugins/org.mitk.gui.qt.fit.inspector/CMakeLists.txt
index a3af7cd4ef..44f462019a 100644
--- a/Plugins/org.mitk.gui.qt.fit.inspector/CMakeLists.txt
+++ b/Plugins/org.mitk.gui.qt.fit.inspector/CMakeLists.txt
@@ -1,7 +1,7 @@
 project(org_mitk_gui_qt_fit_inspector)
 
 mitk_create_plugin(
   EXPORT_DIRECTIVE MODELFIT_INSPECTOR_EXPORT
   EXPORTED_INCLUDE_SUFFIXES src
-  MODULE_DEPENDS MitkQtWidgetsExt MitkModelFit MitkModelFitUI
+  MODULE_DEPENDS MitkModelFit MitkModelFitUI MitkChart
 )
diff --git a/Plugins/org.mitk.gui.qt.fit.inspector/src/internal/ModelFitInspectorView.cpp b/Plugins/org.mitk.gui.qt.fit.inspector/src/internal/ModelFitInspectorView.cpp
index a851bc57c8..ff06c012f0 100644
--- a/Plugins/org.mitk.gui.qt.fit.inspector/src/internal/ModelFitInspectorView.cpp
+++ b/Plugins/org.mitk.gui.qt.fit.inspector/src/internal/ModelFitInspectorView.cpp
@@ -1,909 +1,883 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
-
 // Blueberry
 #include <berryISelectionService.h>
-#include <berryIWorkbenchWindow.h>
 #include <berryIWorkbenchPage.h>
+#include <berryIWorkbenchWindow.h>
 
 // mitk
 #include <QmitkRenderWindow.h>
 
 // Qt
-#include <QMessageBox>
-#include <QFileDialog>
 #include <QTableWidget>
-#include <qwt_plot_marker.h>
-#include "QmitkPlotWidget.h"
 
-#include "mitkNodePredicateFunction.h"
-#include "mitkScalarListLookupTableProperty.h"
-#include "mitkModelFitConstants.h"
 #include "mitkExtractTimeGrid.h"
-#include "mitkModelGenerator.h"
+#include "mitkModelFitConstants.h"
 #include "mitkModelFitException.h"
 #include "mitkModelFitParameterValueExtraction.h"
+#include "mitkModelGenerator.h"
+#include "mitkNodePredicateFunction.h"
+#include "mitkScalarListLookupTableProperty.h"
 #include "mitkTimeGridHelper.h"
 
 #include "mitkModelFitPlotDataHelper.h"
 
 #include "ModelFitInspectorView.h"
 
 const std::string ModelFitInspectorView::VIEW_ID = "org.mitk.gui.gt.fit.inspector";
 const unsigned int ModelFitInspectorView::INTERPOLATION_STEPS = 10;
 const std::string DEFAULT_X_AXIS = "Time [s]";
 
-ModelFitInspectorView::ModelFitInspectorView() :
-  m_renderWindowPart(nullptr),
-  m_internalUpdateFlag(false),
-  m_currentFit(nullptr),
-  m_currentModelParameterizer(nullptr),
-  m_currentModelProviderService(nullptr),
-  m_currentSelectedTimeStep(0),
-  m_currentSelectedNode(nullptr)
+ModelFitInspectorView::ModelFitInspectorView()
+  : m_renderWindowPart(nullptr),
+    m_internalUpdateFlag(false),
+    m_currentFit(nullptr),
+    m_currentModelParameterizer(nullptr),
+    m_currentModelProviderService(nullptr),
+    m_currentSelectedTimeStep(0),
+    m_currentSelectedNode(nullptr)
 
 {
   m_currentSelectedPosition.Fill(0.0);
   m_modelfitList.clear();
 }
 
-ModelFitInspectorView::~ModelFitInspectorView()
-{
-}
+ModelFitInspectorView::~ModelFitInspectorView() {}
 
-void ModelFitInspectorView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
+void ModelFitInspectorView::RenderWindowPartActivated(mitk::IRenderWindowPart *renderWindowPart)
 {
   if (m_renderWindowPart != renderWindowPart)
   {
     m_renderWindowPart = renderWindowPart;
   }
 
   this->m_SliceChangeListener.RenderWindowPartActivated(renderWindowPart);
 }
 
-void ModelFitInspectorView::RenderWindowPartDeactivated(
-  mitk::IRenderWindowPart* renderWindowPart)
+void ModelFitInspectorView::RenderWindowPartDeactivated(mitk::IRenderWindowPart *renderWindowPart)
 {
   m_renderWindowPart = nullptr;
   this->m_SliceChangeListener.RenderWindowPartDeactivated(renderWindowPart);
 }
 
-void ModelFitInspectorView::CreateQtPartControl(QWidget* parent)
+void ModelFitInspectorView::CreateQtPartControl(QWidget *parent)
 {
   m_Controls.setupUi(parent);
 
   m_SelectionServiceConnector = std::make_unique<QmitkSelectionServiceConnector>();
   m_SelectionServiceConnector->AddPostSelectionListener(this->GetSite()->GetWorkbenchWindow()->GetSelectionService());
 
   m_Controls.inputNodeSelector->SetDataStorage(GetDataStorage());
   m_Controls.inputNodeSelector->SetEmptyInfo(QString("Please select input data to be viewed."));
   m_Controls.inputNodeSelector->SetInvalidInfo(QString("<b><font color=\"red\">No input data is selected</font></b>"));
   m_Controls.inputNodeSelector->SetPopUpTitel(QString("Choose 3D+t input data that should be viewed!"));
   m_Controls.inputNodeSelector->SetSelectionIsOptional(false);
   m_Controls.inputNodeSelector->SetSelectOnlyVisibleNodes(true);
 
   auto predicate = mitk::NodePredicateFunction::New([](const mitk::DataNode *node) {
-    bool isModelFitNode = node->GetData() && node->GetData()->GetProperty(mitk::ModelFitConstants::FIT_UID_PROPERTY_NAME().c_str()).IsNotNull();
+    bool isModelFitNode =
+      node->GetData() &&
+      node->GetData()->GetProperty(mitk::ModelFitConstants::FIT_UID_PROPERTY_NAME().c_str()).IsNotNull();
     return isModelFitNode || (node && node->GetData() && node->GetData()->GetTimeSteps() > 1);
   });
 
   m_Controls.inputNodeSelector->SetNodePredicate(predicate);
 
-  connect(m_SelectionServiceConnector.get(), &QmitkSelectionServiceConnector::ServiceSelectionChanged, m_Controls.inputNodeSelector, &QmitkSingleNodeSelectionWidget::SetCurrentSelection);
-  connect(m_Controls.inputNodeSelector, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnInputChanged(const QList<mitk::DataNode::Pointer>&)));
+  connect(m_SelectionServiceConnector.get(),
+          &QmitkSelectionServiceConnector::ServiceSelectionChanged,
+          m_Controls.inputNodeSelector,
+          &QmitkSingleNodeSelectionWidget::SetCurrentSelection);
+  connect(m_Controls.inputNodeSelector,
+          SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)),
+          this,
+          SLOT(OnInputChanged(const QList<mitk::DataNode::Pointer> &)));
 
   this->m_SliceChangeListener.RenderWindowPartActivated(this->GetRenderWindowPart());
   connect(&m_SliceChangeListener, SIGNAL(SliceChanged()), this, SLOT(OnSliceChanged()));
 
-  connect(m_Controls.cmbFit, SIGNAL(currentIndexChanged(int)), this,
-          SLOT(OnFitSelectionChanged(int)));
+  connect(m_Controls.cmbFit, SIGNAL(currentIndexChanged(int)), this, SLOT(OnFitSelectionChanged(int)));
 
-  connect(m_Controls.radioScaleFixed, SIGNAL(toggled(bool)), m_Controls.sbFixMin,
-          SLOT(setEnabled(bool)));
-  connect(m_Controls.radioScaleFixed, SIGNAL(toggled(bool)), m_Controls.sbFixMax,
-          SLOT(setEnabled(bool)));
-  connect(m_Controls.radioScaleFixed, SIGNAL(toggled(bool)), m_Controls.labelFixMin,
-          SLOT(setEnabled(bool)));
-  connect(m_Controls.radioScaleFixed, SIGNAL(toggled(bool)), m_Controls.labelFixMax,
-          SLOT(setEnabled(bool)));
-  connect(m_Controls.radioScaleFixed, SIGNAL(toggled(bool)), m_Controls.btnScaleToData,
-          SLOT(setEnabled(bool)));
+  connect(m_Controls.radioScaleFixed, SIGNAL(toggled(bool)), m_Controls.sbFixMin_y, SLOT(setEnabled(bool)));
+  connect(m_Controls.radioScaleFixed, SIGNAL(toggled(bool)), m_Controls.sbFixMax_y, SLOT(setEnabled(bool)));
+  connect(m_Controls.radioScaleFixed, SIGNAL(toggled(bool)), m_Controls.labelFixMin, SLOT(setEnabled(bool)));
+  connect(m_Controls.radioScaleFixed, SIGNAL(toggled(bool)), m_Controls.labelFixMax, SLOT(setEnabled(bool)));
+  connect(m_Controls.radioScaleFixed, SIGNAL(toggled(bool)), m_Controls.btnScaleToData, SLOT(setEnabled(bool)));
 
   connect(m_Controls.radioScaleFixed, SIGNAL(toggled(bool)), this, SLOT(OnScaleFixedYChecked(bool)));
 
   connect(m_Controls.btnScaleToData, SIGNAL(clicked()), this, SLOT(OnScaleToDataYClicked()));
-  connect(m_Controls.sbFixMax, SIGNAL(valueChanged(double)), this,
-          SLOT(OnFixedScalingYChanged(double)));
-  connect(m_Controls.sbFixMin, SIGNAL(valueChanged(double)), this,
-          SLOT(OnFixedScalingYChanged(double)));
-
-  connect(m_Controls.radioScaleFixed_x, SIGNAL(toggled(bool)), m_Controls.sbFixMin_x,
-    SLOT(setEnabled(bool)));
-  connect(m_Controls.radioScaleFixed_x, SIGNAL(toggled(bool)), m_Controls.sbFixMax_x,
-    SLOT(setEnabled(bool)));
-  connect(m_Controls.radioScaleFixed_x, SIGNAL(toggled(bool)), m_Controls.labelFixMin_x,
-    SLOT(setEnabled(bool)));
-  connect(m_Controls.radioScaleFixed_x, SIGNAL(toggled(bool)), m_Controls.labelFixMax_x,
-    SLOT(setEnabled(bool)));
-  connect(m_Controls.radioScaleFixed_x, SIGNAL(toggled(bool)), m_Controls.btnScaleToData_x,
-    SLOT(setEnabled(bool)));
+  connect(m_Controls.sbFixMax_y, SIGNAL(valueChanged(double)), this, SLOT(OnFixedScalingYChanged(double)));
+  connect(m_Controls.sbFixMin_y, SIGNAL(valueChanged(double)), this, SLOT(OnFixedScalingYChanged(double)));
+
+  connect(m_Controls.radioScaleFixed_x, SIGNAL(toggled(bool)), m_Controls.sbFixMin_x, SLOT(setEnabled(bool)));
+  connect(m_Controls.radioScaleFixed_x, SIGNAL(toggled(bool)), m_Controls.sbFixMax_x, SLOT(setEnabled(bool)));
+  connect(m_Controls.radioScaleFixed_x, SIGNAL(toggled(bool)), m_Controls.labelFixMin_x, SLOT(setEnabled(bool)));
+  connect(m_Controls.radioScaleFixed_x, SIGNAL(toggled(bool)), m_Controls.labelFixMax_x, SLOT(setEnabled(bool)));
+  connect(m_Controls.radioScaleFixed_x, SIGNAL(toggled(bool)), m_Controls.btnScaleToData_x, SLOT(setEnabled(bool)));
 
   connect(m_Controls.radioScaleFixed_x, SIGNAL(toggled(bool)), this, SLOT(OnScaleFixedXChecked(bool)));
 
   connect(m_Controls.btnScaleToData_x, SIGNAL(clicked()), this, SLOT(OnScaleToDataXClicked()));
-  connect(m_Controls.sbFixMax_x, SIGNAL(valueChanged(double)), this,
-    SLOT(OnFixedScalingXChanged(double)));
-  connect(m_Controls.sbFixMin_x, SIGNAL(valueChanged(double)), this,
-    SLOT(OnFixedScalingXChanged(double)));
+  connect(m_Controls.sbFixMax_x, SIGNAL(valueChanged(double)), this, SLOT(OnFixedScalingXChanged(double)));
+  connect(m_Controls.sbFixMin_x, SIGNAL(valueChanged(double)), this, SLOT(OnFixedScalingXChanged(double)));
 
   connect(m_Controls.btnFullPlot, SIGNAL(clicked(bool)), this, SLOT(OnFullPlotClicked(bool)));
 
   this->EnsureBookmarkPointSet();
   m_Controls.inspectionPositionWidget->SetPositionBookmarkNode(m_PositionBookmarksNode.Lock());
 
-  connect(m_Controls.inspectionPositionWidget, SIGNAL(PositionBookmarksChanged()), this, SLOT(OnPositionBookmarksChanged()));
-
-  // For some reason this needs to be called to set the plot widget's minimum width to an
-  // acceptable level (since Qwt 6).
-  // Otherwise it tries to keep both axes equal in length, resulting in a minimum width of
-  // 400-500px which is way too much.
-  m_Controls.widgetPlot->GetPlot()->updateAxes();
+  connect(
+    m_Controls.inspectionPositionWidget, SIGNAL(PositionBookmarksChanged()), this, SLOT(OnPositionBookmarksChanged()));
 
   m_Controls.cmbFit->clear();
 
-  mitk::IRenderWindowPart* renderWindowPart = GetRenderWindowPart();
+  mitk::IRenderWindowPart *renderWindowPart = GetRenderWindowPart();
   RenderWindowPartActivated(renderWindowPart);
 }
 
-void ModelFitInspectorView::SetFocus()
-{
-}
+void ModelFitInspectorView::SetFocus() {}
 
-void ModelFitInspectorView::NodeRemoved(const mitk::DataNode* node)
+void ModelFitInspectorView::NodeRemoved(const mitk::DataNode *node)
 {
   if (node == this->m_currentSelectedNode)
   {
     QmitkSingleNodeSelectionWidget::NodeList emptylist;
     this->m_Controls.inputNodeSelector->SetCurrentSelection(emptylist);
   }
 }
 
 void ModelFitInspectorView::OnScaleFixedYChecked(bool checked)
 {
-  m_Controls.widgetPlot->GetPlot()->setAxisAutoScale(QwtPlot::yLeft, !checked);
-
-  if (checked)
+   if (checked)
   {
     OnScaleToDataYClicked();
   }
-
-  m_Controls.widgetPlot->GetPlot()->replot();
+  m_Controls.chartWidget->Show();
 };
 
 void ModelFitInspectorView::OnScaleFixedXChecked(bool checked)
 {
-  m_Controls.widgetPlot->GetPlot()->setAxisAutoScale(QwtPlot::xBottom, !checked);
-
   if (checked)
   {
     OnScaleToDataXClicked();
   }
 
-  m_Controls.widgetPlot->GetPlot()->replot();
+  m_Controls.chartWidget->Show();
 };
 
 void ModelFitInspectorView::OnScaleToDataYClicked()
 {
   auto minmax = this->m_PlotCurves.GetYMinMax();
 
   auto min = minmax.first - abs(minmax.first) * 0.01;
   auto max = minmax.second + abs(minmax.second) * 0.01;
 
-  m_Controls.sbFixMin->setValue(min);
-  m_Controls.sbFixMax->setValue(max);
+  m_Controls.sbFixMin_y->setValue(min);
+  m_Controls.sbFixMax_y->setValue(max);
 };
 
 void ModelFitInspectorView::OnScaleToDataXClicked()
 {
   auto minmax = this->m_PlotCurves.GetXMinMax();
 
   auto min = minmax.first - abs(minmax.first) * 0.01;
   auto max = minmax.second + abs(minmax.second) * 0.01;
 
   m_Controls.sbFixMin_x->setValue(min);
   m_Controls.sbFixMax_x->setValue(max);
 };
 
 void ModelFitInspectorView::OnFixedScalingYChanged(double /*value*/)
 {
-  m_Controls.widgetPlot->GetPlot()->setAxisScale(QwtPlot::yLeft, m_Controls.sbFixMin->value(),
-      m_Controls.sbFixMax->value());
-  m_Controls.widgetPlot->GetPlot()->replot();
+  m_Controls.chartWidget->SetMinMaxValueYView(m_Controls.sbFixMin_y->value(), m_Controls.sbFixMax_y->value());
+  m_Controls.chartWidget->Show();
 };
 
 void ModelFitInspectorView::OnFixedScalingXChanged(double /*value*/)
 {
-  m_Controls.widgetPlot->GetPlot()->setAxisScale(QwtPlot::xBottom, m_Controls.sbFixMin_x->value(),
-    m_Controls.sbFixMax_x->value());
-  m_Controls.widgetPlot->GetPlot()->replot();
+ m_Controls.chartWidget->SetMinMaxValueXView(m_Controls.sbFixMin_x->value(), m_Controls.sbFixMax_x->value());
+  m_Controls.chartWidget->Show();
 };
 
 void ModelFitInspectorView::OnFullPlotClicked(bool checked)
 {
   m_Controls.tabWidget->setVisible(!checked);
+  m_Controls.chartWidget->Show();
 };
 
 int ModelFitInspectorView::ActualizeFitSelectionWidget()
 {
   mitk::NodeUIDType selectedFitUD = "";
   bool isModelFitNode = this->m_currentSelectedNode->GetData()->GetPropertyList()->GetStringProperty(
     mitk::ModelFitConstants::FIT_UID_PROPERTY_NAME().c_str(), selectedFitUD);
 
   mitk::DataStorage::Pointer storage = this->GetDataStorage();
 
-  mitk::modelFit::NodeUIDSetType fitUIDs = mitk::modelFit::GetFitUIDsOfNode(
-    this->m_currentSelectedNode, storage);
+  mitk::modelFit::NodeUIDSetType fitUIDs = mitk::modelFit::GetFitUIDsOfNode(this->m_currentSelectedNode, storage);
 
   this->m_modelfitList.clear();
   this->m_Controls.cmbFit->clear();
 
-  for (const auto & fitUID : fitUIDs)
+  for (const auto &fitUID : fitUIDs)
   {
-    mitk::modelFit::ModelFitInfo::ConstPointer info = mitk::modelFit::CreateFitInfoFromNode(fitUID,
-      storage).GetPointer();
+    mitk::modelFit::ModelFitInfo::ConstPointer info =
+      mitk::modelFit::CreateFitInfoFromNode(fitUID, storage).GetPointer();
 
     if (info.IsNotNull())
     {
       this->m_modelfitList.insert(std::make_pair(info->uid, info));
       std::ostringstream nameStrm;
       if (info->fitName.empty())
       {
         nameStrm << info->uid;
       }
       else
       {
         nameStrm << info->fitName;
       }
       nameStrm << " (" << info->modelName << ")";
       QVariant data(info->uid.c_str());
       m_Controls.cmbFit->addItem(QString::fromStdString(nameStrm.str()), data);
     }
     else
     {
-      MITK_ERROR <<
-        "Was not able to extract model fit information from storage. Node properties in storage may be invalid. Failed fit UID:"
-        << fitUID;
+      MITK_ERROR << "Was not able to extract model fit information from storage. Node properties in storage may be "
+                    "invalid. Failed fit UID:"
+                 << fitUID;
     }
   }
 
   int cmbIndex = 0;
 
   if (m_modelfitList.empty())
   {
     cmbIndex = -1;
   };
 
   if (isModelFitNode)
   {
-    //model was selected, thus select this one in combobox
+    // model was selected, thus select this one in combobox
     QVariant data(selectedFitUD.c_str());
     cmbIndex = m_Controls.cmbFit->findData(data);
 
     if (cmbIndex == -1)
     {
-      MITK_WARN <<
-        "Model fit Inspector in invalid state. Selected fit seems to be not avaible in plugin selection. Failed fit UID:"
-        << selectedFitUD;
+      MITK_WARN << "Model fit Inspector in invalid state. Selected fit seems to be not avaible in plugin selection. "
+                   "Failed fit UID:"
+                << selectedFitUD;
     }
   };
 
   m_Controls.cmbFit->setCurrentIndex(cmbIndex);
 
   return cmbIndex;
 }
 
-void ModelFitInspectorView::OnInputChanged(const QList<mitk::DataNode::Pointer>& nodes)
+void ModelFitInspectorView::OnInputChanged(const QList<mitk::DataNode::Pointer> &nodes)
 {
   if (nodes.size() > 0)
   {
     if (nodes.front() != this->m_currentSelectedNode)
     {
-
       m_internalUpdateFlag = true;
 
       this->m_currentSelectedNode = nodes.front();
 
       mitk::NodeUIDType selectedFitUD = "";
       bool isModelFitNode = this->m_currentSelectedNode->GetData()->GetPropertyList()->GetStringProperty(
-                              mitk::ModelFitConstants::FIT_UID_PROPERTY_NAME().c_str(), selectedFitUD);
+        mitk::ModelFitConstants::FIT_UID_PROPERTY_NAME().c_str(), selectedFitUD);
 
       if (isModelFitNode)
       {
         this->m_currentSelectedNode = this->GetParentNode(this->m_currentSelectedNode);
       }
 
       auto cmbIndex = ActualizeFitSelectionWidget();
 
       m_internalUpdateFlag = false;
 
       m_selectedNodeTime.Modified();
 
       if (cmbIndex == -1)
       {
-        //only raw 4D data selected. Just update plots for current position
+        // only raw 4D data selected. Just update plots for current position
         m_currentFit = nullptr;
         m_currentFitTime.Modified();
         OnSliceChanged();
         m_Controls.plotDataWidget->SetXName(DEFAULT_X_AXIS);
       }
       else
       {
-        //refresh fit selection (and implicitly update plots)
+        // refresh fit selection (and implicitly update plots)
         OnFitSelectionChanged(cmbIndex);
       }
     }
   }
   else
   {
     if (this->m_currentSelectedNode.IsNotNull())
     {
       m_internalUpdateFlag = true;
       this->m_currentSelectedNode = nullptr;
       this->m_currentFit = nullptr;
       this->m_modelfitList.clear();
       this->m_Controls.cmbFit->clear();
       m_internalUpdateFlag = false;
 
       m_selectedNodeTime.Modified();
       OnFitSelectionChanged(0);
       RefreshPlotData();
       m_Controls.plotDataWidget->SetPlotData(&(this->m_PlotCurves));
       m_Controls.fitParametersWidget->setFits(QmitkFitParameterModel::FitVectorType());
       RenderPlot();
     }
   }
-
 }
 
-mitk::DataNode::ConstPointer
-ModelFitInspectorView::GetParentNode(mitk::DataNode::ConstPointer node)
+mitk::DataNode::ConstPointer ModelFitInspectorView::GetParentNode(mitk::DataNode::ConstPointer node)
 {
   if (node.IsNotNull())
   {
-    mitk::DataStorage::SetOfObjects::ConstPointer parentNodeList =
-      GetDataStorage()->GetSources(node);
+    mitk::DataStorage::SetOfObjects::ConstPointer parentNodeList = GetDataStorage()->GetSources(node);
 
     if (parentNodeList->size() > 0)
     {
       return parentNodeList->front().GetPointer();
     }
   }
 
   return mitk::DataNode::ConstPointer();
 }
 
-
 void ModelFitInspectorView::ValidateAndSetCurrentPosition()
 {
   mitk::Point3D currentSelectedPosition = GetRenderWindowPart()->GetSelectedPosition(nullptr);
-  unsigned int currentSelectedTimestep = m_renderWindowPart->GetTimeNavigationController()->GetTime()->
-    GetPos();
+  unsigned int currentSelectedTimestep = m_renderWindowPart->GetTimeNavigationController()->GetTime()->GetPos();
 
-  if (m_currentSelectedPosition != currentSelectedPosition
-      || m_currentSelectedTimeStep != currentSelectedTimestep
-      || m_selectedNodeTime > m_currentPositionTime)
+  if (m_currentSelectedPosition != currentSelectedPosition || m_currentSelectedTimeStep != currentSelectedTimestep ||
+      m_selectedNodeTime > m_currentPositionTime)
   {
-    //the current position has been changed or the selected node has been changed since the last position validation -> check position
+    // the current position has been changed or the selected node has been changed since the last position validation ->
+    // check position
     m_currentSelectedPosition = currentSelectedPosition;
     m_currentSelectedTimeStep = currentSelectedTimestep;
     m_currentPositionTime.Modified();
     m_validSelectedPosition = false;
 
     mitk::Image::Pointer inputImage = this->GetCurrentInputImage();
 
     if (inputImage.IsNull())
     {
       return;
     }
 
-    mitk::BaseGeometry::Pointer geometry = inputImage->GetTimeGeometry()->GetGeometryForTimeStep(
-      m_currentSelectedTimeStep);
+    mitk::BaseGeometry::Pointer geometry =
+      inputImage->GetTimeGeometry()->GetGeometryForTimeStep(m_currentSelectedTimeStep);
 
     // check for invalid time step
     if (geometry.IsNull())
     {
       geometry = inputImage->GetTimeGeometry()->GetGeometryForTimeStep(0);
     }
 
     if (geometry.IsNull())
     {
       return;
     }
 
     m_validSelectedPosition = geometry->IsInside(m_currentSelectedPosition);
-
+    if (m_validSelectedPosition)
+    {
+      //*0.001, because it's ms
+      m_currentSelectedTimePoint = inputImage->GetTimeGeometry()->TimeStepToTimePoint(m_currentSelectedTimeStep)*0.001;
+    }
   }
 }
 
-mitk::Image::Pointer  ModelFitInspectorView::GetCurrentInputImage() const
+mitk::Image::Pointer ModelFitInspectorView::GetCurrentInputImage() const
 {
   mitk::Image::Pointer result = nullptr;
 
   if (this->m_currentFit.IsNotNull())
   {
     result = m_currentFit->inputImage;
   }
   else if (this->m_currentSelectedNode.IsNotNull())
   {
-    result = dynamic_cast<mitk::Image*>(this->m_currentSelectedNode->GetData());
+    result = dynamic_cast<mitk::Image *>(this->m_currentSelectedNode->GetData());
 
     if (result.IsNotNull() && result->GetTimeSteps() <= 1)
     {
-      //if the image is not dynamic, we can't use it.
+      // if the image is not dynamic, we can't use it.
       result = nullptr;
     }
   }
 
   return result;
 };
 
 const mitk::ModelBase::TimeGridType ModelFitInspectorView::GetCurrentTimeGrid() const
 {
   if (m_currentModelProviderService && m_currentFit.IsNotNull())
   {
     return m_currentModelProviderService->GetVariableGrid(m_currentFit);
   }
   else
-  { //fall back if there is no model provider we assume to use the normal time grid.
+  { // fall back if there is no model provider we assume to use the normal time grid.
     return ExtractTimeGrid(GetCurrentInputImage());
   }
 };
 
 void ModelFitInspectorView::OnSliceChanged()
 {
   ValidateAndSetCurrentPosition();
 
-  m_Controls.widgetPlot->setEnabled(m_validSelectedPosition);
-
   if (m_currentSelectedNode.IsNotNull())
   {
     m_Controls.inspectionPositionWidget->SetCurrentPosition(m_currentSelectedPosition);
 
     if (RefreshPlotData())
     {
       RenderPlot();
       m_Controls.plotDataWidget->SetPlotData(&m_PlotCurves);
       RenderFitInfo();
     }
   }
 }
 
 void ModelFitInspectorView::OnPositionBookmarksChanged()
 {
-    if (RefreshPlotData())
-    {
-      RenderPlot();
-      m_Controls.plotDataWidget->SetPlotData(&m_PlotCurves);
-      RenderFitInfo();
-    }
+  if (RefreshPlotData())
+  {
+    RenderPlot();
+    m_Controls.plotDataWidget->SetPlotData(&m_PlotCurves);
+    RenderFitInfo();
+  }
 }
 
 void ModelFitInspectorView::OnFitSelectionChanged(int index)
 {
   if (!m_internalUpdateFlag)
   {
     MITK_DEBUG << "selected fit index: " << index;
 
     std::string uid = "";
 
-
     if (m_Controls.cmbFit->count() > index)
     {
       uid = m_Controls.cmbFit->itemData(index).toString().toStdString();
     }
 
     mitk::modelFit::ModelFitInfo::ConstPointer newFit = nullptr;
 
     ModelFitInfoListType::iterator finding = m_modelfitList.find(uid);
 
     if (finding != m_modelfitList.end())
     {
       newFit = finding->second;
     }
 
     if (m_currentFit != newFit)
     {
       m_currentModelParameterizer = nullptr;
       m_currentModelProviderService = nullptr;
 
       if (newFit.IsNotNull())
       {
         m_currentModelParameterizer = mitk::ModelGenerator::GenerateModelParameterizer(*newFit);
         m_currentModelProviderService = mitk::ModelGenerator::GetProviderService(newFit->functionClassID);
       }
 
       m_currentFit = newFit;
 
       m_currentFitTime.Modified();
 
       auto name = m_currentFit->xAxisName;
       if (!m_currentFit->xAxisUnit.empty())
       {
         name += " [" + m_currentFit->xAxisUnit + "]";
       }
       m_Controls.plotDataWidget->SetXName(name);
 
       OnSliceChanged();
     }
   }
 }
 
-mitk::PlotDataCurveCollection::Pointer ModelFitInspectorView::RefreshPlotDataCurveCollection(const mitk::Point3D& position,
-  const mitk::Image* input, const mitk::modelFit::ModelFitInfo* fitInfo,
-  const mitk::ModelBase::TimeGridType& timeGrid, mitk::ModelParameterizerBase* parameterizer)
+mitk::PlotDataCurveCollection::Pointer ModelFitInspectorView::RefreshPlotDataCurveCollection(
+  const mitk::Point3D &position,
+  const mitk::Image *input,
+  const mitk::modelFit::ModelFitInfo *fitInfo,
+  const mitk::ModelBase::TimeGridType &timeGrid,
+  mitk::ModelParameterizerBase *parameterizer)
 {
   mitk::PlotDataCurveCollection::Pointer result = mitk::PlotDataCurveCollection::New();
 
-  //sample curve
+  // sample curve
   if (input)
   {
     result->InsertElement(mitk::MODEL_FIT_PLOT_SAMPLE_NAME(), GenerateImageSamplePlotData(position, input, timeGrid));
   }
 
-  //model signal curve
+  // model signal curve
   if (fitInfo)
   {
     // Interpolate time grid (x values) so the curve looks smooth
-    const mitk::ModelBase::TimeGridType interpolatedTimeGrid = mitk::GenerateSupersampledTimeGrid(timeGrid, INTERPOLATION_STEPS);
+    const mitk::ModelBase::TimeGridType interpolatedTimeGrid =
+      mitk::GenerateSupersampledTimeGrid(timeGrid, INTERPOLATION_STEPS);
     auto hires_curve = mitk::GenerateModelSignalPlotData(position, fitInfo, interpolatedTimeGrid, parameterizer);
     result->InsertElement(mitk::MODEL_FIT_PLOT_INTERPOLATED_SIGNAL_NAME(), hires_curve);
     auto curve = mitk::GenerateModelSignalPlotData(position, fitInfo, timeGrid, parameterizer);
     result->InsertElement(mitk::MODEL_FIT_PLOT_SIGNAL_NAME(), curve);
   }
 
   return result;
 };
 
+const std::map<double, double> ModelFitInspectorView::ConvertToMap(const std::vector<std::pair<double, double>> vec)
+{
+  std::map<double, double> returnMap;
+  for (auto part : vec)
+  {
+    returnMap.insert(part);
+  }
+
+  return returnMap;
+}
+
 bool ModelFitInspectorView::RefreshPlotData()
 {
   bool changed = false;
 
   if (m_currentSelectedNode.IsNull())
   {
     this->m_PlotCurves = mitk::ModelFitPlotData();
 
     changed = m_selectedNodeTime > m_lastRefreshTime;
     m_lastRefreshTime.Modified();
   }
   else
   {
     assert(GetRenderWindowPart() != NULL);
 
-    const mitk::Image* input = GetCurrentInputImage();
+    const mitk::Image *input = GetCurrentInputImage();
     const mitk::ModelBase::TimeGridType timeGrid = GetCurrentTimeGrid();
 
     if (m_currentFitTime > m_lastRefreshTime || m_currentPositionTime > m_lastRefreshTime)
     {
       if (m_validSelectedPosition)
       {
-        m_PlotCurves.currentPositionPlots = RefreshPlotDataCurveCollection(m_currentSelectedPosition,input,m_currentFit, timeGrid, m_currentModelParameterizer);
+        m_PlotCurves.currentPositionPlots = RefreshPlotDataCurveCollection(
+          m_currentSelectedPosition, input, m_currentFit, timeGrid, m_currentModelParameterizer);
       }
       else
       {
         m_PlotCurves.currentPositionPlots = mitk::PlotDataCurveCollection::New();
       }
 
       changed = true;
     }
 
     auto bookmarks = m_PositionBookmarks.Lock();
     if (bookmarks.IsNotNull())
     {
       if (m_currentFitTime > m_lastRefreshTime || bookmarks->GetMTime() > m_lastRefreshTime)
       {
         m_PlotCurves.positionalPlots.clear();
 
         auto endIter = bookmarks->End();
         for (auto iter = bookmarks->Begin(); iter != endIter; iter++)
         {
-          auto collection = RefreshPlotDataCurveCollection(iter.Value(), input, m_currentFit, timeGrid, m_currentModelParameterizer);
+          auto collection =
+            RefreshPlotDataCurveCollection(iter.Value(), input, m_currentFit, timeGrid, m_currentModelParameterizer);
           m_PlotCurves.positionalPlots.emplace(iter.Index(), std::make_pair(iter.Value(), collection));
         }
 
         changed = true;
       }
     }
     else
     {
       m_PlotCurves.positionalPlots.clear();
     }
 
     // input data curve
     if (m_currentFitTime > m_lastRefreshTime)
     {
       m_PlotCurves.staticPlots->clear();
 
       if (m_currentFit.IsNotNull())
       {
-        m_PlotCurves.staticPlots = GenerateAdditionalModelFitPlotData(m_currentSelectedPosition, m_currentFit, timeGrid);
+        m_PlotCurves.staticPlots =
+          GenerateAdditionalModelFitPlotData(m_currentSelectedPosition, m_currentFit, timeGrid);
       }
 
       changed = true;
     }
 
     m_lastRefreshTime.Modified();
   }
 
   return changed;
 }
 
 void ModelFitInspectorView::RenderFitInfo()
 {
-    assert(m_renderWindowPart != nullptr);
+  assert(m_renderWindowPart != nullptr);
 
-    // configure fit information
+  // configure fit information
 
-    if (m_currentFit.IsNull())
-    {
-        m_Controls.lFitType->setText("");
-        m_Controls.lFitUID->setText("");
-        m_Controls.lModelName->setText("");
-        m_Controls.lModelType->setText("");
-    }
-    else
-    {
-        m_Controls.lFitType->setText(QString::fromStdString(m_currentFit->fitType));
-        m_Controls.lFitUID->setText(QString::fromStdString(m_currentFit->uid));
-        m_Controls.lModelName->setText(QString::fromStdString(m_currentFit->modelName));
-        m_Controls.lModelType->setText(QString::fromStdString(m_currentFit->modelType));
-    }
+  if (m_currentFit.IsNull())
+  {
+    m_Controls.lFitType->setText("");
+    m_Controls.lFitUID->setText("");
+    m_Controls.lModelName->setText("");
+    m_Controls.lModelType->setText("");
+  }
+  else
+  {
+    m_Controls.lFitType->setText(QString::fromStdString(m_currentFit->fitType));
+    m_Controls.lFitUID->setText(QString::fromStdString(m_currentFit->uid));
+    m_Controls.lModelName->setText(QString::fromStdString(m_currentFit->modelName));
+    m_Controls.lModelType->setText(QString::fromStdString(m_currentFit->modelType));
+  }
 
-    // print results
-    std::stringstream infoOutput;
+  // print results
+  std::stringstream infoOutput;
 
   m_Controls.fitParametersWidget->setVisible(false);
-    m_Controls.groupSettings->setVisible(false);
+  m_Controls.groupSettings->setVisible(false);
 
-    if (m_currentFit.IsNull())
-    {
-        infoOutput << "No fit selected. Only raw image data is plotted.";
-    }
-    else if (!m_validSelectedPosition)
-    {
-        infoOutput <<
-               "Current position is outside of the input image of the selected fit.\nInspector is deactivated.";
-    }
-    else
-    {
-        m_Controls.fitParametersWidget->setVisible(true);
-    m_Controls.fitParametersWidget->setFits({ m_currentFit });
+  if (m_currentFit.IsNull())
+  {
+    infoOutput << "No fit selected. Only raw image data is plotted.";
+  }
+  else if (!m_validSelectedPosition)
+  {
+    infoOutput << "Current position is outside of the input image of the selected fit.\nInspector is deactivated.";
+  }
+  else
+  {
+    m_Controls.fitParametersWidget->setVisible(true);
+    m_Controls.fitParametersWidget->setFits({m_currentFit});
 
     m_Controls.fitParametersWidget->setPositionBookmarks(m_PositionBookmarks.Lock());
     m_Controls.fitParametersWidget->setCurrentPosition(m_currentSelectedPosition);
-    }
+  }
 
-    // configure data table
-    m_Controls.tableInputData->clearContents();
+  // configure data table
+  m_Controls.tableInputData->clearContents();
 
-    if (m_currentFit.IsNull())
-    {
-        infoOutput << "No fit selected. Only raw image data is plotted.";
-    }
-    else
-    {
-        m_Controls.groupSettings->setVisible(true);
-        m_Controls.tableInputData->setRowCount(m_PlotCurves.staticPlots->size());
+  if (m_currentFit.IsNull())
+  {
+    infoOutput << "No fit selected. Only raw image data is plotted.";
+  }
+  else
+  {
+    m_Controls.groupSettings->setVisible(true);
+    m_Controls.tableInputData->setRowCount(m_PlotCurves.staticPlots->size());
 
-        unsigned int rowIndex = 0;
+    unsigned int rowIndex = 0;
 
     for (mitk::PlotDataCurveCollection::const_iterator pos = m_PlotCurves.staticPlots->begin();
-            pos != m_PlotCurves.staticPlots->end(); ++pos, ++rowIndex)
-        {
-            QColor dataColor;
-
-            if (pos->first == "ROI")
-            {
-                dataColor = QColor(0, 190, 0);
-            }
-            else
-            {
-                //Use HSV schema of QColor to calculate a different color depending on the
-                //number of already existing free iso lines.
-                dataColor.setHsv(((rowIndex + 1) * 85) % 360, 255, 255);
-            }
-
-            QTableWidgetItem* newItem = new QTableWidgetItem(QString::fromStdString(pos->first));
-            m_Controls.tableInputData->setItem(rowIndex, 0, newItem);
-            newItem = new QTableWidgetItem();
-            newItem->setBackgroundColor(dataColor);
-            m_Controls.tableInputData->setItem(rowIndex, 1, newItem);
-        }
+         pos != m_PlotCurves.staticPlots->end();
+         ++pos, ++rowIndex)
+    {
+      QColor dataColor;
+
+      if (pos->first == "ROI")
+      {
+        dataColor = QColor(0, 190, 0);
+      }
+      else
+      {
+        // Use HSV schema of QColor to calculate a different color depending on the
+        // number of already existing free iso lines.
+        dataColor.setHsv(((rowIndex + 1) * 85) % 360, 255, 255);
+      }
+
+      QTableWidgetItem *newItem = new QTableWidgetItem(QString::fromStdString(pos->first));
+      m_Controls.tableInputData->setItem(rowIndex, 0, newItem);
+      newItem = new QTableWidgetItem();
+      newItem->setBackgroundColor(dataColor);
+      m_Controls.tableInputData->setItem(rowIndex, 1, newItem);
     }
+  }
 
-    m_Controls.lInfo->setText(QString::fromStdString(infoOutput.str()));
+  m_Controls.lInfo->setText(QString::fromStdString(infoOutput.str()));
 }
 
-void ModelFitInspectorView::RenderPlotCurve(const mitk::PlotDataCurveCollection* curveCollection, const QColor& sampleColor, const QColor& signalColor, const std::string& posString)
+void ModelFitInspectorView::RenderPlotCurve(const mitk::PlotDataCurveCollection *curveCollection,
+                                            const QColor &sampleColor,
+                                            const QColor &signalColor,
+                                            const std::string &posString)
 {
   auto sampleCurve = mitk::ModelFitPlotData::GetSamplePlot(curveCollection);
   if (sampleCurve)
   {
     std::string name = mitk::MODEL_FIT_PLOT_SAMPLE_NAME() + posString;
-    unsigned int curveId = m_Controls.widgetPlot->InsertCurve(name.c_str());
-    m_Controls.widgetPlot->SetCurveData(curveId, sampleCurve->GetValues());
-    m_Controls.widgetPlot->SetCurvePen(curveId, QPen(Qt::NoPen));
 
-    // QwtSymbol needs to passed as a real pointer from MITK v2013.09.0 on
-    // (QwtPlotCurve deletes it on destruction and assignment).
-    QwtSymbol* dataSymbol = new QwtSymbol(QwtSymbol::Diamond, sampleColor, sampleColor, QSize(8, 8));
-    m_Controls.widgetPlot->SetCurveSymbol(curveId, dataSymbol);
+    auto sampleCurveMap = ConvertToMap(sampleCurve->GetValues());
+
+    m_Controls.chartWidget->AddData2D(sampleCurveMap, name, QmitkChartWidget::ChartType::scatter);
+    m_Controls.chartWidget->SetColor(name, sampleColor.name().toStdString());
+
+    for (const auto &kv : sampleCurveMap)
+    {
+      if (kv.first == m_currentSelectedTimePoint)
+      {
+        std::string currentTimestepName = "current Timestep";
+        std::map<double, double> currentTimeStepValue;
+        currentTimeStepValue.emplace(kv.first, kv.second);
+        m_Controls.chartWidget->AddData2D(
+          currentTimeStepValue, currentTimestepName, QmitkChartWidget::ChartType::scatter);
+        m_Controls.chartWidget->SetColor(currentTimestepName, "blue");
+      }
+    }
 
-    // Again, there is no way to set a curve's legend attributes via QmitkPlotWidget so this
-    // gets unnecessarily complicated.
-    QwtPlotCurve* measurementCurve = dynamic_cast<QwtPlotCurve*>(m_Controls.widgetPlot->
-      GetPlot()->itemList(QwtPlotItem::Rtti_PlotCurve).back());
-    measurementCurve->setLegendAttribute(QwtPlotCurve::LegendShowSymbol);
-    measurementCurve->setLegendIconSize(QSize(8, 8));
   }
 
-  //draw model curve
+  // draw model curve
   auto signalCurve = mitk::ModelFitPlotData::GetInterpolatedSignalPlot(curveCollection);
   if (signalCurve)
   {
     std::string name = mitk::MODEL_FIT_PLOT_SIGNAL_NAME() + posString;
     QPen pen;
     pen.setColor(signalColor);
     pen.setWidth(2);
-    unsigned int curveId = m_Controls.widgetPlot->InsertCurve(name.c_str());
-    m_Controls.widgetPlot->SetCurveData(curveId, signalCurve->GetValues());
-    m_Controls.widgetPlot->SetCurvePen(curveId, pen);
 
-    // Manually set the legend attribute to use the symbol as the legend icon and alter its
-    // size. Otherwise it would revert to default which is drawing a square which is the color
-    // of the curve's pen, so in this case none which defaults to black.
-    // Unfortunately, QmitkPlotWidget offers no way to set the legend attribute and icon size so
-    // this looks a bit hacky.
-    QwtPlotCurve* fitCurve = dynamic_cast<QwtPlotCurve*>(m_Controls.widgetPlot->GetPlot()->
-      itemList(QwtPlotItem::Rtti_PlotCurve).back());
-    fitCurve->setLegendAttribute(QwtPlotCurve::LegendShowLine);
-  }
+    auto signalCurveMap = ConvertToMap(signalCurve->GetValues());
 
+    m_Controls.chartWidget->AddData2D(signalCurveMap, name, QmitkChartWidget::ChartType::line);
+    m_Controls.chartWidget->SetColor(name, signalColor.name().toStdString());
+  }
 }
 
 void ModelFitInspectorView::RenderPlot()
 {
-  m_Controls.widgetPlot->Clear();
+  m_Controls.chartWidget->Clear();
 
   std::string xAxis = DEFAULT_X_AXIS;
   std::string yAxis = "Intensity";
   std::string plotTitle = "Raw data plot: no data";
 
   if (m_currentSelectedNode.IsNotNull())
   {
     plotTitle = "Raw data plot: " + m_currentSelectedNode->GetName();
   }
 
   if (m_currentFit.IsNotNull())
   {
     plotTitle = m_currentFit->modelName.c_str();
     xAxis = m_currentFit->xAxisName;
 
     if (!m_currentFit->xAxisUnit.empty())
     {
       xAxis += " [" + m_currentFit->xAxisUnit + "]";
     }
 
     yAxis = m_currentFit->yAxisName;
 
     if (!m_currentFit->yAxisUnit.empty())
     {
       yAxis += " [" + m_currentFit->yAxisUnit + "]";
     }
   }
 
-  m_Controls.widgetPlot->SetAxisTitle(QwtPlot::xBottom, xAxis.c_str());
-  m_Controls.widgetPlot->SetAxisTitle(QwtPlot::yLeft, yAxis.c_str());
-  m_Controls.widgetPlot->SetPlotTitle(plotTitle.c_str());
+  m_Controls.chartWidget->SetYAxisLabel(yAxis);
+  m_Controls.chartWidget->SetXAxisLabel(xAxis);
+  m_Controls.chartWidget->SetTitle(plotTitle);
 
   // Draw static curves
   unsigned int colorIndex = 0;
 
   for (mitk::PlotDataCurveCollection::const_iterator pos = m_PlotCurves.staticPlots->begin();
-       pos != m_PlotCurves.staticPlots->end(); ++pos)
+       pos != m_PlotCurves.staticPlots->end();
+       ++pos)
   {
     QColor dataColor;
 
-    unsigned int curveId = m_Controls.widgetPlot->InsertCurve(pos->first.c_str());
-    m_Controls.widgetPlot->SetCurveData(curveId, pos->second->GetValues());
+    auto staticCurveMap = ConvertToMap(pos->second->GetValues());
+
+    std::string name = pos->first.c_str();
+    m_Controls.chartWidget->AddData2D(staticCurveMap, name, QmitkChartWidget::ChartType::line);
 
     if (pos->first == "ROI")
     {
       dataColor = QColor(0, 190, 0);
       QPen pen;
       pen.setColor(dataColor);
       pen.setStyle(Qt::SolidLine);
-      m_Controls.widgetPlot->SetCurvePen(curveId, pen);
+      m_Controls.chartWidget->SetColor(name, dataColor.name().toStdString());
     }
     else
     {
-      //Use HSV schema of QColor to calculate a different color depending on the
-      //number of already existing curves.
+      // Use HSV schema of QColor to calculate a different color depending on the
+      // number of already existing curves.
       dataColor.setHsv((++colorIndex * 85) % 360, 255, 150);
-      m_Controls.widgetPlot->SetCurvePen(curveId, QPen(Qt::NoPen));
     }
 
-    // QwtSymbol needs to passed as a real pointer from MITK v2013.09.0 on
-    // (QwtPlotCurve deletes it on destruction and assignment).
-    QwtSymbol* dataSymbol = new QwtSymbol(QwtSymbol::Triangle, dataColor, dataColor,
-                                          QSize(8, 8));
-    m_Controls.widgetPlot->SetCurveSymbol(curveId, dataSymbol);
 
-    // Again, there is no way to set a curve's legend attributes via QmitkPlotWidget so this
-    // gets unnecessarily complicated.
-    QwtPlotCurve* measurementCurve = dynamic_cast<QwtPlotCurve*>(m_Controls.widgetPlot->
-                                     GetPlot()->itemList(QwtPlotItem::Rtti_PlotCurve).back());
-    measurementCurve->setLegendAttribute(QwtPlotCurve::LegendShowSymbol);
-    measurementCurve->setLegendIconSize(QSize(8, 8));
+    m_Controls.chartWidget->SetColor(name, dataColor.name().toStdString());
   }
 
   // Draw positional curves
-  for (const auto& posIter : this->m_PlotCurves.positionalPlots)
+  for (const auto &posIter : this->m_PlotCurves.positionalPlots)
   {
     QColor dataColor;
     dataColor.setHsv((++colorIndex * 85) % 360, 255, 150);
 
-    this->RenderPlotCurve(posIter.second.second, dataColor, dataColor, " @ "+mitk::ModelFitPlotData::GetPositionalCollectionName(posIter));
+    this->RenderPlotCurve(posIter.second.second,
+                          dataColor,
+                          dataColor,
+                          " @ " + mitk::ModelFitPlotData::GetPositionalCollectionName(posIter));
   }
 
   // Draw current pos curve
   this->RenderPlotCurve(m_PlotCurves.currentPositionPlots, QColor(Qt::red), QColor(Qt::black), "");
 
-  QwtLegend* legend = new QwtLegend();
-  legend->setFrameShape(QFrame::Box);
-  legend->setFrameShadow(QFrame::Sunken);
-  legend->setLineWidth(1);
-  m_Controls.widgetPlot->SetLegend(legend, QwtPlot::BottomLegend);
+  m_Controls.chartWidget->SetLegendPosition(QmitkChartWidget::LegendPosition::bottomRight);
 
-  m_Controls.widgetPlot->Replot();
+  m_Controls.chartWidget->Show();
 }
 
 void ModelFitInspectorView::EnsureBookmarkPointSet()
 {
   if (m_PositionBookmarks.IsExpired() || m_PositionBookmarksNode.IsExpired())
   {
-    const char* nodeName = "org.mitk.gui.qt.fit.inspector.positions";
+    const char *nodeName = "org.mitk.gui.qt.fit.inspector.positions";
     mitk::DataNode::Pointer node = this->GetDataStorage()->GetNamedNode(nodeName);
 
     if (!node)
     {
       node = mitk::DataNode::New();
       node->SetName(nodeName);
       node->SetBoolProperty("helper object", true);
       this->GetDataStorage()->Add(node);
     }
     m_PositionBookmarksNode = node;
 
-    mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet*>(node->GetData());
+    mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet *>(node->GetData());
     if (pointSet.IsNull())
     {
       pointSet = mitk::PointSet::New();
       node->SetData(pointSet);
     }
 
     m_PositionBookmarks = pointSet;
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.fit.inspector/src/internal/ModelFitInspectorView.h b/Plugins/org.mitk.gui.qt.fit.inspector/src/internal/ModelFitInspectorView.h
index 8be8155ee7..4e98c20e86 100644
--- a/Plugins/org.mitk.gui.qt.fit.inspector/src/internal/ModelFitInspectorView.h
+++ b/Plugins/org.mitk.gui.qt.fit.inspector/src/internal/ModelFitInspectorView.h
@@ -1,205 +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 ModelFitInspectorView_h
 #define ModelFitInspectorView_h
 
 // Blueberry
-//#include <berryISelectionListener.h>
 #include <berryIPartListener.h>
 
 // mitk
 #include <QmitkAbstractView.h>
 #include <mitkIRenderWindowPartListener.h>
 #include "QmitkSliceNavigationListener.h"
 
 #include "mitkModelFitStaticParameterMap.h"
 #include "mitkModelParameterizerBase.h"
 #include "mitkModelFitInfo.h"
 #include "mitkIModelFitProvider.h"
 #include "mitkModelFitPlotDataHelper.h"
 #include "QmitkSelectionServiceConnector.h"
 #include "QmitkFitParameterModel.h"
 
 // Qt
 #include "ui_ModelFitInspectorViewControls.h"
 
 
 /**
  *	@brief	View class defining the UI part of the ModelFitInspector plug-in.
  */
 class ModelFitInspectorView :
   public QmitkAbstractView,
   public mitk::IRenderWindowPartListener
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   ModelFitInspectorView();
   ~ModelFitInspectorView();
 
   static const std::string VIEW_ID;
 
 protected slots:
 
   void OnSliceChanged();
 
   /**
    *	@brief			Triggered when the selection of the "Modelfit" combo box changes.
    *					Sets the selected fit as the current one.
    *	@param index	The index (in the combo box) of the selected item.
    */
   void OnFitSelectionChanged(int index);
 
   void OnInputChanged(const QList<mitk::DataNode::Pointer>& nodes);
 
   void OnPositionBookmarksChanged();
 
   /** Triggered when the selection of "fixed" y axis scaling changes*/
   void OnScaleFixedYChecked(bool checked);
   void OnScaleToDataYClicked();
   void OnFixedScalingYChanged(double value);
 
 
   /** Triggered when the selection of "fixed" x axis scaling changes*/
   void OnScaleFixedXChecked(bool checked);
   void OnScaleToDataXClicked();
   void OnFixedScalingXChanged(double value);
 
   void OnFullPlotClicked(bool checked);
 
 protected:
 
   virtual void CreateQtPartControl(QWidget* parent) override;
 
   virtual void SetFocus() override;
 
   virtual void NodeRemoved(const mitk::DataNode* node) override;
 
   /** Helper that actualizes the fit selection widget and returns the index of the currently selected
    * fit.*/
   int ActualizeFitSelectionWidget();
 
   virtual void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart);
   virtual void RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart);
 
-  /**
-   *	@brief			Calculates the curve data using the current fit's model and parameterizer.
-   *	@param position	Indicating the point in the input image for which the model curve should be calculated.
-   *	@return			A vector of points for the curve data.
-   */
-  QmitkPlotWidget::XYDataVector CalcCurveFromModel(const mitk::Point3D& position);
-
-  /**
-   *	@brief			Calculates the curve data using the current fit's function string.
-   *	@param timeGrid	The time grid containing the (interpolated) x values for the curve data.
-   *	@return			A vector of points for the curve data.
-   */
-  QmitkPlotWidget::XYDataVector CalcCurveFromFunction(const mitk::Point3D& position,
-      const mitk::ModelBase::TimeGridType&
-      timeGrid);
-
   /**
    *	@brief		Returns the parent node of the given node if it exists.
    *	@param node	The node whose parent node should be returned.
    *	@return		The parent node of the given node or NULL if it doesn't exist.
    */
   mitk::DataNode::ConstPointer GetParentNode(mitk::DataNode::ConstPointer node);
 
   /** Sets m_currentSelectedPosition to the current selection and validates if this position is valid
    * for the input image of the currently selected fit. If it is valid, m_validSelectedPosition is set to true.
    * If the fit, his input image or geometry is not specified, it will also handled as invalid.*/
   void ValidateAndSetCurrentPosition();
 
   /** Returns the current input image. If a current fit is set it will be its input image.
    * Otherwise it will be the image stored in the currently selected node. If the node is not set, contains no image
    * or the image is not 4D, NULL will be returned.*/
   mitk::Image::Pointer GetCurrentInputImage() const;
 
   /** Returns the variable/time grid of the GetCurrentInputImage(). If a model fit is selected its provider will be used
    to get the correct grid, otherwise just a simple time grid will be extracted.*/
   const mitk::ModelBase::TimeGridType GetCurrentTimeGrid() const;
 
   Ui::ModelFitInspectorViewControls m_Controls;
   mitk::IRenderWindowPart* m_renderWindowPart;
 
   /**	@brief	Is a visualization currently running? */
   bool m_internalUpdateFlag;
   /**	@brief	List of modelfits currently in the data manager */
   typedef std::map<const mitk::modelFit::ModelFitInfo::UIDType, mitk::modelFit::ModelFitInfo::ConstPointer>
   ModelFitInfoListType;
   ModelFitInfoListType m_modelfitList;
   /** @brief	The currently selected modelfit */
   mitk::modelFit::ModelFitInfo::ConstPointer m_currentFit;
 
   /**	@brief	Pointer to the instance of the model parameterizer for the current fit */
   mitk::ModelParameterizerBase::Pointer m_currentModelParameterizer;
   mitk::IModelFitProvider* m_currentModelProviderService;
 
   /** @brief currently valid selected position in the inspector*/
   mitk::Point3D m_currentSelectedPosition;
   /** @brief indicates if the currently selected position is valid for the currently selected fit.
    * This it is within the input image */
   bool m_validSelectedPosition;
 
   /** @brief currently selected time step of the selected node for the visualization logic*/
   unsigned int m_currentSelectedTimeStep;
+  mitk::TimePointType m_currentSelectedTimePoint;
 
   /** @brief currently selected node for the visualization logic*/
   mitk::DataNode::ConstPointer m_currentSelectedNode;
 
   mitk::WeakPointer<mitk::DataNode> m_PositionBookmarksNode;
   mitk::WeakPointer<mitk::PointSet> m_PositionBookmarks;
 
   /** @brief	Number of interpolation steps between two x values */
   static const unsigned int INTERPOLATION_STEPS;
 
   /*************************************/
   /* Members for visualizing the model */
 
   itk::TimeStamp m_selectedNodeTime;
   itk::TimeStamp m_currentFitTime;
   itk::TimeStamp m_currentPositionTime;
   itk::TimeStamp m_lastRefreshTime;
 
   mitk::ModelFitPlotData m_PlotCurves;
 
   std::unique_ptr<QmitkSelectionServiceConnector> m_SelectionServiceConnector;
   QmitkFitParameterModel* m_FitParameterModel;
 
   QmitkSliceNavigationListener m_SliceChangeListener;
 
   /** Check and updates the plot data if needed.
   * @return indicates if something was refreshed (true)*/
   bool RefreshPlotData();
 
   void RenderPlot();
   void RenderPlotCurve(const mitk::PlotDataCurveCollection* curveCollection, const QColor& sampleColor, const QColor& signalColor, const std::string& posString);
 
   void RenderFitInfo();
 
   void EnsureBookmarkPointSet();
 
   static mitk::PlotDataCurveCollection::Pointer RefreshPlotDataCurveCollection(const mitk::Point3D& position,
     const mitk::Image* input, const mitk::modelFit::ModelFitInfo* fitInfo,
     const mitk::ModelBase::TimeGridType& timeGrid, mitk::ModelParameterizerBase* parameterizer);
+
+  const std::map<double, double> ConvertToMap(const std::vector<std::pair<double, double> > vec);
 };
 
 #endif // ModelFitInspectorView_h
diff --git a/Plugins/org.mitk.gui.qt.fit.inspector/src/internal/ModelFitInspectorViewControls.ui b/Plugins/org.mitk.gui.qt.fit.inspector/src/internal/ModelFitInspectorViewControls.ui
index 28f81f5577..ff478a4e35 100644
--- a/Plugins/org.mitk.gui.qt.fit.inspector/src/internal/ModelFitInspectorViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.fit.inspector/src/internal/ModelFitInspectorViewControls.ui
@@ -1,762 +1,759 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>ModelFitInspectorViewControls</class>
  <widget class="QWidget" name="ModelFitInspectorViewControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>721</width>
-    <height>865</height>
+    <height>1070</height>
    </rect>
   </property>
   <property name="minimumSize">
    <size>
     <width>0</width>
     <height>0</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>QmitkTemplate</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout" stretch="0,4,0,0,0">
    <property name="spacing">
     <number>5</number>
    </property>
    <property name="leftMargin">
     <number>5</number>
    </property>
    <property name="topMargin">
     <number>5</number>
    </property>
    <property name="rightMargin">
     <number>5</number>
    </property>
    <property name="bottomMargin">
     <number>5</number>
    </property>
    <item>
     <layout class="QFormLayout" name="formLayout_2">
      <property name="horizontalSpacing">
       <number>6</number>
      </property>
      <property name="verticalSpacing">
       <number>6</number>
      </property>
      <item row="2" column="0">
       <widget class="QLabel" name="lblFit">
        <property name="text">
         <string>Modelfit:</string>
        </property>
       </widget>
      </item>
      <item row="2" column="1">
       <widget class="QComboBox" name="cmbFit"/>
      </item>
      <item row="1" column="1">
       <widget class="QmitkSingleNodeSelectionWidget" name="inputNodeSelector" native="true"/>
      </item>
      <item row="1" column="0">
       <widget class="QLabel" name="lblInput">
        <property name="text">
         <string>Input</string>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
-    <widget class="QmitkPlotWidget" name="widgetPlot" native="true">
-     <property name="enabled">
-      <bool>true</bool>
-     </property>
+    <widget class="QmitkChartWidget" name="chartWidget" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="MinimumExpanding" vsizetype="MinimumExpanding">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="minimumSize">
       <size>
        <width>0</width>
        <height>400</height>
       </size>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QLabel" name="lInfo">
      <property name="text">
       <string/>
      </property>
     </widget>
    </item>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout_3">
      <item>
       <spacer name="horizontalSpacer_5">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>40</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
      <item>
       <widget class="QPushButton" name="btnFullPlot">
        <property name="text">
         <string>Full screen plot</string>
        </property>
        <property name="checkable">
         <bool>true</bool>
        </property>
        <property name="flat">
         <bool>false</bool>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <widget class="QTabWidget" name="tabWidget">
      <property name="enabled">
       <bool>true</bool>
      </property>
      <property name="currentIndex">
-      <number>0</number>
+      <number>3</number>
      </property>
      <widget class="QWidget" name="tabInfo">
       <attribute name="title">
        <string>Fit info</string>
       </attribute>
       <layout class="QFormLayout" name="formLayout">
        <item row="0" column="0">
         <widget class="QLabel" name="label_3">
          <property name="maximumSize">
           <size>
            <width>50</width>
            <height>16777215</height>
           </size>
          </property>
          <property name="text">
           <string>Fit type</string>
          </property>
         </widget>
        </item>
        <item row="0" column="1">
         <widget class="QLabel" name="lFitType">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="text">
           <string/>
          </property>
         </widget>
        </item>
        <item row="1" column="0">
         <widget class="QLabel" name="label_4">
          <property name="text">
           <string>Fit uid:</string>
          </property>
         </widget>
        </item>
        <item row="1" column="1">
         <widget class="QLabel" name="lFitUID">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="text">
           <string/>
          </property>
         </widget>
        </item>
        <item row="2" column="0">
         <widget class="QLabel" name="label">
          <property name="text">
           <string>Model name:</string>
          </property>
         </widget>
        </item>
        <item row="3" column="0">
         <widget class="QLabel" name="label_2">
          <property name="text">
           <string>Model type:</string>
          </property>
         </widget>
        </item>
        <item row="2" column="1">
         <widget class="QLabel" name="lModelName">
          <property name="text">
           <string/>
          </property>
         </widget>
        </item>
        <item row="3" column="1">
         <widget class="QLabel" name="lModelType">
          <property name="text">
           <string/>
          </property>
         </widget>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tabResults">
       <attribute name="title">
        <string>Fit parameter</string>
       </attribute>
       <attribute name="toolTip">
        <string>Parameter used for the fit.</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_4">
        <property name="spacing">
         <number>3</number>
        </property>
        <property name="leftMargin">
         <number>5</number>
        </property>
        <property name="topMargin">
         <number>5</number>
        </property>
        <property name="rightMargin">
         <number>5</number>
        </property>
        <property name="bottomMargin">
         <number>5</number>
        </property>
        <item>
         <widget class="QmitkFitParameterWidget" name="fitParametersWidget" native="true"/>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tabBookmarks">
       <attribute name="title">
        <string>Inspection positions</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_3">
        <property name="spacing">
         <number>3</number>
        </property>
        <property name="leftMargin">
         <number>5</number>
        </property>
        <property name="topMargin">
         <number>5</number>
        </property>
        <property name="rightMargin">
         <number>5</number>
        </property>
        <property name="bottomMargin">
         <number>5</number>
        </property>
        <item>
         <widget class="QmitkInspectionPositionWidget" name="inspectionPositionWidget" native="true"/>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tabSettings">
       <attribute name="title">
        <string>View settings</string>
       </attribute>
       <attribute name="toolTip">
        <string>Settings for the visualization of fittings</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_5">
        <property name="spacing">
         <number>3</number>
        </property>
        <property name="leftMargin">
         <number>5</number>
        </property>
        <property name="topMargin">
         <number>5</number>
        </property>
        <property name="rightMargin">
         <number>5</number>
        </property>
        <property name="bottomMargin">
         <number>5</number>
        </property>
        <item>
         <widget class="QGroupBox" name="groupBox_x">
          <property name="title">
           <string>X-axis scaling:</string>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_8">
           <item>
            <widget class="QRadioButton" name="radioScaleAuto_x">
             <property name="enabled">
              <bool>true</bool>
             </property>
             <property name="text">
              <string>automatic</string>
             </property>
             <property name="checked">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QRadioButton" name="radioScaleFixed_x">
             <property name="enabled">
              <bool>true</bool>
             </property>
             <property name="text">
              <string>fixed</string>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item>
            <layout class="QHBoxLayout" name="horizontalLayout_2">
             <item>
              <widget class="QLabel" name="labelFixMin_x">
               <property name="enabled">
                <bool>false</bool>
               </property>
               <property name="maximumSize">
                <size>
                 <width>40</width>
                 <height>16777215</height>
                </size>
               </property>
               <property name="text">
                <string>min:</string>
               </property>
              </widget>
             </item>
             <item>
              <widget class="QDoubleSpinBox" name="sbFixMin_x">
               <property name="enabled">
                <bool>false</bool>
               </property>
               <property name="minimum">
                <double>-9999.000000000000000</double>
               </property>
               <property name="maximum">
                <double>9999.000000000000000</double>
               </property>
              </widget>
             </item>
             <item>
              <spacer name="horizontalSpacer_3">
               <property name="orientation">
                <enum>Qt::Horizontal</enum>
               </property>
               <property name="sizeHint" stdset="0">
                <size>
                 <width>40</width>
                 <height>20</height>
                </size>
               </property>
              </spacer>
             </item>
             <item>
              <widget class="QLabel" name="labelFixMax_x">
               <property name="enabled">
                <bool>false</bool>
               </property>
               <property name="maximumSize">
                <size>
                 <width>40</width>
                 <height>16777215</height>
                </size>
               </property>
               <property name="text">
                <string>max:</string>
               </property>
              </widget>
             </item>
             <item>
              <widget class="QDoubleSpinBox" name="sbFixMax_x">
               <property name="enabled">
                <bool>false</bool>
               </property>
               <property name="minimum">
                <double>-9999.000000000000000</double>
               </property>
               <property name="maximum">
                <double>9999.000000000000000</double>
               </property>
              </widget>
             </item>
             <item>
              <spacer name="horizontalSpacer_4">
               <property name="orientation">
                <enum>Qt::Horizontal</enum>
               </property>
               <property name="sizeHint" stdset="0">
                <size>
                 <width>40</width>
                 <height>20</height>
                </size>
               </property>
              </spacer>
             </item>
             <item>
              <widget class="QPushButton" name="btnScaleToData_x">
               <property name="enabled">
                <bool>false</bool>
               </property>
               <property name="toolTip">
                <string>Sets the min and max to the current range of data +-10%</string>
               </property>
               <property name="text">
                <string>Scale to data</string>
               </property>
              </widget>
             </item>
            </layout>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <widget class="QGroupBox" name="groupBox_y">
          <property name="title">
           <string>Y-axis scaling:</string>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_6">
           <item>
            <widget class="QRadioButton" name="radioScaleAuto">
             <property name="enabled">
              <bool>true</bool>
             </property>
             <property name="text">
              <string>automatic</string>
             </property>
             <property name="checked">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QRadioButton" name="radioScaleFixed">
             <property name="enabled">
              <bool>true</bool>
             </property>
             <property name="text">
              <string>fixed</string>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item>
            <layout class="QHBoxLayout" name="horizontalLayout">
             <item>
              <widget class="QLabel" name="labelFixMin">
               <property name="enabled">
                <bool>false</bool>
               </property>
               <property name="maximumSize">
                <size>
                 <width>40</width>
                 <height>16777215</height>
                </size>
               </property>
               <property name="text">
                <string>min:</string>
               </property>
              </widget>
             </item>
             <item>
-             <widget class="QDoubleSpinBox" name="sbFixMin">
+             <widget class="QDoubleSpinBox" name="sbFixMin_y">
               <property name="enabled">
                <bool>false</bool>
               </property>
               <property name="minimum">
                <double>-9999.000000000000000</double>
               </property>
               <property name="maximum">
                <double>9999.000000000000000</double>
               </property>
              </widget>
             </item>
             <item>
              <spacer name="horizontalSpacer">
               <property name="orientation">
                <enum>Qt::Horizontal</enum>
               </property>
               <property name="sizeHint" stdset="0">
                <size>
                 <width>40</width>
                 <height>20</height>
                </size>
               </property>
              </spacer>
             </item>
             <item>
              <widget class="QLabel" name="labelFixMax">
               <property name="enabled">
                <bool>false</bool>
               </property>
               <property name="maximumSize">
                <size>
                 <width>40</width>
                 <height>16777215</height>
                </size>
               </property>
               <property name="text">
                <string>max:</string>
               </property>
              </widget>
             </item>
             <item>
-             <widget class="QDoubleSpinBox" name="sbFixMax">
+             <widget class="QDoubleSpinBox" name="sbFixMax_y">
               <property name="enabled">
                <bool>false</bool>
               </property>
               <property name="minimum">
                <double>-9999.000000000000000</double>
               </property>
               <property name="maximum">
                <double>9999.000000000000000</double>
               </property>
              </widget>
             </item>
             <item>
              <spacer name="horizontalSpacer_2">
               <property name="orientation">
                <enum>Qt::Horizontal</enum>
               </property>
               <property name="sizeHint" stdset="0">
                <size>
                 <width>40</width>
                 <height>20</height>
                </size>
               </property>
              </spacer>
             </item>
             <item>
              <widget class="QPushButton" name="btnScaleToData">
               <property name="enabled">
                <bool>false</bool>
               </property>
               <property name="toolTip">
                <string>Sets the min and max to the current range of data +-10%</string>
               </property>
               <property name="text">
                <string>Scale to data</string>
               </property>
              </widget>
             </item>
            </layout>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <widget class="QGroupBox" name="groupSettings">
          <property name="title">
           <string>Additional input data visibility:</string>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_2">
           <property name="spacing">
            <number>5</number>
           </property>
           <property name="leftMargin">
            <number>5</number>
           </property>
           <property name="topMargin">
            <number>5</number>
           </property>
           <property name="rightMargin">
            <number>5</number>
           </property>
           <property name="bottomMargin">
            <number>5</number>
           </property>
           <item>
            <widget class="QTableWidget" name="tableInputData">
             <property name="font">
              <font>
               <pointsize>8</pointsize>
              </font>
             </property>
             <attribute name="horizontalHeaderDefaultSectionSize">
              <number>150</number>
             </attribute>
             <attribute name="horizontalHeaderHighlightSections">
              <bool>false</bool>
             </attribute>
             <attribute name="horizontalHeaderStretchLastSection">
              <bool>true</bool>
             </attribute>
             <attribute name="verticalHeaderVisible">
              <bool>false</bool>
             </attribute>
             <attribute name="verticalHeaderDefaultSectionSize">
              <number>20</number>
             </attribute>
             <attribute name="verticalHeaderMinimumSectionSize">
              <number>20</number>
             </attribute>
             <column>
              <property name="text">
               <string>Name</string>
              </property>
              <property name="toolTip">
               <string extracomment="Name of the data"/>
              </property>
             </column>
             <column>
              <property name="text">
               <string>Color</string>
              </property>
              <property name="toolTip">
               <string extracomment="Visibility of the data in diagram"/>
              </property>
             </column>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tabData">
       <attribute name="title">
        <string>Plot data export</string>
       </attribute>
       <attribute name="toolTip">
        <string>Display and export option for the current data samples, model signals and additinal fitting informations of the plot.</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_7">
        <property name="spacing">
         <number>3</number>
        </property>
        <property name="leftMargin">
         <number>5</number>
        </property>
        <property name="topMargin">
         <number>5</number>
        </property>
        <property name="rightMargin">
         <number>5</number>
        </property>
        <property name="bottomMargin">
         <number>5</number>
        </property>
        <item>
         <widget class="QmitkFitPlotDataWidget" name="plotDataWidget" native="true">
          <property name="minimumSize">
           <size>
            <width>80</width>
            <height>0</height>
           </size>
          </property>
         </widget>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
   </layout>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>
   <customwidget>
-   <class>QmitkSingleNodeSelectionWidget</class>
+   <class>QmitkChartWidget</class>
    <extends>QWidget</extends>
-   <header location="global">QmitkSingleNodeSelectionWidget.h</header>
-   <container>1</container>
+   <header location="global">QmitkChartWidget.h</header>
   </customwidget>
   <customwidget>
-   <class>QmitkPlotWidget</class>
+   <class>QmitkSingleNodeSelectionWidget</class>
    <extends>QWidget</extends>
-   <header>QmitkPlotWidget.h</header>
+   <header location="global">QmitkSingleNodeSelectionWidget.h</header>
+   <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkFitParameterWidget</class>
    <extends>QWidget</extends>
    <header>QmitkFitParameterWidget.h</header>
   </customwidget>
   <customwidget>
    <class>QmitkInspectionPositionWidget</class>
    <extends>QWidget</extends>
    <header>QmitkInspectionPositionWidget.h</header>
   </customwidget>
   <customwidget>
    <class>QmitkFitPlotDataWidget</class>
    <extends>QWidget</extends>
    <header>QmitkFitPlotDataWidget.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections>
   <connection>
    <sender>radioScaleFixed</sender>
    <signal>clicked(bool)</signal>
-   <receiver>sbFixMin</receiver>
+   <receiver>sbFixMin_y</receiver>
    <slot>setEnabled(bool)</slot>
    <hints>
     <hint type="sourcelabel">
      <x>66</x>
      <y>528</y>
     </hint>
     <hint type="destinationlabel">
      <x>86</x>
      <y>559</y>
     </hint>
    </hints>
   </connection>
   <connection>
    <sender>radioScaleFixed</sender>
    <signal>clicked(bool)</signal>
-   <receiver>sbFixMax</receiver>
+   <receiver>sbFixMax_y</receiver>
    <slot>setEnabled(bool)</slot>
    <hints>
     <hint type="sourcelabel">
      <x>208</x>
      <y>535</y>
     </hint>
     <hint type="destinationlabel">
      <x>195</x>
      <y>559</y>
     </hint>
    </hints>
   </connection>
   <connection>
    <sender>radioScaleFixed</sender>
    <signal>clicked(bool)</signal>
    <receiver>btnScaleToData</receiver>
    <slot>setEnabled(bool)</slot>
    <hints>
     <hint type="sourcelabel">
      <x>299</x>
      <y>530</y>
     </hint>
     <hint type="destinationlabel">
      <x>292</x>
      <y>557</y>
     </hint>
    </hints>
   </connection>
  </connections>
 </ui>