diff --git a/Modules/ToFUI/Qmitk/QmitkToFCompositeFilterWidget.cpp b/Modules/ToFUI/Qmitk/QmitkToFCompositeFilterWidget.cpp
index 6a24e17155..2077361fa9 100644
--- a/Modules/ToFUI/Qmitk/QmitkToFCompositeFilterWidget.cpp
+++ b/Modules/ToFUI/Qmitk/QmitkToFCompositeFilterWidget.cpp
@@ -1,283 +1,283 @@
 /*===================================================================
 
 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 <QmitkToFCompositeFilterWidget.h>
 
 #include <mitkProperties.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateProperty.h>
 
 const std::string QmitkToFCompositeFilterWidget::VIEW_ID = "org.mitk.views.qmitktofcompositefilterwidget";
 
 QmitkToFCompositeFilterWidget::QmitkToFCompositeFilterWidget(QWidget* parent, Qt::WindowFlags f): QWidget(parent, f)
 {
   this->m_ToFCompositeFilter = nullptr;
 
   m_Controls = nullptr;
   CreateQtPartControl(this);
 }
 
 QmitkToFCompositeFilterWidget::~QmitkToFCompositeFilterWidget()
 {
 }
 
 void QmitkToFCompositeFilterWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkToFCompositeFilterWidgetControls;
     m_Controls->setupUi(parent);
 
     int min = m_Controls->m_ThresholdFilterMinValueSpinBox->value();
     int max = m_Controls->m_ThresholdFilterMaxValueSpinBox->value();
     m_Controls->m_ThresholdFilterRangeSlider->setMinimum(min);
     m_Controls->m_ThresholdFilterRangeSlider->setMaximum(max);
     m_Controls->m_ThresholdFilterRangeSlider->setMinimumValue(min);
     m_Controls->m_ThresholdFilterRangeSlider->setMaximumValue(max);
     this->CreateConnections();
 
     this->OnShowAdvancedOptionsCheckboxChecked(false);
   }
 }
 
 void QmitkToFCompositeFilterWidget::CreateConnections()
 {
   if ( m_Controls )
   {
     connect(m_Controls->m_TemporalMedianFilterNumOfFramesSpinBox, SIGNAL(valueChanged(int)), this, SLOT(OnTemporalMedianFilterNumOfFramesSpinBoxValueChanged(int)));
     connect(m_Controls->m_BilateralFilterDomainSigmaSpinBox, SIGNAL(valueChanged(double)), this, SLOT(OnBilateralFilterDomainSigmaSpinBoxValueChanged(double)));
     connect(m_Controls->m_BilateralFilterRangeSigmaSpinBox, SIGNAL(valueChanged(double)), this, SLOT(OnBilateralFilterRangeSigmaSpinBoxValueChanged(double)));
     connect(m_Controls->m_BilateralFilterKernelRadiusSpinBox, SIGNAL(valueChanged(int)), this, SLOT(OnBilateralFilterKernelRadiusSpinBoxValueChanged(int)));
     connect(m_Controls->m_ThresholdFilterMinValueSpinBox, SIGNAL(valueChanged(int)), this, SLOT(OnThresholdFilterMinValueChanged(int)));
     connect(m_Controls->m_ThresholdFilterMaxValueSpinBox, SIGNAL(valueChanged(int)), this, SLOT(OnThresholdFilterMaxValueChanged(int)));
 
     connect( (QObject*)(m_Controls->m_TemporalMedianFilterCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnTemporalMedianFilterCheckBoxChecked(bool)) );
     connect( (QObject*)(m_Controls->m_AverageFilterCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnAverageFilterCheckBoxChecked(bool)) );
     connect( (QObject*)(m_Controls->m_ThresholdFilterCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnThresholdFilterCheckBoxChecked(bool)) );
     connect( (QObject*)(m_Controls->maskSegmentationCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnMaskSegmentationCheckBoxChecked(bool)) );
     connect( (QObject*)(m_Controls->m_BilateralFilterCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnBilateralFilterCheckBoxChecked(bool)) );
     connect( (QObject*)(m_Controls->m_MedianFilterCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnMedianFilterCheckBoxChecked(bool)) );
     connect( (QObject*)(m_Controls->m_ShowAdvancedOptionsCheckbox), SIGNAL(toggled(bool)), this, SLOT(OnShowAdvancedOptionsCheckboxChecked(bool)) );
 
-    connect(m_Controls->m_ThresholdFilterRangeSlider, SIGNAL(spanChanged(int, int)  ),this, SLOT( OnSpanChanged(int , int ) ));
+    connect(m_Controls->m_ThresholdFilterRangeSlider, SIGNAL(valuesChanged(int, int)  ),this, SLOT( OnSpanChanged(int , int ) ));
 
     //reset button
     connect(m_Controls->m_ThresholdFilterRangeSliderReset, SIGNAL(pressed()), this, SLOT(OnResetThresholdFilterRangeSlider()));
 
   }
 }
 
 void QmitkToFCompositeFilterWidget::SetToFCompositeFilter(mitk::ToFCompositeFilter* toFCompositeFilter)
 {
   this->m_ToFCompositeFilter = toFCompositeFilter;
 }
 
 mitk::ToFCompositeFilter* QmitkToFCompositeFilterWidget::GetToFCompositeFilter()
 {
   if (this->m_ToFCompositeFilter.IsNull())
   {
     this->m_ToFCompositeFilter = mitk::ToFCompositeFilter::New();
   }
   return this->m_ToFCompositeFilter;
 }
 
 void QmitkToFCompositeFilterWidget::SetDataStorage(mitk::DataStorage::Pointer dataStorage)
 {
   m_DataStorage = dataStorage;
   m_Controls->maskImageComboBox->SetDataStorage(dataStorage);
   m_Controls->maskImageComboBox->SetPredicate(mitk::NodePredicateAnd::New(mitk::NodePredicateDataType::New("Image"),mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true))));
 }
 
 void QmitkToFCompositeFilterWidget::UpdateFilterParameter()
 {
   OnTemporalMedianFilterCheckBoxChecked(m_Controls->m_TemporalMedianFilterCheckBox->isChecked());
   OnAverageFilterCheckBoxChecked(m_Controls->m_AverageFilterCheckBox->isChecked());
   OnMedianFilterCheckBoxChecked(m_Controls->m_MedianFilterCheckBox->isChecked());
   OnThresholdFilterCheckBoxChecked(m_Controls->m_ThresholdFilterCheckBox->isChecked());
   OnBilateralFilterCheckBoxChecked(m_Controls->m_BilateralFilterCheckBox->isChecked());
 }
 
 void QmitkToFCompositeFilterWidget::SetWidgetConfiguration(bool threshold, bool mask, bool tempMedian, bool tempAverage, bool median, bool bilateral )
 {
   m_Controls->m_ThresholdFilterCheckBox->setChecked(threshold);
   m_Controls->maskSegmentationCheckBox->setChecked(mask);
   m_Controls->m_TemporalMedianFilterCheckBox->setChecked(tempMedian);
   m_Controls->m_AverageFilterCheckBox->setChecked(tempAverage);
   m_Controls->m_MedianFilterCheckBox->setChecked(median);
   m_Controls->m_BilateralFilterCheckBox->setChecked(bilateral);
 }
 
 void QmitkToFCompositeFilterWidget::SetStandardParametersBilateralFilter(double domainSigma, double rangeSigma, int kernelRadius)
 {
   m_Controls->m_BilateralFilterDomainSigmaSpinBox->setValue(domainSigma);
   m_Controls->m_BilateralFilterRangeSigmaSpinBox->setValue(rangeSigma);
   m_Controls->m_BilateralFilterKernelRadiusSpinBox->setValue(kernelRadius);
 }
 
 void QmitkToFCompositeFilterWidget::SetStandardParametersThresholdFilter(int min, int max)
 {
   m_Controls->m_ThresholdFilterMinValueSpinBox->setValue(min);
   m_Controls->m_ThresholdFilterMaxValueSpinBox->setValue(max);
 }
 
 void QmitkToFCompositeFilterWidget::SetStandardParameterTemporalAveraging(int nImages)
 {
   m_Controls->m_TemporalMedianFilterNumOfFramesSpinBox->setValue(nImages);
 }
 
 void QmitkToFCompositeFilterWidget::OnTemporalMedianFilterCheckBoxChecked(bool checked)
 {
   this->m_ToFCompositeFilter->SetApplyTemporalMedianFilter(checked);
   // disable average filter if temporal median filter is enabled
   if (checked)
   {
     m_Controls->m_AverageFilterCheckBox->setChecked(false);
     this->m_ToFCompositeFilter->SetApplyAverageFilter(false);
   }
 }
 
 void QmitkToFCompositeFilterWidget::OnAverageFilterCheckBoxChecked(bool checked)
 {
   this->m_ToFCompositeFilter->SetApplyAverageFilter(checked);
   // disable temporal median filter if average filter is enabled
   if (checked)
   {
     m_Controls->m_TemporalMedianFilterCheckBox->setChecked(false);
     this->m_ToFCompositeFilter->SetApplyTemporalMedianFilter(false);
   }
 }
 
 void QmitkToFCompositeFilterWidget::OnShowAdvancedOptionsCheckboxChecked(bool checked)
 {
   this->m_Controls->m_AverageFilterCheckBox->setVisible(checked);
   this->m_Controls->m_BilateralFilterCheckBox->setVisible(checked);
   this->m_Controls->m_BilateralFilterDomainSigmaSpinBox->setVisible(checked);
   this->m_Controls->m_BilateralFilterKernelRadiusSpinBox->setVisible(checked);
   this->m_Controls->m_BilateralFilterRangeSigmaSpinBox->setVisible(checked);
   this->m_Controls->m_MedianFilterCheckBox->setVisible(checked);
   this->m_Controls->m_TemporalMedianFilterCheckBox->setVisible(checked);
   this->m_Controls->m_TemporalMedianFilterNumOfFramesSpinBox->setVisible(checked);
   this->m_Controls->m_ThresholdFilterCheckBox->setVisible(checked);
   this->m_Controls->m_ThresholdFilterMaxValueSpinBox->setVisible(checked);
   this->m_Controls->m_ThresholdFilterMinValueSpinBox->setVisible(checked);
   this->m_Controls->m_ThresholdFilterRangeSlider->setVisible(checked);
   this->m_Controls->m_ThresholdFilterRangeSliderReset->setVisible(checked);
   this->m_Controls->label_3->setVisible(checked);
   this->m_Controls->label_4->setVisible(checked);
   this->m_Controls->label_12->setVisible(checked);
   this->m_Controls->maskImageComboBox->setVisible(checked);
   this->m_Controls->maskSegmentationCheckBox->setVisible(checked);
 }
 
 void QmitkToFCompositeFilterWidget::OnThresholdFilterCheckBoxChecked(bool checked)
 {
   this->m_ToFCompositeFilter->SetApplyThresholdFilter(checked);
 }
 
 void QmitkToFCompositeFilterWidget::OnMaskSegmentationCheckBoxChecked(bool checked)
 {
   this->m_ToFCompositeFilter->SetApplyMaskSegmentation(checked);
   if (checked)
   {
     mitk::DataNode::Pointer maskImageNode = m_Controls->maskImageComboBox->GetSelectedNode();
     if (maskImageNode.IsNotNull())
     {
       mitk::Image::Pointer maskImage = dynamic_cast<mitk::Image*>(maskImageNode->GetData());
       this->m_ToFCompositeFilter->SetSegmentationMask(maskImage);
     }
   }
 }
 
 void QmitkToFCompositeFilterWidget::OnMedianFilterCheckBoxChecked(bool checked)
 {
   this->m_ToFCompositeFilter->SetApplyMedianFilter(checked);
 }
 
 void QmitkToFCompositeFilterWidget::OnBilateralFilterCheckBoxChecked(bool checked)
 {
   this->m_ToFCompositeFilter->SetApplyBilateralFilter(checked);
 }
 
 void QmitkToFCompositeFilterWidget::OnTemporalMedianFilterNumOfFramesSpinBoxValueChanged(int value)
 {
   this->m_ToFCompositeFilter->SetTemporalMedianFilterParameter(value);
 }
 
 void QmitkToFCompositeFilterWidget::OnBilateralFilterDomainSigmaSpinBoxValueChanged(double)
 {
   SetBilateralFilterParameter();
 }
 
 void QmitkToFCompositeFilterWidget::OnBilateralFilterRangeSigmaSpinBoxValueChanged(double)
 {
   SetBilateralFilterParameter();
 }
 
 void QmitkToFCompositeFilterWidget::OnBilateralFilterKernelRadiusSpinBoxValueChanged(int)
 {
   SetBilateralFilterParameter();
 }
 
 void QmitkToFCompositeFilterWidget::OnThresholdFilterMinValueChanged(int value)
 {
   m_Controls->m_ThresholdFilterRangeSlider->setMinimumValue(value);
   SetThresholdFilterParameter();
 }
 
 void QmitkToFCompositeFilterWidget::OnThresholdFilterMaxValueChanged(int value)
 {
   m_Controls->m_ThresholdFilterRangeSlider->setMaximumValue(value);
   SetThresholdFilterParameter();
 }
 
 
 void QmitkToFCompositeFilterWidget::SetThresholdFilterParameter()
 {
   int min = m_Controls->m_ThresholdFilterMinValueSpinBox->value();
   int max = m_Controls->m_ThresholdFilterMaxValueSpinBox->value();
   this->m_ToFCompositeFilter->SetThresholdFilterParameter(min, max);
 }
 
 void QmitkToFCompositeFilterWidget::SetBilateralFilterParameter()
 {
   double domainSigma = m_Controls->m_BilateralFilterDomainSigmaSpinBox->value();
   double rangeSigma = m_Controls->m_BilateralFilterRangeSigmaSpinBox->value();
   int kernelRadius = m_Controls->m_BilateralFilterKernelRadiusSpinBox->value();
   this->m_ToFCompositeFilter->SetBilateralFilterParameter(domainSigma, rangeSigma, kernelRadius);
 }
 
 void QmitkToFCompositeFilterWidget::OnSpanChanged(int, int)
 {
   int lowerVal =  m_Controls->m_ThresholdFilterRangeSlider->minimumValue();
   int upperVal =  m_Controls->m_ThresholdFilterRangeSlider->maximumValue();
 
   m_Controls->m_ThresholdFilterMinValueSpinBox->setValue(lowerVal);
   m_Controls->m_ThresholdFilterMaxValueSpinBox->setValue(upperVal);
 }
 
 void QmitkToFCompositeFilterWidget::OnResetThresholdFilterRangeSlider()
 {
   int lower =  1;
   int upper =  7000;
 
   m_Controls->m_ThresholdFilterRangeSlider->setMinimumValue(lower);
   m_Controls->m_ThresholdFilterRangeSlider->setMaximumValue(upper);
 
   m_Controls->m_ThresholdFilterMinValueSpinBox->setValue(lower);
   m_Controls->m_ThresholdFilterMaxValueSpinBox->setValue(upper);
 }
diff --git a/Modules/ToFUI/Qmitk/QmitkToFVisualisationSettingsWidget.cpp b/Modules/ToFUI/Qmitk/QmitkToFVisualisationSettingsWidget.cpp
index be5f8d7576..818c3e10c3 100644
--- a/Modules/ToFUI/Qmitk/QmitkToFVisualisationSettingsWidget.cpp
+++ b/Modules/ToFUI/Qmitk/QmitkToFVisualisationSettingsWidget.cpp
@@ -1,419 +1,419 @@
 /*===================================================================
 
 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 "QmitkToFVisualisationSettingsWidget.h"
 
 #include <mitkTransferFunction.h>
 #include <mitkTransferFunctionProperty.h>
 #include <mitkImageStatisticsHolder.h>
 
 //QT headers
 #include <QString>
 #include <mitkTransferFunctionProperty.h>
 #include <mitkTransferFunction.h>
 
 const std::string QmitkToFVisualisationSettingsWidget::VIEW_ID = "org.mitk.views.qmitktofvisualisationsettingswidget";
 
 QmitkToFVisualisationSettingsWidget::QmitkToFVisualisationSettingsWidget(QWidget* parent, Qt::WindowFlags f): QWidget(parent, f)
 , m_Controls(nullptr)
 , m_RangeSliderMin(0)
 , m_RangeSliderMax(0)
 , m_MitkDistanceImageNode(nullptr)
 , m_MitkAmplitudeImageNode(nullptr)
 , m_MitkIntensityImageNode(nullptr)
 , m_Widget1ColorTransferFunction(nullptr)
 , m_Widget2ColorTransferFunction(nullptr)
 , m_Widget3ColorTransferFunction(nullptr)
 , m_Widget1TransferFunctionType(1)
 , m_Widget2TransferFunctionType(0)
 , m_Widget3TransferFunctionType(0)
 {
   CreateQtPartControl(this);
 }
 
 QmitkToFVisualisationSettingsWidget::~QmitkToFVisualisationSettingsWidget()
 {
 }
 
 void QmitkToFVisualisationSettingsWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkToFVisualisationSettingsWidgetControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
   }
 }
 
 void QmitkToFVisualisationSettingsWidget::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_SelectWidgetCombobox), SIGNAL(currentIndexChanged(int)),(QObject*) this, SLOT(OnWidgetSelected(int)) );
     connect( (QObject*)(m_Controls->m_SelectTransferFunctionTypeCombobox), SIGNAL(currentIndexChanged(int)),(QObject*) this, SLOT(OnTransferFunctionTypeSelected(int)) );
     connect( (QObject*)(m_Controls->m_TransferFunctionResetButton), SIGNAL(clicked()),(QObject*) this, SLOT(OnTransferFunctionReset()) );
     connect(m_Controls->m_XEditColor, SIGNAL(returnPressed()), this, SLOT(OnSetXValueColor()));
     connect(m_Controls->m_RangeSliderMaxEdit, SIGNAL(returnPressed()), this, SLOT(OnRangeSliderMaxChanged()));
     connect(m_Controls->m_RangeSliderMinEdit, SIGNAL(returnPressed()), this, SLOT(OnRangeSliderMinChanged()));
     connect(m_Controls->m_RangeSliderReset, SIGNAL(pressed()), this, SLOT(OnResetSlider()));
-    connect(m_Controls->m_RangeSlider, SIGNAL(spanChanged(int, int)  ),this, SLOT( OnSpanChanged(int , int ) ));
+    connect(m_Controls->m_RangeSlider, SIGNAL(valuesChanged(int, int)  ),this, SLOT( OnSpanChanged(int , int ) ));
     connect(m_Controls->m_AdvancedOptionsCheckbox, SIGNAL(toggled(bool)  ),this, SLOT( OnShowAdvancedOptionsCheckboxChecked(bool) ));
 
     m_Controls->m_RangeSlider->setMaximum(2048);
     m_Controls->m_RangeSlider->setMinimum(-2048);
 
     m_Controls->m_ColorTransferFunctionCanvas->SetQLineEdits(m_Controls->m_XEditColor, nullptr);
     m_Controls->m_ColorTransferFunctionCanvas->SetTitle(""/*"Value -> Grayscale/Color"*/);
 
     this->OnShowAdvancedOptionsCheckboxChecked(false);
   }
 }
 
 void QmitkToFVisualisationSettingsWidget::OnSetXValueColor()
 {
   m_Controls->m_ColorTransferFunctionCanvas->SetX(m_Controls->m_XEditColor->text().toFloat());
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkToFVisualisationSettingsWidget::OnRangeSliderMaxChanged()
 {
   m_Controls->m_RangeSlider->setMaximum(m_Controls->m_RangeSliderMaxEdit->text().toInt());
   UpdateRanges();
   m_Controls->m_ColorTransferFunctionCanvas->update();
 }
 
 void QmitkToFVisualisationSettingsWidget::OnRangeSliderMinChanged()
 {
   m_Controls->m_RangeSlider->setMinimum(m_Controls->m_RangeSliderMinEdit->text().toInt());
   UpdateRanges();
   m_Controls->m_ColorTransferFunctionCanvas->update();
 }
 
 void QmitkToFVisualisationSettingsWidget::OnSpanChanged(int /*lower*/, int /*upper*/)
 {
   UpdateRanges();
   m_Controls->m_ColorTransferFunctionCanvas->update();
 }
 
 void QmitkToFVisualisationSettingsWidget::OnResetSlider()
 {
   m_Controls->m_RangeSlider->setMaximumValue(m_RangeSliderMax);
   m_Controls->m_RangeSlider->setMinimumValue(m_RangeSliderMin);
 
   UpdateRanges();
   m_Controls->m_ColorTransferFunctionCanvas->update();
 }
 
 void QmitkToFVisualisationSettingsWidget::UpdateRanges()
 {
   int lower =  m_Controls->m_RangeSlider->minimumValue();
   int upper =  m_Controls->m_RangeSlider->maximumValue();
 
   m_Controls->m_ColorTransferFunctionCanvas->SetMin(lower);
   m_Controls->m_ColorTransferFunctionCanvas->SetMax(upper);
 }
 
 void QmitkToFVisualisationSettingsWidget::UpdateSurfaceProperty()
 {
   if(this->m_MitkSurfaceNode.IsNotNull())
   {
     mitk::TransferFunction::Pointer transferFunction = mitk::TransferFunction::New();
     transferFunction->SetColorTransferFunction(this->GetSelectedColorTransferFunction());
 
     this->m_MitkSurfaceNode->SetProperty("Surface.TransferFunction", mitk::TransferFunctionProperty::New(transferFunction));
   }
 }
 
 void QmitkToFVisualisationSettingsWidget::Initialize(mitk::DataNode* distanceImageNode, mitk::DataNode* amplitudeImageNode,
                                                      mitk::DataNode* intensityImageNode, mitk::DataNode* surfaceNode)
 {
   this->m_MitkDistanceImageNode = distanceImageNode;
   this->m_MitkAmplitudeImageNode = amplitudeImageNode;
   this->m_MitkIntensityImageNode = intensityImageNode;
   this->m_MitkSurfaceNode = surfaceNode;
 
   // Initialize transfer functions for image DataNodes such that:
   // Widget1 (Distance): color from red (2nd min) to blue (max)
   // Widget2 (Amplitude): grey value from black (2nd min) to white (max)
   // Widget3 (Intensity): grey value from black (2nd min) to white (max)
   if (!m_MitkDistanceImageNode && !m_MitkAmplitudeImageNode && !m_MitkIntensityImageNode)
   {
     m_Controls->m_ColorTransferFunctionCanvas->setEnabled(false);
   }
   else
   {
     m_Controls->m_ColorTransferFunctionCanvas->setEnabled(true);
     int numberOfImages = 0;
     if (m_MitkDistanceImageNode)
     {
       m_Widget1ColorTransferFunction = vtkColorTransferFunction::New();
       this->m_Widget1TransferFunctionType = 1;
       m_Controls->m_SelectTransferFunctionTypeCombobox->setCurrentIndex(this->m_Widget1TransferFunctionType);
       numberOfImages++;
     }
     if (m_MitkAmplitudeImageNode)
     {
       m_Widget2ColorTransferFunction = vtkColorTransferFunction::New();
       this->m_Widget2TransferFunctionType = 0;
       numberOfImages++;
     }
     if (m_MitkIntensityImageNode)
     {
       m_Widget3ColorTransferFunction = vtkColorTransferFunction::New();
       this->m_Widget3TransferFunctionType = 0;
       numberOfImages++;
     }
     m_Controls->m_SelectWidgetCombobox->setMaxCount(numberOfImages);
   }
   this->ReinitTransferFunction(0,1);
   this->ReinitTransferFunction(1,0);
   this->ReinitTransferFunction(2,0);
 }
 
 void QmitkToFVisualisationSettingsWidget::UpdateCanvas()
 {
   m_Controls->m_ColorTransferFunctionCanvas->SetColorTransferFunction( this->GetSelectedColorTransferFunction() );
   UpdateRanges();
   m_Controls->m_ColorTransferFunctionCanvas->update();
 }
 
 void QmitkToFVisualisationSettingsWidget::OnTransferFunctionTypeSelected(int index)
 {
   int currentWidgetIndex = m_Controls->m_SelectWidgetCombobox->currentIndex();
   if (currentWidgetIndex == 0)
   {
     this->m_Widget1TransferFunctionType = index;
   }
   else if (currentWidgetIndex == 1)
   {
     this->m_Widget2TransferFunctionType = index;
   }
   else if (currentWidgetIndex == 2)
   {
     this->m_Widget3TransferFunctionType = index;
   }
   else
   {
     return;
   }
   this->UpdateSurfaceProperty();
 }
 
 void QmitkToFVisualisationSettingsWidget::OnShowAdvancedOptionsCheckboxChecked(bool checked)
 {
   this->m_Controls->m_MappingGroupBox->setVisible(checked);
   this->m_Controls->m_SelectTransferFunctionTypeCombobox->setVisible(checked);
   this->m_Controls->m_SelectWidgetCombobox->setVisible(checked);
   this->m_Controls->m_TransferFunctionResetButton->setVisible(checked);
 }
 
 void QmitkToFVisualisationSettingsWidget::OnWidgetSelected(int index)
 {
   int currentWidgetIndex = index;
 
   double valMin[6];
   double valMax[6];
   int numPoints;
   if (currentWidgetIndex == 0)
   {
     m_Controls->m_SelectTransferFunctionTypeCombobox->setCurrentIndex(this->m_Widget1TransferFunctionType);
     numPoints = this->m_Widget1ColorTransferFunction->GetSize();
     this->m_Widget1ColorTransferFunction->GetNodeValue( 0, valMin );
     this->m_Widget1ColorTransferFunction->GetNodeValue( numPoints-1, valMax );
     m_Controls->m_ColorTransferFunctionCanvas->SetColorTransferFunction( this->m_Widget1ColorTransferFunction );
   }
   else if (currentWidgetIndex == 1)
   {
     m_Controls->m_SelectTransferFunctionTypeCombobox->setCurrentIndex(this->m_Widget2TransferFunctionType);
     numPoints = this->m_Widget2ColorTransferFunction->GetSize();
     this->m_Widget2ColorTransferFunction->GetNodeValue( 0, valMin );
     this->m_Widget2ColorTransferFunction->GetNodeValue( numPoints-1, valMax );
     m_Controls->m_ColorTransferFunctionCanvas->SetColorTransferFunction( this->m_Widget2ColorTransferFunction );
   }
   else if (currentWidgetIndex == 2)
   {
     m_Controls->m_SelectTransferFunctionTypeCombobox->setCurrentIndex(this->m_Widget3TransferFunctionType);
     numPoints = this->m_Widget3ColorTransferFunction->GetSize();
     this->m_Widget3ColorTransferFunction->GetNodeValue( 0, valMin );
     this->m_Widget3ColorTransferFunction->GetNodeValue( numPoints-1, valMax );
     m_Controls->m_ColorTransferFunctionCanvas->SetColorTransferFunction( this->m_Widget3ColorTransferFunction );
   }
   else if (currentWidgetIndex == 3)
   {
   }
   else
   {
     return;
   }
   m_RangeSliderMin = valMin[0];
   m_RangeSliderMax = valMax[0];
   int border = (m_RangeSliderMax - m_RangeSliderMin) * 0.1;
   m_Controls->m_RangeSlider->setMinimum(m_RangeSliderMin - border);
   m_Controls->m_RangeSlider->setMaximum(m_RangeSliderMax + border);
   m_Controls->m_RangeSliderMinEdit->setText(QString("").setNum(m_RangeSliderMin - border));
   m_Controls->m_RangeSliderMaxEdit->setText(QString("").setNum(m_RangeSliderMax + border));
   m_Controls->m_RangeSlider->setRange( m_RangeSliderMin, m_RangeSliderMax);
   UpdateRanges();
   m_Controls->m_ColorTransferFunctionCanvas->update();
   this->UpdateSurfaceProperty();
 }
 
 void QmitkToFVisualisationSettingsWidget::ResetTransferFunction(vtkColorTransferFunction* colorTransferFunction, int type, double min, double max)
 {
   colorTransferFunction->RemoveAllPoints();
   if (type == 0)
   {
     colorTransferFunction->AddRGBPoint(min, 0, 0, 0);
     colorTransferFunction->AddRGBPoint(max, 1, 1, 1);
   }
   else
   {
     if (min>0.01)
     {
       colorTransferFunction->AddRGBPoint(0.0, 0, 0, 0);
       colorTransferFunction->AddRGBPoint(min-0.01, 0, 0, 0);
     }
     colorTransferFunction->AddRGBPoint(min, 1, 0, 0);
     colorTransferFunction->AddRGBPoint(min+(max-min)/2, 1, 1, 0);
     colorTransferFunction->AddRGBPoint(max, 0, 0, 1);
   }
   colorTransferFunction->SetColorSpaceToHSV();
 }
 
 void QmitkToFVisualisationSettingsWidget::ReinitTransferFunction(int widget, int type)
 {
   switch (widget)
   {
   case 0:
   {
     mitk::Image::Pointer distanceImage = dynamic_cast<mitk::Image*>(m_MitkDistanceImageNode->GetData());
     // use second minimum to draw 0 values (that are usually segmented) black
     m_RangeSliderMin = distanceImage->GetStatistics()->GetScalarValue2ndMin();
     m_RangeSliderMax = distanceImage->GetStatistics()->GetScalarValueMax();
     MITK_INFO<<"Distance Min: "<<m_RangeSliderMin;
     MITK_INFO<<"Distance Max: "<<m_RangeSliderMax;
     ResetTransferFunction(this->m_Widget1ColorTransferFunction, type, this->m_RangeSliderMin, this->m_RangeSliderMax);
     m_Controls->m_ColorTransferFunctionCanvas->SetColorTransferFunction( this->m_Widget1ColorTransferFunction );
     mitk::TransferFunction::Pointer tf1 = mitk::TransferFunction::New();
     tf1->SetColorTransferFunction( m_Widget1ColorTransferFunction );
     m_MitkDistanceImageNode->SetProperty("Image Rendering.Transfer Function",mitk::TransferFunctionProperty::New(tf1));
     break;
   }
   case 1:
   {
     if (m_MitkAmplitudeImageNode)
     {
       mitk::Image::Pointer amplitudeImage = dynamic_cast<mitk::Image*>(m_MitkAmplitudeImageNode->GetData());
       if (amplitudeImage.IsNotNull())
       {
         m_RangeSliderMin = amplitudeImage->GetStatistics()->GetScalarValueMin();
         m_RangeSliderMax = amplitudeImage->GetStatistics()->GetScalarValueMax();
         MITK_INFO<<"Amplitude Min: "<<m_RangeSliderMin;
         MITK_INFO<<"Amplitude Max: "<<m_RangeSliderMax;
         ResetTransferFunction(this->m_Widget2ColorTransferFunction, type, this->m_RangeSliderMin, this->m_RangeSliderMax);
         m_Controls->m_ColorTransferFunctionCanvas->SetColorTransferFunction( this->m_Widget2ColorTransferFunction );
         mitk::TransferFunction::Pointer tf2 = mitk::TransferFunction::New();
         tf2->SetColorTransferFunction( m_Widget2ColorTransferFunction );
         m_MitkAmplitudeImageNode->SetProperty("Image Rendering.Transfer Function",mitk::TransferFunctionProperty::New(tf2));
       }
     }
     break;
   }
   case 2:
   {
     if (m_MitkIntensityImageNode)
     {
       mitk::Image::Pointer intensityImage = dynamic_cast<mitk::Image*>(m_MitkIntensityImageNode->GetData());
       if (intensityImage.IsNotNull())
       {
         m_RangeSliderMin = intensityImage->GetStatistics()->GetScalarValueMin();
         m_RangeSliderMax = intensityImage->GetStatistics()->GetScalarValueMax();
         MITK_INFO<<"Intensity Min: "<<m_RangeSliderMin;
         MITK_INFO<<"Intensity Max: "<<m_RangeSliderMax;
         ResetTransferFunction(this->m_Widget3ColorTransferFunction, type, this->m_RangeSliderMin, this->m_RangeSliderMax);
         m_Controls->m_ColorTransferFunctionCanvas->SetColorTransferFunction( this->m_Widget3ColorTransferFunction );
         mitk::TransferFunction::Pointer tf3 = mitk::TransferFunction::New();
         tf3->SetColorTransferFunction( m_Widget3ColorTransferFunction );
         m_MitkIntensityImageNode->SetProperty("Image Rendering.Transfer Function",mitk::TransferFunctionProperty::New(tf3));
       }
     }
     break;
   }
   default:
     break;
   }
   this->UpdateSurfaceProperty();
 }
 
 void QmitkToFVisualisationSettingsWidget::OnTransferFunctionReset()
 {
   int currentTransferFunctionTypeIndex = m_Controls->m_SelectTransferFunctionTypeCombobox->currentIndex();
   int currentWidgetIndex = m_Controls->m_SelectWidgetCombobox->currentIndex();
 
   this->ReinitTransferFunction(currentWidgetIndex,currentTransferFunctionTypeIndex);
 
   int border = (m_RangeSliderMax - m_RangeSliderMin) * 0.1;
   m_Controls->m_RangeSlider->setMinimum(m_RangeSliderMin - border);
   m_Controls->m_RangeSlider->setMaximum(m_RangeSliderMax + border);
   m_Controls->m_RangeSliderMinEdit->setText(QString("").setNum(m_RangeSliderMin - border));
   m_Controls->m_RangeSliderMaxEdit->setText(QString("").setNum(m_RangeSliderMax + border));
   m_Controls->m_RangeSlider->setRange( m_RangeSliderMin, m_RangeSliderMax);
   UpdateRanges();
   m_Controls->m_ColorTransferFunctionCanvas->update();
   this->UpdateSurfaceProperty();
 }
 
 vtkColorTransferFunction* QmitkToFVisualisationSettingsWidget::GetWidget1ColorTransferFunction()
 {
   return this->m_Widget1ColorTransferFunction;
 }
 
 vtkColorTransferFunction* QmitkToFVisualisationSettingsWidget::GetWidget2ColorTransferFunction()
 {
   return this->m_Widget2ColorTransferFunction;
 }
 
 vtkColorTransferFunction* QmitkToFVisualisationSettingsWidget::GetWidget3ColorTransferFunction()
 {
   return this->m_Widget3ColorTransferFunction;
 }
 
 vtkColorTransferFunction* QmitkToFVisualisationSettingsWidget::GetSelectedColorTransferFunction()
 {
   int currentWidgetIndex = m_Controls->m_SelectWidgetCombobox->currentIndex();
   if (currentWidgetIndex==0)
   {
     return this->m_Widget1ColorTransferFunction;
   }
   else if (currentWidgetIndex==1)
   {
     return this->m_Widget2ColorTransferFunction;
   }
   else if (currentWidgetIndex==2)
   {
     return this->m_Widget3ColorTransferFunction;
   }
   else
   {
     return this->m_Widget3ColorTransferFunction;
   }
 }
 
 int QmitkToFVisualisationSettingsWidget::GetSelectedImageIndex()
 {
   return this->m_Controls->m_SelectWidgetCombobox->currentIndex();
 }