diff --git a/Modules/Chart/include/QmitkChartData.h b/Modules/Chart/include/QmitkChartData.h
index 9f8040269c..2a9d5e07a3 100644
--- a/Modules/Chart/include/QmitkChartData.h
+++ b/Modules/Chart/include/QmitkChartData.h
@@ -1,86 +1,80 @@
 /*===================================================================
 
 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 QmitkC3Data_h
 #define QmitkC3Data_h
 
 #include <QmitkChartWidget.h>
 #include <QVariant>
 
 /** \brief This class holds the relevant properties for the chart generation with C3 such as labels and diagram type.
 * It is derived from QObject, because we need Q_PROPERTIES to send Data via QWebChannel to JavaScript.
 * \sa The actual data for the chart generation is in QmitkC3xyData!
 */
 class QmitkChartData : public QObject
 {
   Q_OBJECT
 
-  Q_PROPERTY(QList<QVariant> m_dataLabels READ GetDataLabels WRITE SetDataLabels NOTIFY SignalDataLabelsChanged);
   Q_PROPERTY(QVariant m_xAxisLabel READ GetXAxisLabel WRITE SetXAxisLabel NOTIFY SignalXAxisLabelChanged);
   Q_PROPERTY(QVariant m_yAxisLabel READ GetYAxisLabel WRITE SetYAxisLabel NOTIFY SignalYAxisLabelChanged);
   Q_PROPERTY(QVariant m_diagramTitle READ GetDiagramTitle WRITE SetDiagramTitle NOTIFY SignalDiagramTitleChanged);
   Q_PROPERTY(QVariant m_LegendPosition READ GetLegendPosition WRITE SetLegendPosition NOTIFY SignalLegendPositionChanged);
   Q_PROPERTY(QVariant m_ShowSubchart READ GetShowSubchart WRITE SetShowSubchart NOTIFY SignalShowSubchartChanged);
   Q_PROPERTY(QVariant m_UsePercentageInPieChart READ GetUsePercentageInPieChart WRITE SetUsePercentageInPieChart NOTIFY SignalUsePercentageInPieChartChanged);
 
 public:
   QmitkChartData();
 
   void SetAppearance(bool showSubChart = true, bool usePercentageInPieChart = false);
 
-  Q_INVOKABLE QList<QVariant> GetDataLabels() const { return m_dataLabels; };
-  Q_INVOKABLE void SetDataLabels(const QList<QVariant>& dataLabels) { m_dataLabels = dataLabels; emit SignalDataLabelsChanged(dataLabels); };
-
   Q_INVOKABLE QVariant GetXAxisLabel() const { return m_xAxisLabel; };
   Q_INVOKABLE void SetXAxisLabel(const QVariant& label) { m_xAxisLabel = label; emit SignalXAxisLabelChanged(label); };
 
   Q_INVOKABLE QVariant GetYAxisLabel() const { return m_yAxisLabel; };
   Q_INVOKABLE void SetYAxisLabel(const QVariant& label) { m_yAxisLabel = label; emit SignalYAxisLabelChanged(label); };
 
   Q_INVOKABLE QVariant GetDiagramTitle() const { return m_diagramTitle; };
   Q_INVOKABLE void SetDiagramTitle(const QVariant& title) { m_diagramTitle = title; emit SignalDiagramTitleChanged(title); };
 
   Q_INVOKABLE QVariant GetLegendPosition() const { return m_LegendPosition; };
   Q_INVOKABLE void SetLegendPosition(const QVariant& legendPosition) { m_LegendPosition = legendPosition; emit SignalLegendPositionChanged(legendPosition); };
 
   Q_INVOKABLE QVariant GetShowSubchart() const { return m_ShowSubchart; };
   Q_INVOKABLE void SetShowSubchart(const QVariant& showSubchart) { m_ShowSubchart = showSubchart; emit SignalShowSubchartChanged(showSubchart); };
 
   Q_INVOKABLE QVariant GetUsePercentageInPieChart() const { return m_UsePercentageInPieChart; };
   Q_INVOKABLE void SetUsePercentageInPieChart(const QVariant& usePercentageInPieChart) { m_UsePercentageInPieChart = usePercentageInPieChart; emit SignalUsePercentageInPieChartChanged(usePercentageInPieChart); };
 
 signals:
-  void SignalDataLabelsChanged(const QList<QVariant> dataLabels);
   void SignalYAxisLabelChanged(const QVariant label);
   void SignalXAxisLabelChanged(const QVariant label);
   void SignalLegendPositionChanged(const QVariant legendPosition);
   void SignalDiagramTitleChanged(const QVariant title);
   void SignalShowSubchartChanged(const QVariant showSubchart);
   void SignalUsePercentageInPieChartChanged(const QVariant usePercentageInPieChart);
 
 private:
-  QList<QVariant> m_dataLabels;
   QVariant m_xAxisLabel;
   QVariant m_yAxisLabel;
   QVariant m_diagramTitle;
 
   QVariant m_LegendPosition;
   QVariant m_ShowSubchart;
   QVariant m_UsePercentageInPieChart;
   QVariant m_numberDatasets;
 };
 
 #endif  //QmitkC3Data_h
\ No newline at end of file
diff --git a/Modules/Chart/resource/Chart.js b/Modules/Chart/resource/Chart.js
index ad6516c867..19d10eeeb2 100644
--- a/Modules/Chart/resource/Chart.js
+++ b/Modules/Chart/resource/Chart.js
@@ -1,239 +1,234 @@
 //Based on C3.js (http://c3js.org). See Website for examples!
 
 document.body.style.backgroundColor = 'rgb(240, 240, 240)';
 
 var minHeight = 255;
 
 var chart;
 GenerateChart('bar', false, false)
 
 var chartData;
 var xValues=[];
 var yValues=[];
 var xs = {};
 var dataColors = {};
 var chartTypes = {};
 var lineStyle = {};
 
 //Is executed when js is loaded first.
 //Extracts relevant information from chartData in variables
 window.onload = function() 
 {
   new QWebChannel(qt.webChannelTransport, function(channel) {
     chartData = channel.objects.chartData;
 
 	var count = 0;
 	for(var propertyName in channel.objects) {
 		if (propertyName != 'chartData'){
 			var xDataTemp = channel.objects[propertyName].m_XData
 			var yDataTemp = channel.objects[propertyName].m_YData
 			var dataLabelsTemp;
 			//add label to x array
 			xDataTemp.unshift('x'+count.toString())
-			if (count < chartData.m_dataLabels.length){
-				dataLabelsTemp = chartData.m_dataLabels[count]
-			}
-			else {
-				dataLabelsTemp = "data" + count.toString()
-			}
+			dataLabelsTemp = channel.objects[propertyName].m_Label
 
 			xs[dataLabelsTemp] = 'x'+count.toString()
 			
 			xDataTemp.push(null); //append null value, to make sure the last tick on x-axis is displayed correctly
 			yDataTemp.unshift(dataLabelsTemp)
 			yDataTemp.push(null); //append null value, to make sure the last tick on y-axis is displayed correctly
 			xValues[count] = xDataTemp
 			yValues[count] = yDataTemp
 			dataColors[dataLabelsTemp] = channel.objects[propertyName].m_Color
 			chartTypes[dataLabelsTemp] = channel.objects[propertyName].m_ChartType
 
 			if (channel.objects[propertyName].m_LineStyleName=="solid"){
 				lineStyle[dataLabelsTemp]= ''
 			}
 			else {
 				lineStyle[dataLabelsTemp]= [{'style':'dashed'}]
 			}
 
 			count++;
 		}
 	}
     setupChart(chartData)
 
   });
 }
 
 //This is necessary to resize the chart, after the size of the parent changed
 window.onresize = function () {
   var size = window.innerHeight-(window.innerHeight/100*10); //subtract 5% of height to hide vertical scrool bar
   
   if (size < minHeight)
   {
     size = minHeight;
   }
 
   chart.resize({
     height: size,
   });
 }
 
 function ReloadChart(showSubchart)
 { 
     chartData.m_ShowSubchart = showSubchart;
     
     setupChart(chartData);
 }
 
 function setupChart(chartData)
 {
   window.onresize();
 
   GenerateChart(chartData.m_DiagramTypeName, chartData.m_ShowSubchart, chartData.m_UsePercentageInPieChart, 
   chartData.m_xAxisLabel, chartData.m_yAxisLabel, chartData.m_diagramTitle, chartData.m_LegendPosition)
     
   chart.unload(); //unload data before loading new data
   
   //for multiple xy line chart, see http://c3js.org/samples/simple_xy_multiple.html
   var columns = [];
   for (var i in xValues){
 	columns.push(xValues[i])
   }  
   for (var i in yValues){
 	columns.push(yValues[i])
   }
 
   chart.load({
 	  xs: xs,
 		columns: columns
   });
 }
 
 //Transformation between different chart types
 //takes the name of the chart type as a parameter
 //called by QmitkC3jsWidget
 function transformView(TransformTo) {
   chart.transform(TransformTo);
 };
 
 function changeTheme(color) {
   if (color == 'dark') {
     link = document.getElementsByTagName("link")[0];
     link.href = "Chart_dark.css";
   }
   else
   {
     link = document.getElementsByTagName("link")[0];
     link.href = "Chart.css";
   }
 };
 
 //Here, the chart magic takes place. C3js is called
 //chartType: either bar, line or pie
 //showSubchart: see http://c3js.org/samples/options_subchart.html
 //usePercentageInPieChart: percentage labels (only for pie chart)
 function GenerateChart(chartType, showSubchart, usePercentageInPieChart, xAxisLabel, yAxisLabel, title, legendPosition)
 {
 	//adaption for bar ratio indepenend of amount of data points
 	//otherwise, bars could be covered.
 	var barRatio;
 	try {
 		barRatio = 0.8*Math.exp(-0.015*xValues[0].length);
 	}
 	catch (err){
 		barRatio=0.42
 	}
 	var formatCharacter;
 	if (usePercentageInPieChart==true){
 		formatCharacter = '%'
 	}
 	else{
 		formatCharacter = 's'
 	}
   chart = c3.generate({
 	title:{
 		text: title,
 		position: 'top-center'
 	},
     data: {
         xs: {}, //use first "column" as x axis values
         columns: [],  //initialize empty. Data will be loaded in function setupChart(chartData)
         types: chartTypes,
         selection: {
           enabled: false,
           multiple: false,
         },
 		colors: dataColors,
 		regions: lineStyle,
     },
     legend: {
         position: legendPosition,
 		show: true
     },
     grid: {
       y: {
         lines: [{value:0}] //Draws a horizontal line at y=0
       }
     },
     bar: {
         width: {
             ratio: barRatio
         }
     },
 	pie:{
 		label: {
 		   format: function (value, ratio, id) {
 				if (usePercentageInPieChart==true){
 					return d3.format('%') (ratio);
 				}
 				else{
 					return value;
 				}
 			}
 		}
 	},
     zoom: {
         enabled: true,
     },
     subchart: {
         show: showSubchart  //Shows a subchart that shows the region the primary chart is zoomed in to by overlay.
     }, 
     axis: {
         x: {
           tick: {
             multiline: false,
             fit: false, //to make more x labels appear on zoom
             centered: true,
 			format: d3.format(".1f"),
           },
 		  label: {
 			text: xAxisLabel,
 			position: 'outer-center'
 		  }
         },
         y: {
           tick: {
             format: d3.format(formatCharacter)
           },
 		  label: {
 			text: yAxisLabel,
 			position: 'outer-middle'
 		  }
         }
     },
 	tooltip: {
 		format: {
 			title: function (x) { return xAxisLabel +  ': ' +  d3.format(".2f")(x)}
 		},
 	},
     //Style data points in linegraph
     point: {
         r: 0.2,
         focus: 
         {
           expand: {
             r: 4
           }
         }
     },
 
   });
 }
diff --git a/Modules/Chart/src/QmitkChartWidget.cpp b/Modules/Chart/src/QmitkChartWidget.cpp
index 529c837e29..1d142f293f 100644
--- a/Modules/Chart/src/QmitkChartWidget.cpp
+++ b/Modules/Chart/src/QmitkChartWidget.cpp
@@ -1,453 +1,445 @@
 /*===================================================================
 
 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 <QmitkChartWidget.h>
 #include <QGridLayout>
 #include <QWebChannel>
 #include <QWebEngineView>
 
 #include <QmitkChartData.h>
 #include <QmitkChartxyData.h>
 #include "mitkExceptionMacro.h"
 
 class QmitkChartWidget::Impl final
 {
 public:
   explicit Impl(QWidget* parent);
   ~Impl();
 
   Impl(const Impl&) = delete;
   Impl& operator=(const Impl&) = delete;
 
   void AddData1D(const std::vector<double>& data1D, const std::string& label, QmitkChartWidget::ChartType diagramType);
 
   void AddData2D(const std::map<double, double>& data2D, const std::string& label, QmitkChartWidget::ChartType diagramType);
 
   void RemoveData(const std::string& label);
 
   void ClearData();
 
-  void SetDataLabels(const std::vector<std::string>& labels);
-  std::vector<std::string> GetDataLabels() const;
-
   void SetColor(const std::string& label, const std::string& colorName);
   void SetLineStyle(const std::string& label, LineStyle style);
 
   void SetXAxisLabel(const std::string& label);
   std::string GetXAxisLabel() const;
 
   void SetYAxisLabel(const std::string& label);
   std::string GetYAxisLabel() const;
 
   void SetDiagramTitle(const std::string &title);
   std::string GetDiagramTitle() const;
 
   void SetLegendPosition(LegendPosition position);
   LegendPosition GetLegendPosition() const;
   std::string GetLegendPositionAsString() const;
 
   void SetChartType(const std::string& label, QmitkChartWidget::ChartType diagramType);
   std::string ConvertChartTypeToString(QmitkChartWidget::ChartType diagramType) const;
 
   void ClearJavaScriptChart();
   void InitializeJavaScriptChart();
   void CallJavaScriptFuntion(const QString& command);
 
   QmitkChartData* GetC3Data() const;
   std::vector<QmitkChartxyData*>* GetC3xyData() const;
 
 private:
-  void AddLabelIfNotAlreadyDefined(QList<QVariant>& labelList, const std::string& label) const;
+  std::string GetUniqueLabelName(const QList<QVariant>& labelList, const std::string& label) const;
   QmitkChartxyData* GetElementByLabel(const std::vector<QmitkChartxyData*>* c3xyData, const std::string& label) const;
+  QList<QVariant> GetDataLabels(const std::vector<QmitkChartxyData*>* c3xyData) const;
 
   QWebChannel* m_WebChannel;
   QWebEngineView* m_WebEngineView;
 
   QmitkChartData * m_C3Data;
   std::vector<QmitkChartxyData*> * m_C3xyData;
   std::map<QmitkChartWidget::ChartType, std::string> m_DiagramTypeToName;
   std::map<QmitkChartWidget::LegendPosition, std::string> m_LegendPositionToName;
   std::map<QmitkChartWidget::LineStyle, std::string> m_LineStyleToName;
 };
 
 QmitkChartWidget::Impl::Impl(QWidget* parent)
   : m_WebChannel(new QWebChannel(parent)),
   m_WebEngineView(new QWebEngineView(parent))
 {
   //disable context menu for QWebEngineView
   m_WebEngineView->setContextMenuPolicy(Qt::NoContextMenu);
 
   //Set the webengineview to an initial empty page. The actual chart will be loaded once the data is calculated.
   m_WebEngineView->setUrl(QUrl(QStringLiteral("qrc:///C3js/empty.html")));
   m_WebEngineView->page()->setWebChannel(m_WebChannel);
 
   connect(m_WebEngineView, SIGNAL(loadFinished(bool)), parent, SLOT(OnLoadFinished(bool)));
 
   auto layout = new QGridLayout(parent);
   layout->setMargin(0);
   layout->addWidget(m_WebEngineView);
 
   parent->setLayout(layout);
 
   m_DiagramTypeToName.emplace(ChartType::bar, "bar");
   m_DiagramTypeToName.emplace(ChartType::line, "line");
   m_DiagramTypeToName.emplace(ChartType::spline, "spline");
   m_DiagramTypeToName.emplace(ChartType::pie, "pie");
   m_DiagramTypeToName.emplace(ChartType::area, "area");
   m_DiagramTypeToName.emplace(ChartType::area_spline  , "area-spline");
 
   m_LegendPositionToName.emplace(LegendPosition::bottom, "bottom");
   m_LegendPositionToName.emplace(LegendPosition::right, "right");
   m_LegendPositionToName.emplace(LegendPosition::inset, "inset");
 
   m_LineStyleToName.emplace(LineStyle::solid, "solid");
   m_LineStyleToName.emplace(LineStyle::dashed, "dashed");
 
   m_C3Data = new QmitkChartData();
   m_C3xyData = new std::vector<QmitkChartxyData*>();
 }
 
 QmitkChartWidget::Impl::~Impl()
 {
   delete m_C3Data;
   delete m_C3xyData;
 }
 
 
-void QmitkChartWidget::Impl::AddLabelIfNotAlreadyDefined(QList<QVariant>& labelList, const std::string& label) const
+std::string QmitkChartWidget::Impl::GetUniqueLabelName(const QList<QVariant>& labelList, const std::string& label) const
 {
   QString currentLabel = QString::fromStdString(label);
   int counter = 0;
   while (labelList.contains(currentLabel))
   {
     currentLabel = QString::fromStdString(label + std::to_string(counter));
     counter++;
   }
-  labelList.append(currentLabel);
+  return currentLabel.toStdString();
 }
 
 void QmitkChartWidget::Impl::AddData1D(const std::vector<double>& data1D, const std::string& label, QmitkChartWidget::ChartType type) {
   QList<QVariant> data1DConverted;
   for (const auto& aValue : data1D) {
     data1DConverted.append(aValue);
   }
   const std::string diagramTypeName(m_DiagramTypeToName.at(type));
-  GetC3xyData()->push_back(new QmitkChartxyData(data1DConverted, QVariant(QString::fromStdString(label)), QVariant(QString::fromStdString(diagramTypeName))));
-  auto definedLabels = GetC3Data()->GetDataLabels();
-  AddLabelIfNotAlreadyDefined(definedLabels, label);
-  GetC3Data()->SetDataLabels(definedLabels);
+  auto definedLabels = GetDataLabels(GetC3xyData());
+  auto uniqueLabel = GetUniqueLabelName(definedLabels, label);
+
+  GetC3xyData()->push_back(new QmitkChartxyData(data1DConverted, QVariant(QString::fromStdString(uniqueLabel)), QVariant(QString::fromStdString(diagramTypeName))));
 }
 
 void QmitkChartWidget::Impl::RemoveData(const std::string& label) {
   std::vector<QmitkChartxyData*>::const_iterator iter_temp;
   for (std::vector<QmitkChartxyData*>::const_iterator iter = GetC3xyData()->begin(); iter != GetC3xyData()->end(); ++iter)
   {
     const auto &temp = *iter;
     if (temp->GetLabel().toString().toStdString() == label)
     {
       iter_temp = iter;
     }
   }
   GetC3xyData()->erase(iter_temp);
 }
 
 void QmitkChartWidget::Impl::AddData2D(const std::map<double, double>& data2D, const std::string& label, QmitkChartWidget::ChartType type) {
   QMap<QVariant, QVariant> data2DConverted;
   for (const auto& aValue : data2D) {
     data2DConverted.insert(aValue.first, aValue.second);
   }
   const std::string diagramTypeName(m_DiagramTypeToName.at(type));
-  GetC3xyData()->push_back(new QmitkChartxyData(data2DConverted, QVariant(QString::fromStdString(label)), QVariant(QString::fromStdString(diagramTypeName))));
-  auto definedLabels = GetC3Data()->GetDataLabels();
-  AddLabelIfNotAlreadyDefined(definedLabels, label);
-  GetC3Data()->SetDataLabels(definedLabels);
-}
 
-std::vector<std::string> QmitkChartWidget::Impl::GetDataLabels() const {
-  auto dataLabels = GetC3Data()->GetDataLabels();
-  std::vector<std::string> dataLabelsAsStringVector;
-  for (const auto& label : dataLabels) {
-    dataLabelsAsStringVector.push_back(label.toString().toStdString());
-  }
-  return dataLabelsAsStringVector;
+  auto definedLabels = GetDataLabels(GetC3xyData());
+  auto uniqueLabel = GetUniqueLabelName(definedLabels, label);
+
+  GetC3xyData()->push_back(new QmitkChartxyData(data2DConverted, QVariant(QString::fromStdString(uniqueLabel)), QVariant(QString::fromStdString(diagramTypeName))));
 }
 
 void QmitkChartWidget::Impl::SetColor(const std::string& label, const std::string& colorName)
 {
   auto element = GetElementByLabel(GetC3xyData(), label);
   if (element) {
     element->SetColor(QVariant(QString::fromStdString(colorName)));
   }
 }
 
 void QmitkChartWidget::Impl::SetLineStyle(const std::string& label, LineStyle style) {
   auto element = GetElementByLabel(GetC3xyData(), label);
   //only has effect with chart type line
   if (element && element->GetChartType()==QVariant(QString::fromStdString(ConvertChartTypeToString(ChartType::line)))) {
     const std::string lineStyleName(m_LineStyleToName.at(style));
     element->SetLineStyle(QVariant(QString::fromStdString(lineStyleName)));
   }
 }
 
 QmitkChartxyData* QmitkChartWidget::Impl::GetElementByLabel(const std::vector<QmitkChartxyData*>* c3xyData, const std::string& label) const
 {
   for (auto element = c3xyData->begin(); element != c3xyData->end(); ++element) {
     if ((*element)->GetLabel().toString().toStdString() == label) {
       return *element;
     }
   }
   MITK_WARN << "label " << label << " not found in QmitkChartWidget";
   return nullptr;
 }
 
+QList<QVariant> QmitkChartWidget::Impl::GetDataLabels(const std::vector<QmitkChartxyData*>* c3xyData) const {
+  QList<QVariant> dataLabels;
+  for (auto element = c3xyData->begin(); element != c3xyData->end(); ++element) {
+    dataLabels.push_back((*element)->GetLabel());
+  }
+  return dataLabels;
+}
+
 void QmitkChartWidget::Impl::SetXAxisLabel(const std::string& label) { 
   GetC3Data()->SetXAxisLabel(QString::fromStdString(label)); 
 }
 
 std::string QmitkChartWidget::Impl::GetXAxisLabel() const { 
   return GetC3Data()->GetXAxisLabel().toString().toStdString(); 
 }
 
 void QmitkChartWidget::Impl::SetYAxisLabel(const std::string& label) {
   GetC3Data()->SetYAxisLabel(QString::fromStdString(label)); 
 }
 
 std::string QmitkChartWidget::Impl::GetYAxisLabel() const { 
   return GetC3Data()->GetYAxisLabel().toString().toStdString(); 
 }
 
 void QmitkChartWidget::Impl::SetDiagramTitle(const std::string& title) {
   GetC3Data()->SetDiagramTitle(QString::fromStdString(title));
 }
 
 std::string QmitkChartWidget::Impl::GetDiagramTitle() const {
   return GetC3Data()->GetDiagramTitle().toString().toStdString();
 }
 
 void QmitkChartWidget::Impl::SetLegendPosition(QmitkChartWidget::LegendPosition legendPosition) {
   const std::string legendPositionName(m_LegendPositionToName.at(legendPosition));
   GetC3Data()->SetLegendPosition(QString::fromStdString(legendPositionName));
 }
 
 QmitkChartWidget::LegendPosition QmitkChartWidget::Impl::GetLegendPosition() const {
   for (const auto& aLegendPosition : m_LegendPositionToName) {
     if (aLegendPosition.second == GetLegendPositionAsString()) {
       return aLegendPosition.first;
     }
   }
   mitkThrow() << "can't find legend position!";
 }
 
 std::string QmitkChartWidget::Impl::GetLegendPositionAsString() const {
   return GetC3Data()->GetLegendPosition().toString().toStdString();
 }
 
 
 void QmitkChartWidget::Impl::SetChartType(const std::string& label, QmitkChartWidget::ChartType chartType) {
   auto element = GetElementByLabel(GetC3xyData(), label);
   if (element) {
     const std::string chartTypeName(m_DiagramTypeToName.at(chartType));
     element->SetChartType(QVariant(QString::fromStdString(chartTypeName)));
   }
 }
 
 std::string QmitkChartWidget::Impl::ConvertChartTypeToString(QmitkChartWidget::ChartType diagramType) const {
   return m_DiagramTypeToName.at(diagramType);
 }
 
 QmitkChartData* QmitkChartWidget::Impl::GetC3Data() const {
   return m_C3Data; 
 }
 
 std::vector<QmitkChartxyData*>* QmitkChartWidget::Impl::GetC3xyData() const {
   return m_C3xyData; 
 }
 
 void QmitkChartWidget::Impl::ClearData() {
   for (auto& xyData : *m_C3xyData) {
     m_WebChannel->deregisterObject(xyData);
   }
   GetC3xyData()->clear(); 
 }
 
 QmitkChartWidget::QmitkChartWidget(QWidget* parent)
   : QWidget(parent),
   m_Impl(new Impl(this))
 {
 }
 
 void QmitkChartWidget::Impl::CallJavaScriptFuntion(const QString& command)
 {
   m_WebEngineView->page()->runJavaScript(command);
 }
 
 void QmitkChartWidget::Impl::ClearJavaScriptChart()
 {
   m_WebEngineView->setUrl(QUrl(QStringLiteral("qrc:///C3js/empty.html")));
 }
 
 void QmitkChartWidget::Impl::InitializeJavaScriptChart()
 {
   m_WebChannel->registerObject(QStringLiteral("chartData"), m_C3Data);
   unsigned count = 0;
   for (auto& xyData : *m_C3xyData) {
 	  QString variableName = "xyData" + QString::number(count);
 	  m_WebChannel->registerObject(variableName, xyData);
 	  count++;
   }
   m_WebEngineView->load(QUrl(QStringLiteral("qrc:///C3js/QmitkChartWidget.html")));
 }
 
 QmitkChartWidget::~QmitkChartWidget()
 {
   delete m_Impl;
 }
 
 void QmitkChartWidget::AddData2D(const std::map<double, double>& data2D, const std::string& label, ChartType type)
 {
   m_Impl->AddData2D(data2D, label, type);
 }
 
 void QmitkChartWidget::SetColor(const std::string& label, const std::string& colorName)
 {
   m_Impl->SetColor(label, colorName);
 }
 
 void QmitkChartWidget::SetLineStyle(const std::string& label, LineStyle style)
 {
   m_Impl->SetLineStyle(label, style);
 }
 
 void QmitkChartWidget::AddData1D(const std::vector<double>& data1D, const std::string& label, ChartType type)
 {
   m_Impl->AddData1D(data1D, label, type);
 }
 
 void QmitkChartWidget::RemoveData(const std::string& label)
 {
   m_Impl->RemoveData(label);
 }
 
-std::vector<std::string> QmitkChartWidget::GetDataLabels() const
-{
-	return m_Impl->GetDataLabels();
-}
-
 void QmitkChartWidget::SetXAxisLabel(const std::string & label)
 {
 	m_Impl->SetXAxisLabel(label);
 }
 
 std::string QmitkChartWidget::GetXAxisLabel() const
 {
 	return m_Impl->GetXAxisLabel();
 }
 
 void QmitkChartWidget::SetYAxisLabel(const std::string & label)
 {
 	m_Impl->SetYAxisLabel(label);
 }
 
 std::string QmitkChartWidget::GetYAxisLabel() const
 {
 	return m_Impl->GetYAxisLabel();
 }
 
 void QmitkChartWidget::SetDiagramTitle(const std::string & title)
 {
   m_Impl->SetDiagramTitle(title);
 }
 
 std::string QmitkChartWidget::GetDiagramTitle() const
 {
   return m_Impl->GetDiagramTitle();
 }
 
 void QmitkChartWidget::SetChartType(const std::string& label, ChartType type)
 {
   m_Impl->SetChartType(label, type);
 }
 
 void QmitkChartWidget::SetLegendPosition(LegendPosition position)
 {
   m_Impl->SetLegendPosition(position);
 }
 
 QmitkChartWidget::LegendPosition QmitkChartWidget::GetLegendPosition() const
 {
   return m_Impl->GetLegendPosition();
 }
 
 void QmitkChartWidget::Show(bool showSubChart)
 {
   if (m_Impl->GetC3xyData()->empty()) {
     mitkThrow() << "no data available for display in chart";
   }
   this->m_Impl->GetC3Data()->SetAppearance(showSubChart, m_Impl->GetC3xyData()->front()->GetChartType()== QVariant("pie"));
   m_Impl->InitializeJavaScriptChart();
 }
 
 void QmitkChartWidget::Clear()
 {
 	m_Impl->ClearData();
-	//m_Impl->GetC3xyData()->clear();
 	m_Impl->ClearJavaScriptChart();
 }
 
 void QmitkChartWidget::OnLoadFinished(bool isLoadSuccessfull)
 {
   if(isLoadSuccessfull)
   {
     emit PageSuccessfullyLoaded();
   }
 }
 
 void QmitkChartWidget::SetChartTypeForAllDataAndReload(ChartType type)
 {
   auto allData = this->m_Impl->GetC3xyData();
   for (auto iterator = allData->begin(); iterator != allData->end(); ++iterator) {
     SetChartType((*iterator)->GetLabel().toString().toStdString(), type);
   }
   auto diagramTypeName = m_Impl->ConvertChartTypeToString(type);
   const QString command = QString::fromStdString("transformView('" + diagramTypeName + "')");
   m_Impl->CallJavaScriptFuntion(command);
 }
 
 void QmitkChartWidget::SetTheme(ChartStyle themeEnabled)
 {
   QString command;
   if (themeEnabled == ChartStyle::darkstyle)
   {
     command = QString("changeTheme('dark')");
   }
   else {
     command = QString("changeTheme('default')");
   }
   m_Impl->CallJavaScriptFuntion(command);
 }
 
 void QmitkChartWidget::Reload(bool showSubChart)
 {
   QString subChartString;
   if (showSubChart) {
     subChartString = "true";
   }
   else {
     subChartString = "false";
   }
   const QString command = QString("ReloadChart(" + subChartString + ")");
   m_Impl->CallJavaScriptFuntion(command);
 }