diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/manifest_headers.cmake b/Plugins/org.mitk.gui.qt.diffusionimaging/manifest_headers.cmake
index f9deaced2c..4150a434d0 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/manifest_headers.cmake
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/manifest_headers.cmake
@@ -1,5 +1,5 @@
 set(Plugin-Name "MITK Diffusion Imaging")
 set(Plugin-Version "0.1")
 set(Plugin-Vendor "DKFZ, Medical and Biological Informatics")
 set(Plugin-ContactAddress "http://www.mitk.org")
-set(Require-Plugin org.mitk.gui.qt.common.legacy org.mitk.gui.qt.common org.mitk.diffusionimaging)
+set(Require-Plugin org.mitk.gui.qt.common org.mitk.diffusionimaging)
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkAstrosticksModelParametersWidget.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkAstrosticksModelParametersWidget.h
index cb1882ad7a..b93040846c 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkAstrosticksModelParametersWidget.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkAstrosticksModelParametersWidget.h
@@ -1,64 +1,62 @@
 /*===================================================================
 
 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 _QMITKAstrosticksModelParametersWidget_H_INCLUDED
 #define _QMITKAstrosticksModelParametersWidget_H_INCLUDED
 
 //QT headers
 #include <QWidget>
 #include <QString>
 #include "ui_QmitkAstrosticksModelParametersWidgetControls.h"
 #include <org_mitk_gui_qt_diffusionimaging_Export.h>
 
-class QmitkStdMultiWidget;
-
 /** @brief
   */
 class DIFFUSIONIMAGING_EXPORT QmitkAstrosticksModelParametersWidget : public QWidget
 {
     //this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
     Q_OBJECT
 
 public:
 
     static const std::string VIEW_ID;
 
     QmitkAstrosticksModelParametersWidget (QWidget* parent = nullptr, Qt::WindowFlags f = nullptr);
     virtual ~QmitkAstrosticksModelParametersWidget();
 
     virtual void CreateQtPartControl(QWidget *parent);
 
     void SetT1(double t1){ m_Controls->m_T1box->setValue(t1); }
     void SetT2(double t2){ m_Controls->m_T2box->setValue(t2); }
     void SetD(double d){ m_Controls->m_D1box->setValue(d); }
     void SetRandomizeSticks(bool r){ m_Controls->m_RandomCheck->setChecked(r); }
 
     double GetD(){ return m_Controls->m_D1box->value(); }
     unsigned int GetT2(){ return m_Controls->m_T2box->value(); }
     unsigned int GetT1(){ return m_Controls->m_T1box->value(); }
     bool GetRandomizeSticks(){ return m_Controls->m_RandomCheck->isChecked(); }
 
 public slots:
 
 protected:
     // member variables
     Ui::QmitkAstrosticksModelParametersWidgetControls* m_Controls;
 
 private:
 
 };
 
 #endif // _QMITKAstrosticksModelParametersWidget_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkBallModelParametersWidget.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkBallModelParametersWidget.h
index fd53f652d5..31773056be 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkBallModelParametersWidget.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkBallModelParametersWidget.h
@@ -1,62 +1,60 @@
 /*===================================================================
 
 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 _QMITKBallModelParametersWidget_H_INCLUDED
 #define _QMITKBallModelParametersWidget_H_INCLUDED
 
 //QT headers
 #include <QWidget>
 #include <QString>
 #include "ui_QmitkBallModelParametersWidgetControls.h"
 #include <org_mitk_gui_qt_diffusionimaging_Export.h>
 
-class QmitkStdMultiWidget;
-
 /** @brief
   */
 class DIFFUSIONIMAGING_EXPORT QmitkBallModelParametersWidget : public QWidget
 {
     //this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
     Q_OBJECT
 
 public:
 
     static const std::string VIEW_ID;
 
     QmitkBallModelParametersWidget (QWidget* parent = nullptr, Qt::WindowFlags f = nullptr);
     virtual ~QmitkBallModelParametersWidget();
 
     virtual void CreateQtPartControl(QWidget *parent);
 
     void SetT1(double t1){ m_Controls->m_T1box->setValue(t1); }
     void SetT2(double t2){ m_Controls->m_T2box->setValue(t2); }
     void SetD(double d){ m_Controls->m_D1box->setValue(d); }
 
     double GetD(){ return m_Controls->m_D1box->value(); }
     unsigned int GetT2(){ return m_Controls->m_T2box->value(); }
     unsigned int GetT1(){ return m_Controls->m_T1box->value(); }
 
 public slots:
 
 protected:
     // member variables
     Ui::QmitkBallModelParametersWidgetControls* m_Controls;
 
 private:
 
 };
 
 #endif // _QMITKBallModelParametersWidget_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkDotModelParametersWidget.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkDotModelParametersWidget.h
index 95ecb48312..6b0d016302 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkDotModelParametersWidget.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkDotModelParametersWidget.h
@@ -1,59 +1,57 @@
 /*===================================================================
 
 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 _QMITKDotModelParametersWidget_H_INCLUDED
 #define _QMITKDotModelParametersWidget_H_INCLUDED
 
 //QT headers
 #include <QWidget>
 #include <QString>
 #include "ui_QmitkDotModelParametersWidgetControls.h"
 #include <org_mitk_gui_qt_diffusionimaging_Export.h>
 
-class QmitkStdMultiWidget;
-
 /** @brief
   */
 class DIFFUSIONIMAGING_EXPORT QmitkDotModelParametersWidget : public QWidget
 {
     //this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
     Q_OBJECT
 
 public:
 
     static const std::string VIEW_ID;
 
     QmitkDotModelParametersWidget (QWidget* parent = nullptr, Qt::WindowFlags f = nullptr);
     virtual ~QmitkDotModelParametersWidget();
 
     virtual void CreateQtPartControl(QWidget *parent);
 
     void SetT1(double t1){ m_Controls->m_T1box->setValue(t1); }
     void SetT2(double t2){ m_Controls->m_T2box->setValue(t2); }
     unsigned int GetT2(){ return m_Controls->m_T2box->value(); }
     unsigned int GetT1(){ return m_Controls->m_T1box->value(); }
 
 public slots:
 
 protected:
     // member variables
     Ui::QmitkDotModelParametersWidgetControls* m_Controls;
 
 private:
 
 };
 
 #endif // _QMITKDotModelParametersWidget_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkMlbstTrainingDataWidget.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkMlbstTrainingDataWidget.h
index 14f29bcb44..436b96e507 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkMlbstTrainingDataWidget.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkMlbstTrainingDataWidget.h
@@ -1,71 +1,69 @@
 /*===================================================================
 
 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 _QmitkMlbstTrainingDataWidget_H_INCLUDED
 #define _QmitkMlbstTrainingDataWidget_H_INCLUDED
 
 //QT headers
 #include <QWidget>
 #include <QString>
 #include "ui_QmitkMlbstTrainingDataWidgetControls.h"
 #include <org_mitk_gui_qt_diffusionimaging_Export.h>
 #include <mitkDataNode.h>
 #include <mitkDataStorage.h>
 
-class QmitkStdMultiWidget;
-
 /** @brief
   */
 class DIFFUSIONIMAGING_EXPORT QmitkMlbstTrainingDataWidget : public QWidget
 {
     //this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
     Q_OBJECT
 
 public:
 
     static const std::string VIEW_ID;
 
     QmitkMlbstTrainingDataWidget (QWidget* parent = nullptr, Qt::WindowFlags f = nullptr);
 
     virtual ~QmitkMlbstTrainingDataWidget();
 
     virtual void CreateQtPartControl(QWidget *parent);
 
     mitk::DataNode::Pointer GetImage(){ return m_Controls->image->GetSelectedNode(); }
     mitk::DataNode::Pointer GetFibers(){ return m_Controls->fibers->GetSelectedNode(); }
     mitk::DataNode::Pointer GetMask(){ return m_Controls->mask->GetSelectedNode(); }
     mitk::DataNode::Pointer GetWhiteMatter(){ return m_Controls->whiteMatter->GetSelectedNode(); }
     void SetDataStorage(mitk::DataStorage::Pointer ds)
     {
         m_Controls->image->SetDataStorage(ds);
         m_Controls->fibers->SetDataStorage(ds);
         m_Controls->mask->SetDataStorage(ds);
         m_Controls->whiteMatter->SetDataStorage(ds);
         m_Controls->mask->SetZeroEntryText("--");
         m_Controls->whiteMatter->SetZeroEntryText("--");
     }
 
 public slots:
 
 protected:
     // member variables
     Ui::QmitkMlbstTrainingDataWidgetControls* m_Controls;
 
 private:
 
 };
 
 #endif // _QmitkMlbstTrainingDataWidget_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkPrototypeSignalParametersWidget.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkPrototypeSignalParametersWidget.h
index 18418051d8..ee819c2e20 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkPrototypeSignalParametersWidget.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkPrototypeSignalParametersWidget.h
@@ -1,66 +1,64 @@
 /*===================================================================
 
 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 _QmitkPrototypeSignalParametersWidget_H_INCLUDED
 #define _QmitkPrototypeSignalParametersWidget_H_INCLUDED
 
 //QT headers
 #include <QWidget>
 #include <QString>
 #include "ui_QmitkPrototypeSignalParametersWidgetControls.h"
 #include <org_mitk_gui_qt_diffusionimaging_Export.h>
 
-class QmitkStdMultiWidget;
-
 /** @brief
   */
 class DIFFUSIONIMAGING_EXPORT QmitkPrototypeSignalParametersWidget : public QWidget
 {
     //this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
     Q_OBJECT
 
 public:
 
     static const std::string VIEW_ID;
 
     QmitkPrototypeSignalParametersWidget (QWidget* parent = nullptr, Qt::WindowFlags f = nullptr);
     virtual ~QmitkPrototypeSignalParametersWidget();
 
     virtual void CreateQtPartControl(QWidget *parent);
 
     void SetMinAdc(double min){ m_Controls->m_MinAdcBox->setValue(min); }
     void SetMaxAdc(double max){ m_Controls->m_MaxAdcBox->setValue(max); }
     void SetMinFa(double min){ m_Controls->m_MinFaBox->setValue(min); }
     void SetMaxFa(double max){ m_Controls->m_MaxFaBox->setValue(max); }
     void SetNumberOfSamples(int n){ m_Controls->m_NumSamplesBox->setValue(n); }
 
     double GetMinAdc(){ return m_Controls->m_MinAdcBox->value(); }
     double GetMaxAdc(){ return m_Controls->m_MaxAdcBox->value(); }
     double GetMinFa(){ return m_Controls->m_MinFaBox->value(); }
     double GetMaxFa(){ return m_Controls->m_MaxFaBox->value(); }
     double GetNumberOfSamples(){ return m_Controls->m_NumSamplesBox->value(); }
 
 public slots:
 
 protected:
     // member variables
     Ui::QmitkPrototypeSignalParametersWidgetControls* m_Controls;
 
 private:
 
 };
 
 #endif // _QmitkPrototypeSignalParametersWidget_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkStickModelParametersWidget.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkStickModelParametersWidget.h
index 66236fa1de..a0f883e044 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkStickModelParametersWidget.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkStickModelParametersWidget.h
@@ -1,62 +1,60 @@
 /*===================================================================
 
 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 _QMITKStickModelParametersWidget_H_INCLUDED
 #define _QMITKStickModelParametersWidget_H_INCLUDED
 
 //QT headers
 #include <QWidget>
 #include <QString>
 #include "ui_QmitkStickModelParametersWidgetControls.h"
 #include <org_mitk_gui_qt_diffusionimaging_Export.h>
 
-class QmitkStdMultiWidget;
-
 /** @brief
   */
 class DIFFUSIONIMAGING_EXPORT QmitkStickModelParametersWidget : public QWidget
 {
     //this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
     Q_OBJECT
 
 public:
 
     static const std::string VIEW_ID;
 
     QmitkStickModelParametersWidget (QWidget* parent = nullptr, Qt::WindowFlags f = nullptr);
     virtual ~QmitkStickModelParametersWidget();
 
     virtual void CreateQtPartControl(QWidget *parent);
 
     void SetT1(double t1){ m_Controls->m_T1box->setValue(t1); }
     void SetT2(double t2){ m_Controls->m_T2box->setValue(t2); }
     void SetD(double d){ m_Controls->m_D1box->setValue(d); }
 
     double GetD(){ return m_Controls->m_D1box->value(); }
     unsigned int GetT2(){ return m_Controls->m_T2box->value(); }
     unsigned int GetT1(){ return m_Controls->m_T1box->value(); }
 
 public slots:
 
 protected:
     // member variables
     Ui::QmitkStickModelParametersWidgetControls* m_Controls;
 
 private:
 
 };
 
 #endif // _QMITKStickModelParametersWidget_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTensorModelParametersWidget.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTensorModelParametersWidget.h
index 5de7d43c20..bb54aef097 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTensorModelParametersWidget.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkTensorModelParametersWidget.h
@@ -1,69 +1,67 @@
 /*===================================================================
 
 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 _QMITKTensorModelParametersWidget_H_INCLUDED
 #define _QMITKTensorModelParametersWidget_H_INCLUDED
 
 //QT headers
 #include <QWidget>
 #include <QString>
 #include "ui_QmitkTensorModelParametersWidgetControls.h"
 #include <org_mitk_gui_qt_diffusionimaging_Export.h>
 
-class QmitkStdMultiWidget;
-
 /** @brief
   */
 class DIFFUSIONIMAGING_EXPORT QmitkTensorModelParametersWidget : public QWidget
 {
     //this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
     Q_OBJECT
 
 public:
 
     static const std::string VIEW_ID;
 
     QmitkTensorModelParametersWidget (QWidget* parent = nullptr, Qt::WindowFlags f = nullptr);
     virtual ~QmitkTensorModelParametersWidget();
 
     virtual void CreateQtPartControl(QWidget *parent);
 
     void SetT1(double t1){ m_Controls->m_T1box->setValue(t1); }
     void SetT2(double t2){ m_Controls->m_T2box->setValue(t2); }
     void SetD1(double d1){ m_Controls->m_D1box->setValue(d1); }
     void SetD2(double d2){ m_Controls->m_D2box->setValue(d2); }
     void SetD3(double d3){ m_Controls->m_D3box->setValue(d3); }
 
     double GetD1(){ return m_Controls->m_D1box->value(); }
     double GetD2(){ return m_Controls->m_D2box->value(); }
     double GetD3(){ return m_Controls->m_D3box->value(); }
     unsigned int GetT2(){ return m_Controls->m_T2box->value(); }
     unsigned int GetT1(){ return m_Controls->m_T1box->value(); }
 
 public slots:
 
     void DChanged( double value );
 
 protected:
     // member variables
     Ui::QmitkTensorModelParametersWidgetControls* m_Controls;
     void UpdateUi();
 
 private:
 
 };
 
 #endif // _QMITKTensorModelParametersWidget_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkZeppelinModelParametersWidget.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkZeppelinModelParametersWidget.h
index 17acf74385..1ecc194be2 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkZeppelinModelParametersWidget.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/QmitkZeppelinModelParametersWidget.h
@@ -1,67 +1,65 @@
 /*===================================================================
 
 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 _QMITKZeppelinModelParametersWidget_H_INCLUDED
 #define _QMITKZeppelinModelParametersWidget_H_INCLUDED
 
 //QT headers
 #include <QWidget>
 #include <QString>
 #include "ui_QmitkZeppelinModelParametersWidgetControls.h"
 #include <org_mitk_gui_qt_diffusionimaging_Export.h>
 
-class QmitkStdMultiWidget;
-
 /** @brief
   */
 class DIFFUSIONIMAGING_EXPORT QmitkZeppelinModelParametersWidget : public QWidget
 {
     //this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
     Q_OBJECT
 
 public:
 
     static const std::string VIEW_ID;
 
     QmitkZeppelinModelParametersWidget (QWidget* parent = nullptr, Qt::WindowFlags f = nullptr);
     virtual ~QmitkZeppelinModelParametersWidget();
 
     virtual void CreateQtPartControl(QWidget *parent);
 
     void SetT1(double t1){ m_Controls->m_T1box->setValue(t1); }
     void SetT2(double t2){ m_Controls->m_T2box->setValue(t2); }
     void SetD1(double d1){ m_Controls->m_D1box->setValue(d1); }
     void SetD2(double d2){ m_Controls->m_D2box->setValue(d2); }
 
     double GetD1(){ return m_Controls->m_D1box->value(); }
     double GetD2(){ return m_Controls->m_D2box->value(); }
     unsigned int GetT2(){ return m_Controls->m_T2box->value(); }
     unsigned int GetT1(){ return m_Controls->m_T1box->value(); }
 
 public slots:
 
     void DChanged( double value );
 
 protected:
     // member variables
     Ui::QmitkZeppelinModelParametersWidgetControls* m_Controls;
     void UpdateUi();
 
 private:
 
 };
 
 #endif // _QMITKZeppelinModelParametersWidget_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsDataView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsDataView.cpp
index 4e3f633a63..1b16665c5f 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsDataView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsDataView.cpp
@@ -1,533 +1,522 @@
 /*===================================================================
 
 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 includes #######
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // ####### Qmitk includes #######
 #include "QmitkConnectomicsDataView.h"
-#include "QmitkStdMultiWidget.h"
 
 // ####### Qt includes #######
 #include <QMessageBox>
 
 // ####### ITK includes #######
 #include <itkRGBAPixel.h>
 
 // ####### MITK includes #######
 
 #include <mitkConnectomicsConstantsManager.h>
 #include "mitkConnectomicsSyntheticNetworkGenerator.h"
 #include "mitkConnectomicsSimulatedAnnealingManager.h"
 #include "mitkConnectomicsSimulatedAnnealingPermutationModularity.h"
 #include "mitkConnectomicsSimulatedAnnealingCostFunctionModularity.h"
 #include <mitkCorrelationCalculator.h>
 
 // Includes for image casting between ITK and MITK
 #include "mitkImageCast.h"
 #include "mitkITKImageImport.h"
 #include "mitkImageAccessByItk.h"
 
 const std::string QmitkConnectomicsDataView::VIEW_ID = "org.mitk.views.connectomicsdata";
 
 QmitkConnectomicsDataView::QmitkConnectomicsDataView()
-: QmitkFunctionality()
+: QmitkAbstractView()
 , m_Controls( 0 )
-, m_MultiWidget( NULL )
 , m_ConnectomicsNetworkCreator( mitk::ConnectomicsNetworkCreator::New() )
 , m_demomode( false )
 , m_currentIndex( 0 )
 {
 }
 
 QmitkConnectomicsDataView::~QmitkConnectomicsDataView()
 {
 }
 
 
 void QmitkConnectomicsDataView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkConnectomicsDataViewControls;
     m_Controls->setupUi( parent );
 
     QObject::connect( m_Controls->networkifyPushButton, SIGNAL(clicked()), this, SLOT(OnNetworkifyPushButtonClicked()) );
     QObject::connect( m_Controls->syntheticNetworkCreationPushButton, SIGNAL(clicked()), this, SLOT(OnSyntheticNetworkCreationPushButtonClicked()) );
     QObject::connect( (QObject*)( m_Controls->syntheticNetworkComboBox ), SIGNAL(currentIndexChanged (int)),  this, SLOT(OnSyntheticNetworkComboBoxCurrentIndexChanged(int)) );
     QObject::connect( m_Controls->createCorrelationMatrixPushButton, SIGNAL(clicked()), this, SLOT(OnCreateCorrelationMatrixPushButtonClicked()) );
   }
 
   // GUI is different for developer and demo mode
   m_demomode = true;
   if( m_demomode )
   {
     this->m_Controls->networkifyPushButton->show();
     this->m_Controls->networkifyPushButton->setText( "Create Network" );
     this->m_Controls->syntheticNetworkOptionsGroupBox->show();
     //--------------------------- fill comboBox---------------------------
     this->m_Controls->syntheticNetworkComboBox->insertItem(0,"Regular lattice");
     this->m_Controls->syntheticNetworkComboBox->insertItem(1,"Heterogenic sphere");
     this->m_Controls->syntheticNetworkComboBox->insertItem(2,"Random network");
 
     this->m_Controls->mappingStrategyComboBox->insertItem(m_ConnectomicsNetworkCreator->EndElementPosition, "Use label of end position of fibers");
     this->m_Controls->mappingStrategyComboBox->insertItem(m_ConnectomicsNetworkCreator->EndElementPositionAvoidingWhiteMatter, "Extrapolate label");
   }
   else
   {
     this->m_Controls->networkifyPushButton->show();
     this->m_Controls->networkifyPushButton->setText( "Networkify" );
     this->m_Controls->syntheticNetworkOptionsGroupBox->show();
     //--------------------------- fill comboBox---------------------------
     this->m_Controls->syntheticNetworkComboBox->insertItem(0,"Regular lattice");
     this->m_Controls->syntheticNetworkComboBox->insertItem(1,"Heterogenic sphere");
     this->m_Controls->syntheticNetworkComboBox->insertItem(2,"Random network");
     this->m_Controls->syntheticNetworkComboBox->insertItem(3,"Scale free network");
     this->m_Controls->syntheticNetworkComboBox->insertItem(4,"Small world network");
 
     this->m_Controls->mappingStrategyComboBox->insertItem(m_ConnectomicsNetworkCreator->EndElementPosition, "Use label of end position of fibers");
     this->m_Controls->mappingStrategyComboBox->insertItem(m_ConnectomicsNetworkCreator->EndElementPositionAvoidingWhiteMatter, "Extrapolate label");
     this->m_Controls->mappingStrategyComboBox->insertItem(m_ConnectomicsNetworkCreator->JustEndPointVerticesNoLabel, "Use end position of fibers, no label");
   }
 
   this->WipeDisplay();
 }
 
 
-void QmitkConnectomicsDataView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
+void QmitkConnectomicsDataView::SetFocus()
 {
-  m_MultiWidget = &stdMultiWidget;
-}
-
-
-void QmitkConnectomicsDataView::StdMultiWidgetNotAvailable()
-{
-  m_MultiWidget = NULL;
+  m_Controls->mappingStrategyComboBox->setFocus();
 }
 
 void QmitkConnectomicsDataView::WipeDisplay()
 {
   m_Controls->lblWarning->setVisible( true );
   m_Controls->inputImageOneNameLabel->setText( mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_DASH );
   m_Controls->inputImageOneNameLabel->setVisible( false );
   m_Controls->inputImageOneLabel->setVisible( false );
   m_Controls->inputImageTwoNameLabel->setText( mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_DASH );
   m_Controls->inputImageTwoNameLabel->setVisible( false );
   m_Controls->inputImageTwoLabel->setVisible( false );
 }
 
-void QmitkConnectomicsDataView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
+void QmitkConnectomicsDataView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
   this->WipeDisplay();
 
   // Valid options are either
   // 1 image (parcellation)
   //
   // 1 image (parcellation)
   // 1 fiber bundle
   //
   // 1 network
   if( nodes.size() > 2 )
   {
     return;
   }
 
   bool alreadyFiberBundleSelected( false ), alreadyImageSelected( false ), currentFormatUnknown( true );
   // iterate all selected objects, adjust warning visibility
-  for( std::vector<mitk::DataNode*>::iterator it = nodes.begin();
-       it != nodes.end();
-       ++it )
+  for (mitk::DataNode::Pointer node: nodes)
   {
-    mitk::DataNode::Pointer node = *it;
     currentFormatUnknown = true;
 
     if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
     {
       currentFormatUnknown = false;
       if( alreadyImageSelected )
       {
         this->WipeDisplay();
         return;
       }
       alreadyImageSelected = true;
       m_Controls->lblWarning->setVisible( false );
       m_Controls->inputImageOneNameLabel->setText(node->GetName().c_str());
       m_Controls->inputImageOneNameLabel->setVisible( true );
       m_Controls->inputImageOneLabel->setVisible( true );
     }
 
     if( node.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(node->GetData()) )
     {
       currentFormatUnknown = false;
       // a fiber bundle has to be in conjunction with a parcellation
       if( nodes.size() != 2 || alreadyFiberBundleSelected )
       {
         this->WipeDisplay();
         return;
       }
       alreadyFiberBundleSelected = true;
       m_Controls->lblWarning->setVisible( false );
       m_Controls->inputImageTwoNameLabel->setText(node->GetName().c_str());
       m_Controls->inputImageTwoNameLabel->setVisible( true );
       m_Controls->inputImageTwoLabel->setVisible( true );
     }
 
     { // network section
       mitk::ConnectomicsNetwork* network = dynamic_cast<mitk::ConnectomicsNetwork*>( node->GetData() );
       if( node.IsNotNull() && network )
       {
         currentFormatUnknown = false;
         if( nodes.size() != 1 )
         {
           // only valid option is a single network
           this->WipeDisplay();
           return;
         }
         m_Controls->lblWarning->setVisible( false );
         m_Controls->inputImageOneNameLabel->setText(node->GetName().c_str());
         m_Controls->inputImageOneNameLabel->setVisible( true );
         m_Controls->inputImageOneLabel->setVisible( true );
       }
     } // end network section
 
     if ( currentFormatUnknown )
     {
       this->WipeDisplay();
       return;
     }
   } // end for loop
 }
 
 void QmitkConnectomicsDataView::OnSyntheticNetworkComboBoxCurrentIndexChanged(int currentIndex)
 {
   m_currentIndex = currentIndex;
 
     switch (m_currentIndex) {
   case 0:
     this->m_Controls->parameterOneLabel->setText( "Nodes per side" );
     this->m_Controls->parameterTwoLabel->setText( "Internode distance" );
     this->m_Controls->parameterOneSpinBox->setEnabled( true );
     this->m_Controls->parameterOneSpinBox->setValue( 5 );
     this->m_Controls->parameterTwoDoubleSpinBox->setEnabled( true );
     this->m_Controls->parameterTwoDoubleSpinBox->setMaximum( 999.999 );
     this->m_Controls->parameterTwoDoubleSpinBox->setValue( 10.0 );
     break;
   case 1:
     this->m_Controls->parameterOneLabel->setText( "Number of nodes" );
     this->m_Controls->parameterTwoLabel->setText( "Radius" );
     this->m_Controls->parameterOneSpinBox->setEnabled( true );
     this->m_Controls->parameterOneSpinBox->setValue( 1000 );
     this->m_Controls->parameterTwoDoubleSpinBox->setEnabled( true );
     this->m_Controls->parameterTwoDoubleSpinBox->setMaximum( 999.999 );
     this->m_Controls->parameterTwoDoubleSpinBox->setValue( 50.0 );
     break;
   case 2:
     this->m_Controls->parameterOneLabel->setText( "Number of nodes" );
     this->m_Controls->parameterTwoLabel->setText( "Edge percentage" );
     this->m_Controls->parameterOneSpinBox->setEnabled( true );
     this->m_Controls->parameterOneSpinBox->setValue( 100 );
     this->m_Controls->parameterTwoDoubleSpinBox->setEnabled( true );
     this->m_Controls->parameterTwoDoubleSpinBox->setMaximum( 1.0 );
     this->m_Controls->parameterTwoDoubleSpinBox->setValue( 0.5 );
     break;
   case 3:
     //GenerateSyntheticScaleFreeNetwork( network, 1000 );
     break;
   case 4:
     //GenerateSyntheticSmallWorldNetwork( network, 1000 );
     break;
   default:
     this->m_Controls->parameterOneLabel->setText( "Parameter 1" );
     this->m_Controls->parameterTwoLabel->setText( "Paramater 2" );
     this->m_Controls->parameterOneSpinBox->setEnabled( false );
     this->m_Controls->parameterOneSpinBox->setValue( 0 );
     this->m_Controls->parameterTwoDoubleSpinBox->setEnabled( false );
     this->m_Controls->parameterTwoDoubleSpinBox->setValue( 0.0 );
     }
 }
 
 void QmitkConnectomicsDataView::OnSyntheticNetworkCreationPushButtonClicked()
 {
   // warn if trying to create a very big network
   // big network is a network with > 5000 nodes (estimate)
   // this might fill up the memory to the point it freezes
   int numberOfNodes( 0 );
   switch (m_currentIndex) {
   case 0:
     numberOfNodes = this->m_Controls->parameterOneSpinBox->value()
       * this->m_Controls->parameterOneSpinBox->value()
       * this->m_Controls->parameterOneSpinBox->value();
     break;
   case 1:
     numberOfNodes = this->m_Controls->parameterOneSpinBox->value();
     break;
   case 2:
     numberOfNodes = this->m_Controls->parameterOneSpinBox->value();
     break;
   case 3:
     // not implemented yet
     break;
   case 4:
     // not implemented yet
     break;
   default:
     break;
   }
 
   if( numberOfNodes > 5000 )
   {
     QMessageBox msgBox;
     msgBox.setText("Trying to generate very large network.");
     msgBox.setIcon( QMessageBox::Warning );
     msgBox.setInformativeText("You are trying to generate a network with more than 5000 nodes, this is very resource intensive and might lead to program instability. Proceed with network generation?");
     msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
     msgBox.setDefaultButton(QMessageBox::No);
     int ret = msgBox.exec();
 
     switch (ret) {
   case QMessageBox::Yes:
     // continue
     break;
   case QMessageBox::No:
     // stop
     return;
     break;
 
   default:
     // should never be reached
     break;
     }
   }
 
   // proceed
   mitk::ConnectomicsSyntheticNetworkGenerator::Pointer generator = mitk::ConnectomicsSyntheticNetworkGenerator::New();
 
   mitk::DataNode::Pointer networkNode = mitk::DataNode::New();
   int parameterOne = this->m_Controls->parameterOneSpinBox->value();
   double parameterTwo = this->m_Controls->parameterTwoDoubleSpinBox->value();
   //add network to datastorage
   networkNode->SetData( generator->CreateSyntheticNetwork( m_currentIndex, parameterOne, parameterTwo ) );
   networkNode->SetName( mitk::ConnectomicsConstantsManager::CONNECTOMICS_PROPERTY_DEFAULT_CNF_NAME );
   if( generator->WasGenerationSuccessfull() )
   {
-    this->GetDefaultDataStorage()->Add( networkNode );
+    this->GetDataStorage()->Add( networkNode );
   }
   else
   {
     MITK_WARN << "Problem occured during synthetic network generation.";
   }
 
   mitk::RenderingManager::GetInstance()->InitializeViews(
     networkNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   return;
 }
 
 void QmitkConnectomicsDataView::OnNetworkifyPushButtonClicked()
 {
-  std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
+  QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if ( nodes.empty() )
   {
     QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS_CREATION, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_SELECTION_WARNING);
     return;
   }
 
   if (! ( nodes.size() == 2 ) )
   {
     QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS_CREATION, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_SELECTION_WARNING);
     return;
   }
   mitk::DataNode* firstNode = nodes.front();
   mitk::DataNode* secondNode = nodes.at(1);
 
   if (!firstNode)
   {
     // Nothing selected. Inform the user and return
     QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS_CREATION, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_SELECTION_WARNING);
     return;
   }
 
   // here we have a valid mitk::DataNode
 
   // a node itself is not very useful, we need its data item (the image)
   mitk::BaseData* firstData = firstNode->GetData();
   mitk::BaseData* secondData = secondNode->GetData();
   if (firstData && secondData)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     mitk::Image* image = dynamic_cast<mitk::Image*>( firstData );
     mitk::FiberBundle* fiberBundle = dynamic_cast<mitk::FiberBundle*>( secondData );
 
     // check whether order was switched
     if (! (image && fiberBundle) )
     {
       image = dynamic_cast<mitk::Image*>( secondData );
       fiberBundle = dynamic_cast<mitk::FiberBundle*>( firstData );
     }
 
     if (image && fiberBundle)
     {
       mitk::ConnectomicsNetworkCreator::MappingStrategy mappingStrategy =
         static_cast<mitk::ConnectomicsNetworkCreator::MappingStrategy>(this->m_Controls->mappingStrategyComboBox->currentIndex());
 
       m_ConnectomicsNetworkCreator->SetSegmentation( image );
       m_ConnectomicsNetworkCreator->SetFiberBundle( fiberBundle );
       m_ConnectomicsNetworkCreator->CalculateCenterOfMass();
       m_ConnectomicsNetworkCreator->SetEndPointSearchRadius( 15 );
       m_ConnectomicsNetworkCreator->SetMappingStrategy( mappingStrategy );
       m_ConnectomicsNetworkCreator->CreateNetworkFromFibersAndSegmentation();
       mitk::DataNode::Pointer networkNode = mitk::DataNode::New();
 
       //add network to datastorage
       networkNode->SetData( m_ConnectomicsNetworkCreator->GetNetwork() );
       networkNode->SetName( mitk::ConnectomicsConstantsManager::CONNECTOMICS_PROPERTY_DEFAULT_CNF_NAME );
-      this->GetDefaultDataStorage()->Add( networkNode );
+      this->GetDataStorage()->Add( networkNode );
     }
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkConnectomicsDataView::OnCreateCorrelationMatrixPushButtonClicked()
 {
 
-  std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
+  QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if ( nodes.empty() )
   {
     QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_FMRI_CORRELATION_SELECTION_WARNING);
     return;
   }
 
   if( nodes.size() == 1 )
   {
     mitk::DataNode* firstNode = nodes.front();
 
     if (!firstNode)
     {
       // Nothing selected. Inform the user and return
       QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_FMRI_CORRELATION_SELECTION_WARNING);
       return;
     }
 
     // here we have a valid mitk::DataNode
 
     // a node itself is not very useful, we need its data item (the image)
     mitk::BaseData* firstData = firstNode->GetData();
     if (firstData)
     {
       // test if this data item is an image or not (could also be a surface or something totally different)
       mitk::Image* image = dynamic_cast<mitk::Image*>( firstData );
       if(image && image->GetDimension() == 4)
       {
         AccessFixedDimensionByItk(image, DoWholeCorrelation, 4);
       }
     }
   }
   else if( nodes.size() == 2 )
   {
     mitk::DataNode* firstNode = nodes.front();
     mitk::DataNode* secondNode = nodes.at(1);
 
     if (!firstNode)
     {
       // Nothing selected. Inform the user and return
       QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_FMRI_CORRELATION_SELECTION_WARNING);
       return;
     }
     if (!secondNode)
     {
       // Nothing selected. Inform the user and return
       QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_FMRI_CORRELATION_SELECTION_WARNING);
       return;
     }
 
 
     // here we have a valid mitk::DataNode
 
     // a node itself is not very useful, we need its data item (the image)
     mitk::BaseData* firstData = firstNode->GetData();
     mitk::BaseData* secondData = secondNode->GetData();
     if (firstData && secondData)
     {
       // test if this data item is an image or not (could also be a surface or something totally different)
       mitk::Image* firstImage = dynamic_cast<mitk::Image*>( firstData );
       mitk::Image* secondImage = dynamic_cast<mitk::Image*>( secondData );
       if(firstImage && secondImage)
       {
         if( firstImage->GetDimension() == 4 && secondImage->GetDimension() == 3 )
         {
           AccessFixedDimensionByItk_n(firstImage, DoParcelCorrelation, 4, ( secondImage));
         }
         else if( firstImage->GetDimension() == 3 && secondImage->GetDimension() == 4 )
         {
           AccessFixedDimensionByItk_n(secondImage, DoParcelCorrelation, 4, ( firstImage));
         }
         else
         {
           QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_FMRI_CORRELATION_SELECTION_WARNING);
           return;
         }
       }
     }
   }
 }
 
 template< typename TPixel, unsigned int VImageDimension >
 void QmitkConnectomicsDataView::DoWholeCorrelation( itk::Image<TPixel, VImageDimension>* itkTimeSeriesImage )
 {
   typename mitk::CorrelationCalculator<TPixel>::Pointer correlationCalculator = mitk::CorrelationCalculator<TPixel>::New();
 
   mitk::Image::Pointer timeSeriesImage = mitk::Image::New();
   mitk::CastToMitkImage(itkTimeSeriesImage, timeSeriesImage);
 
   correlationCalculator->SetTimeSeriesImage( timeSeriesImage );
   correlationCalculator->SetParcellationImage( nullptr );
 
   correlationCalculator->DoWholeCorrelation();
   const vnl_matrix< double >* vnlmat = correlationCalculator->GetCorrelationMatrix();
   std::stringstream output;
   for(unsigned int i(0); i < (*vnlmat).rows(); ++i)
   {
     for(unsigned int j(0); j < (*vnlmat).cols(); ++j)
     {
       output << (*vnlmat)[i][j] << " ";
     }
     output << "\n";
   }
   MITK_INFO << "\n" << output.str();
 }
 
 template< typename TPixel, unsigned int VImageDimension >
 void QmitkConnectomicsDataView::DoParcelCorrelation( itk::Image<TPixel, VImageDimension>* itkTimeSeriesImage, mitk::Image::Pointer parcelImage )
 {
   typename mitk::CorrelationCalculator<TPixel>::Pointer correlationCalculator = mitk::CorrelationCalculator<TPixel>::New();
 
   mitk::Image::Pointer timeSeriesImage = mitk::Image::New();
   mitk::CastToMitkImage(itkTimeSeriesImage, timeSeriesImage);
 
   correlationCalculator->SetTimeSeriesImage( timeSeriesImage );
   correlationCalculator->SetParcellationImage( parcelImage );
 
   correlationCalculator->DoParcelCorrelation();
   mitk::DataNode::Pointer networkNode = mitk::DataNode::New();
   networkNode->SetData( correlationCalculator->GetConnectomicsNetwork() );
   networkNode->SetName("ParcelCorrelationNetwork");
-  this->GetDefaultDataStorage()->Add(networkNode);
+  this->GetDataStorage()->Add(networkNode);
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsDataView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsDataView.h
index c15011281c..55cce873d4 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsDataView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsDataView.h
@@ -1,112 +1,109 @@
 /*===================================================================
 
 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 QmitkConnectomicsDataView_h
 #define QmitkConnectomicsDataView_h
 
 #include <berryISelectionListener.h>
 
-#include <QmitkFunctionality.h>
+#include <QmitkAbstractView.h>
 
 #include "ui_QmitkConnectomicsDataViewControls.h"
 
 #include "mitkConnectomicsNetworkCreator.h"
 #include "mitkConnectomicsNetworkMapper3D.h"
 
 // ####### ITK includes #######
 #include <itkImage.h>
 
 /*!
 \brief QmitkConnectomicsDataView
 
 This view provides functionality for the generation of networks. Either from parcellation and fiber bundle or synthetically.
-
-\sa QmitkFunctionality
-\ingroup Functionalities
 */
-class QmitkConnectomicsDataView : public QmitkFunctionality
+class QmitkConnectomicsDataView : public QmitkAbstractView
 {
   // 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:
 
   static const std::string VIEW_ID;
 
   QmitkConnectomicsDataView();
   virtual ~QmitkConnectomicsDataView();
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
-  virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget) override;
-  virtual void StdMultiWidgetNotAvailable() override;
+  ///
+  /// Sets the focus to an internal widget.
+  ///
+  virtual void SetFocus() override;
 
   protected slots:
 
     /// \brief Align two images by copying the geometry
     void OnNetworkifyPushButtonClicked();
 
     /// \brief Create synthetic networks
     void OnSyntheticNetworkCreationPushButtonClicked();
 
     /// \brief Adjust parameters depending on synthetic network type
     void OnSyntheticNetworkComboBoxCurrentIndexChanged(int currentIndex);
 
     /// \brief Create #voxel x #voxel correlation matrix of a timeseries image
     void OnCreateCorrelationMatrixPushButtonClicked();
 
 protected:
 
   // ####### Functions #######
-  /// \brief called by QmitkFunctionality when DataManager's selection has changed
-  virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes ) override;
+  /// \brief called by QmitkAbstractView when DataManager's selection has changed
+  virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
   /// \brief Converts an image into a RGBA image
   template < typename TPixel, unsigned int VImageDimension >
   void TurnIntoRGBA( itk::Image<TPixel, VImageDimension>* inputImage);
 
   /// \brief Wipe display and empty statistics
   void WipeDisplay();
 
   template< typename TPixel, unsigned int VImageDimension >
   void DoWholeCorrelation( itk::Image<TPixel, VImageDimension>* itkTimeSeriesImage );
 
   template< typename TPixel, unsigned int VImageDimension >
   void DoParcelCorrelation( itk::Image<TPixel, VImageDimension>* itkTimeSeriesImage, mitk::Image::Pointer parcelImage );
 
   // ####### Variables #######
 
 
   Ui::QmitkConnectomicsDataViewControls* m_Controls;
 
-  QmitkStdMultiWidget* m_MultiWidget;
-
   mitk::ConnectomicsNetworkCreator::Pointer m_ConnectomicsNetworkCreator;
 
   mitk::ConnectomicsNetworkMapper3D::Pointer m_NetworkMapper;
 
   // Demo/Developer mode toggle
   bool m_demomode;
 
   // The selected synthetic network type
   int m_currentIndex;
 };
 
 
 
 #endif // _QMITKBRAINNETWORKANALYSISVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsNetworkOperationsView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsNetworkOperationsView.cpp
index 9e05634083..4ca7bd97ad 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsNetworkOperationsView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsNetworkOperationsView.cpp
@@ -1,587 +1,564 @@
 /*===================================================================
 
 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 includes #######
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // ####### Qmitk includes #######
 #include "QmitkConnectomicsNetworkOperationsView.h"
-#include "QmitkStdMultiWidget.h"
 
 // ####### Qt includes #######
 #include <QMessageBox>
 
 // ####### ITK includes #######
 #include <itkRGBAPixel.h>
 
 // ####### MITK includes #######
 
 #include <mitkConnectomicsConstantsManager.h>
 #include "mitkConnectomicsSimulatedAnnealingManager.h"
 #include "mitkConnectomicsSimulatedAnnealingPermutationModularity.h"
 #include "mitkConnectomicsSimulatedAnnealingCostFunctionModularity.h"
 #include <itkConnectomicsNetworkToConnectivityMatrixImageFilter.h>
 #include <mitkConnectomicsNetworkThresholder.h>
 #include <mitkFreeSurferParcellationTranslator.h>
 #include <mitkRenderingModeProperty.h>
 
 // Includes for image casting between ITK and MITK
 #include "mitkImageCast.h"
 #include "mitkITKImageImport.h"
 #include "mitkImageAccessByItk.h"
 
 const std::string QmitkConnectomicsNetworkOperationsView::VIEW_ID = "org.mitk.views.connectomicsnetworkoperations";
 
 QmitkConnectomicsNetworkOperationsView::QmitkConnectomicsNetworkOperationsView()
-: QmitkFunctionality()
+: QmitkAbstractView()
 , m_Controls( 0 )
-, m_MultiWidget( NULL )
 , m_demomode( false )
 , m_currentIndex( 0 )
 {
 }
 
 QmitkConnectomicsNetworkOperationsView::~QmitkConnectomicsNetworkOperationsView()
 {
 }
 
 
 void QmitkConnectomicsNetworkOperationsView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkConnectomicsNetworkOperationsViewControls;
     m_Controls->setupUi( parent );
 
     QObject::connect( m_Controls->convertToRGBAImagePushButton, SIGNAL(clicked()), this, SLOT(OnConvertToRGBAImagePushButtonClicked()) );
     QObject::connect( m_Controls->assignFreeSurferColorsPushButton, SIGNAL(clicked()), this, SLOT(OnAssignFreeSurferColorsPushButtonClicked()) );
     QObject::connect( (QObject*)( m_Controls->modularizePushButton ), SIGNAL(clicked()),  this, SLOT(OnModularizePushButtonClicked()) );
     QObject::connect( (QObject*)( m_Controls->prunePushButton ), SIGNAL(clicked()),  this, SLOT(OnPrunePushButtonClicked()) );
     QObject::connect( (QObject*)( m_Controls->createConnectivityMatrixImagePushButton ), SIGNAL(clicked()),  this, SLOT(OnCreateConnectivityMatrixImagePushButtonClicked()) );
   }
 
   // GUI is different for developer and demo mode
   m_demomode = true;
   if( m_demomode )
   {
     this->m_Controls->convertToRGBAImagePushButton->show();
     this->m_Controls->assignFreeSurferColorsPushButton->show();
     this->m_Controls->modularizePushButton->hide();
     this->m_Controls->pruneOptionsGroupBox->show();
   }
   else
   {
     this->m_Controls->convertToRGBAImagePushButton->show();
     this->m_Controls->assignFreeSurferColorsPushButton->show();
     this->m_Controls->modularizePushButton->show();
     this->m_Controls->pruneOptionsGroupBox->show();
   }
 
   this->WipeDisplay();
 }
 
 
-void QmitkConnectomicsNetworkOperationsView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
+void QmitkConnectomicsNetworkOperationsView::SetFocus()
 {
-  m_MultiWidget = &stdMultiWidget;
-}
-
-
-void QmitkConnectomicsNetworkOperationsView::StdMultiWidgetNotAvailable()
-{
-  m_MultiWidget = NULL;
+  m_Controls->convertToRGBAImagePushButton->setFocus();
 }
 
 void QmitkConnectomicsNetworkOperationsView::WipeDisplay()
 {
   m_Controls->lblWarning->setVisible( true );
   m_Controls->inputImageOneNameLabel->setText( mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_DASH );
   m_Controls->inputImageOneNameLabel->setVisible( false );
   m_Controls->inputImageOneLabel->setVisible( false );
 }
 
-void QmitkConnectomicsNetworkOperationsView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
+void QmitkConnectomicsNetworkOperationsView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
   this->WipeDisplay();
 
   // Valid options are either
   if( nodes.size() > 2 )
   {
     return;
   }
 
   bool currentFormatUnknown(true), alreadyImageSelected(false);
 
   // iterate all selected objects, adjust warning visibility
-  for( std::vector<mitk::DataNode*>::iterator it = nodes.begin();
-       it != nodes.end();
-       ++it )
+  for (mitk::DataNode::Pointer node: nodes)
   {
-    mitk::DataNode::Pointer node = *it;
     currentFormatUnknown = true;
 
     if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
     {
       currentFormatUnknown = false;
       if( alreadyImageSelected )
       {
         this->WipeDisplay();
         return;
       }
       alreadyImageSelected = true;
       m_Controls->lblWarning->setVisible( false );
       m_Controls->inputImageOneNameLabel->setText(node->GetName().c_str());
       m_Controls->inputImageOneNameLabel->setVisible( true );
       m_Controls->inputImageOneLabel->setVisible( true );
     }
 
     if( node.IsNotNull() )
     { // network section
       mitk::ConnectomicsNetwork* network = dynamic_cast<mitk::ConnectomicsNetwork*>( node->GetData() );
       if( network )
       {
         currentFormatUnknown = false;
         if( nodes.size() != 1 )
         {
           // only valid option is a single network
           this->WipeDisplay();
           return;
         }
         m_Controls->lblWarning->setVisible( false );
         m_Controls->inputImageOneNameLabel->setText(node->GetName().c_str());
         m_Controls->inputImageOneNameLabel->setVisible( true );
         m_Controls->inputImageOneLabel->setVisible( true );
 
       }
     } // end network section
 
     if ( currentFormatUnknown )
     {
       this->WipeDisplay();
       return;
     }
   } // end for loop
 }
 
 void QmitkConnectomicsNetworkOperationsView::OnConvertToRGBAImagePushButtonClicked()
 {
-  std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
+  QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if (nodes.empty()) return;
 
   mitk::DataNode* node = nodes.front();
 
   if (!node)
   {
     // Nothing selected. Inform the user and return
     QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_ONLY_PARCELLATION_SELECTION_WARNING);
     return;
   }
 
   // here we have a valid mitk::DataNode
 
   // a node itself is not very useful, we need its data item (the image)
   mitk::BaseData* data = node->GetData();
   if (data)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     mitk::Image* image = dynamic_cast<mitk::Image*>( data );
     if (image)
     {
       std::stringstream message;
       std::string name;
       message << mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_PERFORMING_IMAGE_PROCESSING_FOR_IMAGE;
       if (node->GetName(name))
       {
         // a property called "name" was found for this DataNode
         message << "'" << name << "'";
       }
       message << ".";
       MITK_INFO << message.str();
 
       // Convert to RGBA
       AccessByItk( image, TurnIntoRGBA );
-      this->GetDefaultDataStorage()->GetNamedNode( mitk::ConnectomicsConstantsManager::CONNECTOMICS_PROPERTY_DEFAULT_RGBA_NAME )->GetData()->SetGeometry( node->GetData()->GetGeometry() );
+      this->GetDataStorage()->GetNamedNode( mitk::ConnectomicsConstantsManager::CONNECTOMICS_PROPERTY_DEFAULT_RGBA_NAME )->GetData()->SetGeometry( node->GetData()->GetGeometry() );
 
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
     else
     {
       QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_ONLY_PARCELLATION_SELECTION_WARNING);
       return;
     }
   }
   else
   {
     QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_ONLY_PARCELLATION_SELECTION_WARNING);
     return;
   }
 }
 
 void QmitkConnectomicsNetworkOperationsView::OnAssignFreeSurferColorsPushButtonClicked()
 {
-  std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
+  QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if (nodes.empty()) return;
 
   mitk::DataNode* node = nodes.front();
 
   if (!node)
   {
     // Nothing selected. Inform the user and return
     QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_ONLY_PARCELLATION_SELECTION_WARNING);
     return;
   }
 
   // here we have a valid mitk::DataNode
 
   // a node itself is not very useful, we need its data item (the image)
   mitk::BaseData* data = node->GetData();
   if (data)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     mitk::Image* image = dynamic_cast<mitk::Image*>( data );
     if (image)
     {
       std::stringstream message;
       std::string name;
       message << mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_PERFORMING_IMAGE_PROCESSING_FOR_IMAGE;
       if (node->GetName(name))
       {
         // a property called "name" was found for this DataNode
         message << "'" << name << "'";
       }
       message << ".";
       MITK_INFO << message.str();
 
       // Convert to RGBA
       AssignFreeSurferColors( node );
 
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
     else
     {
       QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_ONLY_PARCELLATION_SELECTION_WARNING);
       return;
     }
   }
   else
   {
     QMessageBox::information( NULL, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_CONNECTOMICS, mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_ONLY_PARCELLATION_SELECTION_WARNING);
     return;
   }
 }
 
 void QmitkConnectomicsNetworkOperationsView::AssignFreeSurferColors( mitk::DataNode::Pointer node )
 {
   mitk::FreeSurferParcellationTranslator::Pointer translator = mitk::FreeSurferParcellationTranslator::New();
   //translator->AssignLookupTable(node);
   translator->AssignTransferFunction(node);
   node->SetProperty("Image Rendering.Mode", mitk::RenderingModeProperty::New(mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR));
 }
 
 template < typename TPixel, unsigned int VImageDimension >
 void QmitkConnectomicsNetworkOperationsView::TurnIntoRGBA( itk::Image<TPixel, VImageDimension>* inputImage)
 {
   typedef itk::RGBAPixel< unsigned char >               RGBAPixelType;
   typedef itk::Image< TPixel, VImageDimension >         TemplateImageType;
   typedef itk::Image< RGBAPixelType, VImageDimension >  RGBAImageType;
 
   itk::ImageRegionIterator<TemplateImageType> it_inputImage(inputImage, inputImage->GetLargestPossibleRegion());
 
   TPixel minimumValue, maximumValue;
 
   it_inputImage.GoToBegin();
   maximumValue = minimumValue = it_inputImage.Value();
 
   for(it_inputImage.GoToBegin(); !it_inputImage.IsAtEnd(); ++it_inputImage)
   {
     if ( it_inputImage.Value() < minimumValue )
     {
       minimumValue = it_inputImage.Value();
     }
     else
     {
       if ( it_inputImage.Value() > maximumValue )
       {
         maximumValue = it_inputImage.Value();
       }
     }
   }
 
   int range = int ( maximumValue - minimumValue ); //needs to be castable to int
   int offset = int ( minimumValue );
 
   if ( range < 0 ) //error
   {
     return;
   }
 
   std::vector< unsigned int > histogram;
   histogram.resize( range + 1, 0 );
 
   for(it_inputImage.GoToBegin(); !it_inputImage.IsAtEnd(); ++it_inputImage)
   {
     histogram[ int ( it_inputImage.Value() ) - offset ] += 1;
   }
 
   int gapCounter = 0; //this variable will be used to count the empty labels
 
   //stores how much has to be subtracted from the image to remove gaps
   std::vector< TPixel > subtractionStorage;
   subtractionStorage.resize( range + 1, 0 );
 
   for( int index = 0; index <= range; index++ )
   {
     if( histogram[ index ] == 0 )
     {
       gapCounter++; //if the label is empty, increase gapCounter
     }
     else
     {
       subtractionStorage[ index ] = TPixel ( gapCounter );
     }
   }
 
   //remove gaps from label image
   //for(it_inputImage.GoToBegin(); !it_inputImage.IsAtEnd(); ++it_inputImage)
   //{
   //  it_inputImage.Value() = it_inputImage.Value() - subtractionStorage[int ( it_inputImage.Value() ) - offset ];
   //}
 
   // create colour vector
   std::vector< RGBAPixelType > lookupTable;
 
   {
     RGBAPixelType backgroundColour;
     for( int elementIndex = 0; elementIndex < 4; ++elementIndex )
     {
       backgroundColour.SetElement( elementIndex, 0 );
     }
 
     lookupTable.push_back( backgroundColour );
 
     for(int colourNumber = 0; colourNumber < range ; ++colourNumber)
     {
       RGBAPixelType colour;
       for( int elementIndex = 0; elementIndex < 3; ++elementIndex )
       {
         colour.SetElement( elementIndex, rand() % 256 );
       }
       colour.SetAlpha( 255 );
       lookupTable.push_back( colour );
     }
   }
 
   // create RGBA image
   typename RGBAImageType::Pointer rgbaImage = RGBAImageType::New();
 
   rgbaImage->SetRegions(inputImage->GetLargestPossibleRegion().GetSize());
   rgbaImage->SetSpacing(inputImage->GetSpacing());
   rgbaImage->SetOrigin(inputImage->GetOrigin());
   rgbaImage->Allocate();
 
   //fill with appropriate colours
   itk::ImageRegionIterator<RGBAImageType> it_rgbaImage(rgbaImage, rgbaImage->GetLargestPossibleRegion());
 
   for(it_inputImage.GoToBegin(), it_rgbaImage.GoToBegin(); !it_inputImage.IsAtEnd(); ++it_inputImage, ++it_rgbaImage)
   {
     it_rgbaImage.Value() = lookupTable[ int ( it_inputImage.Value() - subtractionStorage[int ( it_inputImage.Value() ) - offset ] ) - offset ];
   }
 
   mitk::Image::Pointer mitkRGBAImage = mitk::ImportItkImage( rgbaImage )->Clone();
 
   mitk::DataNode::Pointer rgbaImageNode = mitk::DataNode::New();
   rgbaImageNode->SetData(mitkRGBAImage);
   rgbaImageNode->SetProperty(mitk::ConnectomicsConstantsManager::CONNECTOMICS_PROPERTY_NAME, mitk::StringProperty::New(mitk::ConnectomicsConstantsManager::CONNECTOMICS_PROPERTY_DEFAULT_RGBA_NAME));
   rgbaImageNode->SetBoolProperty( mitk::ConnectomicsConstantsManager::CONNECTOMICS_PROPERTY_VOLUMERENDERING, true);
-  this->GetDefaultDataStorage()->Add( rgbaImageNode );
+  this->GetDataStorage()->Add( rgbaImageNode );
 }
 
 void QmitkConnectomicsNetworkOperationsView::OnModularizePushButtonClicked()
 {
-  std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
+  QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if ( nodes.empty() )
   {
     QMessageBox::information( NULL, "Modularization calculation", "Please select exactly one network.");
     return;
   }
 
-  for( std::vector<mitk::DataNode*>::iterator it = nodes.begin();
-    it != nodes.end();
-    ++it )
+  for (auto node: nodes)
   {
-    mitk::DataNode::Pointer node = *it;
-
     if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
     {
       return;
     }
 
     {
       mitk::ConnectomicsNetwork* network = dynamic_cast<mitk::ConnectomicsNetwork*>( node->GetData() );
       if( node.IsNotNull() && network )
       {
 
         typedef mitk::ConnectomicsSimulatedAnnealingPermutationModularity::ToModuleMapType MappingType;
 
         int depthOfModuleRecursive( 2 );
         double startTemperature( 2.0 );
         double stepSize( 4.0 );
 
         mitk::ConnectomicsNetwork::Pointer connectomicsNetwork( network );
         mitk::ConnectomicsSimulatedAnnealingManager::Pointer manager = mitk::ConnectomicsSimulatedAnnealingManager::New();
         mitk::ConnectomicsSimulatedAnnealingPermutationModularity::Pointer permutation = mitk::ConnectomicsSimulatedAnnealingPermutationModularity::New();
         mitk::ConnectomicsSimulatedAnnealingCostFunctionModularity::Pointer costFunction = mitk::ConnectomicsSimulatedAnnealingCostFunctionModularity::New();
 
         permutation->SetCostFunction( costFunction.GetPointer() );
         permutation->SetNetwork( connectomicsNetwork );
         permutation->SetDepth( depthOfModuleRecursive );
         permutation->SetStepSize( stepSize );
 
         manager->SetPermutation( permutation.GetPointer() );
 
         manager->RunSimulatedAnnealing( startTemperature, stepSize );
 
         MappingType mapping = permutation->GetMapping();
 
         MappingType::iterator iter = mapping.begin();
         MappingType::iterator end =  mapping.end();
 
         while( iter != end )
         {
           MBI_DEBUG << "Vertex " << iter->first << " belongs to module " << iter->second ;
           MBI_INFO << "Vertex " << iter->first << " belongs to module " << iter->second ;
           iter++;
         }
 
         MBI_DEBUG << "Overall number of modules is " << permutation->getNumberOfModules( &mapping ) ;
         MBI_DEBUG << "Cost is " << costFunction->Evaluate( network, &mapping ) ;
         MBI_INFO << "Overall number of modules is " << permutation->getNumberOfModules( &mapping ) ;
         MBI_INFO << "Cost is " << costFunction->Evaluate( network, &mapping ) ;
 
         return;
       }
     }
   }
 
 }
 
 void QmitkConnectomicsNetworkOperationsView::OnPrunePushButtonClicked()
 {
-  std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
+  QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if ( nodes.empty() )
   {
     QMessageBox::information( NULL, "Network pruning", "Please select one or more networks.");
     return;
   }
 
-  for( std::vector<mitk::DataNode*>::iterator it = nodes.begin();
-    it != nodes.end();
-    ++it )
+  for (auto node: nodes)
   {
-    mitk::DataNode::Pointer node = *it;
-
     if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
     {
       return;
     }
 
     {
       mitk::ConnectomicsNetwork* network = dynamic_cast<mitk::ConnectomicsNetwork*>( node->GetData() );
 
       if( node.IsNotNull() && network )
       {
         mitk::ConnectomicsNetworkThresholder::Pointer thresholder = mitk::ConnectomicsNetworkThresholder::New();
         thresholder->SetNetwork( network );
         thresholder->SetTargetThreshold( this->m_Controls->targetThresholdSpinBox->value() );
         thresholder->SetTargetDensity( this->m_Controls->densityThresholdDoubleSpinBox->value() );
 
         if( this->m_Controls->thresholdBasedThresholdingCheckBox->isChecked() )
         {
           thresholder->SetThresholdingScheme( mitk::ConnectomicsNetworkThresholder::ThresholdBased );
 
           mitk::DataNode::Pointer thresholdBasedNode = mitk::DataNode::New();
           thresholdBasedNode->SetData ( thresholder->GetThresholdedNetwork() );
           thresholdBasedNode->SetName( "Threshold based" );
-          this->GetDefaultDataStorage()->Add(thresholdBasedNode, node );
+          this->GetDataStorage()->Add(thresholdBasedNode, node );
         }
 
         if( this->m_Controls->largestDensityLowerThanCheckBox->isChecked() )
         {
           thresholder->SetThresholdingScheme( mitk::ConnectomicsNetworkThresholder::LargestLowerThanDensity );
 
           mitk::DataNode::Pointer thresholdBasedNode = mitk::DataNode::New();
           thresholdBasedNode->SetData ( thresholder->GetThresholdedNetwork() );
           thresholdBasedNode->SetName( "Largest density below threshold" );
-          this->GetDefaultDataStorage()->Add(thresholdBasedNode, node );
+          this->GetDataStorage()->Add(thresholdBasedNode, node );
         }
 
         if( this->m_Controls->RandomRemovalThresholdingCheckBox->isChecked() )
         {
           thresholder->SetThresholdingScheme( mitk::ConnectomicsNetworkThresholder::RandomRemovalOfWeakest );
 
           mitk::DataNode::Pointer thresholdBasedNode = mitk::DataNode::New();
           thresholdBasedNode->SetData ( thresholder->GetThresholdedNetwork() );
           thresholdBasedNode->SetName( "Random removal threshold" );
-          this->GetDefaultDataStorage()->Add(thresholdBasedNode, node );
+          this->GetDataStorage()->Add(thresholdBasedNode, node );
         }
       }
     }
   }
 }
 
 
 void QmitkConnectomicsNetworkOperationsView::OnCreateConnectivityMatrixImagePushButtonClicked()
 {
-  std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
+  QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if ( nodes.empty() )
   {
     QMessageBox::information( NULL, "Connectivity Matrix Image creation", "Please select one or more networks.");
     return;
   }
 
-  for( std::vector<mitk::DataNode*>::iterator it = nodes.begin();
-    it != nodes.end();
-    ++it )
+  for (auto node: nodes)
   {
-    mitk::DataNode::Pointer node = *it;
-
     if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
     {
       return;
     }
 
     {
       mitk::ConnectomicsNetwork* network = dynamic_cast<mitk::ConnectomicsNetwork*>( node->GetData() );
       if( node.IsNotNull() && network )
       {
         itk::ConnectomicsNetworkToConnectivityMatrixImageFilter::Pointer filter = itk::ConnectomicsNetworkToConnectivityMatrixImageFilter::New();
         filter->SetInputNetwork( network );
         filter->SetBinaryConnectivity(m_Controls->binaryCheckBox->isChecked());
         filter->SetRescaleConnectivity(m_Controls->rescaleCheckBox->isChecked());
         filter->Update();
 
         mitk::Image::Pointer connectivityMatrixImage = mitk::ImportItkImage( filter->GetOutput())->Clone();
         mitk::DataNode::Pointer connectivityMatrixImageNode = mitk::DataNode::New();
         connectivityMatrixImageNode->SetData ( connectivityMatrixImage );
         connectivityMatrixImageNode->SetName( "Connectivity matrix" );
-        this->GetDefaultDataStorage()->Add(connectivityMatrixImageNode, node );
+        this->GetDataStorage()->Add(connectivityMatrixImageNode, node );
       }
     }
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsNetworkOperationsView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsNetworkOperationsView.h
index dfc16f2c31..08b3655ad2 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsNetworkOperationsView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsNetworkOperationsView.h
@@ -1,110 +1,107 @@
 /*===================================================================
 
 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 QmitkConnectomicsNetworkOperationsView_h
 #define QmitkConnectomicsNetworkOperationsView_h
 
 #include <berryISelectionListener.h>
 
-#include <QmitkFunctionality.h>
+#include <QmitkAbstractView.h>
 
 #include "ui_QmitkConnectomicsNetworkOperationsViewControls.h"
 
 #include "mitkConnectomicsNetworkMapper3D.h"
 
 // ####### ITK includes #######
 #include <itkImage.h>
 
 /*!
 \brief QmitkConnectomicsNetworkOperationsView
 
 This bundle provides GUI for the brain network analysis algorithms.
-
-\sa QmitkFunctionality
-\ingroup Functionalities
 */
-class QmitkConnectomicsNetworkOperationsView : public QmitkFunctionality
+class QmitkConnectomicsNetworkOperationsView : public QmitkAbstractView
 {
   // 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:
 
   static const std::string VIEW_ID;
 
   QmitkConnectomicsNetworkOperationsView();
   virtual ~QmitkConnectomicsNetworkOperationsView();
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
-  virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget) override;
-  virtual void StdMultiWidgetNotAvailable() override;
+  ///
+  /// Sets the focus to an internal widget.
+  ///
+  virtual void SetFocus() override;
 
   protected slots:
 
     /// \brief Called when the user clicks the GUI button
     void OnConvertToRGBAImagePushButtonClicked();
 
     /// \brief Called when the user clicks the GUI button
     void OnAssignFreeSurferColorsPushButtonClicked();
 
     /// \brief Create modularization of network
     void OnModularizePushButtonClicked();
 
     /// \brief Prune network
     void OnPrunePushButtonClicked();
 
     /// \brief Create 2D Connecivity Matrix image from network
     void OnCreateConnectivityMatrixImagePushButtonClicked();
 
 protected:
 
   // ####### Functions #######
-  /// \brief called by QmitkFunctionality when DataManager's selection has changed
-  virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes ) override;
+  /// \brief called by QmitkAbstractView when DataManager's selection has changed
+  virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
   /// \brief Converts an image into a RGBA image
   template < typename TPixel, unsigned int VImageDimension >
   void TurnIntoRGBA( itk::Image<TPixel, VImageDimension>* inputImage);
 
   /// \brief Assigns an image the Freesurfer LUT
   void AssignFreeSurferColors( mitk::DataNode::Pointer node );
 
   /// \brief Wipe display and empty statistics
   void WipeDisplay();
 
 
   // ####### Variables #######
 
 
   Ui::QmitkConnectomicsNetworkOperationsViewControls* m_Controls;
 
-  QmitkStdMultiWidget* m_MultiWidget;
-
   mitk::ConnectomicsNetworkMapper3D::Pointer m_NetworkMapper;
 
   // Demo/Developer mode toggle
   bool m_demomode;
 
   // The selected synthetic network type
   int m_currentIndex;
 };
 
 
 
 #endif // _QMITKBRAINNETWORKANALYSISVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsStatisticsView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsStatisticsView.cpp
index ce40779dd0..c9a5fcf462 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsStatisticsView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsStatisticsView.cpp
@@ -1,262 +1,256 @@
 /*===================================================================
 
 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 includes #######
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // ####### Qmitk includes #######
 #include "QmitkConnectomicsStatisticsView.h"
-#include "QmitkStdMultiWidget.h"
 
 // ####### Qt includes #######
 #include <QMessageBox>
 #include <QStringList>
 
 // ####### ITK includes #######
 #include <itkRGBAPixel.h>
 
 // ####### MITK includes #######
 #include <mbilog.h>
 #include <mitkConnectomicsConstantsManager.h>
 #include <mitkConnectomicsStatisticsCalculator.h>
 #include <mitkConnectomicsRenderingProperties.h>
 
 // Includes for image casting between ITK and MITK
 #include "mitkImageCast.h"
 #include "mitkITKImageImport.h"
 #include "mitkImageAccessByItk.h"
 
 #include <string>
 
 const std::string QmitkConnectomicsStatisticsView::VIEW_ID = "org.mitk.views.connectomicsstatistics";
 
 QmitkConnectomicsStatisticsView::QmitkConnectomicsStatisticsView()
-: QmitkFunctionality()
+: QmitkAbstractView()
 , m_Controls( nullptr )
-, m_MultiWidget( nullptr )
 {
 }
 
 QmitkConnectomicsStatisticsView::~QmitkConnectomicsStatisticsView()
 {
 }
 
 void QmitkConnectomicsStatisticsView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {// create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkConnectomicsStatisticsViewControls;
     m_Controls-> setupUi( parent );
     connect( m_Controls-> networkBalloonsNodeLabelsComboBox, SIGNAL( currentIndexChanged( int ) ),
              this, SLOT( OnNetworkBalloonsNodeLabelsComboBoxCurrentIndexChanged( ) ) );
   }
   this-> WipeDisplay();
 }
 
-void QmitkConnectomicsStatisticsView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
+void QmitkConnectomicsStatisticsView::SetFocus()
 {
-  m_MultiWidget = &stdMultiWidget;
-}
-
-void QmitkConnectomicsStatisticsView::StdMultiWidgetNotAvailable()
-{
-  m_MultiWidget = nullptr;
+  m_Controls->networkStatisticsPlainTextEdit->setFocus();
 }
 
 void QmitkConnectomicsStatisticsView::WipeDisplay()
 {
   m_Controls->lblWarning->setVisible( true );
   m_Controls->inputImageOneNameLabel->setText( mitk::ConnectomicsConstantsManager::CONNECTOMICS_GUI_DASH );
   m_Controls->inputImageOneNameLabel->setVisible( false );
   m_Controls->inputImageOneLabel->setVisible( false );
   m_Controls->networkStatisticsPlainTextEdit->clear();
   m_Controls->betweennessNetworkHistogramCanvas->SetHistogram(  nullptr );
   m_Controls->degreeNetworkHistogramCanvas->SetHistogram(       nullptr );
   m_Controls->shortestPathNetworkHistogramCanvas->SetHistogram( nullptr );
   m_Controls->betweennessNetworkHistogramCanvas->update();
   m_Controls->degreeNetworkHistogramCanvas->update();
   m_Controls->shortestPathNetworkHistogramCanvas->update();
   m_Controls->betweennessNetworkHistogramCanvas->Clear();
   m_Controls->degreeNetworkHistogramCanvas->Clear();
   m_Controls->shortestPathNetworkHistogramCanvas->Clear();
   m_Controls->betweennessNetworkHistogramCanvas->Replot();
   m_Controls->degreeNetworkHistogramCanvas->Replot();
   m_Controls->shortestPathNetworkHistogramCanvas->Replot();
   m_Controls-> networkBalloonsNodeLabelsComboBox-> QComboBox::clear();
   m_Controls-> networkBalloonsPlainTextEdit-> clear();
 }
 
 void QmitkConnectomicsStatisticsView::OnNetworkBalloonsNodeLabelsComboBoxCurrentIndexChanged( )
 {
-  std::vector<mitk::DataNode*> nodes = this-> GetDataManagerSelection();
+  QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
 
   if( nodes.size() != 1 ) { return; }
 
   mitk::DataNode::Pointer node = *nodes.begin();
 
   if( node.IsNotNull() )
     {
     mitk::ConnectomicsNetwork* network =
       dynamic_cast< mitk::ConnectomicsNetwork* >( node-> GetData() );
 
     if( network )
       {
       std::string tempCurrentText = m_Controls-> networkBalloonsNodeLabelsComboBox->
         QComboBox::currentText().toStdString(); // get text of currently selected item.
 
       if( tempCurrentText.size() > 3 && tempCurrentText.rfind( ":" ) != tempCurrentText.npos )
       { // update chosenNode property.
         tempCurrentText = tempCurrentText.substr( tempCurrentText.rfind( ":" ) + 2 );
         node-> SetProperty( mitk::connectomicsRenderingNodeChosenNodeName.c_str(),
                             mitk::StringProperty::New( tempCurrentText.c_str() ) );
-        this-> m_MultiWidget-> ForceImmediateUpdate(); //RequestUpdate() is too slow.
+        auto renderWindowPart = this->GetRenderWindowPart();
+        if (renderWindowPart)
+        {
+          renderWindowPart->ForceImmediateUpdate(); //RequestUpdate() is too slow.
+        }
       }
 
       std::stringstream balloonTextStream;
       node-> Update();
 
       if( node-> GetProperty( mitk::connectomicsRenderingBalloonTextName.c_str() ) != nullptr &&
           node-> GetProperty( mitk::connectomicsRenderingBalloonNodeStatsName.c_str() ) != nullptr &&
           tempCurrentText != "-1" )
       {
         balloonTextStream << node-> GetProperty( mitk::connectomicsRenderingBalloonTextName.c_str() )
                              -> GetValueAsString()
                           << node-> GetProperty( mitk::connectomicsRenderingBalloonNodeStatsName.c_str() )
                              -> GetValueAsString() << std::endl;
         QString balloonQString ( balloonTextStream.str().c_str() );
         // setPlainText() overwrites, insertPlainText() appends.
         m_Controls-> networkBalloonsPlainTextEdit-> setPlainText( balloonQString );
       }
       if( tempCurrentText == "-1" )
       {
         m_Controls-> networkBalloonsPlainTextEdit-> setPlainText( "" );
       }
     }
   }
   return;
 }
 
-void QmitkConnectomicsStatisticsView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
+void QmitkConnectomicsStatisticsView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
   this->WipeDisplay();
 
   // Valid options are either
   // 1 image (parcellation)
   //
   // 1 image (parcellation)
   // 1 fiber bundle
   //
   // 1 network
   if( nodes.size() > 2 )
   {
     return;
   }
 
   bool currentFormatUnknown(true);
 
   // iterate all selected objects, adjust warning visibility
-  for( std::vector<mitk::DataNode*>::iterator it = nodes.begin();
-       it != nodes.end();
-       ++it )
+  for (mitk::DataNode::Pointer node: nodes)
   {
-    mitk::DataNode::Pointer node = *it;
     currentFormatUnknown = true;
 
     if( node.IsNotNull()  )
     { // network section
       mitk::ConnectomicsNetwork* network = dynamic_cast<mitk::ConnectomicsNetwork*>( node->GetData() );
       if( network )
       {
         currentFormatUnknown = false;
         if( nodes.size() != 1 )
         {
           // only valid option is a single network
           this->WipeDisplay();
           return;
         }
 
         m_Controls->lblWarning->setVisible( false );
         m_Controls->inputImageOneNameLabel->setText(node->GetName().c_str());
         m_Controls->inputImageOneNameLabel->setVisible( true );
         m_Controls->inputImageOneLabel->setVisible( true );
 
         {
           std::stringstream statisticsStream;
 
           mitk::ConnectomicsStatisticsCalculator::Pointer calculator = mitk::ConnectomicsStatisticsCalculator::New();
 
           calculator->SetNetwork( network );
           calculator->Update();
 
           statisticsStream << "# Vertices: " << calculator->GetNumberOfVertices() << "\n";
           statisticsStream << "# Edges: " << calculator->GetNumberOfEdges() << "\n";
           statisticsStream << "Average Degree: " << calculator->GetAverageDegree() << "\n";
           statisticsStream << "Density: " << calculator->GetConnectionDensity() << "\n";
           statisticsStream << "Small Worldness: " << calculator->GetSmallWorldness() << "\n";
           statisticsStream << "Average Path Length: " << calculator->GetAveragePathLength() << "\n";
           statisticsStream << "Efficiency: " << (1 / calculator->GetAveragePathLength() ) << "\n";
           statisticsStream << "# Connected Components: " << calculator->GetNumberOfConnectedComponents() << "\n";
           statisticsStream << "Average Component Size: " << calculator->GetAverageComponentSize() << "\n";
           statisticsStream << "Largest Component Size: " << calculator->GetLargestComponentSize() << "\n";
           statisticsStream << "Average Clustering Coefficient: " << calculator->GetAverageClusteringCoefficientsC() << "\n";
           statisticsStream << "Average Vertex Betweenness Centrality: " << calculator->GetAverageVertexBetweennessCentrality() << "\n";
           statisticsStream << "Average Edge Betweenness Centrality: " << calculator->GetAverageEdgeBetweennessCentrality() << "\n";
           statisticsStream << "# Isolated Points: " << calculator->GetNumberOfIsolatedPoints() << "\n";
           statisticsStream << "# End Points: " << calculator->GetNumberOfEndPoints() << "\n";
           statisticsStream << "Diameter: " << calculator->GetDiameter() << "\n";
           statisticsStream << "Radius: " << calculator->GetRadius() << "\n";
           statisticsStream << "Average Eccentricity: " << calculator->GetAverageEccentricity() << "\n";
           statisticsStream << "# Central Points: " << calculator->GetNumberOfCentralPoints() << "\n";
 
           QString statisticsString( statisticsStream.str().c_str() );
           m_Controls-> networkStatisticsPlainTextEdit-> setPlainText( statisticsString );
         }
 
         mitk::ConnectomicsNetwork::Pointer connectomicsNetwork( network );
         mitk::ConnectomicsHistogramsContainer *histogramContainer = histogramCache[ connectomicsNetwork ];
         if(histogramContainer)
         {
           m_Controls->betweennessNetworkHistogramCanvas->SetHistogram(  histogramContainer->GetBetweennessHistogram() );
           m_Controls->degreeNetworkHistogramCanvas->SetHistogram(       histogramContainer->GetDegreeHistogram() );
           m_Controls->shortestPathNetworkHistogramCanvas->SetHistogram( histogramContainer->GetShortestPathHistogram() );
           m_Controls->betweennessNetworkHistogramCanvas->DrawProfiles();
           m_Controls->degreeNetworkHistogramCanvas->DrawProfiles();
           m_Controls->shortestPathNetworkHistogramCanvas->DrawProfiles();
         }
 
         // For the balloon overlay:
         if( node-> GetProperty( mitk::connectomicsRenderingBalloonAllNodeLabelsName.c_str() ) != nullptr )
           { // QComboBox with node label names and numbers.
             QString allNodesLabel = node->
                 GetProperty( mitk::connectomicsRenderingBalloonAllNodeLabelsName.c_str() )->
                 GetValueAsString().c_str();
             QStringList allNodesLabelList = allNodesLabel.simplified().split( "," );
             allNodesLabelList.sort( Qt::CaseInsensitive );
             m_Controls-> networkBalloonsNodeLabelsComboBox-> QComboBox::addItem( "no node chosen: -1" );
             m_Controls-> networkBalloonsNodeLabelsComboBox-> QComboBox::addItems( allNodesLabelList );
           }
       }
     } // end network section
 
     if ( currentFormatUnknown )
     {
       this->WipeDisplay();
       return;
     }
   } // end for loop
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsStatisticsView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsStatisticsView.h
index bd619ce73e..c216290956 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsStatisticsView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkConnectomicsStatisticsView.h
@@ -1,84 +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 QmitkConnectomicsStatisticsView_h
 #define QmitkConnectomicsStatisticsView_h
 
 #include <berryISelectionListener.h>
 
-#include <QmitkFunctionality.h>
 #include <QmitkAbstractView.h>
 
 #include "ui_QmitkConnectomicsStatisticsViewControls.h"
 
 #include "mitkConnectomicsHistogramCache.h"
 
 // ####### ITK includes #######
 #include <itkImage.h>
 
 /*!
 \brief QmitkConnectomicsStatisticsView
 
 This view provides the statistics GUI.
-
-\sa QmitkFunctionality
-\ingroup Functionalities
 */
-class QmitkConnectomicsStatisticsView : public QmitkFunctionality
+class QmitkConnectomicsStatisticsView : public QmitkAbstractView
 {
   // 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:
 
   static const std::string VIEW_ID;
 
   QmitkConnectomicsStatisticsView();
   virtual ~QmitkConnectomicsStatisticsView();
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
-  virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget) override;
-  virtual void StdMultiWidgetNotAvailable() override;
+  ///
+  /// Sets the focus to an internal widget.
+  ///
+  virtual void SetFocus() override;
 
 protected slots:
 
   void OnNetworkBalloonsNodeLabelsComboBoxCurrentIndexChanged(  );
 
 protected:
 
   // ####### Functions #######
-  /// \brief called by QmitkFunctionality when DataManager's selection has changed
-  virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes ) override;
+  /// \brief called by QmitkAbstractView when DataManager's selection has changed
+  virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
   /// \brief Wipe display and empty statistics
   void WipeDisplay();
 
 
   // ####### Variables #######
   Ui::QmitkConnectomicsStatisticsViewControls* m_Controls;
 
-  QmitkStdMultiWidget* m_MultiWidget;
-
   /// Cache for histograms
   mitk::ConnectomicsHistogramCache histogramCache;
 };
 
 
 
 #endif // _QMITKBRAINNETWORKANALYSISVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkRandomParcellationView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkRandomParcellationView.cpp
index f753714261..2992579cd7 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkRandomParcellationView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkRandomParcellationView.cpp
@@ -1,359 +1,359 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // Qmitk
 #include "QmitkRandomParcellationView.h"
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qt
 #include <QMessageBox>
 
 // Includes for image casting between ITK and MITK
 #include "mitkImageCast.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkITKImageImport.h"
 
 //To convert integer to string
 #include <stdlib.h>
 #include <sstream>
 
 //Itk Iterators
 #include <itkNeighborhoodIterator.h>
 #include <itkImageRegionIterator.h>
 
 // mitk
 #include <mitkRegionVoxelCounter.h>
 #include <mitkRandomParcellationGenerator.h>
 
 
 //Child
 const std::string QmitkRandomParcellationView::PROPERTYNAME              = "name";
 const std::string QmitkRandomParcellationView::PROPERTYOPACITY           = "opacity";
 const std::string QmitkRandomParcellationView::m_NAMEFORRANDOMVOXELIMAGE = "Random Voxel Image";
 
 const std::string QmitkRandomParcellationView::VIEW_ID = "org.mitk.views.randomparcellationview";
 
 
 void QmitkRandomParcellationView::SetFocus()
 {
   m_Controls.buttonSelectRandomNodes->setFocus();
 }
 
 void QmitkRandomParcellationView::CreateQtPartControl( QWidget *parent )
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi( parent );
   connect( m_Controls.buttonSelectRandomNodes, SIGNAL(clicked()), this, SLOT(SelectRandomNodes()) );
   connect( m_Controls.checkBoxMerging, SIGNAL(stateChanged(int)),this, SLOT(OnMergingCheckboxChanged(int)));
   connect( m_Controls.radioButtonNumberParcels, SIGNAL(clicked()), this, SLOT(OnRadioButtonNumberParcelsChanged(int)));
   connect( m_Controls.radioButtonSmallestParcel, SIGNAL(clicked()), this, SLOT(OnRadioButtonSmallestParcelChanged(int)));
 }
 
 void QmitkRandomParcellationView::OnMergingCheckboxChanged(int state)
 {
   if (m_Controls.checkBoxMerging->isChecked())
   {
     //Make the frame visible
     m_Controls.frameMerging->setEnabled(true);
     m_Controls.frameNumberParcels->setEnabled(true);
     m_Controls.frameSmallestParcel->setEnabled(true);
   }
   else
   {
     m_Controls.frameMerging->setEnabled(false);
   }
 }
 
 void QmitkRandomParcellationView::OnRadioButtonNumberParcelsChanged(int state)
 {
   if (m_Controls.radioButtonNumberParcels->isChecked())
   {
     m_Controls.frameNumberParcels->setEnabled(true);
     m_Controls.radioButtonSmallestParcel->setChecked(false);
   }
   else
   {
     m_Controls.frameNumberParcels->setEnabled(false);
   }
 }
 
 void QmitkRandomParcellationView::OnRadioButtonSmallestParcelChanged(int state)
 {
   if (m_Controls.radioButtonSmallestParcel->isChecked())
   {
     m_Controls.frameSmallestParcel->setEnabled(true);
     m_Controls.radioButtonNumberParcels->setChecked(false);
   }
   else
   {
     m_Controls.frameSmallestParcel->setEnabled(false);
   }
 }
 
-void QmitkRandomParcellationView::OnSelectionChanged(std::vector<mitk::DataNode*> nodes )
+void QmitkRandomParcellationView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
   // iterate all selected objects, adjust warning visibility
-  foreach( mitk::DataNode::Pointer node, nodes )
+  for (mitk::DataNode::Pointer node: nodes)
   {
     if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
     {
       m_Controls.labelWarning->setVisible( false );
       m_Controls.buttonSelectRandomNodes->setEnabled( true );
       mitk::Image* imageDisplay = dynamic_cast<mitk::Image*>(node->GetData());
       AccessFixedDimensionByItk(imageDisplay, ShowNumberOfVoxels, 3);
       return;
     }
   }
 
   m_Controls.labelWarning->setVisible( true );
   m_Controls.buttonSelectRandomNodes->setEnabled( false );
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void QmitkRandomParcellationView::ShowNumberOfVoxels( itk::Image<TPixel, VImageDimension> * inputImage)
 {
   typedef itk::Image< TPixel, VImageDimension > ImageType;
 
   mitk::RegionVoxelCounter<TPixel, VImageDimension> counter;
   counter.SetRegion(inputImage->GetLargestPossibleRegion());
   counter.SetImage(inputImage);
   int numberVoxelsDisplay = counter.VoxelWithValue(1);
   std::string stringDisplay = "Number of voxels with value 1: ";
   std::ostringstream convertDisplay;
   convertDisplay << numberVoxelsDisplay;
   std::string stringNumberVoxels = convertDisplay.str();
   stringDisplay += stringNumberVoxels;
   QString textNumberVoxelsDisplay = QString::fromStdString(stringDisplay);
   m_Controls.labelNumberVoxels->setText(textNumberVoxelsDisplay);
 }
 
 
 void QmitkRandomParcellationView::SelectRandomNodes()
 {
-  std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
+  QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if (nodes.empty()) return;
 
   mitk::DataNode* node = nodes.front();
 
   if (!node)
   {
     // Nothing selected. Inform the user and return
     QMessageBox::information( NULL, "No image available", "Please load and select an image before starting image processing.");
     return;
   }
 
   // here we have a valid mitk::DataNode
 
   // a node itself is not very useful, we need its data item (the image)
   mitk::BaseData* data = node->GetData();
   if (data)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     mitk::Image* image = dynamic_cast<mitk::Image*>( data );
     if (image)
     {
       //get numberNodes (number of nodes) with SpinBox
       int numberNodes( 0 );
       numberNodes = m_Controls.spinBoxNumberNodes->value();
 
       std::stringstream message;
       std::string name;
       message << "Selecting " << numberNodes << " random nodes for ";
       if (node->GetName(name))
       {
         // a property called "name" was found for this DataNode
         message << "'" << name << "'";
       }
       message << ".";
       MITK_INFO << message.str();
 
       //MITK into ITK image, function GetRandomParcels gets executed, Dimension is 3
       AccessFixedDimensionByItk(image, GetRandomParcels, 3);
 
     }
   }
 }
 
 
 
 template <typename TPixel, unsigned int VImageDimension>
 void QmitkRandomParcellationView::GetRandomParcels( itk::Image<TPixel, VImageDimension> * inputImage)
 {
   typedef itk::Image< TPixel, VImageDimension > ImageType;
   typedef itk::Image< int, VImageDimension > IntegerImageType;
 
   //new Image which will contain the parcellation
   typename IntegerImageType::Pointer voxelImage = IntegerImageType::New();
 
   voxelImage->SetRegions(inputImage->GetLargestPossibleRegion().GetSize());
   voxelImage->SetSpacing(inputImage->GetSpacing());
   voxelImage->SetOrigin(inputImage->GetOrigin());
   voxelImage->Allocate();
 
   //Voxel iterators
   itk::ImageRegionIterator<ImageType> it_inputImage(inputImage, inputImage->GetLargestPossibleRegion());
   itk::ImageRegionIterator<IntegerImageType> it_voxelImage(voxelImage, voxelImage->GetLargestPossibleRegion());
 
   //Copy the inputImage -> voxelImage
   for (it_inputImage.GoToBegin(), it_voxelImage.GoToBegin(); !it_inputImage.IsAtEnd(); ++it_inputImage, ++it_voxelImage)
   {
     it_voxelImage.Value() = it_inputImage.Value();
   }
 
   //Neighborhood Iterator
   typedef itk::NeighborhoodIterator< IntegerImageType > NeighborhoodIteratorType;
   typename NeighborhoodIteratorType::RadiusType radius;
   radius.Fill(1);
 
   //Counter for voxels with value 1
   mitk::RegionVoxelCounter<int, 3> counter;
   counter.SetImage(voxelImage);
   counter.SetRegion(voxelImage->GetLargestPossibleRegion());
 
   int numberVoxels = counter.VoxelWithValue(1);
 
   //Get numberNodes with SpinBox
   int numberNodes(0);
   numberNodes = m_Controls.spinBoxNumberNodes->value();
 
   //WARNINGS
   if (numberNodes > numberVoxels )
   {
     QMessageBox::information( NULL, "Smaller Number of Nodes", "The number of nodes is greater than the number of voxels. Please choose a smaller number!");
     return;
   }
 
   if (m_Controls.checkBoxMerging->isChecked() && m_Controls.radioButtonNumberParcels->isChecked())
   {
     int numberParcels = m_Controls.spinBoxNumberParcels->value();
     if (numberNodes<numberParcels )
     {
       QMessageBox::information( NULL, "Smaller Number of Parcels", "The number of parcels is greater than the number of nodes. Please choose a smaller number of parcels!");
       return;
     }
   }
 
   if (m_Controls.checkBoxMerging->isChecked() && m_Controls.radioButtonSmallestParcel->isChecked())
   {
     int sizeSmallestParcel = m_Controls.spinBoxSmallestParcel->value();
     if (sizeSmallestParcel > numberVoxels )
     {
       QMessageBox::information( NULL, "Smaller Size", "The size of the smallest parcel is greater than the number of voxels. Please choose a smaller size!");
       return;
     }
   }
 
   //Get a RandomParcellationGenerator to generate the parcels
   mitk::RandomParcellationGenerator<int, 3> generator;
   generator.SetImage(voxelImage);
   generator.SetNumberNodes(numberNodes);
 
   //Chooses random initial voxels, with which we can start the parcellation growth
   generator.GetRandomSeedVoxels();
   //Now we add all the voxels (which share a face with one of the voxels of a region) to a region, particular constraints have to be fulfilled
   generator.ParcelGrowthOverFaces();
   //Because of the constraints or the position of some voxels we now add voxels to the regions which just share an edge or vertex with one region
   generator.FillOverEdgeOrVertex();
   //Isolated voxels also have to be allocated to the regions
   generator.AllocateIsolatedVoxels();
 
   //Show the sizeOfRegions in the window
   MITK_DEBUG << "Without merging we get the following size of regions: " << endl;
   generator.ShowSizeOfRegions();
 
   //Check if the Merge-Buttons are chosen
   int newNumberNodes;
 
   if (m_Controls.checkBoxMerging->isChecked())
   {
     int givenSizeOfSmallestRegion(0);
     int desiredNumberOfParcels(0);
     int givenSizeOfSmallestRegionBeginning = numberVoxels;
     bool mergingWithNumberParcels(false);
     bool mergingWithSmallestParcel(false);
     bool justMergeSmallParcels(false);
 
     if (m_Controls.radioButtonSmallestParcel->isChecked() )
     {
       mergingWithSmallestParcel = true;
       givenSizeOfSmallestRegionBeginning = m_Controls.spinBoxSmallestParcel->value();
       if( m_Controls.checkBoxJustMergeSmallParcels-> isChecked() )
       {
         //Spinbox: How many voxels should the smallest parcel have?
         givenSizeOfSmallestRegion = m_Controls.spinBoxSmallestParcel->value();
         justMergeSmallParcels = true;
       }
       else
       {
         givenSizeOfSmallestRegion = numberVoxels;
       }
     }
     else if (m_Controls.radioButtonNumberParcels->isChecked())
     {
       givenSizeOfSmallestRegion = numberVoxels;
       desiredNumberOfParcels = m_Controls.spinBoxNumberParcels->value();
       mergingWithNumberParcels = true;
     }
 
     //Merge parcels according to a costfunction
     generator.SetVariablesForMerging(givenSizeOfSmallestRegion, desiredNumberOfParcels, givenSizeOfSmallestRegionBeginning);
     generator.SetBoolsForMerging(mergingWithNumberParcels, mergingWithSmallestParcel, justMergeSmallParcels);
     newNumberNodes = generator.MergeParcels();
 
     MITK_DEBUG << "After merging we get the following size of regions:" << endl;
     generator.ShowSizeOfRegions();
   }
 
   //Show NumberOfNodes on the GUI
   if (m_Controls.checkBoxMerging->isChecked()) //merging was used
   {
     ShowNumberOfNodes(newNumberNodes);
   }
   else
   {
     ShowNumberOfNodes(numberNodes);
   }
 
   //Change the values of the nodes, such that no gaps exist and the values starts with 1
   generator.SetAppropriateValues();
 
   //Get a new data node which contains the random parcellation
   mitk::Image::Pointer mitkRandomVoxelImage = mitk::GrabItkImageMemory( voxelImage );
   mitk::DataNode::Pointer newRandomVoxelImageNode = mitk::DataNode::New();
   newRandomVoxelImageNode->SetData(mitkRandomVoxelImage);
   newRandomVoxelImageNode->SetProperty(PROPERTYNAME.c_str(),
     mitk::StringProperty::New(m_NAMEFORRANDOMVOXELIMAGE));
   newRandomVoxelImageNode->SetProperty(PROPERTYOPACITY.c_str(),
     mitk::FloatProperty::New(1.0));
-  this->GetDefaultDataStorage()->Add( newRandomVoxelImageNode );
+  this->GetDataStorage()->Add( newRandomVoxelImageNode );
 
   return;
 }
 
 void QmitkRandomParcellationView::ShowNumberOfNodes(int numberNodes)
 {
   std::string string = "Number of nodes: ";
   std::string stringNumberNodes;
   std::ostringstream convert;
   convert << numberNodes;
   stringNumberNodes = convert.str();
   string += stringNumberNodes;
   QString textNumberNodes = QString::fromStdString(string);
   m_Controls.labelNumberNodes->setText(textNumberNodes);
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkRandomParcellationView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkRandomParcellationView.h
index 5517794b44..7a93554bb3 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkRandomParcellationView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/Connectomics/QmitkRandomParcellationView.h
@@ -1,101 +1,98 @@
 /*===================================================================
 
 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 RandomParcellationView_h
 #define RandomParcellationView_h
 
 #include <berryISelectionListener.h>
 
-#include <QmitkFunctionality.h>
+#include <QmitkAbstractView.h>
 
 #include "ui_QmitkRandomParcellationViewControls.h"
 
 #include <vector>
 
 #include <itkImage.h>
 
 //To use pair
 #include <utility>
 
 
 /**
 \brief QmitkRandomParcellationView for GUI Interactions
-\sa QmitkFunctionality
 \ingroup ${plugin_target}_internal
 */
-class QmitkRandomParcellationView : public QmitkFunctionality
+class QmitkRandomParcellationView : public QmitkAbstractView
 {
   Q_OBJECT
 
 public:
   static const std::string VIEW_ID;
   virtual void CreateQtPartControl(QWidget *parent) override;
 
+  virtual void SetFocus() override;
+
   /** \brief Interaction with GUI and mitkRandomParcellationGenerator to get random parcels.*/
   template <typename TPixel, unsigned int VImageDimension>
   void GetRandomParcels( itk::Image<TPixel, VImageDimension>* );
 
   /** \brief Method to set the default data storage.*/
   virtual void SetDataStorage(mitk::DataStorage* dataStorage)
   {
     m_DataStorage = dataStorage;
   }
 
   protected slots:
 
     /** \brief Called when the user clicks the GUI button*/
     void SelectRandomNodes();
 
     /** \brief Called when the user checks the GUI checkbox*/
     void OnMergingCheckboxChanged(int state);
 
     /** \brief Called when the user ckecks the GUI radio button*/
     void OnRadioButtonNumberParcelsChanged(int state);
 
     /** \brief Called when the user ckecks the GUI radio button*/
     void OnRadioButtonSmallestParcelChanged(int state);
 
 protected:
 
-  QmitkStdMultiWidget* m_MultiWidget;
-
   mitk::DataStorage* m_DataStorage;
 
   //to save an itk image
   mitk::DataNode::Pointer m_InputImageNode;
 
   /** \brief Shows the number of voxels with value one on the GUI*/
   template <typename TPixel, unsigned int VImageDimension>
   void ShowNumberOfVoxels( itk::Image<TPixel, VImageDimension> * inputImage);
 
   /** \brief Shows the number of nodes on the GUI (may have changed after merging)*/
   void ShowNumberOfNodes(int numberNodes);
 
-  virtual void SetFocus() override;
-
-  /** \brief called by QmitkFunctionality when DataManager's selection has changed*/
-  virtual void OnSelectionChanged(std::vector<mitk::DataNode*> nodes) override;
+  /** \brief called by QmitkAbstractView when DataManager's selection has changed*/
+  virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
   Ui::QmitkRandomParcellationViewControls m_Controls;
 
   static const std::string PROPERTYNAME;
   static const std::string PROPERTYOPACITY;
   static const std::string m_NAMEFORRANDOMVOXELIMAGE;
 
 };
 
 #endif // RandomParcellationView_h
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
index cd2dad1a5e..ae5a977d09 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.cpp
@@ -1,1214 +1,1188 @@
 /*===================================================================
 
 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 "QmitkControlVisualizationPropertiesView.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkDataNodeObject.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
 #include "mitkResliceMethodProperty.h"
 #include "mitkRenderingManager.h"
 
 #include "mitkTbssImage.h"
 #include "mitkPlanarFigure.h"
 #include "mitkFiberBundle.h"
 #include "QmitkDataStorageComboBox.h"
-#include "QmitkStdMultiWidget.h"
 #include "mitkPlanarFigureInteractor.h"
 #include <mitkQBallImage.h>
 #include <mitkTensorImage.h>
 #include <mitkImage.h>
 #include <mitkDiffusionPropertyHelper.h>
 #include <mitkConnectomicsNetwork.h>
 #include "usModuleRegistry.h"
 
+#include <mitkBaseRenderer.h>
 #include "mitkPlaneGeometry.h"
+#include <QmitkRenderWindow.h>
 
 #include "berryIWorkbenchWindow.h"
 #include "berryIWorkbenchPage.h"
 #include "berryISelectionService.h"
 #include "berryConstants.h"
 #include "berryPlatformUI.h"
 
 #include "itkRGBAPixel.h"
 #include <itkTractDensityImageFilter.h>
 
 #include "qwidgetaction.h"
 #include "qcolordialog.h"
 #include <QRgb>
 #include <itkMultiThreader.h>
 
 #include <ciso646>
 
 #define ROUND(a) ((a)>0 ? (int)((a)+0.5) : -(int)(0.5-(a)))
 
 const std::string QmitkControlVisualizationPropertiesView::VIEW_ID = "org.mitk.views.controlvisualizationpropertiesview";
 
 using namespace berry;
 
 QmitkControlVisualizationPropertiesView::QmitkControlVisualizationPropertiesView()
-  : QmitkFunctionality(),
+  : QmitkAbstractView(),
     m_Controls(NULL),
-    m_MultiWidget(NULL),
     m_NodeUsedForOdfVisualization(NULL),
     m_IconTexOFF(new QIcon(":/QmitkDiffusionImaging/texIntOFFIcon.png")),
     m_IconTexON(new QIcon(":/QmitkDiffusionImaging/texIntONIcon.png")),
     m_IconGlyOFF_T(new QIcon(":/QmitkDiffusionImaging/glyphsoff_T.png")),
     m_IconGlyON_T(new QIcon(":/QmitkDiffusionImaging/glyphson_T.png")),
     m_IconGlyOFF_C(new QIcon(":/QmitkDiffusionImaging/glyphsoff_C.png")),
     m_IconGlyON_C(new QIcon(":/QmitkDiffusionImaging/glyphson_C.png")),
     m_IconGlyOFF_S(new QIcon(":/QmitkDiffusionImaging/glyphsoff_S.png")),
     m_IconGlyON_S(new QIcon(":/QmitkDiffusionImaging/glyphson_S.png")),
     m_CurrentSelection(0),
     m_CurrentPickingNode(0),
     m_GlyIsOn_S(false),
     m_GlyIsOn_C(false),
     m_GlyIsOn_T(false),
     m_FiberBundleObserverTag(0),
     m_FiberBundleObserveOpacityTag(0),
     m_Color(NULL)
 {
   currentThickSlicesMode = 1;
   m_MyMenu = NULL;
   int numThread = itk::MultiThreader::GetGlobalMaximumNumberOfThreads();
   if (numThread > 12)
     numThread = 12;
   itk::MultiThreader::SetGlobalDefaultNumberOfThreads(numThread);
 }
 
 
 QmitkControlVisualizationPropertiesView::~QmitkControlVisualizationPropertiesView()
 {
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener.data());
 }
 
 
 void QmitkControlVisualizationPropertiesView::OnThickSlicesModeSelected( QAction* action )
 {
   currentThickSlicesMode = action->data().toInt();
 
   switch( currentThickSlicesMode )
   {
     case 0: // toInt() returns 0 'otherwise'.
     {
       return; // dummy code/todo: implement stuff.
       break;
     }
     case 1:
     {
       this->m_Controls->m_TSMenu->setText("MIP");
       break;
     }
     case 2:
     {
       this->m_Controls->m_TSMenu->setText("SUM");
       break;
     }
     case 3:
     {
       this->m_Controls->m_TSMenu->setText("WEIGH");
       break;
     }
     default:
     {
       return; // dummy code/todo: implement stuff.
       break;
     }
   }
 
-  if( this->m_MultiWidget )
+  if (auto renderWindowPart = this->GetRenderWindowPart(OPEN))
   {
-    mitk::DataNode* n = nullptr;
-    n = this->m_MultiWidget->GetWidgetPlane1();
-    if(n) { n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) ); }
+    /// TODO There is no way to access the individual crosshair planes through the render window part API.
+    /// There could be a new 'mitk::DataNode* mitk::ILinkedRenderWindowPart::GetSlicingPlane(const std::string& name) const'
+    /// function for this purpose. For the time being, I comment out the lines below, but they are valid
+    /// and they have to be re-enabled after the crosshair planes can be accessed again.
 
-    n = nullptr;
-    n = this->m_MultiWidget->GetWidgetPlane2();
-    if(n) { n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) ); }
+//    mitk::DataNode* n;
+//    n = renderWindowPart->GetSlicingPlane("axial");
+//    if (n) { n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) ); }
 
-    n = nullptr;
-    n = this->m_MultiWidget->GetWidgetPlane3();
-    if(n) { n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) ); }
+//    n = renderWindowPart->GetSlicingPlane("sagittal");
+//    if (n) { n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) ); }
 
+//    n = renderWindowPart->GetSlicingPlane("coronal");
+//    if (n) { n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) ); }
 
-    mitk::BaseRenderer::Pointer renderer = nullptr;
-    renderer = this->GetActiveStdMultiWidget()->GetRenderWindow1()->GetRenderer();
-    if(renderer.IsNotNull()) { renderer->SendUpdateSlice(); }
 
-    renderer = nullptr;
-    renderer = this->GetActiveStdMultiWidget()->GetRenderWindow2()->GetRenderer();
-    if(renderer.IsNotNull()) { renderer->SendUpdateSlice(); }
+    mitk::BaseRenderer::Pointer renderer;
+    renderer = renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer();
+    if (renderer.IsNotNull()) { renderer->SendUpdateSlice(); }
 
-    renderer = nullptr;
-    renderer = this->GetActiveStdMultiWidget()->GetRenderWindow3()->GetRenderer();
-    if(renderer.IsNotNull()) { renderer->SendUpdateSlice(); }
+    renderer = renderWindowPart->GetQmitkRenderWindow("sagittal")->GetRenderer();
+    if (renderer.IsNotNull()) { renderer->SendUpdateSlice(); }
+
+    renderer = renderWindowPart->GetQmitkRenderWindow("coronal")->GetRenderer();
+    if (renderer.IsNotNull()) { renderer->SendUpdateSlice(); }
 
     renderer->GetRenderingManager()->RequestUpdateAll();
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::OnTSNumChanged( int num )
 {
-  if( this->m_MultiWidget )
+  if (auto renderWindowPart = this->GetRenderWindowPart(OPEN))
   {
-    if( num==0 )
-    {
-      mitk::DataNode* n = nullptr;
-      n = this->m_MultiWidget->GetWidgetPlane1();
-      if(n)
-      {
-        n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
-        n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
-        n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) );
-      }
-
-      n = nullptr;
-      n = this->m_MultiWidget->GetWidgetPlane2();
-      if(n)
-      {
-        n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
-        n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
-        n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) );
-      }
 
-      n = nullptr;
-      n = this->m_MultiWidget->GetWidgetPlane3();
-      if(n)
-      {
-        n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
-        n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
-        n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) );
-      }
-    }
-    else
-    {
-      mitk::DataNode* n = nullptr;
-      n = this->m_MultiWidget->GetWidgetPlane1();
-      if(n)
-      {
-        n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
-        n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
-        n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( (num>0) ) );
-      }
-
-      n = nullptr;
-      n = this->m_MultiWidget->GetWidgetPlane2();
-      if(n)
-      {
-        n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
-        n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
-        n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( (num>0) ) );
-      }
-
-      n = nullptr;
-      n = this->m_MultiWidget->GetWidgetPlane3();
-      if(n)
-      {
-        n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
-        n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
-        n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( (num>0) ) );
-      }
-    }
+    /// TODO There is no way to access the individual crosshair planes through the render window part API.
+    /// There could be a new 'mitk::DataNode* mitk::ILinkedRenderWindowPart::GetSlicingPlane(const std::string& name) const'
+    /// function for this purpose. For the time being, I comment out the lines below, but they are valid
+    /// and they have to be re-enabled after the crosshair planes can be accessed again.
+
+//    if(num==0)
+//    {
+//      mitk::DataNode* n;
+//      n = renderWindowPart->GetSlicingPlane("axial");
+//      if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
+//      if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
+//      if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) );
+//
+//      n = renderWindowPart->GetSlicingPlane("sagittal");
+//      if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
+//      if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
+//      if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) );
+//
+//      n = renderWindowPart->GetSlicingPlane("coronal");
+//      if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( 0 ) );
+//      if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
+//      if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( false ) );
+//    }
+//    else
+//    {
+//      mitk::DataNode* n;
+//      n = renderWindowPart->GetSlicingPlane("axial");
+//      if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
+//      if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
+//      if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( (num>0) ) );
+//
+//      n = renderWindowPart->GetSlicingPlane("sagittal");
+//      if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
+//      if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
+//      if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( (num>0) ) );
+//
+//      n = renderWindowPart->GetSlicingPlane("coronal");
+//      if(n) n->SetProperty( "reslice.thickslices", mitk::ResliceMethodProperty::New( currentThickSlicesMode ) );
+//      if(n) n->SetProperty( "reslice.thickslices.num", mitk::IntProperty::New( num ) );
+//      if(n) n->SetProperty( "reslice.thickslices.showarea", mitk::BoolProperty::New( (num>0) ) );
+//    }
 
     m_TSLabel->setText(QString::number( num*2 + 1 ));
 
-    mitk::BaseRenderer::Pointer renderer = nullptr;
-    renderer = this->GetActiveStdMultiWidget()->GetRenderWindow1()->GetRenderer();
+    mitk::BaseRenderer::Pointer renderer;
+    renderer = renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer();
     if(renderer.IsNotNull()) { renderer->SendUpdateSlice(); }
 
     renderer = nullptr;
-    renderer = this->GetActiveStdMultiWidget()->GetRenderWindow2()->GetRenderer();
+    renderer = renderWindowPart->GetQmitkRenderWindow("sagittal")->GetRenderer();
     if(renderer.IsNotNull()) { renderer->SendUpdateSlice(); }
 
     renderer = nullptr;
-    renderer = this->GetActiveStdMultiWidget()->GetRenderWindow3()->GetRenderer();
+    renderer = renderWindowPart->GetQmitkRenderWindow("coronal")->GetRenderer();
     if(renderer.IsNotNull()) { renderer->SendUpdateSlice(); }
 
     renderer->GetRenderingManager()->RequestUpdateAll(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS);
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkControlVisualizationPropertiesViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     // hide warning (ODFs in rotated planes)
     m_Controls->m_lblRotatedPlanesWarning->hide();
 
     m_MyMenu = new QMenu(parent);
     m_Controls->m_TSMenu->setMenu( m_MyMenu );
 
     QIcon iconFiberFade(":/QmitkDiffusionImaging/MapperEfx2D.png");
     m_Controls->m_FiberFading2D->setIcon(iconFiberFade);
 
 #ifndef DIFFUSION_IMAGING_EXTENDED
     int size = m_Controls->m_AdditionalScaling->count();
     for(int t=0; t<size; t++)
     {
       if(m_Controls->m_AdditionalScaling->itemText(t).toStdString() == "Scale by ASR")
       {
         m_Controls->m_AdditionalScaling->removeItem(t);
       }
     }
 #endif
 
     m_Controls->m_ScalingFrame->setVisible(false);
     m_Controls->m_NormalizationFrame->setVisible(false);
   }
 }
 
-
-void QmitkControlVisualizationPropertiesView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
+void QmitkControlVisualizationPropertiesView::SetFocus()
 {
-  m_MultiWidget = &stdMultiWidget;
+  m_Controls->m_TSMenu->setFocus();
 }
 
 
 void QmitkControlVisualizationPropertiesView::SliceRotation(const itk::EventObject&)
 {
   // test if plane rotated
   if( m_GlyIsOn_T || m_GlyIsOn_C || m_GlyIsOn_S )
   {
     if( this->IsPlaneRotated() )
     {
       // show label
       m_Controls->m_lblRotatedPlanesWarning->show();
     }
     else
     {
       //hide label
       m_Controls->m_lblRotatedPlanesWarning->hide();
     }
   }
 }
 
 
-void QmitkControlVisualizationPropertiesView::StdMultiWidgetNotAvailable()
-{
-  m_MultiWidget = NULL;
-}
-
-
 void QmitkControlVisualizationPropertiesView::NodeRemoved(const mitk::DataNode* /*node*/)
 {
 }
 
 
 #include <mitkMessage.h>
 void QmitkControlVisualizationPropertiesView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_VisibleOdfsON_T), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_T()) );
     connect( (QObject*)(m_Controls->m_VisibleOdfsON_S), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_S()) );
     connect( (QObject*)(m_Controls->m_VisibleOdfsON_C), SIGNAL(clicked()), this, SLOT(VisibleOdfsON_C()) );
     connect( (QObject*)(m_Controls->m_ShowMaxNumber), SIGNAL(editingFinished()), this, SLOT(ShowMaxNumberChanged()) );
     connect( (QObject*)(m_Controls->m_NormalizationDropdown), SIGNAL(currentIndexChanged(int)), this, SLOT(NormalizationDropdownChanged(int)) );
     connect( (QObject*)(m_Controls->m_ScalingFactor), SIGNAL(valueChanged(double)), this, SLOT(ScalingFactorChanged(double)) );
     connect( (QObject*)(m_Controls->m_AdditionalScaling), SIGNAL(currentIndexChanged(int)), this, SLOT(AdditionalScaling(int)) );
     connect( (QObject*)(m_Controls->m_ScalingCheckbox), SIGNAL(clicked()), this, SLOT(ScalingCheckbox()) );
     connect((QObject*) m_Controls->m_ResetColoring, SIGNAL(clicked()), (QObject*) this, SLOT(BundleRepresentationResetColoring()));
     connect((QObject*) m_Controls->m_FiberFading2D, SIGNAL(clicked()), (QObject*) this, SLOT( Fiber2DfadingEFX() ) );
     connect((QObject*) m_Controls->m_FiberThicknessSlider, SIGNAL(sliderReleased()), (QObject*) this, SLOT( FiberSlicingThickness2D() ) );
     connect((QObject*) m_Controls->m_FiberThicknessSlider, SIGNAL(valueChanged(int)), (QObject*) this, SLOT( FiberSlicingUpdateLabel(int) ));
     connect((QObject*) m_Controls->m_Crosshair, SIGNAL(clicked()), (QObject*) this, SLOT(SetInteractor()));
     connect((QObject*) m_Controls->m_LineWidth, SIGNAL(editingFinished()), (QObject*) this, SLOT(LineWidthChanged()));
     connect((QObject*) m_Controls->m_TubeWidth, SIGNAL(editingFinished()), (QObject*) this, SLOT(TubeRadiusChanged()));
     connect( (QObject*) m_Controls->m_EllipsoidViewRadioButton, SIGNAL(toggled(bool)), (QObject*) this, SLOT(OnTensorViewChanged() ) );
     connect( (QObject*) m_Controls->m_colouriseRainbowRadioButton, SIGNAL(toggled(bool)), (QObject*) this, SLOT(OnColourisationModeChanged() ) );
     connect( (QObject*) m_Controls->m_randomModeRadioButton, SIGNAL(toggled(bool)), (QObject*) this, SLOT(OnRandomModeChanged() ) );
   }
 }
 
 
-void QmitkControlVisualizationPropertiesView::Activated()
-{
-}
-
-
-void QmitkControlVisualizationPropertiesView::Deactivated()
-{
-}
-
-
 // set diffusion image channel to b0 volume
 void QmitkControlVisualizationPropertiesView::NodeAdded(const mitk::DataNode *node)
 {
   mitk::DataNode* notConst = const_cast<mitk::DataNode*>(node);
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
 
   if (isDiffusionImage)
   {
     mitk::Image::Pointer dimg = dynamic_cast<mitk::Image*>(notConst->GetData());
 
     // if there is no b0 image in the dataset, the GetB0Indices() returns a vector of size 0
     // and hence we cannot set the Property directly to .front()
     int displayChannelPropertyValue = 0;
     mitk::BValueMapProperty* bmapproperty
         = static_cast<mitk::BValueMapProperty*>
         (dimg->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() );
 
     mitk::DiffusionPropertyHelper::BValueMapType map = bmapproperty->GetBValueMap();
 
     if( map[0].size() > 0) { displayChannelPropertyValue = map[0].front(); }
 
     notConst->SetIntProperty("DisplayChannel", displayChannelPropertyValue );
   }
 }
 
 
 /* OnSelectionChanged is registered to SelectionService, therefore no need to
 implement SelectionService Listener explicitly */
-void QmitkControlVisualizationPropertiesView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
+void QmitkControlVisualizationPropertiesView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
   m_Controls->m_BundleControlsFrame->setVisible(false);
   m_Controls->m_ImageControlsFrame->setVisible(false);
 
   if (nodes.size()>1) // only do stuff if one node is selected
     return;
 
   m_Controls->m_NumberGlyphsFrame->setVisible(false);
   m_Controls->m_GlyphFrame->setVisible(false);
   m_Controls->m_TSMenu->setVisible(false);
 
   m_SelectedNode = NULL;
 
   int numOdfImages = 0;
-  for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
+  for (mitk::DataNode::Pointer node: nodes)
   {
-    mitk::DataNode::Pointer node = *it;
     if(node.IsNull())
       continue;
 
     mitk::BaseData* nodeData = node->GetData();
     if(nodeData == NULL)
       continue;
 
     m_SelectedNode = node;
 
     if (dynamic_cast<mitk::FiberBundle*>(nodeData))
     {
       // handle fiber bundle property observers
       if (m_Color.IsNotNull()) { m_Color->RemoveObserver(m_FiberBundleObserverTag); }
       itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command
           = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
       command->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SetFiberBundleCustomColor );
       m_Color = dynamic_cast<mitk::ColorProperty*>(node->GetProperty("color", NULL));
       if (m_Color.IsNotNull())
         m_FiberBundleObserverTag = m_Color->AddObserver( itk::ModifiedEvent(), command );
 
       if (m_Opacity.IsNotNull())
       {
         m_Opacity->RemoveObserver(m_FiberBundleObserveOpacityTag);
       }
       itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::Pointer command2
           = itk::ReceptorMemberCommand<QmitkControlVisualizationPropertiesView>::New();
       command2->SetCallbackFunction( this, &QmitkControlVisualizationPropertiesView::SetFiberBundleOpacity );
       m_Opacity = dynamic_cast<mitk::FloatProperty*>(node->GetProperty("opacity", NULL));
 
       if (m_Opacity.IsNotNull())
       {
         m_FiberBundleObserveOpacityTag = m_Opacity->AddObserver( itk::ModifiedEvent(), command2 );
       }
 
       m_Controls->m_BundleControlsFrame->setVisible(true);
 
       if(m_CurrentPickingNode != 0 && node.GetPointer() != m_CurrentPickingNode)
       { m_Controls->m_Crosshair->setEnabled(false); }
       else
       { m_Controls->m_Crosshair->setEnabled(true); }
 
       int width;
       node->GetIntProperty("shape.linewidth", width);
       m_Controls->m_LineWidth->setValue(width);
 
       float radius;
       node->GetFloatProperty("shape.tuberadius", radius);
       m_Controls->m_TubeWidth->setValue(radius);
 
       float range;
       node->GetFloatProperty("Fiber2DSliceThickness",range);
       mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
       mitk::BaseGeometry::Pointer geo = fib->GetGeometry();
       mitk::ScalarType max = geo->GetExtentInMM(0);
       max = std::max(max, geo->GetExtentInMM(1));
       max = std::max(max, geo->GetExtentInMM(2));
 
       m_Controls->m_FiberThicknessSlider->setMaximum(max * 10);
       m_Controls->m_FiberThicknessSlider->setValue(range * 10);
     }
     else if(dynamic_cast<mitk::QBallImage*>(nodeData) || dynamic_cast<mitk::TensorImage*>(nodeData))
     {
       m_Controls->m_ImageControlsFrame->setVisible(true);
       m_Controls->m_NumberGlyphsFrame->setVisible(true);
       m_Controls->m_GlyphFrame->setVisible(true);
       m_Controls->m_NormalizationFrame->setVisible(true);
 
       if(m_NodeUsedForOdfVisualization.IsNotNull())
       {
         m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", false);
         m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", false);
         m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", false);
       }
       m_NodeUsedForOdfVisualization = node;
       m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", m_GlyIsOn_S);
       m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", m_GlyIsOn_C);
       m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", m_GlyIsOn_T);
 
       int val;
       node->GetIntProperty("ShowMaxNumber", val);
       m_Controls->m_ShowMaxNumber->setValue(val);
 
       m_Controls->m_NormalizationDropdown
           ->setCurrentIndex(dynamic_cast<mitk::EnumerationProperty*>(node->GetProperty("Normalization"))
                             ->GetValueAsId());
 
       float fval;
       node->GetFloatProperty("Scaling",fval);
       m_Controls->m_ScalingFactor->setValue(fval);
 
       m_Controls->m_AdditionalScaling
           ->setCurrentIndex(dynamic_cast<mitk::EnumerationProperty*>(node->GetProperty("ScaleBy"))->GetValueAsId());
 
       bool switchTensorViewValue = false;
       node->GetBoolProperty( "DiffusionCore.Rendering.OdfVtkMapper.SwitchTensorView", switchTensorViewValue );
       if( dynamic_cast<mitk::TensorImage*>(nodeData) )
       {
         m_Controls-> m_EllipsoidViewRadioButton-> setEnabled( true );
         m_Controls-> m_EllipsoidViewRadioButton-> setChecked( switchTensorViewValue );
       }
       else
       {
         m_Controls-> m_EllipsoidViewRadioButton-> setEnabled( false );
         m_Controls-> m_EllipsoidViewRadioButton-> setChecked( false );
       }
 
       bool colourisationModeBit = false;
       node-> GetBoolProperty( "DiffusionCore.Rendering.OdfVtkMapper.ColourisationModeBit", colourisationModeBit );
       m_Controls-> m_colouriseSimpleRadioButton-> setChecked( colourisationModeBit );
 
       bool randomModeBit = false;
       node-> GetBoolProperty( "DiffusionCore.Rendering.OdfVtkMapper.RandomModeBit", randomModeBit );
       m_Controls-> m_randomModeRadioButton-> setChecked( randomModeBit );
 
       numOdfImages++;
     }
     else if(dynamic_cast<mitk::PlanarFigure*>(nodeData))
     {
       PlanarFigureFocus();
     }
     else if( dynamic_cast<mitk::Image*>(nodeData) )
     {
       m_Controls->m_ImageControlsFrame->setVisible(true);
       m_Controls->m_TSMenu->setVisible(true);
     }
   }
 
   if( nodes.empty() ) { return; }
 
   mitk::DataNode::Pointer node = nodes.at(0);
 
   if( node.IsNull() ) { return; }
 
   QMenu *myMenu = m_MyMenu;
   myMenu->clear();
 
   QActionGroup* thickSlicesActionGroup = new QActionGroup(myMenu);
   thickSlicesActionGroup->setExclusive(true);
 
   int currentTSMode = 0;
   {
     mitk::ResliceMethodProperty::Pointer m = dynamic_cast<mitk::ResliceMethodProperty*>(node->GetProperty( "reslice.thickslices" ));
     if( m.IsNotNull() )
       currentTSMode = m->GetValueAsId();
   }
 
   int maxTS = 30;
 
-  for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
+  for (auto node: nodes)
   {
-    mitk::Image* image = dynamic_cast<mitk::Image*>((*it)->GetData());
+    mitk::Image* image = dynamic_cast<mitk::Image*>(node->GetData());
     if (image)
     {
       int size = std::max(image->GetDimension(0), std::max(image->GetDimension(1), image->GetDimension(2)));
 
       if (size>maxTS) { maxTS=size; }
     }
   }
   maxTS /= 2;
 
   int currentNum = 0;
   {
     mitk::IntProperty::Pointer m = dynamic_cast<mitk::IntProperty*>(node->GetProperty( "reslice.thickslices.num" ));
     if( m.IsNotNull() )
     {
       currentNum = m->GetValue();
       if(currentNum < 0) { currentNum = 0; }
       if(currentNum > maxTS) { currentNum = maxTS; }
     }
   }
 
   if(currentTSMode==0) { currentNum=0; }
 
   QSlider *m_TSSlider = new QSlider(myMenu);
   m_TSSlider->setMinimum(0);
   m_TSSlider->setMaximum(maxTS-1);
   m_TSSlider->setValue(currentNum);
 
   m_TSSlider->setOrientation(Qt::Horizontal);
 
   connect( m_TSSlider, SIGNAL( valueChanged(int) ), this, SLOT( OnTSNumChanged(int) ) );
 
   QHBoxLayout* _TSLayout = new QHBoxLayout;
   _TSLayout->setContentsMargins(4,4,4,4);
   _TSLayout->addWidget(m_TSSlider);
   _TSLayout->addWidget(m_TSLabel=new QLabel(QString::number(currentNum*2+1),myMenu));
 
   QWidget* _TSWidget = new QWidget;
   _TSWidget->setLayout(_TSLayout);
 
   QActionGroup* thickSliceModeActionGroup = new QActionGroup(myMenu);
   thickSliceModeActionGroup->setExclusive(true);
 
   QWidgetAction *m_TSSliderAction = new QWidgetAction(myMenu);
   m_TSSliderAction->setDefaultWidget(_TSWidget);
   myMenu->addAction(m_TSSliderAction);
 
   QAction* mipThickSlicesAction = new QAction(myMenu);
   mipThickSlicesAction->setActionGroup(thickSliceModeActionGroup);
   mipThickSlicesAction->setText("MIP (max. intensity proj.)");
   mipThickSlicesAction->setCheckable(true);
   mipThickSlicesAction->setChecked(currentThickSlicesMode==1);
   mipThickSlicesAction->setData(1);
   myMenu->addAction( mipThickSlicesAction );
 
   QAction* sumThickSlicesAction = new QAction(myMenu);
   sumThickSlicesAction->setActionGroup(thickSliceModeActionGroup);
   sumThickSlicesAction->setText("SUM (sum intensity proj.)");
   sumThickSlicesAction->setCheckable(true);
   sumThickSlicesAction->setChecked(currentThickSlicesMode==2);
   sumThickSlicesAction->setData(2);
   myMenu->addAction( sumThickSlicesAction );
 
   QAction* weightedThickSlicesAction = new QAction(myMenu);
   weightedThickSlicesAction->setActionGroup(thickSliceModeActionGroup);
   weightedThickSlicesAction->setText("WEIGHTED (gaussian proj.)");
   weightedThickSlicesAction->setCheckable(true);
   weightedThickSlicesAction->setChecked(currentThickSlicesMode==3);
   weightedThickSlicesAction->setData(3);
   myMenu->addAction( weightedThickSlicesAction );
 
   connect( thickSliceModeActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(OnThickSlicesModeSelected(QAction*)) );
 }
 
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON_S()
 {
   m_GlyIsOn_S = m_Controls->m_VisibleOdfsON_S->isChecked();
   if (m_NodeUsedForOdfVisualization.IsNull())
   {
     MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is NULL";
     return;
   }
   m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_S", m_GlyIsOn_S);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON_T()
 {
   m_GlyIsOn_T = m_Controls->m_VisibleOdfsON_T->isChecked();
   if (m_NodeUsedForOdfVisualization.IsNull())
   {
     MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is NULL";
     return;
   }
   m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_T", m_GlyIsOn_T);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 
 void QmitkControlVisualizationPropertiesView::VisibleOdfsON_C()
 {
   m_GlyIsOn_C = m_Controls->m_VisibleOdfsON_C->isChecked();
   if (m_NodeUsedForOdfVisualization.IsNull())
   {
     MITK_WARN << "ODF visualization activated but m_NodeUsedForOdfVisualization is NULL";
     return;
   }
   m_NodeUsedForOdfVisualization->SetBoolProperty("VisibleOdfs_C", m_GlyIsOn_C);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 
 bool QmitkControlVisualizationPropertiesView::IsPlaneRotated()
 {
   mitk::Image* currentImage = dynamic_cast<mitk::Image* >( m_NodeUsedForOdfVisualization->GetData() );
   if( currentImage == NULL )
   {
     MITK_ERROR << " Casting problems. Returning false";
     return false;
   }
 
   mitk::Vector3D imageNormal0 = currentImage->GetSlicedGeometry()->GetAxisVector(0);
   mitk::Vector3D imageNormal1 = currentImage->GetSlicedGeometry()->GetAxisVector(1);
   mitk::Vector3D imageNormal2 = currentImage->GetSlicedGeometry()->GetAxisVector(2);
   imageNormal0.Normalize();
   imageNormal1.Normalize();
   imageNormal2.Normalize();
 
+  auto renderWindowPart = this->GetRenderWindowPart();
+
   double eps = 0.000001;
-  // for all 2D renderwindows of m_MultiWidget check alignment
+  // for all 2D renderwindows of the render window part check alignment
   {
     mitk::PlaneGeometry::ConstPointer displayPlane
         = dynamic_cast<const mitk::PlaneGeometry*>
-        ( m_MultiWidget->GetRenderWindow1()->GetRenderer()->GetCurrentWorldGeometry2D() );
+        ( renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer()->GetCurrentWorldGeometry2D() );
 
     if (displayPlane.IsNull()) { return false; }
 
     mitk::Vector3D normal = displayPlane->GetNormal();
     normal.Normalize();
     int test = 0;
     if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal0.GetVnlVector()))-1) > eps ) { test++; }
 
     if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal1.GetVnlVector()))-1) > eps ) { test++; }
 
     if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal2.GetVnlVector()))-1) > eps ) { test++; }
 
     if (test==3) { return true; }
   }
   {
     mitk::PlaneGeometry::ConstPointer displayPlane
         = dynamic_cast<const mitk::PlaneGeometry*>
-        ( m_MultiWidget->GetRenderWindow2()->GetRenderer()->GetCurrentWorldGeometry2D() );
+        ( renderWindowPart->GetQmitkRenderWindow("sagittal")->GetRenderer()->GetCurrentWorldGeometry2D() );
 
     if (displayPlane.IsNull()) { return false; }
 
     mitk::Vector3D normal = displayPlane->GetNormal();
     normal.Normalize();
     int test = 0;
     if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal0.GetVnlVector()))-1) > eps ) { test++; }
 
     if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal1.GetVnlVector()))-1) > eps ) { test++; }
 
     if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal2.GetVnlVector()))-1) > eps ) { test++; }
 
     if (test==3) { return true; }
   }
   {
     mitk::PlaneGeometry::ConstPointer displayPlane
         = dynamic_cast<const mitk::PlaneGeometry*>
-        ( m_MultiWidget->GetRenderWindow3()->GetRenderer()->GetCurrentWorldGeometry2D() );
+        ( renderWindowPart->GetQmitkRenderWindow("coronal")->GetRenderer()->GetCurrentWorldGeometry2D() );
 
     if (displayPlane.IsNull()) { return false; }
 
     mitk::Vector3D normal = displayPlane->GetNormal();
     normal.Normalize();
     int test = 0;
     if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal0.GetVnlVector()))-1) > eps ) { test++; }
 
     if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal1.GetVnlVector()))-1) > eps ) { test++; }
 
     if( fabs(fabs(dot_product(normal.GetVnlVector(),imageNormal2.GetVnlVector()))-1) > eps ) { test++; }
 
     if (test==3) { return true; }
   }
 
   return false;
 }
 
 
 void QmitkControlVisualizationPropertiesView::ShowMaxNumberChanged()
 {
   int maxNr = m_Controls->m_ShowMaxNumber->value();
   if ( maxNr < 1 )
   {
     m_Controls->m_ShowMaxNumber->setValue( 1 );
     maxNr = 1;
   }
 
   if ( dynamic_cast<mitk::QBallImage*>(m_SelectedNode->GetData())
        || dynamic_cast<mitk::TensorImage*>(m_SelectedNode->GetData()) )
   {
     m_SelectedNode->SetIntProperty("ShowMaxNumber", maxNr);
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 
 void QmitkControlVisualizationPropertiesView::NormalizationDropdownChanged(int normDropdown)
 {
   typedef mitk::OdfNormalizationMethodProperty PropType;
   PropType::Pointer normMeth = PropType::New();
 
   switch(normDropdown)
   {
     case 0:
       normMeth->SetNormalizationToMinMax();
     break;
     case 1:
       normMeth->SetNormalizationToMax();
     break;
     case 2:
       normMeth->SetNormalizationToNone();
     break;
     case 3:
       normMeth->SetNormalizationToGlobalMax();
     break;
     default:
       normMeth->SetNormalizationToMinMax();
   }
 
   if ( dynamic_cast<mitk::QBallImage*>(m_SelectedNode->GetData())
        || dynamic_cast<mitk::TensorImage*>(m_SelectedNode->GetData()) )
   {
     m_SelectedNode->SetProperty("Normalization", normMeth.GetPointer());
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 
 void QmitkControlVisualizationPropertiesView::ScalingFactorChanged(double scalingFactor)
 {
   if ( dynamic_cast<mitk::QBallImage*>(m_SelectedNode->GetData())
        || dynamic_cast<mitk::TensorImage*>(m_SelectedNode->GetData()) )
   {
     m_SelectedNode->SetFloatProperty("Scaling", scalingFactor);
   }
 
-  if(m_MultiWidget){ m_MultiWidget->RequestUpdate(); }
+  if (auto renderWindowPart = this->GetRenderWindowPart())
+  {
+    renderWindowPart->RequestUpdate();
+  }
 }
 
 
 void QmitkControlVisualizationPropertiesView::AdditionalScaling(int additionalScaling)
 {
 
   typedef mitk::OdfScaleByProperty PropType;
   PropType::Pointer scaleBy = PropType::New();
 
   switch(additionalScaling)
   {
     case 0:
       scaleBy->SetScaleByNothing();
     break;
     case 1:
       scaleBy->SetScaleByGFA();
       //m_Controls->params_frame->setVisible(true);
     break;
 #ifdef DIFFUSION_IMAGING_EXTENDED
     case 2:
       scaleBy->SetScaleByPrincipalCurvature();
       // commented in for SPIE paper, Principle curvature scaling
       //m_Controls->params_frame->setVisible(true);
     break;
 #endif
     default:
       scaleBy->SetScaleByNothing();
   }
 
   if ( dynamic_cast<mitk::QBallImage*>(m_SelectedNode->GetData())
        || dynamic_cast<mitk::TensorImage*>(m_SelectedNode->GetData()) )
   {
     m_SelectedNode->SetProperty("Normalization", scaleBy.GetPointer());
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 
 void QmitkControlVisualizationPropertiesView::ScalingCheckbox()
 {
   m_Controls->m_ScalingFrame->setVisible( m_Controls->m_ScalingCheckbox->isChecked() );
 
   if( ! m_Controls->m_ScalingCheckbox->isChecked() )
   {
     m_Controls->m_AdditionalScaling->setCurrentIndex(0);
     m_Controls->m_ScalingFactor->setValue(1.0);
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::Fiber2DfadingEFX()
 {
   if (m_SelectedNode && dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData()) )
   {
     bool currentMode;
     m_SelectedNode->GetBoolProperty("Fiber2DfadeEFX", currentMode);
     m_SelectedNode->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(!currentMode));
     dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData())->RequestUpdate2D();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::FiberSlicingThickness2D()
 {
   if (m_SelectedNode && dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData()))
   {
     float fibThickness = m_Controls->m_FiberThicknessSlider->value() * 0.1;
     float currentThickness = 0;
     m_SelectedNode->GetFloatProperty("Fiber2DSliceThickness", currentThickness);
     if ( fabs(fibThickness-currentThickness) < 0.001 )
     {
       return;
     }
 
     m_SelectedNode->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(fibThickness));
     dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData())->RequestUpdate2D();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::FiberSlicingUpdateLabel(int value)
 {
   QString label = "Range %1 mm";
   label = label.arg(value * 0.1);
   m_Controls->label_range->setText(label);
   FiberSlicingThickness2D();
 }
 
 
 void QmitkControlVisualizationPropertiesView::SetFiberBundleOpacity(const itk::EventObject& /*e*/)
 {
   if(m_SelectedNode)
   {
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData());
     fib->RequestUpdate();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::SetFiberBundleCustomColor(const itk::EventObject& /*e*/)
 {
   if(m_SelectedNode && dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData()))
   {
     float color[3];
     m_SelectedNode->GetColor(color);
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData());
     fib->SetFiberColors(color[0]*255, color[1]*255, color[2]*255);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::BundleRepresentationResetColoring()
 {
   if(m_SelectedNode && dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData()))
   {
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData());
     fib->ColorFibersByOrientation();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::PlanarFigureFocus()
 {
   if(m_SelectedNode)
   {
     mitk::PlanarFigure* _PlanarFigure = 0;
     _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (m_SelectedNode->GetData());
 
     if (_PlanarFigure && _PlanarFigure->GetPlaneGeometry())
     {
 
       QmitkRenderWindow* selectedRenderWindow = 0;
       bool PlanarFigureInitializedWindow = false;
 
-      QmitkRenderWindow* RenderWindow1 =
-          this->GetActiveStdMultiWidget()->GetRenderWindow1();
+      auto renderWindowPart = this->GetRenderWindowPart(OPEN);
+
+      QmitkRenderWindow* axialRenderWindow =
+          renderWindowPart->GetQmitkRenderWindow("axial");
 
       if (m_SelectedNode->GetBoolProperty("PlanarFigureInitializedWindow",
-                                          PlanarFigureInitializedWindow, RenderWindow1->GetRenderer()))
+                                          PlanarFigureInitializedWindow, axialRenderWindow->GetRenderer()))
       {
-        selectedRenderWindow = RenderWindow1;
+        selectedRenderWindow = axialRenderWindow;
       }
 
-      QmitkRenderWindow* RenderWindow2 =
-          this->GetActiveStdMultiWidget()->GetRenderWindow2();
+      QmitkRenderWindow* sagittalRenderWindow =
+          renderWindowPart->GetQmitkRenderWindow("sagittal");
 
       if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
             "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
-            RenderWindow2->GetRenderer()))
+            sagittalRenderWindow->GetRenderer()))
       {
-        selectedRenderWindow = RenderWindow2;
+        selectedRenderWindow = sagittalRenderWindow;
       }
 
-      QmitkRenderWindow* RenderWindow3 =
-          this->GetActiveStdMultiWidget()->GetRenderWindow3();
+      QmitkRenderWindow* coronalRenderWindow =
+          renderWindowPart->GetQmitkRenderWindow("coronal");
 
       if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
             "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
-            RenderWindow3->GetRenderer()))
+            coronalRenderWindow->GetRenderer()))
       {
-        selectedRenderWindow = RenderWindow3;
+        selectedRenderWindow = coronalRenderWindow;
       }
 
-      QmitkRenderWindow* RenderWindow4 =
-          this->GetActiveStdMultiWidget()->GetRenderWindow4();
+      QmitkRenderWindow* _3DRenderWindow =
+          renderWindowPart->GetQmitkRenderWindow("3d");
 
       if (!selectedRenderWindow && m_SelectedNode->GetBoolProperty(
             "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
-            RenderWindow4->GetRenderer()))
+            _3DRenderWindow->GetRenderer()))
       {
-        selectedRenderWindow = RenderWindow4;
+        selectedRenderWindow = _3DRenderWindow;
       }
 
       const mitk::PlaneGeometry* _PlaneGeometry = _PlanarFigure->GetPlaneGeometry();
 
       mitk::VnlVector normal = _PlaneGeometry->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry1 =
-          RenderWindow1->GetRenderer()->GetCurrentWorldGeometry2D();
+          axialRenderWindow->GetRenderer()->GetCurrentWorldGeometry2D();
       mitk::PlaneGeometry::ConstPointer _Plane1 =
           dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry1.GetPointer() );
       mitk::VnlVector normal1 = _Plane1->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry2 =
-          RenderWindow2->GetRenderer()->GetCurrentWorldGeometry2D();
+          sagittalRenderWindow->GetRenderer()->GetCurrentWorldGeometry2D();
       mitk::PlaneGeometry::ConstPointer _Plane2 =
           dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry2.GetPointer() );
       mitk::VnlVector normal2 = _Plane2->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry3 =
-          RenderWindow3->GetRenderer()->GetCurrentWorldGeometry2D();
+          coronalRenderWindow->GetRenderer()->GetCurrentWorldGeometry2D();
       mitk::PlaneGeometry::ConstPointer _Plane3 =
           dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry3.GetPointer() );
       mitk::VnlVector normal3 = _Plane3->GetNormalVnl();
 
       normal[0]  = fabs(normal[0]);  normal[1]  = fabs(normal[1]);  normal[2]  = fabs(normal[2]);
       normal1[0] = fabs(normal1[0]); normal1[1] = fabs(normal1[1]); normal1[2] = fabs(normal1[2]);
       normal2[0] = fabs(normal2[0]); normal2[1] = fabs(normal2[1]); normal2[2] = fabs(normal2[2]);
       normal3[0] = fabs(normal3[0]); normal3[1] = fabs(normal3[1]); normal3[2] = fabs(normal3[2]);
 
       double ang1 = angle(normal, normal1);
       double ang2 = angle(normal, normal2);
       double ang3 = angle(normal, normal3);
 
       if(ang1 < ang2 && ang1 < ang3)
       {
-        selectedRenderWindow = RenderWindow1;
+        selectedRenderWindow = axialRenderWindow;
       }
       else
       {
         if(ang2 < ang3)
         {
-          selectedRenderWindow = RenderWindow2;
+          selectedRenderWindow = sagittalRenderWindow;
         }
         else
         {
-          selectedRenderWindow = RenderWindow3;
+          selectedRenderWindow = coronalRenderWindow;
         }
       }
 
       // make node visible
       if (selectedRenderWindow)
       {
         const mitk::Point3D& centerP = _PlaneGeometry->GetOrigin();
         selectedRenderWindow->GetSliceNavigationController()->ReorientSlices(
               centerP, _PlaneGeometry->GetNormal());
       }
     }
 
     // set interactor for new node (if not already set)
     mitk::PlanarFigureInteractor::Pointer figureInteractor
         = dynamic_cast<mitk::PlanarFigureInteractor*>(m_SelectedNode->GetDataInteractor().GetPointer());
 
     if(figureInteractor.IsNull())
     {
       figureInteractor = mitk::PlanarFigureInteractor::New();
       us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
       figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
       figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
       figureInteractor->SetDataNode( m_SelectedNode );
     }
 
     m_SelectedNode->SetProperty("planarfigure.iseditable",mitk::BoolProperty::New(true));
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::SetInteractor()
 {
   // BUG 19179
   //    typedef std::vector<mitk::DataNode*> Container;
   //    Container _NodeSet = this->GetDataManagerSelection();
   //    mitk::DataNode* node = 0;
   //    mitk::FiberBundle* bundle = 0;
   //    mitk::FiberBundleInteractor::Pointer bundleInteractor = 0;
 
   //    // finally add all nodes to the model
   //    for(Container::const_iterator it=_NodeSet.begin(); it!=_NodeSet.end()
   //        ; it++)
   //    {
   //        node = const_cast<mitk::DataNode*>(*it);
   //        bundle = dynamic_cast<mitk::FiberBundle*>(node->GetData());
 
   //        if(bundle)
   //        {
   //            bundleInteractor = dynamic_cast<mitk::FiberBundleInteractor*>(node->GetInteractor());
 
   //            if(bundleInteractor.IsNotNull())
   //                mitk::GlobalInteraction::GetInstance()->RemoveInteractor(bundleInteractor);
 
   //            if(!m_Controls->m_Crosshair->isChecked())
   //            {
   //                m_Controls->m_Crosshair->setChecked(false);
   //                this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::ArrowCursor);
   //                m_CurrentPickingNode = 0;
   //            }
   //            else
   //            {
   //                m_Controls->m_Crosshair->setChecked(true);
   //                bundleInteractor = mitk::FiberBundleInteractor::New("FiberBundleInteractor", node);
   //                mitk::GlobalInteraction::GetInstance()->AddInteractor(bundleInteractor);
   //                this->GetActiveStdMultiWidget()->GetRenderWindow4()->setCursor(Qt::CrossCursor);
   //                m_CurrentPickingNode = node;
   //            }
 
   //        }
   //    }
 }
 
 
 void QmitkControlVisualizationPropertiesView::TubeRadiusChanged()
 {
   if(m_SelectedNode && dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData()))
   {
     float newRadius = m_Controls->m_TubeWidth->value();
     m_SelectedNode->SetFloatProperty("shape.tuberadius", newRadius);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::LineWidthChanged()
 {
   if(m_SelectedNode && dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData()))
   {
     int newWidth = m_Controls->m_LineWidth->value();
     int currentWidth = 0;
     m_SelectedNode->GetIntProperty("shape.linewidth", currentWidth);
     if (currentWidth==newWidth)
       return;
     m_SelectedNode->SetIntProperty("shape.linewidth", newWidth);
     dynamic_cast<mitk::FiberBundle*>(m_SelectedNode->GetData())->RequestUpdate();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::Welcome()
 {
   berry::PlatformUI::GetWorkbench()->GetIntroManager()
       ->ShowIntro(GetSite()->GetWorkbenchWindow(), false);
 }
 
 
 void QmitkControlVisualizationPropertiesView::OnTensorViewChanged()
 {
   if( m_NodeUsedForOdfVisualization.IsNotNull() )
   {
     if( m_Controls-> m_EllipsoidViewRadioButton-> isChecked() )
     {
       if ( m_SelectedNode and dynamic_cast<mitk::TensorImage*>( m_SelectedNode->GetData() ) )
       {
         m_SelectedNode-> SetProperty( "DiffusionCore.Rendering.OdfVtkMapper.SwitchTensorView", mitk::BoolProperty::New( true ) );
 
         mitk::OdfNormalizationMethodProperty::Pointer normalizationProperty
             = mitk::OdfNormalizationMethodProperty::New( mitk::ODFN_MAX );
 
         m_SelectedNode-> SetProperty( "Normalization", normalizationProperty ); // type OdfNormalizationMethodProperty
 
         m_Controls-> m_NormalizationDropdown->setCurrentIndex
             ( dynamic_cast<mitk::EnumerationProperty*>( m_SelectedNode->GetProperty("Normalization") )->GetValueAsId() );
       }
       else
       {
         m_SelectedNode-> SetProperty( "DiffusionCore.Rendering.OdfVtkMapper.SwitchTensorView", mitk::BoolProperty::New( false ) );
         m_Controls-> m_OdfViewRadioButton-> setChecked(true);
         m_Controls-> m_EllipsoidViewRadioButton-> setEnabled(false);
       }
     }
     else if( m_Controls-> m_OdfViewRadioButton-> isChecked() )
     {
       m_SelectedNode-> SetProperty( "DiffusionCore.Rendering.OdfVtkMapper.SwitchTensorView", mitk::BoolProperty::New( false ) );
     }
     mitk::RenderingManager::GetInstance()-> RequestUpdateAll();
   }
   else
   {
     MITK_DEBUG << "QmitkControlVisualizationPropertiesView::OnTensorViewChanged()"
                   " was called but m_NodeUsedForOdfVisualization was Null.";
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::OnColourisationModeChanged()
 {
   if( m_SelectedNode and m_NodeUsedForOdfVisualization.IsNotNull() )
   {
     if( m_Controls-> m_colouriseRainbowRadioButton-> isChecked() )
     {
       m_SelectedNode-> SetProperty( "DiffusionCore.Rendering.OdfVtkMapper.ColourisationModeBit", mitk::BoolProperty::New( false ) );
     }
     else if ( m_Controls-> m_colouriseSimpleRadioButton-> isChecked() )
     {
       m_SelectedNode-> SetProperty( "DiffusionCore.Rendering.OdfVtkMapper.ColourisationModeBit", mitk::BoolProperty::New( true ) );
     }
     mitk::RenderingManager::GetInstance()-> RequestUpdateAll();
   }
   else
   {
     MITK_DEBUG << "QmitkControlVisualizationPropertiesView::OnColourisationModeChanged()"
                   " was called but m_NodeUsedForOdfVisualization was Null.";
   }
 }
 
 
 void QmitkControlVisualizationPropertiesView::OnRandomModeChanged()
 {
   if( m_SelectedNode and m_NodeUsedForOdfVisualization.IsNotNull() )
   {
     if( m_Controls-> m_randomModeRadioButton-> isChecked() )
     {
       m_SelectedNode-> SetProperty( "DiffusionCore.Rendering.OdfVtkMapper.RandomModeBit", mitk::BoolProperty::New( true ) );
     }
     else if ( m_Controls-> m_orderedModeRadioButton-> isChecked() )
     {
       m_SelectedNode-> SetProperty( "DiffusionCore.Rendering.OdfVtkMapper.RandomModeBit", mitk::BoolProperty::New( false ) );
     }
     mitk::RenderingManager::GetInstance()-> RequestUpdateAll();
   }
   else
   {
     MITK_DEBUG << "QmitkControlVisualizationPropertiesView::OnRandomModeChanged()"
                   " was called but m_NodeUsedForOdfVisualization was Null.";
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.h
index 0317958355..3b82573dfd 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesView.h
@@ -1,160 +1,153 @@
 /*===================================================================
 
 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 _QMITKControlVisualizationPropertiesView_H_INCLUDED
 #define _QMITKControlVisualizationPropertiesView_H_INCLUDED
 
-#include <QmitkFunctionality.h>
+#include <QmitkAbstractView.h>
 
 #include <string>
 
 #include "berryISelectionListener.h"
 #include "berryIStructuredSelection.h"
 #include "berryISizeProvider.h"
 
 #include "ui_QmitkControlVisualizationPropertiesViewControls.h"
 
 #include "mitkEnumerationProperty.h"
 
 /*!
  * \ingroup org_mitk_gui_qt_diffusionquantification_internal
  *
  * \brief QmitkControlVisualizationPropertiesView
  *
  * Document your class here.
- *
- * \sa QmitkFunctionality
  */
-class QmitkControlVisualizationPropertiesView : public QmitkFunctionality//, public berry::ISizeProvider
+class QmitkControlVisualizationPropertiesView : public QmitkAbstractView//, public berry::ISizeProvider
 {
 
   friend struct CvpSelListener;
 
   // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
   public:
 
   static const std::string VIEW_ID;
 
   QmitkControlVisualizationPropertiesView();
   virtual ~QmitkControlVisualizationPropertiesView();
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
   /// \brief Creation of the connections of main and control widget
   virtual void CreateConnections();
 
-  /// \brief Called when the functionality is activated
-  virtual void Activated() override;
-
-  virtual void Deactivated() override;
-
-  virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget) override;
-  virtual void StdMultiWidgetNotAvailable() override;
+  ///
+  /// Sets the focus to an internal widget.
+  ///
+  virtual void SetFocus() override;
 
 protected slots:
 
   void VisibleOdfsON_S();
   void VisibleOdfsON_T();
   void VisibleOdfsON_C();
 
   void ShowMaxNumberChanged();
   void NormalizationDropdownChanged(int);
   void ScalingFactorChanged(double);
   void AdditionalScaling(int);
   void ScalingCheckbox();
 
   void OnThickSlicesModeSelected( QAction* action );
   void OnTSNumChanged(int num);
 
   void BundleRepresentationResetColoring();
   void PlanarFigureFocus();
   void Fiber2DfadingEFX();
   void FiberSlicingThickness2D();
   void FiberSlicingUpdateLabel(int);
   void LineWidthChanged();
   void TubeRadiusChanged();
 
   void SetInteractor();
 
   void Welcome();
 
   /// \brief Slot function for switching tensor view between ODF q-balls and ellipsoids from tensors.
   void OnTensorViewChanged();
 
   /// \brief Slot function for switching colourisation mode of glyphs.
   void OnColourisationModeChanged();
 
   /// \brief Slot function for switching glyph placement mode.
   void OnRandomModeChanged();
 
 protected:
 
   virtual void NodeRemoved(const mitk::DataNode* node) override;
 
-  /// \brief called by QmitkFunctionality when DataManager's selection has changed
-  virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes ) override;
+  /// \brief called by QmitkAbstractView when DataManager's selection has changed
+  virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
   virtual void NodeAdded(const mitk::DataNode *node) override;
   void SetFiberBundleCustomColor(const itk::EventObject& /*e*/);
   void SetFiberBundleOpacity(const itk::EventObject& /*e*/);
   bool IsPlaneRotated();
 
   void SliceRotation(const itk::EventObject&);
 
   Ui::QmitkControlVisualizationPropertiesViewControls* m_Controls;
 
-  QmitkStdMultiWidget* m_MultiWidget;
-
   QScopedPointer<berry::ISelectionListener> m_SelListener;
   berry::IStructuredSelection::ConstPointer m_CurrentSelection;
 
   mitk::DataNode::Pointer m_NodeUsedForOdfVisualization;
 
   QIcon* m_IconTexOFF;
   QIcon* m_IconTexON;
   QIcon* m_IconGlyOFF_T;
   QIcon* m_IconGlyON_T;
   QIcon* m_IconGlyOFF_C;
   QIcon* m_IconGlyON_C;
   QIcon* m_IconGlyOFF_S;
   QIcon* m_IconGlyON_S;
 
   bool m_TexIsOn;
   bool m_GlyIsOn_T;
   bool m_GlyIsOn_C;
   bool m_GlyIsOn_S;
 
   int currentThickSlicesMode;
   QLabel* m_TSLabel;
   QMenu* m_MyMenu;
 
   // for planarfigure and bundle handling:
   mitk::DataNode::Pointer m_SelectedNode;
   mitk::DataNode* m_CurrentPickingNode;
 
   unsigned long m_FiberBundleObserverTag;
   unsigned long m_FiberBundleObserveOpacityTag;
   mitk::ColorProperty::Pointer m_Color;
   mitk::FloatProperty::Pointer m_Opacity;
 };
 
 
 
 
 #endif // _QMITKControlVisualizationPropertiesView_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDenoisingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDenoisingView.cpp
index 77dee17b43..dd72d5d92a 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDenoisingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDenoisingView.cpp
@@ -1,525 +1,524 @@
 /*===================================================================
 
 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>
 
 // Qmitk
 #include "QmitkDenoisingView.h"
 #include <mitkImageCast.h>
 #include <mitkProgressBar.h>
 #include <mitkDiffusionPropertyHelper.h>
 #include <mitkITKImageImport.h>
 
 QmitkDenoisingWorker::QmitkDenoisingWorker(QmitkDenoisingView *view)
   : m_View(view)
 {
 }
 
 void QmitkDenoisingWorker::run()
 {
   if (m_View->m_ImageNode.IsNotNull())
   {
     switch (m_View->m_SelectedFilter)
     {
       case QmitkDenoisingView::NOFILTERSELECTED:
       case QmitkDenoisingView::GAUSS:
       {
         break;
       }
       case QmitkDenoisingView::NLM:
       {
         try
         {
           m_View->m_CompletedCalculation = true;
           m_View->m_NonLocalMeansFilter->Update();
         }
         catch (itk::ExceptionObject& e)
         {
           m_View->m_CompletedCalculation = false;
           MITK_ERROR << e.what();
         }
           break;
       }
     }
     m_View->m_DenoisingThread.quit();
   }
 }
 
 const std::string QmitkDenoisingView::VIEW_ID = "org.mitk.views.denoisingview";
 
 QmitkDenoisingView::QmitkDenoisingView()
-  : QmitkFunctionality()
+  : QmitkAbstractView()
   , m_Controls( 0 )
   , m_ImageNode(NULL)
   , m_BrainMaskNode(NULL)
   , m_DenoisingWorker(this)
   , m_ThreadIsRunning(false)
   , m_NonLocalMeansFilter(NULL)
   , m_InputImage(NULL)
   , m_LastProgressCount(0)
   , m_MaxProgressCount(0)
   , m_SelectedFilter(NOFILTERSELECTED)
 {
   m_DenoisingWorker.moveToThread(&m_DenoisingThread);
   connect(&m_DenoisingThread, SIGNAL(started()), this, SLOT(BeforeThread()));
   connect(&m_DenoisingThread, SIGNAL(started()), &m_DenoisingWorker, SLOT(run()));
   connect(&m_DenoisingThread, SIGNAL(finished()), this, SLOT(AfterThread()));
   connect(&m_DenoisingThread, SIGNAL(terminated()), this, SLOT(AfterThread()));
   m_DenoisingTimer = new QTimer(this);
 }
 
 QmitkDenoisingView::~QmitkDenoisingView()
 {
   delete m_DenoisingTimer;
 }
 
 void QmitkDenoisingView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkDenoisingViewControls;
     m_Controls->setupUi( parent );
+
+    m_Controls->m_SelectFilterComboBox->clear();
+    m_Controls->m_SelectFilterComboBox->insertItem(NOFILTERSELECTED, "Please select a filter");
+    m_Controls->m_SelectFilterComboBox->insertItem(NLM, "Non-local means filter");
+    m_Controls->m_SelectFilterComboBox->insertItem(GAUSS, "Discrete gaussian filter");
+
     CreateConnections();
     ResetParameterPanel();
   }
 }
 
 void QmitkDenoisingView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_ApplyButton), SIGNAL(clicked()), this, SLOT(StartDenoising()));
     connect( (QObject*)(m_Controls->m_SelectFilterComboBox), SIGNAL(activated(int)), this, SLOT(SelectFilter(int)));
     connect( m_DenoisingTimer, SIGNAL(timeout()), this, SLOT(UpdateProgress()));
   }
 }
 
-void QmitkDenoisingView::Activated()
+void QmitkDenoisingView::SetFocus()
 {
-  QmitkFunctionality::Activated();
-
-  m_Controls->m_SelectFilterComboBox->clear();
-  m_Controls->m_SelectFilterComboBox->insertItem(NOFILTERSELECTED, "Please select a filter");
-  m_Controls->m_SelectFilterComboBox->insertItem(NLM, "Non-local means filter");
-  m_Controls->m_SelectFilterComboBox->insertItem(GAUSS, "Discrete gaussian filter");
+  m_Controls->m_SelectFilterComboBox->setFocus();
 }
 
-void QmitkDenoisingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
+void QmitkDenoisingView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
   if (m_ThreadIsRunning)
     return;
 
   if (m_SelectedFilter != NOFILTERSELECTED)
   {
     m_Controls->m_InputImageLabel->setText("<font color='red'>mandatory</font>");
   }
   else
   {
     m_Controls->m_InputImageLabel->setText("mandatory");
   }
   m_Controls->m_InputBrainMaskLabel->setText("optional");
   m_Controls->m_ApplyButton->setEnabled(false);
 
   m_ImageNode = NULL;
   m_BrainMaskNode = NULL;
 
   // iterate selection
-  for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
+  for (mitk::DataNode::Pointer node: nodes)
   {
-    mitk::DataNode::Pointer node = *it;
-
     bool isDiffusionImage(false);
     if(node.IsNotNull())
     {
       isDiffusionImage = mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData()));
     }
 
     if( node.IsNotNull() && isDiffusionImage)
     {
       m_Controls->m_InputImageLabel->setText(node->GetName().c_str());
       m_ImageNode = node;
     }
 
     bool isBinary = false;
     node->GetBoolProperty("binary", isBinary);
     // look for a brainmask in selection
     if( node.IsNotNull() && static_cast<mitk::Image*>(node->GetData()) && isBinary)
     {
         m_Controls->m_InputBrainMaskLabel->setText(node->GetName().c_str());
         m_BrainMaskNode = node;
     }
   }
 
   // Preparation of GUI to start denoising if a filter is selected
   if (m_ImageNode.IsNotNull() && m_SelectedFilter != NOFILTERSELECTED)
   {
     m_Controls->m_ApplyButton->setEnabled(true);
   }
 }
 
 void QmitkDenoisingView::StartDenoising()
 {
   if (!m_ThreadIsRunning)
   {
     if (m_ImageNode.IsNotNull())
     {
       m_LastProgressCount = 0;
       switch (m_SelectedFilter)
       {
         case NOFILTERSELECTED:
         {
           break;
         }
         case NLM:
         {
           // initialize NLM
           m_InputImage = dynamic_cast<mitk::Image*> (m_ImageNode->GetData());
           m_NonLocalMeansFilter = NonLocalMeansDenoisingFilterType::New();
 
           if (m_BrainMaskNode.IsNotNull())
           {
             // use brainmask if set
             m_ImageMask = dynamic_cast<mitk::Image*>(m_BrainMaskNode->GetData());
             itk::Image<DiffusionPixelType, 3>::Pointer itkMask;
             mitk::CastToItkImage(m_ImageMask, itkMask);
             m_NonLocalMeansFilter->SetInputMask(itkMask);
 
             itk::ImageRegionIterator< itk::Image<DiffusionPixelType, 3> > mit(itkMask, itkMask->GetLargestPossibleRegion());
             mit.GoToBegin();
             itk::Image<DiffusionPixelType, 3>::IndexType minIndex;
             itk::Image<DiffusionPixelType, 3>::IndexType maxIndex;
             minIndex.Fill(10000);
             maxIndex.Fill(0);
             while (!mit.IsAtEnd())
             {
               if (mit.Get())
               {
                 // calculation of the start & end index of the smallest masked region
                 minIndex[0] = minIndex[0] < mit.GetIndex()[0] ? minIndex[0] : mit.GetIndex()[0];
                 minIndex[1] = minIndex[1] < mit.GetIndex()[1] ? minIndex[1] : mit.GetIndex()[1];
                 minIndex[2] = minIndex[2] < mit.GetIndex()[2] ? minIndex[2] : mit.GetIndex()[2];
 
                 maxIndex[0] = maxIndex[0] > mit.GetIndex()[0] ? maxIndex[0] : mit.GetIndex()[0];
                 maxIndex[1] = maxIndex[1] > mit.GetIndex()[1] ? maxIndex[1] : mit.GetIndex()[1];
                 maxIndex[2] = maxIndex[2] > mit.GetIndex()[2] ? maxIndex[2] : mit.GetIndex()[2];
               }
               ++mit;
             }
             itk::Image<DiffusionPixelType, 3>::SizeType size;
             size[0] = maxIndex[0] - minIndex[0] + 1;
             size[1] = maxIndex[1] - minIndex[1] + 1;
             size[2] = maxIndex[2] - minIndex[2] + 1;
 
             m_MaxProgressCount = size[0] * size[1] * size[2];
           }
           else
           {
             // initialize the progressbar
             m_MaxProgressCount = m_InputImage->GetDimension(0) * m_InputImage->GetDimension(1) * m_InputImage->GetDimension(2);
           }
 
 
           mitk::ProgressBar::GetInstance()->AddStepsToDo(m_MaxProgressCount);
 
           ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
   mitk::CastToItkImage(m_InputImage, itkVectorImagePointer);
 
           m_NonLocalMeansFilter->SetInputImage( itkVectorImagePointer );
           m_NonLocalMeansFilter->SetUseRicianAdaption(m_Controls->m_RicianCheckbox->isChecked());
           m_NonLocalMeansFilter->SetUseJointInformation(m_Controls->m_JointInformationCheckbox->isChecked());
           m_NonLocalMeansFilter->SetSearchRadius(m_Controls->m_SpinBoxParameter1->value());
           m_NonLocalMeansFilter->SetComparisonRadius(m_Controls->m_SpinBoxParameter2->value());
           m_NonLocalMeansFilter->SetVariance(m_Controls->m_DoubleSpinBoxParameter3->value());
 
 
 
 
 
           // start denoising in detached thread
           m_DenoisingThread.start(QThread::HighestPriority);
 
           break;
         }
         case GAUSS:
         {
           // initialize GAUSS and run
           m_InputImage = dynamic_cast<mitk::Image*> (m_ImageNode->GetData());
 
           ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
           mitk::CastToItkImage(m_InputImage, itkVectorImagePointer);
 
           ExtractFilterType::Pointer extractor = ExtractFilterType::New();
           extractor->SetInput( itkVectorImagePointer );
           ComposeFilterType::Pointer composer = ComposeFilterType::New();
 
           for (unsigned int i = 0; i < itkVectorImagePointer->GetVectorLength(); ++i)
           {
             extractor->SetIndex(i);
             extractor->Update();
 
             m_GaussianFilter = GaussianFilterType::New();
             m_GaussianFilter->SetVariance(m_Controls->m_SpinBoxParameter1->value());
 
             if (m_BrainMaskNode.IsNotNull())
             {
               m_ImageMask = dynamic_cast<mitk::Image*>(m_BrainMaskNode->GetData());
               itk::Image<DiffusionPixelType, 3>::Pointer itkMask = itk::Image<DiffusionPixelType, 3>::New();
               mitk::CastToItkImage(m_ImageMask, itkMask);
 
               itk::MaskImageFilter<itk::Image<DiffusionPixelType, 3> , itk::Image<DiffusionPixelType, 3> >::Pointer maskImageFilter = itk::MaskImageFilter<itk::Image<DiffusionPixelType, 3> , itk::Image<DiffusionPixelType, 3> >::New();
               maskImageFilter->SetInput(extractor->GetOutput());
               maskImageFilter->SetMaskImage(itkMask);
               maskImageFilter->Update();
               m_GaussianFilter->SetInput(maskImageFilter->GetOutput());
             }
             else
             {
               m_GaussianFilter->SetInput(extractor->GetOutput());
             }
             m_GaussianFilter->Update();
 
             composer->SetInput(i, m_GaussianFilter->GetOutput());
           }
           composer->Update();
 
 
           mitk::Image::Pointer image = mitk::GrabItkImageMemory(composer->GetOutput());
 
           image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( static_cast<mitk::GradientDirectionsProperty*>( m_InputImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() ) );
           image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(m_InputImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
 
           mitk::DiffusionPropertyHelper propertyHelper( image );
           propertyHelper.InitializeImage();
 
           mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
           imageNode->SetData( image );
           QString name = m_ImageNode->GetName().c_str();
 
           imageNode->SetName((name+"_gauss_"+QString::number(m_Controls->m_SpinBoxParameter1->value())).toStdString().c_str());
-          GetDefaultDataStorage()->Add(imageNode);
+          GetDataStorage()->Add(imageNode);
 
           break;
         }
       }
     }
   }
 
   else
   {
     m_NonLocalMeansFilter->AbortGenerateDataOn();
     m_CompletedCalculation = false;
   }
 }
 
 void QmitkDenoisingView::ResetParameterPanel()
 {
   m_Controls->m_DwiLabel->setEnabled(false);
   m_Controls->m_InputImageLabel->setEnabled(false);
   m_Controls->m_BrainMaskLabel->setEnabled(false);
   m_Controls->m_InputBrainMaskLabel->setEnabled(false);
   m_Controls->m_ParameterBox->hide();
   m_Controls->m_LabelParameter_1->hide();
   m_Controls->m_LabelParameter_2->hide();
   m_Controls->m_LabelParameter_3->hide();
   m_Controls->m_SpinBoxParameter1->hide();
   m_Controls->m_SpinBoxParameter2->hide();
   m_Controls->m_DoubleSpinBoxParameter3->hide();
   m_Controls->m_RicianLabel->hide();
   m_Controls->m_RicianCheckbox->hide();
   m_Controls->m_JointInformationLabel->hide();
   m_Controls->m_JointInformationCheckbox->hide();
   m_Controls->m_ApplyButton->setEnabled(false);
 }
 
 void QmitkDenoisingView::SelectFilter(int filter)
 {
   if (m_ThreadIsRunning)
     return;
 
   //Prepare GUI
   this->ResetParameterPanel();
 
   switch (filter)
   {
     case 0:
     {
       m_SelectedFilter = NOFILTERSELECTED;
 
       break;
     }
 
     case 1:
     {
       m_SelectedFilter = NLM;
       m_Controls->m_DwiLabel->setEnabled(true);
       m_Controls->m_InputImageLabel->setEnabled(true);
       m_Controls->m_BrainMaskLabel->setEnabled(true);
       m_Controls->m_InputBrainMaskLabel->setEnabled(true);
       m_Controls->m_ParameterBox->show();
       m_Controls->m_LabelParameter_1->show();
       m_Controls->m_LabelParameter_1->setText("Search Radius:");
       m_Controls->m_LabelParameter_2->show();
       m_Controls->m_LabelParameter_2->setText("Comparision Radius:");
       m_Controls->m_LabelParameter_3->show();
       m_Controls->m_LabelParameter_3->setText("Noise variance:");
       m_Controls->m_SpinBoxParameter1->show();
       m_Controls->m_SpinBoxParameter1->setValue(4);
       m_Controls->m_SpinBoxParameter2->show();
       m_Controls->m_SpinBoxParameter2->setValue(1);
       m_Controls->m_DoubleSpinBoxParameter3->show();
       m_Controls->m_DoubleSpinBoxParameter3->setValue(1.0);
       m_Controls->m_RicianLabel->show();
       m_Controls->m_RicianCheckbox->show();
       m_Controls->m_RicianCheckbox->setChecked(true);
       m_Controls->m_JointInformationLabel->show();
       m_Controls->m_JointInformationCheckbox->show();
       m_Controls->m_JointInformationCheckbox->setChecked(false);
 
       break;
     }
 
     case 2:
     {
       m_SelectedFilter = GAUSS;
       m_Controls->m_DwiLabel->setEnabled(true);
       m_Controls->m_InputImageLabel->setEnabled(true);
       m_Controls->m_BrainMaskLabel->setEnabled(true);
       m_Controls->m_InputBrainMaskLabel->setEnabled(true);
       m_Controls->m_ParameterBox->show();
       m_Controls->m_LabelParameter_1->show();
       m_Controls->m_LabelParameter_1->setText("Variance:");
       m_Controls->m_SpinBoxParameter1->show();
       m_Controls->m_SpinBoxParameter1->setValue(2);
 
       break;
     }
   }
 
   if (m_ImageNode.IsNull())
   {
     if (m_SelectedFilter != NOFILTERSELECTED)
       m_Controls->m_InputImageLabel->setText("<font color='red'>mandatory</font>");
     else
       m_Controls->m_InputImageLabel->setText("mandatory");
   }
 
   if (m_ImageNode.IsNotNull())
   {
     m_Controls->m_ApplyButton->setEnabled(false);
     switch(filter)
     {
       case NOFILTERSELECTED:
       {
         break;
       }
       case NLM:
       case GAUSS:
       {
         m_Controls->m_ApplyButton->setEnabled(true);
         break;
       }
     }
   }
 }
 
 void QmitkDenoisingView::BeforeThread()
 {
   m_ThreadIsRunning = true;
 
   // initialize timer to update the progressbar at each timestep
   m_DenoisingTimer->start(500);
   m_Controls->m_ParameterBox->setEnabled(false);
   m_Controls->m_ApplyButton->setText("Abort");
 }
 
 void QmitkDenoisingView::AfterThread()
 {
   m_ThreadIsRunning = false;
   // stop timer to stop updates of progressbar
   m_DenoisingTimer->stop();
   // make sure progressbar is finished
   mitk::ProgressBar::GetInstance()->Progress(m_MaxProgressCount);
   if (m_CompletedCalculation)
   {
     switch (m_SelectedFilter)
     {
       case NOFILTERSELECTED:
       case GAUSS:
       {
         break;
       }
 
       case NLM:
         {
           mitk::Image::Pointer image = mitk::GrabItkImageMemory( m_NonLocalMeansFilter->GetOutput() );
           image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( static_cast<mitk::GradientDirectionsProperty*>( m_InputImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() ) );
           image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(m_InputImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
           mitk::DiffusionPropertyHelper propertyHelper( image );
           propertyHelper.InitializeImage();
 
           mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
           imageNode->SetData( image );
         QString name = m_ImageNode->GetName().c_str();
 
         //TODO: Rician adaption & joint information in name
         if (m_Controls->m_RicianCheckbox->isChecked() && !m_Controls->m_JointInformationCheckbox->isChecked())
         {
           imageNode->SetName((name+"_NLMr_"+QString::number(m_Controls->m_SpinBoxParameter1->value())+"-"+QString::number(m_Controls->m_SpinBoxParameter2->value())).toStdString().c_str());
         }
         else if(!m_Controls->m_RicianCheckbox->isChecked() && m_Controls->m_JointInformationCheckbox->isChecked())
         {
           imageNode->SetName((name+"_NLMv_"+QString::number(m_Controls->m_SpinBoxParameter1->value())+"-"+QString::number(m_Controls->m_SpinBoxParameter2->value())).toStdString().c_str());
         }
         else if(m_Controls->m_RicianCheckbox->isChecked() && m_Controls->m_JointInformationCheckbox->isChecked())
         {
           imageNode->SetName((name+"_NLMvr_"+QString::number(m_Controls->m_SpinBoxParameter1->value())+"-"+QString::number(m_Controls->m_SpinBoxParameter2->value())).toStdString().c_str());
         }
         else
         {
           imageNode->SetName((name+"_NLM_"+QString::number(m_Controls->m_SpinBoxParameter1->value())+"-"+QString::number(m_Controls->m_SpinBoxParameter2->value())).toStdString().c_str());
         }
-        GetDefaultDataStorage()->Add(imageNode);
+        GetDataStorage()->Add(imageNode);
         break;
       }
     }
   }
 
   m_Controls->m_ParameterBox->setEnabled(true);
   m_Controls->m_ApplyButton->setText("Apply");
 }
 
 void QmitkDenoisingView::UpdateProgress()
 {
   switch (m_SelectedFilter)
   {
     case NOFILTERSELECTED:
     case GAUSS:
     {
       break;
     }
     case NLM:
     {
       unsigned int currentProgressCount = m_NonLocalMeansFilter->GetCurrentVoxelCount();
       mitk::ProgressBar::GetInstance()->Progress(currentProgressCount-m_LastProgressCount);
       m_LastProgressCount = currentProgressCount;
       break;
     }
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDenoisingView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDenoisingView.h
index 8da26d4ca8..1bfbb673f9 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDenoisingView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDenoisingView.h
@@ -1,134 +1,135 @@
 /*===================================================================
 
 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 _QMITKQmitkDenoisingView_H_INCLUDED
 #define _QMITKQmitkDenoisingView_H_INCLUDED
 
 #include <berryISelectionListener.h>
 
-#include <QmitkFunctionality.h>
+#include <QmitkAbstractView.h>
 
 #include "ui_QmitkDenoisingViewControls.h"
 
 #include <itkVectorImage.h>
 #include <itkImage.h>
 #include <mitkImage.h>
 #include <itkNonLocalMeansDenoisingFilter.h>
 #include <itkMaskImageFilter.h>
 #include <itkDiscreteGaussianImageFilter.h>
 #include <itkVectorImageToImageFilter.h>
 #include <itkComposeImageFilter.h>
 #include <QThread>
 #include <QTimer>
 
 /**
  * \class QmitkDenoisingView
  * \brief View displaying details to denoise diffusionweighted images.
- *
- * \sa QmitkFunctionality
- * \ingroup Functionalities
  */
 class QmitkDenoisingView;
 
 class QmitkDenoisingWorker : public QObject
 {
   Q_OBJECT
 
 public:
 
   QmitkDenoisingWorker(QmitkDenoisingView* view);
 
 public slots:
 
   void run();
 
 private:
 
   QmitkDenoisingView* m_View;
 };
 
 
-class QmitkDenoisingView : public QmitkFunctionality
+class QmitkDenoisingView : public QmitkAbstractView
 {
   // 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:
 
   static const std::string VIEW_ID;
 
   QmitkDenoisingView();
   virtual ~QmitkDenoisingView();
 
   /** Typedefs */
   typedef short                                                                                                         DiffusionPixelType;
   typedef mitk::Image                                                                                                   MaskImageType;
   typedef itk::NonLocalMeansDenoisingFilter< DiffusionPixelType >                                                       NonLocalMeansDenoisingFilterType;
   typedef itk::DiscreteGaussianImageFilter < itk::Image< DiffusionPixelType, 3>, itk::Image< DiffusionPixelType, 3> >   GaussianFilterType;
   typedef itk::VectorImageToImageFilter < DiffusionPixelType >                                                          ExtractFilterType;
   typedef itk::ComposeImageFilter < itk::Image<DiffusionPixelType, 3> >                                                 ComposeFilterType;
   typedef itk::VectorImage<DiffusionPixelType, 3>
     ITKDiffusionImageType;
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
   /// \brief Creation of the connections of main and control widget
   virtual void CreateConnections();
-  /// \brief Creation of the connections of the FilterComboBox
-  virtual void Activated() override;
+
+  ///
+  /// Sets the focus to an internal widget.
+  ///
+  virtual void SetFocus() override;
 
 private slots:
 
   void StartDenoising();                  //< prepares filter condition and starts thread for denoising
   void SelectFilter(int filter);          //< updates which filter is selected
   void BeforeThread();                    //< starts timer & disables all buttons while denoising
   void AfterThread();                     //< stops timer & creates a new datanode of the denoised image
   void UpdateProgress();                  //< updates the progressbar each timestep
 
 private:
 
-  /// \brief called by QmitkFunctionality when DataManager's selection has changed
-  virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes ) override;
+  /// \brief called by QmitkAbstractView when DataManager's selection has changed
+  virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
+
   void ResetParameterPanel();
 
   Ui::QmitkDenoisingViewControls*  m_Controls;
   mitk::DataNode::Pointer m_ImageNode;
   mitk::DataNode::Pointer m_BrainMaskNode;
   QmitkDenoisingWorker m_DenoisingWorker;
   QThread m_DenoisingThread;
   bool m_ThreadIsRunning;
   bool m_CompletedCalculation;
   NonLocalMeansDenoisingFilterType::Pointer m_NonLocalMeansFilter;
   GaussianFilterType::Pointer m_GaussianFilter;
   mitk::Image::Pointer m_InputImage;
   MaskImageType::Pointer m_ImageMask;
   QTimer* m_DenoisingTimer;
   unsigned int m_LastProgressCount;
   unsigned int m_MaxProgressCount;
 
   enum FilterType {
     NOFILTERSELECTED,
     NLM,
     GAUSS
   }m_SelectedFilter;
 
   friend class QmitkDenoisingWorker;
 };
 
 
 
 #endif // _QmitkDenoisingView_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp
index 6930ce34df..91e0be3a3f 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.cpp
@@ -1,558 +1,558 @@
 /*===================================================================
 
 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 "QmitkDiffusionDicomImportView.h"
 
 // qt includes
 #include <QFileDialog>
 
 // itk includes
 #include "itkTimeProbesCollectorBase.h"
 #include "itkGDCMSeriesFileNames.h"
 #include "itksys/SystemTools.hxx"
 
 // mitk includes
 #include "mitkProgressBar.h"
 #include "mitkStatusBar.h"
 #include "mitkProperties.h"
 #include "mitkRenderingManager.h"
 #include "mitkMemoryUtilities.h"
 #include "mitkIOUtil.h"
 
 // diffusion module includes
 #include "mitkDicomDiffusionImageHeaderReader.h"
 #include "mitkDicomDiffusionImageReader.h"
 #include "mitkImage.h"
 #include <mitkDiffusionPropertyHelper.h>
 
 #include "mitkDiffusionDICOMFileReader.h"
 #include "mitkDICOMTagBasedSorter.h"
 #include "mitkDICOMSortByTag.h"
 #include "mitkSortByImagePositionPatient.h"
 
 #include "gdcmDirectory.h"
 #include "gdcmScanner.h"
 #include "gdcmSorter.h"
 #include "gdcmIPPSorter.h"
 #include "gdcmAttribute.h"
 #include "gdcmVersion.h"
 
 #include <itksys/SystemTools.hxx>
 #include <itksys/Directory.hxx>
 
 #include <QMessageBox>
 
 const std::string QmitkDiffusionDicomImport::VIEW_ID = "org.mitk.views.diffusiondicomimport";
 
 
 QmitkDiffusionDicomImport::QmitkDiffusionDicomImport(QObject* /*parent*/, const char* /*name*/)
-  : QmitkFunctionality(), m_Controls(NULL), m_MultiWidget(NULL),
+  : QmitkAbstractView(), m_Controls(NULL),
     m_OutputFolderName(""), m_OutputFolderNameSet(false)
 {
 }
 
 QmitkDiffusionDicomImport::QmitkDiffusionDicomImport(const QmitkDiffusionDicomImport& other)
 {
   Q_UNUSED(other)
   throw std::runtime_error("Copy constructor not implemented");
 }
 
 QmitkDiffusionDicomImport::~QmitkDiffusionDicomImport()
 {}
 
 void QmitkDiffusionDicomImport::CreateQtPartControl(QWidget *parent)
 {
   m_Parent = parent;
   if (m_Controls == NULL)
   {
     m_Controls = new Ui::QmitkDiffusionDicomImportControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     m_Controls->m_DicomLoadRecursiveCheckbox->setChecked(false);
     m_Controls->m_DicomLoadAverageDuplicatesCheckbox->setChecked(false);
 
     m_Controls->m_DicomLoadRecursiveCheckbox->setVisible(true);
     m_Controls->m_OverrideOptionCheckbox->setVisible(false);
     m_Controls->m_SubdirPrefixLineEdit->setVisible(false);
     m_Controls->m_SetPrefixButton->setVisible(false);
     m_Controls->m_ResetPrefixButton->setVisible(false);
 
     AverageClicked();
   }
 }
 
 
 
 void QmitkDiffusionDicomImport::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( m_Controls->m_AddFoldersButton, SIGNAL(clicked()), this, SLOT(DicomLoadAddFolderNames()) );
     connect( m_Controls->m_DeleteFoldersButton, SIGNAL(clicked()), this, SLOT(DicomLoadDeleteFolderNames()) );
     //connect( m_Controls->m_DicomLoadStartLoadButton, SIGNAL(clicked()), this, SLOT(DicomLoadStartLoad()) );
     connect( m_Controls->m_DicomLoadStartLoadButton, SIGNAL(clicked()), this, SLOT(NewDicomLoadStartLoad()) );
     connect( m_Controls->m_DicomLoadAverageDuplicatesCheckbox, SIGNAL(clicked()), this, SLOT(AverageClicked()) );
     connect( m_Controls->m_OutputSetButton, SIGNAL(clicked()), this, SLOT(OutputSet()) );
     connect( m_Controls->m_OutputClearButton, SIGNAL(clicked()), this, SLOT(OutputClear()) );
     connect( m_Controls->m_Remove, SIGNAL(clicked()), this, SLOT(Remove()) );
     connect( m_Controls->m_SetPrefixButton, SIGNAL(clicked()), this, SLOT(SetPrefixButtonPushed()));
     connect( m_Controls->m_ResetPrefixButton, SIGNAL(clicked()), this, SLOT(ResetPrefixButtonPushed()));
     connect( m_Controls->m_DicomLoadRecursiveCheckbox, SIGNAL(clicked()), this, SLOT(RecursiveSettingsChanged()) );
   }
 }
 
+void QmitkDiffusionDicomImport::SetFocus()
+{
+  m_Controls->textBrowser->setFocus();
+}
+
 void QmitkDiffusionDicomImport::RecursiveSettingsChanged()
 {
   m_Controls->m_SubdirPrefixLineEdit->setVisible( m_Controls->m_DicomLoadRecursiveCheckbox->isChecked() );
   m_Controls->m_SetPrefixButton->setVisible( m_Controls->m_DicomLoadRecursiveCheckbox->isChecked() );
   m_Controls->m_SubdirPrefixLineEdit->clear();
   this->m_Controls->m_SubdirPrefixLineEdit->setEnabled(true);
 }
 
 void QmitkDiffusionDicomImport::SetPrefixButtonPushed()
 {
   m_Prefix = this->m_Controls->m_SubdirPrefixLineEdit->text().toStdString();
   if( !this->m_Controls->m_ResetPrefixButton->isVisible() )
     this->m_Controls->m_ResetPrefixButton->setVisible(true);
 
   this->m_Controls->m_SubdirPrefixLineEdit->setEnabled(false);
   this->m_Controls->m_ResetPrefixButton->setEnabled(true);
   this->m_Controls->m_SetPrefixButton->setEnabled(false);
 }
 
 void QmitkDiffusionDicomImport::ResetPrefixButtonPushed()
 {
   m_Controls->m_SubdirPrefixLineEdit->clear();
 
   this->m_Controls->m_SubdirPrefixLineEdit->setEnabled(true);
 
   this->m_Controls->m_ResetPrefixButton->setEnabled(false);
   this->m_Controls->m_SetPrefixButton->setEnabled(true);
 }
 
 void QmitkDiffusionDicomImport::Remove()
 {
   int i = m_Controls->listWidget->currentRow();
   m_Controls->listWidget->takeItem(i);
 }
 
 void QmitkDiffusionDicomImport::OutputSet()
 {
   // SELECT FOLDER DIALOG
   QFileDialog* w = new QFileDialog( m_Parent, QString("Select folders containing DWI data") );
   w->setFileMode( QFileDialog::Directory );
 
   // RETRIEVE SELECTION
   if ( w->exec() != QDialog::Accepted )
     return;
 
   m_OutputFolderName = w->selectedFiles()[0];
   m_OutputFolderNameSet = true;
   m_Controls->m_OutputLabel->setText(m_OutputFolderName);
 
   // show file override option checkbox
   m_Controls->m_OverrideOptionCheckbox->setVisible(true);
 }
 
 void QmitkDiffusionDicomImport::OutputClear()
 {
   m_OutputFolderName = "";
   m_OutputFolderNameSet = false;
   m_Controls->m_OutputLabel->setText("... optional out-folder ...");
 
   // hide file override option checkbox - no output specified
   m_Controls->m_OverrideOptionCheckbox->setVisible(false);
 }
 
 void QmitkDiffusionDicomImport::AverageClicked()
 {
   m_Controls->m_Blur->setEnabled(m_Controls->m_DicomLoadAverageDuplicatesCheckbox->isChecked());
 }
 
-void QmitkDiffusionDicomImport::Activated()
-{
-  QmitkFunctionality::Activated();
-}
-
 void QmitkDiffusionDicomImport::DicomLoadDeleteFolderNames()
 {
   m_Controls->listWidget->clear();
 }
 
 void QmitkDiffusionDicomImport::DicomLoadAddFolderNames()
 {
   // SELECT FOLDER DIALOG
   QFileDialog* w = new QFileDialog( m_Parent, QString("Select folders containing DWI data") );
   w->setFileMode( QFileDialog::Directory );
 
   // RETRIEVE SELECTION
   if ( w->exec() != QDialog::Accepted )
     return;
 
   m_Controls->listWidget->addItems(w->selectedFiles());
 }
 
 bool SortBySeriesUID(gdcm::DataSet const & ds1, gdcm::DataSet const & ds2 )
 {
   gdcm::Attribute<0x0020,0x000e> at1;
   at1.Set( ds1 );
   gdcm::Attribute<0x0020,0x000e> at2;
   at2.Set( ds2 );
   return at1 < at2;
 }
 
 bool SortByAcquisitionNumber(gdcm::DataSet const & ds1, gdcm::DataSet const & ds2 )
 {
   gdcm::Attribute<0x0020,0x0012> at1;
   at1.Set( ds1 );
   gdcm::Attribute<0x0020,0x0012> at2;
   at2.Set( ds2 );
   return at1 < at2;
 }
 
 bool SortBySeqName(gdcm::DataSet const & ds1, gdcm::DataSet const & ds2 )
 {
   gdcm::Attribute<0x0018, 0x0024> at1;
   at1.Set( ds1 );
   gdcm::Attribute<0x0018, 0x0024> at2;
   at2.Set( ds2 );
 
   std::string str1 = at1.GetValue().Trim();
   std::string str2 = at2.GetValue().Trim();
   return std::lexicographical_compare(str1.begin(), str1.end(),
                                       str2.begin(), str2.end() );
 }
 
 void QmitkDiffusionDicomImport::Status(QString status)
 {
   mitk::StatusBar::GetInstance()->DisplayText(status.toLatin1());
   MITK_INFO << status.toStdString().c_str();
 }
 
 void QmitkDiffusionDicomImport::Status(std::string status)
 {
   mitk::StatusBar::GetInstance()->DisplayText(status.c_str());
   MITK_INFO << status.c_str();
 }
 
 void QmitkDiffusionDicomImport::Status(const char* status)
 {
   mitk::StatusBar::GetInstance()->DisplayText(status);
   MITK_INFO << status;
 }
 
 void QmitkDiffusionDicomImport::Error(QString status)
 {
   mitk::StatusBar::GetInstance()->DisplayErrorText(status.toLatin1());
   MITK_ERROR << status.toStdString().c_str();
 }
 
 void QmitkDiffusionDicomImport::Error(std::string status)
 {
   mitk::StatusBar::GetInstance()->DisplayErrorText(status.c_str());
   MITK_ERROR << status.c_str();
 }
 
 void QmitkDiffusionDicomImport::Error(const char* status)
 {
   mitk::StatusBar::GetInstance()->DisplayErrorText(status);
   MITK_ERROR << status;
 }
 
 void QmitkDiffusionDicomImport::PrintMemoryUsage()
 {
   size_t processSize = mitk::MemoryUtilities::GetProcessMemoryUsage();
   size_t totalSize =  mitk::MemoryUtilities::GetTotalSizeOfPhysicalRam();
   float percentage = ( (float) processSize / (float) totalSize ) * 100.0;
   MITK_INFO << "Current memory usage: " << GetMemoryDescription( processSize, percentage );
 }
 
 std::string QmitkDiffusionDicomImport::FormatMemorySize( size_t size )
 {
   double val = size;
   std::string descriptor("B");
   if ( val >= 1000.0 )
   {
     val /= 1024.0;
     descriptor = "KB";
   }
   if ( val >= 1000.0 )
   {
     val /= 1024.0;
     descriptor = "MB";
   }
   if ( val >= 1000.0 )
   {
     val /= 1024.0;
     descriptor = "GB";
   }
   std::ostringstream str;
   str << std::fixed << std::setprecision(2) << val << " " << descriptor;
   return str.str();
 }
 
 std::string QmitkDiffusionDicomImport::FormatPercentage( double val )
 {
   std::ostringstream str;
   str << std::fixed << std::setprecision(2) << val << " " << "%";
   return str.str();
 }
 
 std::string QmitkDiffusionDicomImport::GetMemoryDescription( size_t processSize, float percentage )
 {
   std::ostringstream str;
   str << FormatMemorySize(processSize) << " (" << FormatPercentage( percentage ) <<")" ;
   return str.str();
 }
 
 void QmitkDiffusionDicomImport::NewDicomLoadStartLoad()
 {
   itk::TimeProbesCollectorBase clock;
   bool imageSuccessfullySaved = true;
 
   bool has_prefix = true;
 
   try
   {
     const std::string& locale = "C";
     const std::string& currLocale = setlocale( LC_ALL, NULL );
 
     if ( locale.compare(currLocale)!=0 )
     {
       try
       {
         MITK_INFO << " ** Changing locale from " << setlocale(LC_ALL, NULL) << " to '" << locale << "'";
         setlocale(LC_ALL, locale.c_str());
       }
       catch(...)
       {
         MITK_INFO << "Could not set locale " << locale;
       }
     }
 
     int nrFolders = m_Controls->listWidget->count();
 
     if(!nrFolders)
     {
       Error(QString("No input folders were selected. ABORTING."));
       return;
     }
 
     Status(QString("GDCM %1 used for DICOM parsing and sorting!").arg(gdcm::Version::GetVersion()));
 
     PrintMemoryUsage();
     QString status;
     mitk::DataNode::Pointer node;
     mitk::ProgressBar::GetInstance()->AddStepsToDo(2*nrFolders);
 
     gdcm::Directory::FilenamesType complete_list;
     while(m_Controls->listWidget->count())
     {
       // RETREIVE FOLDERNAME
       QListWidgetItem * item  = m_Controls->listWidget->takeItem(0);
       QString folderName = item->text();
 
 
       if( this->m_Controls->m_DicomLoadRecursiveCheckbox->isChecked() )
       {
 
         std::string subdir_prefix = "";
         if( has_prefix )
         {
           subdir_prefix = this->m_Prefix;
         }
 
         itksys::Directory rootdir;
         rootdir.Load( folderName.toStdString().c_str() );
 
         for( unsigned int idx=0; idx<rootdir.GetNumberOfFiles(); idx++)
         {
           std::string current_path = rootdir.GetFile(idx);
           std::string directory_path = std::string(rootdir.GetPath()) + std::string("/") + current_path;
 
           MITK_INFO("dicom.loader.inputrootdir.test") << "ProbePath:   " << current_path;
           MITK_INFO("dicom.loader.inputrootdir.test") << "IsDirectory: " << itksys::SystemTools::FileIsDirectory( itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() ).c_str() )
                                                       << " StartsWith: " << itksys::SystemTools::StringStartsWith( current_path.c_str(), subdir_prefix.c_str() );
 
           // test for prefix
           if(    itksys::SystemTools::FileIsDirectory( itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() ).c_str() )
                  && itksys::SystemTools::StringStartsWith( current_path.c_str(), subdir_prefix.c_str() )
                  )
           {
 
             gdcm::Directory d;
             d.Load( itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() ) , false);
 
             MITK_INFO("dicom.load.subdir.attempt") << "In directory " << itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() );
 
             const gdcm::Directory::FilenamesType &l1 = d.GetFilenames();
             const unsigned int ntotalfiles = l1.size();
             Status(QString(" ... found %1 different files").arg(ntotalfiles));
 
             for( unsigned int i=0; i< ntotalfiles; i++)
             {
               complete_list.push_back( l1.at(i) );
             }
 
 
           }
 
         }
       }
       else
       {
         gdcm::Directory d;
         d.Load( folderName.toStdString().c_str(), this->m_Controls->m_DicomLoadRecursiveCheckbox->isChecked() ); // recursive !
         const gdcm::Directory::FilenamesType &l1 = d.GetFilenames();
         const unsigned int ntotalfiles = l1.size();
         Status(QString(" ... found %1 different files").arg(ntotalfiles));
 
         for( unsigned int i=0; i< ntotalfiles; i++)
         {
           complete_list.push_back( l1.at(i) );
         }
 
       }
 
 
 
     }
 
     {
       mitk::DiffusionDICOMFileReader::Pointer gdcmReader = mitk::DiffusionDICOMFileReader::New();
       mitk::DICOMTagBasedSorter::Pointer tagSorter = mitk::DICOMTagBasedSorter::New();
 
       // Use tags as in Qmitk
       // all the things that split by tag in DicomSeriesReader
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0010) ); // Number of Rows
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0011) ); // Number of Columns
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0030) ); // Pixel Spacing
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0018, 0x1164) ); // Imager Pixel Spacing
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0020, 0x0037) ); // Image Orientation (Patient) // TODO add tolerance parameter (l. 1572 of original code)
       // TODO handle as real vectors! cluster with configurable errors!
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0020, 0x000e) ); // Series Instance UID
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0018, 0x0050) ); // Slice Thickness
       tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0008) ); // Number of Frames
       //tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0020, 0x0052) ); // Frame of Reference UID
 
       // gdcmReader->AddSortingElement( tagSorter );
       //mitk::DICOMFileReaderTestHelper::TestOutputsContainInputs( gdcmReader );
 
       mitk::DICOMSortCriterion::ConstPointer sorting =
         mitk::SortByImagePositionPatient::New(  // Image Position (Patient)
           //mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0020, 0x0013), // instance number
              mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0020, 0x0012), // aqcuisition number
                 mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0008, 0x0032), // aqcuisition time
                    mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0018, 0x1060), // trigger time
                       mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0008, 0x0018) // SOP instance UID (last resort, not really meaningful but decides clearly)
                     ).GetPointer()
                   ).GetPointer()
                 ).GetPointer()
              ).GetPointer()
         // ).GetPointer()
         ).GetPointer();
       tagSorter->SetSortCriterion( sorting );
 
       // mosaic
       gdcmReader->SetResolveMosaic( this->m_Controls->m_SplitMosaicCheckBox->isChecked() );
       gdcmReader->AddSortingElement( tagSorter );
       gdcmReader->SetInputFiles( complete_list );
       try
       {
         gdcmReader->AnalyzeInputFiles();
       }
       catch( const itk::ExceptionObject &e)
       {
         MITK_ERROR << "Failed to analyze data. " << e.what();
       }
       catch( const std::exception &se)
       {
         MITK_ERROR << "Std Exception " << se.what();
       }
 
       gdcmReader->LoadImages();
 
       for( int o = 0; o < gdcmReader->GetNumberOfOutputs(); o++ )
       {
         mitk::Image::Pointer loaded_image = gdcmReader->GetOutput(o).GetMitkImage();
 
         std::stringstream ss;
         ss << "ImportedData_" << o;
 
         node = mitk::DataNode::New();
         node->SetData( loaded_image );
         std::string outname;
         loaded_image->GetPropertyList()->GetStringProperty("diffusion.dicom.importname", outname );
 
         node->SetName( outname.c_str() );
 
-        GetDefaultDataStorage()->Add(node);
+        GetDataStorage()->Add(node);
         //SetDwiNodeProperties(node, ss.str() );
         //Status(QString("Image %1 added to datastorage").arg(descr));
       }
 
 
 
     }
 
     Status("Timing information");
     clock.Report();
 
     if(!m_OutputFolderNameSet && node.IsNotNull())
     {
       mitk::BaseData::Pointer basedata = node->GetData();
       if (basedata.IsNotNull())
       {
         mitk::RenderingManager::GetInstance()->InitializeViews(
               basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
       }
     }
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
     try
     {
       MITK_INFO << " ** Changing locale back from " << setlocale(LC_ALL, NULL) << " to '" << currLocale << "'";
       setlocale(LC_ALL, currLocale.c_str());
     }
     catch(...)
     {
       MITK_INFO << "Could not reset locale " << currLocale;
     }
   }
   catch (itk::ExceptionObject &ex)
   {
     Error(QString("%1\n%2\n%3\n%4\n%5\n%6").arg(ex.GetNameOfClass()).arg(ex.GetFile()).arg(ex.GetLine()).arg(ex.GetLocation()).arg(ex.what()).arg(ex.GetDescription()));
     return ;
   }
 
   if (!imageSuccessfullySaved)
     QMessageBox::warning(NULL,"WARNING","One or more files could not be saved! The according files where moved to the datastorage.");
   Status(QString("Finished import with memory:"));
 
   PrintMemoryUsage();
 }
 
 void QmitkDiffusionDicomImport::SetDwiNodeProperties(mitk::DataNode::Pointer node, std::string name)
 {
 
   node->SetProperty( "IsDWIRawVolume", mitk::BoolProperty::New( true ) );
 
   // set foldername as string property
   mitk::StringProperty::Pointer nameProp = mitk::StringProperty::New( name );
   node->SetProperty( "name", nameProp );
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.h
index 623b1c97e6..2cf66c213b 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionDicomImportView.h
@@ -1,115 +1,113 @@
 /*===================================================================
 
 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 QmitkDiffusionDicomImportView_H__INCLUDED
 #define QmitkDiffusionDicomImportView_H__INCLUDED
 
-#include "QmitkFunctionality.h"
+#include <QmitkAbstractView.h>
 #include "ui_QmitkDiffusionDicomImportViewControls.h"
 
 
 /*!
 \brief QmitkDiffusionDicomImport
-
-\sa QmitkFunctionality
-\ingroup Functionalities
 */
-class QmitkDiffusionDicomImport : public QmitkFunctionality
+class QmitkDiffusionDicomImport : public QmitkAbstractView
 {
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
   /*!
   \  Convenient typedefs
   */
   typedef mitk::DataStorage::SetOfObjects  ConstVector;
   typedef ConstVector::ConstPointer        ConstVectorPointer;
   typedef ConstVector::ConstIterator       ConstVectorIterator;
 
   /*!
   \brief default constructor
   */
   QmitkDiffusionDicomImport(QObject *parent=0, const char *name=0);
   QmitkDiffusionDicomImport(const QmitkDiffusionDicomImport& other);
 
   /*!
   \brief default destructor
   */
   virtual ~QmitkDiffusionDicomImport();
 
   /*!
   \brief method for creating the widget containing the application   controls, like sliders, buttons etc.
   */
   virtual void CreateQtPartControl(QWidget *parent) override;
 
   /*!
   \brief method for creating the connections of main and control widget
   */
   virtual void CreateConnections();
 
-  virtual void Activated() override;
+  ///
+  /// Sets the focus to an internal widget.
+  ///
+  virtual void SetFocus() override;
 
   void SetDwiNodeProperties(mitk::DataNode::Pointer node, std::string name);
 
 protected slots:
 
   void DicomLoadAddFolderNames();
   void DicomLoadDeleteFolderNames();
   void NewDicomLoadStartLoad() ;
   void AverageClicked();
   void OutputSet();
   void OutputClear();
   void Remove();
   void RecursiveSettingsChanged();
   void SetPrefixButtonPushed();
   void ResetPrefixButtonPushed();
 
 protected:
 
   void Status(QString status);
   void Status(std::string status);
   void Status(const char* status);
   void Error(QString status);
   void Error(std::string status);
   void Error(const char* status);
 
   void PrintMemoryUsage();
   std::string FormatMemorySize( size_t size );
   std::string FormatPercentage( double val );
   std::string GetMemoryDescription( size_t processSize, float percentage );
 
   /*!
   * controls containing sliders for scrolling through the slices
   */
   Ui::QmitkDiffusionDicomImportControls *m_Controls;
 
-  QmitkStdMultiWidget* m_MultiWidget;
-
   QWidget *m_Parent;
 
   QString m_OutputFolderName;
   bool m_OutputFolderNameSet;
 
   std::string m_Prefix;
 
 };
 
 #endif // !defined(QmitkDiffusionDicomImport_H__INCLUDED)
 
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionQuantificationView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionQuantificationView.cpp
index 507ee54a37..81e42adb18 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionQuantificationView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionQuantificationView.cpp
@@ -1,569 +1,550 @@
 /*===================================================================
 
 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 "QmitkDiffusionQuantificationView.h"
 #include "mitkDiffusionImagingConfigure.h"
 
 #include "itkTimeProbe.h"
 #include "itkImage.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkDataNodeObject.h"
 #include "mitkQBallImage.h"
 #include <mitkTensorImage.h>
 #include "mitkImageCast.h"
 #include "mitkStatusBar.h"
 #include "itkDiffusionQballGeneralizedFaImageFilter.h"
 #include "itkShiftScaleImageFilter.h"
 #include "itkTensorFractionalAnisotropyImageFilter.h"
 #include "itkTensorRelativeAnisotropyImageFilter.h"
 #include "itkTensorDerivedMeasurementsFilter.h"
 
 #include "QmitkDataStorageComboBox.h"
-#include "QmitkStdMultiWidget.h"
 
 #include <QMessageBox>
 
 #include "berryIWorkbenchWindow.h"
 #include "berryISelectionService.h"
 
 
 const std::string QmitkDiffusionQuantificationView::VIEW_ID = "org.mitk.views.diffusionquantification";
 
 
 
 QmitkDiffusionQuantificationView::QmitkDiffusionQuantificationView()
-    : QmitkFunctionality(),
-      m_Controls(NULL),
-      m_MultiWidget(NULL)
+    : QmitkAbstractView(),
+      m_Controls(NULL)
 {
     m_QBallImages = mitk::DataStorage::SetOfObjects::New();
     m_TensorImages = mitk::DataStorage::SetOfObjects::New();
 }
 
 QmitkDiffusionQuantificationView::QmitkDiffusionQuantificationView(const QmitkDiffusionQuantificationView& other)
 {
     Q_UNUSED(other)
     throw std::runtime_error("Copy constructor not implemented");
 }
 
 QmitkDiffusionQuantificationView::~QmitkDiffusionQuantificationView()
 {
 
 }
 
 void QmitkDiffusionQuantificationView::CreateQtPartControl(QWidget *parent)
 {
     if (!m_Controls)
     {
         // create GUI widgets
         m_Controls = new Ui::QmitkDiffusionQuantificationViewControls;
         m_Controls->setupUi(parent);
         this->CreateConnections();
         GFACheckboxClicked();
 
 #ifndef DIFFUSION_IMAGING_EXTENDED
         m_Controls->m_StandardGFACheckbox->setVisible(false);
         m_Controls->frame_3->setVisible(false);
         m_Controls->m_CurvatureButton->setVisible(false);
 #endif
     }
 }
 
-void QmitkDiffusionQuantificationView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
-{
-    m_MultiWidget = &stdMultiWidget;
-}
-
-void QmitkDiffusionQuantificationView::StdMultiWidgetNotAvailable()
-{
-    m_MultiWidget = NULL;
-}
-
 void QmitkDiffusionQuantificationView::CreateConnections()
 {
     if ( m_Controls )
     {
         connect( (QObject*)(m_Controls->m_StandardGFACheckbox), SIGNAL(clicked()), this, SLOT(GFACheckboxClicked()) );
         connect( (QObject*)(m_Controls->m_GFAButton), SIGNAL(clicked()), this, SLOT(GFA()) );
         connect( (QObject*)(m_Controls->m_CurvatureButton), SIGNAL(clicked()), this, SLOT(Curvature()) );
         connect( (QObject*)(m_Controls->m_FAButton), SIGNAL(clicked()), this, SLOT(FA()) );
         connect( (QObject*)(m_Controls->m_RAButton), SIGNAL(clicked()), this, SLOT(RA()) );
         connect( (QObject*)(m_Controls->m_ADButton), SIGNAL(clicked()), this, SLOT(AD()) );
         connect( (QObject*)(m_Controls->m_RDButton), SIGNAL(clicked()), this, SLOT(RD()) );
         connect( (QObject*)(m_Controls->m_MDButton), SIGNAL(clicked()), this, SLOT(MD()) );
         connect( (QObject*)(m_Controls->m_ClusteringAnisotropy), SIGNAL(clicked()), this, SLOT(ClusterAnisotropy()) );
     }
 }
 
-void QmitkDiffusionQuantificationView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
+void QmitkDiffusionQuantificationView::SetFocus()
+{
+  m_Controls->m_ScaleImageValuesBox->setFocus();
+}
+
+void QmitkDiffusionQuantificationView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
     m_QBallImages = mitk::DataStorage::SetOfObjects::New();
     m_TensorImages = mitk::DataStorage::SetOfObjects::New();
     bool foundQBIVolume = false;
     bool foundTensorVolume = false;
     mitk::DataNode::Pointer  selNode = NULL;
 
     int c=0;
-    for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
+    for (mitk::DataNode::Pointer node: nodes)
     {
-        mitk::DataNode::Pointer node = *it;
-
         if( node.IsNotNull() && dynamic_cast<mitk::QBallImage*>(node->GetData()) )
         {
             foundQBIVolume = true;
             m_QBallImages->push_back(node);
             selNode = node;
             c++;
         }
         else if( node.IsNotNull() && dynamic_cast<mitk::TensorImage*>(node->GetData()) )
         {
             foundTensorVolume = true;
             m_TensorImages->push_back(node);
             selNode = node;
             c++;
         }
     }
 
     m_Controls->m_GFAButton->setEnabled(foundQBIVolume);
     m_Controls->m_CurvatureButton->setEnabled(foundQBIVolume);
 
     if (c>0)
     {
         m_Controls->m_InputData->setTitle("Input Data");
         m_Controls->m_InputImageLabel->setText(selNode->GetName().c_str());
     }
     else
     {
         m_Controls->m_InputData->setTitle("Please Select Input Data");
         m_Controls->m_InputImageLabel->setText("<font color='red'>mandatory</font>");
     }
 
     m_Controls->m_FAButton->setEnabled(foundTensorVolume);
     m_Controls->m_RAButton->setEnabled(foundTensorVolume);
     m_Controls->m_ADButton->setEnabled(foundTensorVolume);
     m_Controls->m_RDButton->setEnabled(foundTensorVolume);
     m_Controls->m_MDButton->setEnabled(foundTensorVolume);
     m_Controls->m_ClusteringAnisotropy->setEnabled(foundTensorVolume);
 }
 
-void QmitkDiffusionQuantificationView::Activated()
-{
-    QmitkFunctionality::Activated();
-}
-
-void QmitkDiffusionQuantificationView::Deactivated()
-{
-    QmitkFunctionality::Deactivated();
-}
-
 void QmitkDiffusionQuantificationView::GFACheckboxClicked()
 {
     m_Controls->frame_2->setVisible(m_Controls->m_StandardGFACheckbox->isChecked());
 }
 
 void QmitkDiffusionQuantificationView::GFA()
 {
     if(m_Controls->m_StandardGFACheckbox->isChecked())
     {
         QBIQuantify(13);
     }
     else
     {
         QBIQuantify(0);
     }
 }
 
 void QmitkDiffusionQuantificationView::Curvature()
 {
     QBIQuantify(12);
 }
 
 void QmitkDiffusionQuantificationView::FA()
 {
     TensorQuantify(0);
 }
 
 void QmitkDiffusionQuantificationView::RA()
 {
     TensorQuantify(1);
 }
 
 void QmitkDiffusionQuantificationView::AD()
 {
     TensorQuantify(2);
 }
 
 void QmitkDiffusionQuantificationView::RD()
 {
     TensorQuantify(3);
 }
 
 void QmitkDiffusionQuantificationView::ClusterAnisotropy()
 {
     TensorQuantify(4);
 }
 
 void QmitkDiffusionQuantificationView::MD()
 {
     TensorQuantify(5);
 }
 
 void QmitkDiffusionQuantificationView::QBIQuantify(int method)
 {
     QBIQuantification(m_QBallImages, method);
 }
 
 void QmitkDiffusionQuantificationView::TensorQuantify(int method)
 {
     TensorQuantification(m_TensorImages, method);
 }
 
 void QmitkDiffusionQuantificationView::QBIQuantification(
         mitk::DataStorage::SetOfObjects::Pointer inImages, int method)
 {
     itk::TimeProbe clock;
     QString status;
 
     int nrFiles = inImages->size();
     if (!nrFiles) return;
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
 
     std::vector<mitk::DataNode::Pointer> nodes;
     while ( itemiter != itemiterend ) // for all items
     {
 
         typedef float TOdfPixelType;
         const int odfsize = QBALL_ODFSIZE;
         typedef itk::Vector<TOdfPixelType,odfsize> OdfVectorType;
         typedef itk::Image<OdfVectorType,3> OdfVectorImgType;
         mitk::Image* vol =
                 static_cast<mitk::Image*>((*itemiter)->GetData());
         OdfVectorImgType::Pointer itkvol = OdfVectorImgType::New();
         mitk::CastToItkImage(vol, itkvol);
 
         std::string nodename;
         (*itemiter)->GetStringProperty("name", nodename);
         ++itemiter;
 
         float p1 = m_Controls->m_ParamKEdit->text().toFloat();
         float p2 = m_Controls->m_ParamPEdit->text().toFloat();
 
         // COMPUTE RA
         clock.Start();
         MBI_INFO << "Computing GFA ";
         mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
                                                         "Computing GFA for %s", nodename.c_str()).toLatin1());
         typedef OdfVectorType::ValueType                 RealValueType;
         typedef itk::Image< RealValueType, 3 >                 RAImageType;
         typedef itk::DiffusionQballGeneralizedFaImageFilter<TOdfPixelType,TOdfPixelType,odfsize>
                 GfaFilterType;
         GfaFilterType::Pointer gfaFilter = GfaFilterType::New();
         gfaFilter->SetInput(itkvol);
 
         std::string newname;
         newname.append(nodename);
         switch(method)
         {
         case 0:
         {
             gfaFilter->SetComputationMethod(GfaFilterType::GFA_STANDARD);
             newname.append("GFA");
             break;
         }
         case 1:
         {
             gfaFilter->SetComputationMethod(GfaFilterType::GFA_QUANTILES_HIGH_LOW);
             newname.append("01");
             break;
         }
         case 2:
         {
             gfaFilter->SetComputationMethod(GfaFilterType::GFA_QUANTILE_HIGH);
             newname.append("02");
             break;
         }
         case 3:
         {
             gfaFilter->SetComputationMethod(GfaFilterType::GFA_MAX_ODF_VALUE);
             newname.append("03");
             break;
         }
         case 4:
         {
             gfaFilter->SetComputationMethod(GfaFilterType::GFA_DECONVOLUTION_COEFFS);
             newname.append("04");
             break;
         }
         case 5:
         {
             gfaFilter->SetComputationMethod(GfaFilterType::GFA_MIN_MAX_NORMALIZED_STANDARD);
             newname.append("05");
             break;
         }
         case 6:
         {
             gfaFilter->SetComputationMethod(GfaFilterType::GFA_NORMALIZED_ENTROPY);
             newname.append("06");
             break;
         }
         case 7:
         {
             gfaFilter->SetComputationMethod(GfaFilterType::GFA_NEMATIC_ORDER_PARAMETER);
             newname.append("07");
             break;
         }
         case 8:
         {
             gfaFilter->SetComputationMethod(GfaFilterType::GFA_QUANTILES_LOW_HIGH);
             newname.append("08");
             break;
         }
         case 9:
         {
             gfaFilter->SetComputationMethod(GfaFilterType::GFA_QUANTILE_LOW);
             newname.append("09");
             break;
         }
         case 10:
         {
             gfaFilter->SetComputationMethod(GfaFilterType::GFA_MIN_ODF_VALUE);
             newname.append("10");
             break;
         }
         case 11:
         {
             gfaFilter->SetComputationMethod(GfaFilterType::GFA_STD_BY_MAX);
             newname.append("11");
             break;
         }
         case 12:
         {
             p1 = m_Controls->MinAngle->text().toFloat();
             p2 = m_Controls->MaxAngle->text().toFloat();
             gfaFilter->SetComputationMethod(GfaFilterType::GFA_PRINCIPLE_CURVATURE);
             QString paramString;
             paramString = paramString.append("PC%1-%2").arg(p1).arg(p2);
             newname.append(paramString.toLatin1());
             gfaFilter->SetParam1(p1);
             gfaFilter->SetParam2(p2);
             break;
         }
         case 13:
         {
             gfaFilter->SetComputationMethod(GfaFilterType::GFA_GENERALIZED_GFA);
             QString paramString;
             paramString = paramString.append("GFAK%1P%2").arg(p1).arg(p2);
             newname.append(paramString.toLatin1());
             gfaFilter->SetParam1(p1);
             gfaFilter->SetParam2(p2);
             break;
         }
         default:
         {
             newname.append("0");
             gfaFilter->SetComputationMethod(GfaFilterType::GFA_STANDARD);
         }
         }
         gfaFilter->Update();
         clock.Stop();
 
         typedef itk::Image<TOdfPixelType, 3> ImgType;
         ImgType::Pointer img = ImgType::New();
         img->SetSpacing( gfaFilter->GetOutput()->GetSpacing() );   // Set the image spacing
         img->SetOrigin( gfaFilter->GetOutput()->GetOrigin() );     // Set the image origin
         img->SetDirection( gfaFilter->GetOutput()->GetDirection() );  // Set the image direction
         img->SetLargestPossibleRegion( gfaFilter->GetOutput()->GetLargestPossibleRegion());
         img->SetBufferedRegion( gfaFilter->GetOutput()->GetLargestPossibleRegion() );
         img->Allocate();
         itk::ImageRegionIterator<ImgType> ot (img, img->GetLargestPossibleRegion() );
         ot.GoToBegin();
         itk::ImageRegionConstIterator<GfaFilterType::OutputImageType> it
                 (gfaFilter->GetOutput(), gfaFilter->GetOutput()->GetLargestPossibleRegion() );
 
         for (it.GoToBegin(); !it.IsAtEnd(); ++it)
         {
             GfaFilterType::OutputImageType::PixelType val = it.Get();
             ot.Set(val * m_Controls->m_ScaleImageValuesBox->value());
             ++ot;
         }
 
 
         // GFA TO DATATREE
         mitk::Image::Pointer image = mitk::Image::New();
         image->InitializeByItk( img.GetPointer() );
         image->SetVolume( img->GetBufferPointer() );
         mitk::DataNode::Pointer node=mitk::DataNode::New();
         node->SetData( image );
         node->SetProperty( "name", mitk::StringProperty::New(newname) );
         nodes.push_back(node);
 
         mitk::StatusBar::GetInstance()->DisplayText("Computation complete.");
 
     }
 
     std::vector<mitk::DataNode::Pointer>::iterator nodeIt;
     for(nodeIt = nodes.begin(); nodeIt != nodes.end(); ++nodeIt)
-        GetDefaultDataStorage()->Add(*nodeIt);
+        GetDataStorage()->Add(*nodeIt);
 
-    m_MultiWidget->RequestUpdate();
+    this->GetRenderWindowPart()->RequestUpdate();
 
 }
 
 void QmitkDiffusionQuantificationView::TensorQuantification(
         mitk::DataStorage::SetOfObjects::Pointer inImages, int method)
 {
     itk::TimeProbe clock;
     QString status;
 
     int nrFiles = inImages->size();
     if (!nrFiles) return;
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
 
     std::vector<mitk::DataNode::Pointer> nodes;
     while ( itemiter != itemiterend ) // for all items
     {
 
         typedef float                                       TTensorPixelType;
         typedef itk::DiffusionTensor3D< TTensorPixelType >  TensorPixelType;
         typedef itk::Image< TensorPixelType, 3 >            TensorImageType;
 
         mitk::Image* vol =
                 static_cast<mitk::Image*>((*itemiter)->GetData());
         TensorImageType::Pointer itkvol = TensorImageType::New();
         mitk::CastToItkImage(vol, itkvol);
 
         std::string nodename;
         (*itemiter)->GetStringProperty("name", nodename);
         ++itemiter;
 
         // COMPUTE FA
         clock.Start();
         MBI_INFO << "Computing FA ";
         mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
                                                         "Computing FA for %s", nodename.c_str()).toLatin1());
         typedef itk::Image< TTensorPixelType, 3 >              FAImageType;
 
         typedef itk::ShiftScaleImageFilter<FAImageType, FAImageType>
                 ShiftScaleFilterType;
         ShiftScaleFilterType::Pointer multi =
                 ShiftScaleFilterType::New();
         multi->SetShift(0.0);
         multi->SetScale(m_Controls->m_ScaleImageValuesBox->value());//itk::NumericTraits<RealValueType>::max()
 
         typedef itk::TensorDerivedMeasurementsFilter<TTensorPixelType> MeasurementsType;
 
         if(method == 0) //FA
         {
             /* typedef itk::TensorFractionalAnisotropyImageFilter<
         TensorImageType, FAImageType >                       FilterType;
       FilterType::Pointer anisotropyFilter = FilterType::New();
       anisotropyFilter->SetInput( itkvol.GetPointer() );
       anisotropyFilter->Update();
       multi->SetInput(anisotropyFilter->GetOutput());
       nodename = QString(nodename.c_str()).append("_FA").toStdString();*/
 
 
             MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
             measurementsCalculator->SetInput(itkvol.GetPointer() );
             measurementsCalculator->SetMeasure(MeasurementsType::FA);
             measurementsCalculator->Update();
             multi->SetInput(measurementsCalculator->GetOutput());
             nodename = QString(nodename.c_str()).append("_FA").toStdString();
 
         }
         else if(method == 1) //RA
         {
             /*typedef itk::TensorRelativeAnisotropyImageFilter<
         TensorImageType, FAImageType >                       FilterType;
       FilterType::Pointer anisotropyFilter = FilterType::New();
       anisotropyFilter->SetInput( itkvol.GetPointer() );
       anisotropyFilter->Update();
       multi->SetInput(anisotropyFilter->GetOutput());
       nodename = QString(nodename.c_str()).append("_RA").toStdString();*/
 
             MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
             measurementsCalculator->SetInput(itkvol.GetPointer() );
             measurementsCalculator->SetMeasure(MeasurementsType::RA);
             measurementsCalculator->Update();
             multi->SetInput(measurementsCalculator->GetOutput());
             nodename = QString(nodename.c_str()).append("_RA").toStdString();
 
         }
         else if(method == 2) // AD (Axial diffusivity)
         {
             MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
             measurementsCalculator->SetInput(itkvol.GetPointer() );
             measurementsCalculator->SetMeasure(MeasurementsType::AD);
             measurementsCalculator->Update();
             multi->SetInput(measurementsCalculator->GetOutput());
             nodename = QString(nodename.c_str()).append("_AD").toStdString();
         }
         else if(method == 3) // RD (Radial diffusivity, (Lambda2+Lambda3)/2
         {
             MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
             measurementsCalculator->SetInput(itkvol.GetPointer() );
             measurementsCalculator->SetMeasure(MeasurementsType::RD);
             measurementsCalculator->Update();
             multi->SetInput(measurementsCalculator->GetOutput());
             nodename = QString(nodename.c_str()).append("_RD").toStdString();
         }
         else if(method == 4) // 1-(Lambda2+Lambda3)/(2*Lambda1)
         {
             MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
             measurementsCalculator->SetInput(itkvol.GetPointer() );
             measurementsCalculator->SetMeasure(MeasurementsType::CA);
             measurementsCalculator->Update();
             multi->SetInput(measurementsCalculator->GetOutput());
             nodename = QString(nodename.c_str()).append("_CA").toStdString();
         }
         else if(method == 5) // MD (Mean Diffusivity, (Lambda1+Lambda2+Lambda3)/3 )
         {
             MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
             measurementsCalculator->SetInput(itkvol.GetPointer() );
             measurementsCalculator->SetMeasure(MeasurementsType::MD);
             measurementsCalculator->Update();
             multi->SetInput(measurementsCalculator->GetOutput());
             nodename = QString(nodename.c_str()).append("_MD").toStdString();
         }
 
         multi->Update();
         clock.Stop();
 
         // FA TO DATATREE
         mitk::Image::Pointer image = mitk::Image::New();
         image->InitializeByItk( multi->GetOutput() );
         image->SetVolume( multi->GetOutput()->GetBufferPointer() );
         mitk::DataNode::Pointer node=mitk::DataNode::New();
         node->SetData( image );
         node->SetProperty( "name", mitk::StringProperty::New(nodename) );
         nodes.push_back(node);
 
         mitk::StatusBar::GetInstance()->DisplayText("Computation complete.");
 
     }
 
     std::vector<mitk::DataNode::Pointer>::iterator nodeIt;
     for(nodeIt = nodes.begin(); nodeIt != nodes.end(); ++nodeIt)
-        GetDefaultDataStorage()->Add(*nodeIt);
+        GetDataStorage()->Add(*nodeIt);
 
-    m_MultiWidget->RequestUpdate();
+    this->GetRenderWindowPart()->RequestUpdate();
 
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionQuantificationView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionQuantificationView.h
index fcfe9984a4..d16fb881f9 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionQuantificationView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionQuantificationView.h
@@ -1,102 +1,96 @@
 /*===================================================================
 
 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 _QMITKDIFFUSIONQUANTIFICATIONVIEW_H_INCLUDED
 #define _QMITKDIFFUSIONQUANTIFICATIONVIEW_H_INCLUDED
 
-#include <QmitkFunctionality.h>
+#include <QmitkAbstractView.h>
 
 #include <string>
 
 #include "ui_QmitkDiffusionQuantificationViewControls.h"
 /*!
  * \ingroup org_mitk_gui_qt_diffusionquantification_internal
  *
  * \brief QmitkDiffusionQuantificationView
  *
  * Document your class here.
- *
- * \sa QmitkFunctionality
  */
-class QmitkDiffusionQuantificationView : public QmitkFunctionality
+class QmitkDiffusionQuantificationView : public QmitkAbstractView
 {
 
   friend struct DqSelListener;
 
   // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
   public:
 
   static const std::string VIEW_ID;
 
   QmitkDiffusionQuantificationView();
   QmitkDiffusionQuantificationView(const QmitkDiffusionQuantificationView& other);
   virtual ~QmitkDiffusionQuantificationView();
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
   /// \brief Creation of the connections of main and control widget
   virtual void CreateConnections();
 
-  /// \brief Called when the functionality is activated
-  virtual void Activated() override;
-
-  virtual void Deactivated() override;
-
-  virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget) override;
-  virtual void StdMultiWidgetNotAvailable() override;
+  ///
+  /// Sets the focus to an internal widget.
+  ///
+  virtual void SetFocus() override;
 
 protected slots:
 
   void GFACheckboxClicked();
 
   void GFA();
   void Curvature();
   void FA();
   void RA();
   void AD();
   void RD();
   void ClusterAnisotropy();
   void MD();
 
   void QBIQuantify(int method);
   void QBIQuantification(mitk::DataStorage::SetOfObjects::Pointer inImages,
     int method) ;
 
   void TensorQuantify(int method);
   void TensorQuantification(mitk::DataStorage::SetOfObjects::Pointer inImages,
     int method) ;
 
 protected:
 
-  /// \brief called by QmitkFunctionality when DataManager's selection has changed
-  virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes ) override;
+  /// \brief called by QmitkAbstractView when DataManager's selection has changed
+  virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
   Ui::QmitkDiffusionQuantificationViewControls* m_Controls;
 
-  QmitkStdMultiWidget* m_MultiWidget;
   mitk::DataStorage::SetOfObjects::Pointer m_QBallImages;
   mitk::DataStorage::SetOfObjects::Pointer m_TensorImages;
 
   static const float m_ScaleDAIValues;
 };
 
 
 
 
 #endif // _QMITKDIFFUSIONQUANTIFICATIONVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionRegistrationView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionRegistrationView.cpp
index a99cb6032d..69f88759bc 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionRegistrationView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionRegistrationView.cpp
@@ -1,488 +1,485 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //misc
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkDiffusionRegistrationView.h"
-#include <QmitkStdMultiWidget.h>
 
 // MITK
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkProgressBar.h>
 #include <mitkIOUtil.h>
 #include <mitkDiffusionPropertyHelper.h>
 
 // Qt
 #include <QMessageBox>
 #include <QFileDialog>
 #include <QDir>
 #include <QDirIterator>
-
+#include <QTimer>
 
 #include <mitkDWIHeadMotionCorrectionFilter.h>
 
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 QmitkRegistrationWorker::QmitkRegistrationWorker(QmitkDiffusionRegistrationView* view)
   : m_View(view)
 {
 
 }
 
 void QmitkRegistrationWorker::run()
 {
 
   typedef mitk::DiffusionPropertyHelper::BValueMapType BValueMap;
 
   unsigned int totalImagesCount;
   if( !m_View->m_IsBatch )
   {
     totalImagesCount = m_View->m_SelectedDiffusionNodes.size();
   }
   else
   {
     totalImagesCount = m_View->m_BatchList.size();
   }
   m_View->m_TotalFiles = totalImagesCount;
 
   QString inputPath = m_View->m_Controls->m_InputFolderTextbox->text();
   QString outputPath = m_View->m_Controls->m_OutputFolderTextbox->text();
 
 
   for(unsigned int i=0; i< totalImagesCount; i++)
   {
     if(m_View->m_IsAborted){
       m_View->m_RegistrationThread.quit();
       return;
     }
 
     m_View->m_CurrentFile = i+1;
     m_View->m_GlobalRegisterer = QmitkDiffusionRegistrationView::DWIHeadMotionCorrectionFilterType::New();
 
     //mitk::DataNode::Pointer node = m_View->m_SelectedDiffusionNodes.at(i);
     mitk::Image::Pointer inImage;
     mitk::DataNode::Pointer node;
 
     if( !m_View->m_IsBatch )
     {
       node = m_View->m_SelectedDiffusionNodes.at(i);
       inImage = dynamic_cast<mitk::Image*>(node->GetData());
     }
     else
     {
       mitk::Image::Pointer inImage = mitk::IOUtil::LoadImage( m_View->m_BatchList.at(i).toStdString() );
       mitk::GradientDirectionsProperty::Pointer gradDir = static_cast<mitk::GradientDirectionsProperty*>(inImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer());
     }
 
     bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( inImage ) );
 
     if(!isDiffusionImage)
     {
       MITK_ERROR << "Error occured: can't get input image. \nAborting";
       return;
     }
 
 
     m_View->m_GlobalRegisterer->SetInput(inImage);
 
     try
     {
       m_View->m_GlobalRegisterer->Update();
     }
     catch( mitk::Exception e )
     {
       MITK_ERROR << "Internal error occured: " <<  e.what() << "\nAborting";
     }
 
     if( m_View->m_GlobalRegisterer->GetIsInValidState() )
     {
       if(! m_View->m_IsBatch)
       {
         mitk::Image::Pointer image = m_View->m_GlobalRegisterer->GetOutput();
         mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
         imageNode->SetData( image );
         QString name = node->GetName().c_str();
         imageNode->SetName((name+"_MC").toStdString().c_str());
         m_View->GetDataStorage()->Add(imageNode);
       }
       else
       {
         QString name = m_View->m_BatchList.at(i);
         name = name.replace(".dwi", "_MC.dwi", Qt::CaseInsensitive);
         name = name.replace(inputPath, outputPath, Qt::CaseInsensitive);
 
         try
         {
           mitk::IOUtil::Save(m_View->m_GlobalRegisterer->GetOutput(), name.toStdString().c_str());
         }
         catch( const itk::ExceptionObject& e)
         {
           MITK_ERROR << "Catched exception: " << e.what();
           mitkThrow() << "Failed with exception from subprocess!";
         }
       }
     }
 
   }
   m_View->m_RegistrationThread.quit();
 }
 
 
 const std::string QmitkDiffusionRegistrationView::VIEW_ID = "org.mitk.views.diffusionregistrationview";
 
 QmitkDiffusionRegistrationView::QmitkDiffusionRegistrationView()
   : QmitkAbstractView()
   , m_Controls( 0 )
   , m_DiffusionImage( NULL )
   , m_ThreadIsRunning(false)
   , m_Steps(100)
   , m_LastStep(0)
   , m_GlobalRegisterer(NULL)
   , m_RegistrationWorker(this)
 
 {
 
   m_RegistrationWorker.moveToThread(&m_RegistrationThread);
   connect(&m_RegistrationThread, SIGNAL(started()), this, SLOT(BeforeThread()));
   connect(&m_RegistrationThread, SIGNAL(started()), &m_RegistrationWorker, SLOT(run()));
   connect(&m_RegistrationThread, SIGNAL(finished()), this, SLOT(AfterThread()));
   connect(&m_RegistrationThread, SIGNAL(terminated()), this, SLOT(AfterThread()));
   m_RegistrationTimer = new QTimer(this);
 
 }
 
 // Destructor
 QmitkDiffusionRegistrationView::~QmitkDiffusionRegistrationView()
 {
   delete m_RegistrationTimer;
 }
 
 // update Registration status and generate fiber bundle
 void QmitkDiffusionRegistrationView::TimerUpdate()
 {
   int currentStep = m_GlobalRegisterer->GetCurrentStep();
 
   mitk::ProgressBar::GetInstance()->Progress(currentStep-m_LastStep);
   UpdateRegistrationStatus();
 
   m_LastStep = currentStep;
 }
 
 // update gui elements after registration is finished
 void QmitkDiffusionRegistrationView::AfterThread()
 {
 
   m_ThreadIsRunning = false;
   m_RegistrationTimer->stop();
 
   mitk::ProgressBar::GetInstance()->Progress(m_GlobalRegisterer->GetSteps()-m_LastStep+1);
   UpdateGUI();
 
 
   if( !m_GlobalRegisterer->GetIsInValidState() )
   {
     QMessageBox::critical( NULL,  "Registration", "An internal error occured, or user canceled the Registration.\n Please check the log for details." );
     return;
   }
 
   UpdateRegistrationStatus();
 
 
   m_GlobalRegisterer = 0;
 
 }
 
 // start Registration timer and update gui elements before Registration is started
 void QmitkDiffusionRegistrationView::BeforeThread()
 {
   m_ThreadIsRunning = true;
   m_RegistrationTime = QTime::currentTime();
   m_ElapsedTime = 0;
   m_RegistrationTimer->start(1000);
   m_LastStep = 0;
 
   UpdateGUI();
 }
 
 
 void QmitkDiffusionRegistrationView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkDiffusionRegistrationViewControls;
     m_Controls->setupUi( parent );
 
     AdvancedSettings();
 
     connect( m_RegistrationTimer, SIGNAL(timeout()), this, SLOT(TimerUpdate()) );
     connect( m_Controls->m_RegistrationStopButton, SIGNAL(clicked()), this, SLOT(StopRegistration()) );
     connect( m_Controls->m_RegistrationStartButton, SIGNAL(clicked()), this, SLOT(StartRegistration()) );
     connect( m_Controls->m_AdvancedSettingsCheckbox, SIGNAL(clicked()), this, SLOT(AdvancedSettings()) );
     connect( m_Controls->m_SelectInputButton, SIGNAL(clicked()), this, SLOT(AddInputFolderName()) );
     connect( m_Controls->m_SelectOutputButton, SIGNAL(clicked()), this, SLOT(AddOutputFolderName()) );
     connect( m_Controls->m_StartBatchButton, SIGNAL(clicked()), this, SLOT(StartBatch()) );
 
     this->m_Parent = parent;
   }
 }
 
 // show/hide advanced settings frame
 void QmitkDiffusionRegistrationView::AdvancedSettings()
 {
   m_Controls->m_AdvancedFrame->setVisible(m_Controls->m_AdvancedSettingsCheckbox->isChecked());
 }
 
 
-void QmitkDiffusionRegistrationView::OnSelectionChanged( berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes )
+void QmitkDiffusionRegistrationView::OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes)
 {
 
   if (m_ThreadIsRunning)
     return;
 
   bool foundDwiVolume = false;
   QString tempSelectedNames = "";
   m_DiffusionImage = NULL;
   m_SelectedDiffusionNodes.clear();
 
   // iterate selection
-  for( int i=0; i<nodes.size(); i++)
+  for (mitk::DataNode::Pointer node: nodes)
   {
-    mitk::DataNode::Pointer node = nodes.at(i);
-
     bool isDiffusionImage(false);
     if( node.IsNotNull() )
     {
       isDiffusionImage = mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData()));
     }
 
     if( isDiffusionImage )
     {
       foundDwiVolume = true;
       m_SelectedDiffusionNodes.push_back(node);
 
       if(m_SelectedDiffusionNodes.size() > 0){tempSelectedNames += "\n";}
       tempSelectedNames += (node->GetName().c_str());
     }
 
   }
 
 
   m_Controls->m_RegistrationStartButton->setEnabled(foundDwiVolume);
 
   if (foundDwiVolume)
   {
     m_Controls->m_DiffusionImageLabel->setText(tempSelectedNames);
     m_Controls->m_InputData->setTitle("Input Data");
   }
   else
   {
     m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_InputData->setTitle("Please Select Input Data");
   }
 
   UpdateGUI();
 
 }
 
 
 // update gui elements displaying Registrations status
 void QmitkDiffusionRegistrationView::UpdateRegistrationStatus()
 {
   if (m_GlobalRegisterer.IsNull())
     return;
 
   m_ElapsedTime += m_RegistrationTime.elapsed()/1000;
   m_RegistrationTime.restart();
   unsigned long hours = m_ElapsedTime/3600;
   unsigned long minutes = (m_ElapsedTime%3600)/60;
   unsigned long seconds = m_ElapsedTime%60;
 
   m_Controls->m_RegistrationTimeLabel->setText( QString::number(hours)+QString("h ")+QString::number(minutes)+QString("m ")+QString::number(seconds)+QString("s") );
   m_Controls->m_CurrentStepLabel->setText( QString::number((int)(100*(float)(m_GlobalRegisterer->GetCurrentStep()-1)/m_GlobalRegisterer->GetSteps()))+"%" );
   m_Controls->m_CurrentFileLabel->setText( QString::number(m_CurrentFile)+" / "+QString::number(m_TotalFiles) );
 }
 
 void QmitkDiffusionRegistrationView::UpdateGUI()
 {
 
   if (!m_ThreadIsRunning && (m_SelectedDiffusionNodes.size() > 0) )
   {
     m_Controls->m_RegistrationStopButton->setEnabled(false);
     m_Controls->m_RegistrationStartButton->setEnabled(true);
     m_Controls->m_StartBatchButton->setEnabled(true);
     m_Controls->m_AdvancedFrame->setEnabled(true);
     m_Controls->m_RegistrationStopButton->setText("Stop");
     m_Controls->m_RegistrationStartButton->setToolTip("Start Registration");
     m_Controls->m_RegistrationStopButton->setToolTip("");
   }
   else if (!m_ThreadIsRunning)
   {
     m_Controls->m_RegistrationStopButton->setEnabled(false);
     m_Controls->m_RegistrationStartButton->setEnabled(false);
     m_Controls->m_StartBatchButton->setEnabled(true);
     m_Controls->m_AdvancedFrame->setEnabled(true);
     m_Controls->m_RegistrationStopButton->setText("Stop");
     m_Controls->m_RegistrationStartButton->setToolTip("No Diffusion image selected.");
     m_Controls->m_RegistrationStopButton->setToolTip("");
   }
   else
   {
     m_Controls->m_RegistrationStopButton->setEnabled(true);
     m_Controls->m_RegistrationStartButton->setEnabled(false);
     m_Controls->m_StartBatchButton->setEnabled(false);
     m_Controls->m_AdvancedFrame->setEnabled(false);
     m_Controls->m_RegistrationStartButton->setToolTip("Registration in progress.");
     m_Controls->m_RegistrationStopButton->setToolTip("Cancel Registration");
   }
 
 
 }
 
 void QmitkDiffusionRegistrationView::SetFocus()
 {
   m_Controls->m_RegistrationStartButton->setFocus();
 }
 
 
 void QmitkDiffusionRegistrationView::StartRegistration()
 {
 
   if(m_ThreadIsRunning)
   {
     MITK_WARN("QmitkDiffusionRegistrationView")<<"Thread already running!";
     return;
   }
   m_GlobalRegisterer = NULL;
 
   if (m_SelectedDiffusionNodes.size()<1)
   {
     QMessageBox::information( NULL, "Warning", "Please load and select a diffusion image before starting image processing.");
     return;
   }
 
   m_IsBatch = false;
   m_IsAborted = false;
 
   m_Controls->m_RegistrationStartButton->setEnabled(false);
   m_Controls->m_StartBatchButton->setEnabled(false);
 
   // start worker thread
   m_RegistrationThread.start(QThread::NormalPriority);
 
   return;
 }
 
 void QmitkDiffusionRegistrationView::StopRegistration()
 {
 
   if (m_GlobalRegisterer.IsNull())
     return;
 
   m_IsAborted = true;
   m_GlobalRegisterer->SetAbortRegistration(true);
   m_Controls->m_RegistrationStopButton->setEnabled(false);
   m_Controls->m_RegistrationStopButton->setText("Stopping ...");
 
   return;
 }
 
 void QmitkDiffusionRegistrationView::AddInputFolderName()
 {
 
   // SELECT FOLDER DIALOG
   QFileDialog* w = new QFileDialog( m_Parent, QString("Select the input folder with DWI files within") );
   w->setFileMode( QFileDialog::Directory );
 
   // RETRIEVE SELECTION
   if ( w->exec() != QDialog::Accepted )
     return;
 
   m_Controls->m_InputFolderTextbox->setText(w->selectedFiles()[0]);
 }
 
 void QmitkDiffusionRegistrationView::AddOutputFolderName()
 {
   // SELECT FOLDER DIALOG
   QFileDialog* w = new QFileDialog( m_Parent, QString("Select the output folder") );
   w->setFileMode( QFileDialog::Directory );
 
   // RETRIEVE SELECTION
   if ( w->exec() != QDialog::Accepted )
     return;
 
   m_Controls->m_OutputFolderTextbox->setText(w->selectedFiles()[0]);
 }
 
 void QmitkDiffusionRegistrationView::StartBatch()
 {
   QString inputPath = m_Controls->m_InputFolderTextbox->text();
   QString outputPath = m_Controls->m_OutputFolderTextbox->text();
 
   if(inputPath == outputPath){
     QMessageBox::information( NULL, "Error", "Input and Output folders can't be the same");
     return;
   }
 
   QStringList list, filters;
   filters<<"*.dwi";
   QDirIterator dirIterator(inputPath,
                            filters,
                            QDir::Files|QDir::NoSymLinks);
 
   while (dirIterator.hasNext())
   {
     dirIterator.next();
 
     list.append(dirIterator.fileInfo().absoluteFilePath());
     std::cout << dirIterator.fileInfo().absoluteFilePath().toStdString() << endl;
     m_BatchList = list;
 
     m_IsBatch = true;
     m_IsAborted = false;
 
     if(m_ThreadIsRunning)
     {
       MITK_WARN("QmitkDiffusionRegistrationView")<<"Thread already running!";
       return;
     }
     m_GlobalRegisterer = NULL;
 
     if (m_BatchList.size()<1)
     {
       QMessageBox::information( NULL, "Error", "No diffusion images were found in the selected input folder.");
       return;
     }
 
     m_Controls->m_RegistrationStartButton->setEnabled(false);
     m_Controls->m_StartBatchButton->setEnabled(false);
 
     // start worker thread
     m_RegistrationThread.start(QThread::NormalPriority);
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionRegistrationView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionRegistrationView.h
index 9667f12399..9eaac301a2 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionRegistrationView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDiffusionRegistrationView.h
@@ -1,135 +1,132 @@
 /*===================================================================
 
 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 <berryISelectionListener.h>
 #include <berryIStructuredSelection.h>
 
 #include <QmitkAbstractView.h>
 #include "ui_QmitkDiffusionRegistrationViewControls.h"
 
 #include <mitkImage.h>
 #include <mitkDWIHeadMotionCorrectionFilter.h>
 
 #include <QThread>
 #include <QTime>
 
 typedef short DiffusionPixelType;
 
 /*!
 \brief View for diffusion image registration / head motion correction
-
-\sa QmitkFunctionality
-\ingroup Functionalities
 */
 
 // Forward Qt class declarations
 
 using namespace std;
 
 class QmitkDiffusionRegistrationView;
 
 class QmitkRegistrationWorker : public QObject
 {
   Q_OBJECT
 
 public:
 
   QmitkRegistrationWorker(QmitkDiffusionRegistrationView* view);
 
   public slots:
 
     void run();
 
 private:
 
   QmitkDiffusionRegistrationView* m_View;
 };
 
 
 class QmitkDiffusionRegistrationView : public QmitkAbstractView
 {
 
   // 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:
 
   static const string VIEW_ID;
 
   QmitkDiffusionRegistrationView();
   virtual ~QmitkDiffusionRegistrationView();
 
   virtual void CreateQtPartControl(QWidget *parent) override;
   void SetFocus() override;
 
   typedef mitk::DWIHeadMotionCorrectionFilter       DWIHeadMotionCorrectionFilterType;
 
 protected slots:
 
     void StartRegistration();
     void StopRegistration();
 
     void AfterThread();                       ///< update gui etc. after registrations has finished
     void BeforeThread();                      ///< start timer etc.
     void TimerUpdate();
 
     void AddInputFolderName();
     void AddOutputFolderName();
     void StartBatch();
 
     void AdvancedSettings();
 
 
 protected:
 
-  /// \brief called by QmitkFunctionality when DataManager's selection has changed
-  virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>&) override;
+  /// \brief called by QmitkAbstractView when DataManager's selection has changed
+  virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
   Ui::QmitkDiffusionRegistrationViewControls* m_Controls;
 
   mitk::Image::Pointer m_DiffusionImage;
   std::vector< mitk::DataNode::Pointer >            m_SelectedDiffusionNodes;
 
 private:
 
   void UpdateRegistrationStatus();  ///< update textual status display of the Registration process
   void UpdateGUI();             ///< update button activity etc. dpending on current datamanager selection
 
   /** flags etc. */
   bool            m_IsBatch, m_IsAborted;
   QStringList     m_BatchList;
   bool            m_ThreadIsRunning;
   QTimer*         m_RegistrationTimer;
   QTime           m_RegistrationTime;
   unsigned long   m_ElapsedTime;
   unsigned long   m_Steps;
   int             m_LastStep;
   unsigned int    m_CurrentFile;
   unsigned int    m_TotalFiles;
 
   // the Qt parent of our GUI (NOT of this object)
   QWidget* m_Parent;
 
   /** global Registerer and friends */
   itk::SmartPointer<DWIHeadMotionCorrectionFilterType> m_GlobalRegisterer;
   QmitkRegistrationWorker m_RegistrationWorker;
   QThread m_RegistrationThread;
   friend class QmitkRegistrationWorker;
 
 };
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp
index ea0f98f081..82033da2de 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp
@@ -1,1383 +1,1384 @@
 /*===================================================================
 
 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 <berryIWorkbenchPart.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkFiberProcessingView.h"
-#include <QmitkStdMultiWidget.h>
 
 // Qt
 #include <QMessageBox>
 
 // MITK
 #include <mitkNodePredicateProperty.h>
 #include <mitkImageCast.h>
 #include <mitkPointSet.h>
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarPolygon.h>
 #include <mitkPlanarRectangle.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkDataNodeObject.h>
 #include <mitkTensorImage.h>
 #include "usModuleRegistry.h"
 #include <itkFiberCurvatureFilter.h>
 
 #include "mitkNodePredicateDataType.h"
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateOr.h>
 
 // ITK
 #include <itkResampleImageFilter.h>
 #include <itkGaussianInterpolateImageFunction.h>
 #include <itkImageRegionIteratorWithIndex.h>
 #include <itkTractsToFiberEndingsImageFilter.h>
 #include <itkTractDensityImageFilter.h>
 #include <itkImageRegion.h>
 #include <itkTractsToRgbaImageFilter.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 
 const std::string QmitkFiberProcessingView::VIEW_ID = "org.mitk.views.fiberprocessing";
 const std::string id_DataManager = "org.mitk.views.datamanager";
 using namespace mitk;
 
 QmitkFiberProcessingView::QmitkFiberProcessingView()
-    : QmitkFunctionality()
+    : QmitkAbstractView()
     , m_Controls( 0 )
-    , m_MultiWidget( NULL )
     , m_CircleCounter(0)
     , m_PolygonCounter(0)
     , m_UpsamplingFactor(1)
 {
 
 }
 
 // Destructor
 QmitkFiberProcessingView::~QmitkFiberProcessingView()
 {
 
 }
 
 void QmitkFiberProcessingView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkFiberProcessingViewControls;
         m_Controls->setupUi( parent );
 
         connect( m_Controls->m_CircleButton, SIGNAL( clicked() ), this, SLOT( OnDrawCircle() ) );
         connect( m_Controls->m_PolygonButton, SIGNAL( clicked() ), this, SLOT( OnDrawPolygon() ) );
         connect(m_Controls->PFCompoANDButton, SIGNAL(clicked()), this, SLOT(GenerateAndComposite()) );
         connect(m_Controls->PFCompoORButton, SIGNAL(clicked()), this, SLOT(GenerateOrComposite()) );
         connect(m_Controls->PFCompoNOTButton, SIGNAL(clicked()), this, SLOT(GenerateNotComposite()) );
         connect(m_Controls->m_GenerateRoiImage, SIGNAL(clicked()), this, SLOT(GenerateRoiImage()) );
 
         connect(m_Controls->m_JoinBundles, SIGNAL(clicked()), this, SLOT(JoinBundles()) );
         connect(m_Controls->m_SubstractBundles, SIGNAL(clicked()), this, SLOT(SubstractBundles()) );
         connect(m_Controls->m_CopyBundle, SIGNAL(clicked()), this, SLOT(CopyBundles()) );
 
         connect(m_Controls->m_ExtractFibersButton, SIGNAL(clicked()), this, SLOT(Extract()));
         connect(m_Controls->m_RemoveButton, SIGNAL(clicked()), this, SLOT(Remove()));
         connect(m_Controls->m_ModifyButton, SIGNAL(clicked()), this, SLOT(Modify()));
 
         connect(m_Controls->m_ExtractionMethodBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()));
         connect(m_Controls->m_RemovalMethodBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()));
         connect(m_Controls->m_ModificationMethodBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()));
 
         m_Controls->m_ColorMapBox->SetDataStorage(this->GetDataStorage());
         mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
         mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
         mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
         mitk::NodePredicateDataType::Pointer isQbi = mitk::NodePredicateDataType::New("QBallImage");
         mitk::NodePredicateOr::Pointer isDiffusionImage = mitk::NodePredicateOr::New(isDwi, isDti);
         isDiffusionImage = mitk::NodePredicateOr::New(isDiffusionImage, isQbi);
         mitk::NodePredicateNot::Pointer noDiffusionImage = mitk::NodePredicateNot::New(isDiffusionImage);
         mitk::NodePredicateAnd::Pointer finalPredicate = mitk::NodePredicateAnd::New(isMitkImage, noDiffusionImage);
         m_Controls->m_ColorMapBox->SetPredicate(finalPredicate);
     }
 
     UpdateGui();
 }
 
+void QmitkFiberProcessingView::SetFocus()
+{
+  m_Controls->toolBoxx->setFocus();
+}
+
 void QmitkFiberProcessingView::Modify()
 {
     switch (m_Controls->m_ModificationMethodBox->currentIndex())
     {
     case 0:
     {
         ResampleSelectedBundles();
         break;
     }
     case 1:
     {
         CompressSelectedBundles();
         break;
     }
     case 2:
     {
         DoImageColorCoding();
         break;
     }
     case 3:
     {
         MirrorFibers();
         break;
     }
     case 4:
     {
         WeightFibers();
         break;
     }
     case 5:
     {
         DoCurvatureColorCoding();
         break;
     }
     }
 }
 
 void QmitkFiberProcessingView::WeightFibers()
 {
     float weight = this->m_Controls->m_BundleWeightBox->value();
     for (auto node : m_SelectedFB)
     {
         mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
         fib->SetFiberWeights(weight);
     }
 
 }
 
 void QmitkFiberProcessingView::Remove()
 {
     switch (m_Controls->m_RemovalMethodBox->currentIndex())
     {
     case 0:
     {
         RemoveDir();
         break;
     }
     case 1:
     {
         PruneBundle();
         break;
     }
     case 2:
     {
         ApplyCurvatureThreshold();
         break;
     }
     case 3:
     {
         RemoveWithMask(false);
         break;
     }
     case 4:
     {
         RemoveWithMask(true);
         break;
     }
     }
 }
 
 void QmitkFiberProcessingView::Extract()
 {
     switch (m_Controls->m_ExtractionMethodBox->currentIndex())
     {
     case 0:
     {
         ExtractWithPlanarFigure();
         break;
     }
     case 1:
     {
         switch (m_Controls->m_ExtractionBoxMask->currentIndex())
         {
         {
         case 0:
                 ExtractWithMask(true, false);
                 break;
         }
         {
         case 1:
                 ExtractWithMask(true, true);
                 break;
         }
         {
         case 2:
                 ExtractWithMask(false, false);
                 break;
         }
         {
         case 3:
                 ExtractWithMask(false, true);
                 break;
         }
         }
         break;
     }
     }
 }
 
 void QmitkFiberProcessingView::PruneBundle()
 {
     int minLength = this->m_Controls->m_PruneFibersMinBox->value();
     int maxLength = this->m_Controls->m_PruneFibersMaxBox->value();
     for (auto node : m_SelectedFB)
     {
         mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
         if (!fib->RemoveShortFibers(minLength))
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
         else if (!fib->RemoveLongFibers(maxLength))
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::ApplyCurvatureThreshold()
 {
     int angle = this->m_Controls->m_CurvSpinBox->value();
     int dist = this->m_Controls->m_CurvDistanceSpinBox->value();
     std::vector< DataNode::Pointer > nodes = m_SelectedFB;
     for (auto node : nodes)
     {
         mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
 
         itk::FiberCurvatureFilter::Pointer filter = itk::FiberCurvatureFilter::New();
         filter->SetInputFiberBundle(fib);
         filter->SetAngularDeviation(angle);
         filter->SetDistance(dist);
         filter->SetRemoveFibers(m_Controls->m_RemoveCurvedFibersBox->isChecked());
         filter->Update();
         mitk::FiberBundle::Pointer newFib = filter->GetOutputFiberBundle();
         if (newFib->GetNumFibers()>0)
             node->SetData(newFib);
         else
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::RemoveDir()
 {
     for (auto node : m_SelectedFB)
     {
         mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
         vnl_vector_fixed<double,3> dir;
         dir[0] = m_Controls->m_ExtractDirX->value();
         dir[1] = m_Controls->m_ExtractDirY->value();
         dir[2] = m_Controls->m_ExtractDirZ->value();
         fib->RemoveDir(dir,cos((float)m_Controls->m_ExtractAngle->value()*M_PI/180));
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::RemoveWithMask(bool removeInside)
 {
     if (m_MaskImageNode.IsNull())
         return;
 
     mitk::Image::Pointer mitkMask = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
     for (auto node : m_SelectedFB)
     {
         mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
         QString name(node->GetName().c_str());
 
         itkUCharImageType::Pointer mask = itkUCharImageType::New();
         mitk::CastToItkImage(mitkMask, mask);
         mitk::FiberBundle::Pointer newFib = fib->RemoveFibersOutside(mask, removeInside);
         if (newFib->GetNumFibers()<=0)
         {
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
             continue;
         }
         node->SetData(newFib);
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::ExtractWithMask(bool onlyEnds, bool invert)
 {
     if (m_MaskImageNode.IsNull())
         return;
 
     mitk::Image::Pointer mitkMask = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
     for (auto node : m_SelectedFB)
     {
         mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
         QString name(node->GetName().c_str());
 
         itkUCharImageType::Pointer mask = itkUCharImageType::New();
         mitk::CastToItkImage(mitkMask, mask);
         mitk::FiberBundle::Pointer newFib = fib->ExtractFiberSubset(mask, !onlyEnds, invert, m_Controls->m_BothEnds->isChecked());
         if (newFib->GetNumFibers()<=0)
         {
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
             continue;
         }
 
         DataNode::Pointer newNode = DataNode::New();
         newNode->SetData(newFib);
 
         if (invert)
         {
             name += "_not";
 
             if (onlyEnds)
                 name += "-ending-in-mask";
             else
                 name += "-passing-mask";
         }
         else
         {
             if (onlyEnds)
                 name += "_ending-in-mask";
             else
                 name += "_passing-mask";
         }
 
         newNode->SetName(name.toStdString());
-        GetDefaultDataStorage()->Add(newNode);
+        GetDataStorage()->Add(newNode);
         node->SetVisibility(false);
     }
 }
 
 void QmitkFiberProcessingView::GenerateRoiImage()
 {
     if (m_SelectedPF.empty())
         return;
 
     mitk::BaseGeometry::Pointer geometry;
     if (!m_SelectedFB.empty())
     {
         mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.front()->GetData());
         geometry = fib->GetGeometry();
     }
     else if (m_SelectedImage)
         geometry = m_SelectedImage->GetGeometry();
     else
         return;
 
     itk::Vector<double,3> spacing = geometry->GetSpacing();
     spacing /= m_UpsamplingFactor;
 
     mitk::Point3D newOrigin = geometry->GetOrigin();
     mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
     newOrigin[0] += bounds.GetElement(0);
     newOrigin[1] += bounds.GetElement(2);
     newOrigin[2] += bounds.GetElement(4);
 
     itk::Matrix<double, 3, 3> direction;
     itk::ImageRegion<3> imageRegion;
     for (int i=0; i<3; i++)
         for (int j=0; j<3; j++)
             direction[j][i] = geometry->GetMatrixColumn(i)[j]/spacing[j];
     imageRegion.SetSize(0, geometry->GetExtent(0)*m_UpsamplingFactor);
     imageRegion.SetSize(1, geometry->GetExtent(1)*m_UpsamplingFactor);
     imageRegion.SetSize(2, geometry->GetExtent(2)*m_UpsamplingFactor);
 
     m_PlanarFigureImage = itkUCharImageType::New();
     m_PlanarFigureImage->SetSpacing( spacing );   // Set the image spacing
     m_PlanarFigureImage->SetOrigin( newOrigin );     // Set the image origin
     m_PlanarFigureImage->SetDirection( direction );  // Set the image direction
     m_PlanarFigureImage->SetRegions( imageRegion );
     m_PlanarFigureImage->Allocate();
     m_PlanarFigureImage->FillBuffer( 0 );
 
     Image::Pointer tmpImage = Image::New();
     tmpImage->InitializeByItk(m_PlanarFigureImage.GetPointer());
     tmpImage->SetVolume(m_PlanarFigureImage->GetBufferPointer());
 
     std::string name = m_SelectedPF.at(0)->GetName();
     WritePfToImage(m_SelectedPF.at(0), tmpImage);
     for (unsigned int i=1; i<m_SelectedPF.size(); i++)
     {
         name += "+";
         name += m_SelectedPF.at(i)->GetName();
         WritePfToImage(m_SelectedPF.at(i), tmpImage);
     }
 
     DataNode::Pointer node = DataNode::New();
     tmpImage = Image::New();
     tmpImage->InitializeByItk(m_PlanarFigureImage.GetPointer());
     tmpImage->SetVolume(m_PlanarFigureImage->GetBufferPointer());
     node->SetData(tmpImage);
     node->SetName(name);
-    this->GetDefaultDataStorage()->Add(node);
+    this->GetDataStorage()->Add(node);
 }
 
 void QmitkFiberProcessingView::WritePfToImage(mitk::DataNode::Pointer node, mitk::Image* image)
 {
     if (dynamic_cast<mitk::PlanarFigure*>(node->GetData()))
     {
         m_PlanarFigure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
         AccessFixedDimensionByItk_2(
                     image,
                     InternalReorientImagePlane, 3,
                     m_PlanarFigure->GetGeometry(), -1);
 
         AccessFixedDimensionByItk_2(
                     m_InternalImage,
                     InternalCalculateMaskFromPlanarFigure,
                     3, 2, node->GetName() );
     }
     else if (dynamic_cast<mitk::PlanarFigureComposite*>(node->GetData()))
     {
         DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(node);
         for (unsigned int i=0; i<children->Size(); i++)
         {
             WritePfToImage(children->at(i), image);
         }
     }
 }
 
 template < typename TPixel, unsigned int VImageDimension >
 void QmitkFiberProcessingView::InternalReorientImagePlane( const itk::Image< TPixel, VImageDimension > *image, mitk::BaseGeometry* planegeo3D, int additionalIndex )
 {
     typedef itk::Image< TPixel, VImageDimension > ImageType;
     typedef itk::Image< float, VImageDimension > FloatImageType;
 
     typedef itk::ResampleImageFilter<ImageType, FloatImageType, double> ResamplerType;
     typename ResamplerType::Pointer resampler = ResamplerType::New();
 
     mitk::PlaneGeometry* planegeo = dynamic_cast<mitk::PlaneGeometry*>(planegeo3D);
 
     float upsamp = m_UpsamplingFactor;
     float gausssigma = 0.5;
 
     // Spacing
     typename ResamplerType::SpacingType spacing = planegeo->GetSpacing();
     spacing[0] = image->GetSpacing()[0] / upsamp;
     spacing[1] = image->GetSpacing()[1] / upsamp;
     spacing[2] = image->GetSpacing()[2];
     resampler->SetOutputSpacing( spacing );
 
     // Size
     typename ResamplerType::SizeType size;
     size[0] = planegeo->GetExtentInMM(0) / spacing[0];
     size[1] = planegeo->GetExtentInMM(1) / spacing[1];
     size[2] = 1;
     resampler->SetSize( size );
 
     // Origin
     typename mitk::Point3D orig = planegeo->GetOrigin();
     typename mitk::Point3D corrorig;
     planegeo3D->WorldToIndex(orig,corrorig);
     corrorig[0] += 0.5/upsamp;
     corrorig[1] += 0.5/upsamp;
     corrorig[2] += 0;
     planegeo3D->IndexToWorld(corrorig,corrorig);
     resampler->SetOutputOrigin(corrorig );
 
     // Direction
     typename ResamplerType::DirectionType direction;
     typename mitk::AffineTransform3D::MatrixType matrix = planegeo->GetIndexToWorldTransform()->GetMatrix();
     for(int c=0; c<matrix.ColumnDimensions; c++)
     {
         double sum = 0;
         for(int r=0; r<matrix.RowDimensions; r++)
             sum += matrix(r,c)*matrix(r,c);
         for(int r=0; r<matrix.RowDimensions; r++)
             direction(r,c) = matrix(r,c)/sqrt(sum);
     }
     resampler->SetOutputDirection( direction );
 
     // Gaussian interpolation
     if(gausssigma != 0)
     {
         double sigma[3];
         for( unsigned int d = 0; d < 3; d++ )
             sigma[d] = gausssigma * image->GetSpacing()[d];
         double alpha = 2.0;
         typedef itk::GaussianInterpolateImageFunction<ImageType, double> GaussianInterpolatorType;
         typename GaussianInterpolatorType::Pointer interpolator = GaussianInterpolatorType::New();
         interpolator->SetInputImage( image );
         interpolator->SetParameters( sigma, alpha );
         resampler->SetInterpolator( interpolator );
     }
     else
     {
         typedef typename itk::LinearInterpolateImageFunction<ImageType, double> InterpolatorType;
         typename InterpolatorType::Pointer interpolator = InterpolatorType::New();
         interpolator->SetInputImage( image );
         resampler->SetInterpolator( interpolator );
     }
 
     resampler->SetInput( image );
     resampler->SetDefaultPixelValue(0);
     resampler->Update();
 
     if(additionalIndex < 0)
     {
         this->m_InternalImage = mitk::Image::New();
         this->m_InternalImage->InitializeByItk( resampler->GetOutput() );
         this->m_InternalImage->SetVolume( resampler->GetOutput()->GetBufferPointer() );
     }
 }
 
 template < typename TPixel, unsigned int VImageDimension >
 void QmitkFiberProcessingView::InternalCalculateMaskFromPlanarFigure( itk::Image< TPixel, VImageDimension > *image, unsigned int axis, std::string )
 {
     typedef itk::Image< TPixel, VImageDimension > ImageType;
     typedef itk::CastImageFilter< ImageType, itkUCharImageType > CastFilterType;
 
     // Generate mask image as new image with same header as input image and
     // initialize with "1".
     itkUCharImageType::Pointer newMaskImage = itkUCharImageType::New();
     newMaskImage->SetSpacing( image->GetSpacing() );   // Set the image spacing
     newMaskImage->SetOrigin( image->GetOrigin() );     // Set the image origin
     newMaskImage->SetDirection( image->GetDirection() );  // Set the image direction
     newMaskImage->SetRegions( image->GetLargestPossibleRegion() );
     newMaskImage->Allocate();
     newMaskImage->FillBuffer( 1 );
 
     // Generate VTK polygon from (closed) PlanarFigure polyline
     // (The polyline points are shifted by -0.5 in z-direction to make sure
     // that the extrusion filter, which afterwards elevates all points by +0.5
     // in z-direction, creates a 3D object which is cut by the the plane z=0)
     const PlaneGeometry *planarFigurePlaneGeometry = m_PlanarFigure->GetPlaneGeometry();
     const PlanarFigure::PolyLineType planarFigurePolyline = m_PlanarFigure->GetPolyLine( 0 );
     const BaseGeometry *imageGeometry3D = m_InternalImage->GetGeometry( 0 );
 
     vtkPolyData *polyline = vtkPolyData::New();
     polyline->Allocate( 1, 1 );
 
     // Determine x- and y-dimensions depending on principal axis
     int i0, i1;
     switch ( axis )
     {
     case 0:
         i0 = 1;
         i1 = 2;
         break;
     case 1:
         i0 = 0;
         i1 = 2;
         break;
     case 2:
     default:
         i0 = 0;
         i1 = 1;
         break;
     }
 
     // Create VTK polydata object of polyline contour
     vtkPoints *points = vtkPoints::New();
     PlanarFigure::PolyLineType::const_iterator it;
     unsigned int numberOfPoints = 0;
 
     for ( it = planarFigurePolyline.begin(); it != planarFigurePolyline.end(); ++it )
     {
         Point3D point3D;
 
         // Convert 2D point back to the local index coordinates of the selected image
         Point2D point2D = *it;
         planarFigurePlaneGeometry->WorldToIndex(point2D, point2D);
         point2D[0] -= 0.5/m_UpsamplingFactor;
         point2D[1] -= 0.5/m_UpsamplingFactor;
         planarFigurePlaneGeometry->IndexToWorld(point2D, point2D);
         planarFigurePlaneGeometry->Map( point2D, point3D );
 
         // Polygons (partially) outside of the image bounds can not be processed further due to a bug in vtkPolyDataToImageStencil
         if ( !imageGeometry3D->IsInside( point3D ) )
         {
             float bounds[2] = {0,0};
             bounds[0] =
                     this->m_InternalImage->GetLargestPossibleRegion().GetSize().GetElement(i0);
             bounds[1] =
                     this->m_InternalImage->GetLargestPossibleRegion().GetSize().GetElement(i1);
 
             imageGeometry3D->WorldToIndex( point3D, point3D );
 
             if (point3D[i0]<0)
                 point3D[i0] = 0.0;
             else if (point3D[i0]>bounds[0])
                 point3D[i0] = bounds[0]-0.001;
 
             if (point3D[i1]<0)
                 point3D[i1] = 0.0;
             else if (point3D[i1]>bounds[1])
                 point3D[i1] = bounds[1]-0.001;
 
             points->InsertNextPoint( point3D[i0], point3D[i1], -0.5 );
             numberOfPoints++;
         }
         else
         {
             imageGeometry3D->WorldToIndex( point3D, point3D );
             // Add point to polyline array
             points->InsertNextPoint( point3D[i0], point3D[i1], -0.5 );
             numberOfPoints++;
         }
     }
     polyline->SetPoints( points );
     points->Delete();
 
     vtkIdType *ptIds = new vtkIdType[numberOfPoints];
     for ( vtkIdType i = 0; i < numberOfPoints; ++i )
         ptIds[i] = i;
     polyline->InsertNextCell( VTK_POLY_LINE, numberOfPoints, ptIds );
 
     // Extrude the generated contour polygon
     vtkLinearExtrusionFilter *extrudeFilter = vtkLinearExtrusionFilter::New();
     extrudeFilter->SetInputData( polyline );
     extrudeFilter->SetScaleFactor( 1 );
     extrudeFilter->SetExtrusionTypeToNormalExtrusion();
     extrudeFilter->SetVector( 0.0, 0.0, 1.0 );
 
     // Make a stencil from the extruded polygon
     vtkPolyDataToImageStencil *polyDataToImageStencil = vtkPolyDataToImageStencil::New();
     polyDataToImageStencil->SetInputConnection( extrudeFilter->GetOutputPort() );
 
     // Export from ITK to VTK (to use a VTK filter)
     typedef itk::VTKImageImport< itkUCharImageType > ImageImportType;
     typedef itk::VTKImageExport< itkUCharImageType > ImageExportType;
 
     typename ImageExportType::Pointer itkExporter = ImageExportType::New();
     itkExporter->SetInput( newMaskImage );
 
     vtkImageImport *vtkImporter = vtkImageImport::New();
     this->ConnectPipelines( itkExporter, vtkImporter );
     vtkImporter->Update();
 
     // Apply the generated image stencil to the input image
     vtkImageStencil *imageStencilFilter = vtkImageStencil::New();
     imageStencilFilter->SetInputConnection( vtkImporter->GetOutputPort() );
     imageStencilFilter->SetStencilConnection(polyDataToImageStencil->GetOutputPort() );
     imageStencilFilter->ReverseStencilOff();
     imageStencilFilter->SetBackgroundValue( 0 );
     imageStencilFilter->Update();
 
     // Export from VTK back to ITK
     vtkImageExport *vtkExporter = vtkImageExport::New();
     vtkExporter->SetInputConnection( imageStencilFilter->GetOutputPort() );
     vtkExporter->Update();
 
     typename ImageImportType::Pointer itkImporter = ImageImportType::New();
     this->ConnectPipelines( vtkExporter, itkImporter );
     itkImporter->Update();
 
     // calculate cropping bounding box
     m_InternalImageMask3D = itkImporter->GetOutput();
     m_InternalImageMask3D->SetDirection(image->GetDirection());
 
     itk::ImageRegionConstIterator<itkUCharImageType>
             itmask(m_InternalImageMask3D, m_InternalImageMask3D->GetLargestPossibleRegion());
     itk::ImageRegionIterator<ImageType>
             itimage(image, image->GetLargestPossibleRegion());
 
     itmask.GoToBegin();
     itimage.GoToBegin();
 
     typename ImageType::SizeType lowersize = {{itk::NumericTraits<unsigned long>::max(),itk::NumericTraits<unsigned long>::max(),itk::NumericTraits<unsigned long>::max()}};
     typename ImageType::SizeType uppersize = {{0,0,0}};
     while( !itmask.IsAtEnd() )
     {
         if(itmask.Get() == 0)
             itimage.Set(0);
         else
         {
             typename ImageType::IndexType index = itimage.GetIndex();
             typename ImageType::SizeType signedindex;
             signedindex[0] = index[0];
             signedindex[1] = index[1];
             signedindex[2] = index[2];
 
             lowersize[0] = signedindex[0] < lowersize[0] ? signedindex[0] : lowersize[0];
             lowersize[1] = signedindex[1] < lowersize[1] ? signedindex[1] : lowersize[1];
             lowersize[2] = signedindex[2] < lowersize[2] ? signedindex[2] : lowersize[2];
 
             uppersize[0] = signedindex[0] > uppersize[0] ? signedindex[0] : uppersize[0];
             uppersize[1] = signedindex[1] > uppersize[1] ? signedindex[1] : uppersize[1];
             uppersize[2] = signedindex[2] > uppersize[2] ? signedindex[2] : uppersize[2];
         }
 
         ++itmask;
         ++itimage;
     }
 
     typename ImageType::IndexType index;
     index[0] = lowersize[0];
     index[1] = lowersize[1];
     index[2] = lowersize[2];
 
     typename ImageType::SizeType size;
     size[0] = uppersize[0] - lowersize[0] + 1;
     size[1] = uppersize[1] - lowersize[1] + 1;
     size[2] = uppersize[2] - lowersize[2] + 1;
 
     itk::ImageRegion<3> cropRegion = itk::ImageRegion<3>(index, size);
 
     // crop internal mask
     typedef itk::RegionOfInterestImageFilter< itkUCharImageType, itkUCharImageType > ROIMaskFilterType;
     typename ROIMaskFilterType::Pointer roi2 = ROIMaskFilterType::New();
     roi2->SetRegionOfInterest(cropRegion);
     roi2->SetInput(m_InternalImageMask3D);
     roi2->Update();
     m_InternalImageMask3D = roi2->GetOutput();
 
     Image::Pointer tmpImage = Image::New();
     tmpImage->InitializeByItk(m_InternalImageMask3D.GetPointer());
     tmpImage->SetVolume(m_InternalImageMask3D->GetBufferPointer());
 
     Image::Pointer tmpImage2 = Image::New();
     tmpImage2->InitializeByItk(m_PlanarFigureImage.GetPointer());
     const BaseGeometry *pfImageGeometry3D = tmpImage2->GetGeometry( 0 );
 
     const BaseGeometry *intImageGeometry3D = tmpImage->GetGeometry( 0 );
 
     typedef itk::ImageRegionIteratorWithIndex<itkUCharImageType> IteratorType;
     IteratorType imageIterator (m_InternalImageMask3D, m_InternalImageMask3D->GetRequestedRegion());
     imageIterator.GoToBegin();
     while ( !imageIterator.IsAtEnd() )
     {
         unsigned char val = imageIterator.Value();
         if (val>0)
         {
             itk::Index<3> index = imageIterator.GetIndex();
             Point3D point;
             point[0] = index[0];
             point[1] = index[1];
             point[2] = index[2];
 
             intImageGeometry3D->IndexToWorld(point, point);
             pfImageGeometry3D->WorldToIndex(point, point);
 
             point[i0] += 0.5;
             point[i1] += 0.5;
 
             index[0] = point[0];
             index[1] = point[1];
             index[2] = point[2];
 
             if (pfImageGeometry3D->IsIndexInside(index))
                 m_PlanarFigureImage->SetPixel(index, 1);
         }
         ++imageIterator;
     }
 
     // Clean up VTK objects
     polyline->Delete();
     extrudeFilter->Delete();
     polyDataToImageStencil->Delete();
     vtkImporter->Delete();
     imageStencilFilter->Delete();
     //vtkExporter->Delete(); // TODO: crashes when outcommented; memory leak??
     delete[] ptIds;
 }
 
-void QmitkFiberProcessingView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
-{
-    m_MultiWidget = &stdMultiWidget;
-}
-
-void QmitkFiberProcessingView::StdMultiWidgetNotAvailable()
-{
-    m_MultiWidget = NULL;
-}
-
 void QmitkFiberProcessingView::UpdateGui()
 {
     m_Controls->m_FibLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_PfLabel->setText("<font color='grey'>needed for extraction</font>");
     m_Controls->m_InputData->setTitle("Please Select Input Data");
 
     m_Controls->m_RemoveButton->setEnabled(false);
 
     m_Controls->m_PlanarFigureButtonsFrame->setEnabled(false);
     m_Controls->PFCompoANDButton->setEnabled(false);
     m_Controls->PFCompoORButton->setEnabled(false);
     m_Controls->PFCompoNOTButton->setEnabled(false);
 
     m_Controls->m_GenerateRoiImage->setEnabled(false);
     m_Controls->m_ExtractFibersButton->setEnabled(false);
     m_Controls->m_ModifyButton->setEnabled(false);
 
     m_Controls->m_CopyBundle->setEnabled(false);
     m_Controls->m_JoinBundles->setEnabled(false);
     m_Controls->m_SubstractBundles->setEnabled(false);
 
     // disable alle frames
     m_Controls->m_BundleWeightFrame->setVisible(false);
     m_Controls->m_ExtactionFramePF->setVisible(false);
     m_Controls->m_RemoveDirectionFrame->setVisible(false);
     m_Controls->m_RemoveLengthFrame->setVisible(false);
     m_Controls->m_RemoveCurvatureFrame->setVisible(false);
     m_Controls->m_SmoothFibersFrame->setVisible(false);
     m_Controls->m_CompressFibersFrame->setVisible(false);
     m_Controls->m_ColorFibersFrame->setVisible(false);
     m_Controls->m_MirrorFibersFrame->setVisible(false);
     m_Controls->m_MaskExtractionFrame->setVisible(false);
 
     bool pfSelected = !m_SelectedPF.empty();
     bool fibSelected = !m_SelectedFB.empty();
     bool multipleFibsSelected = (m_SelectedFB.size()>1);
     bool maskSelected = m_MaskImageNode.IsNotNull();
     bool imageSelected = m_SelectedImage.IsNotNull();
 
     // toggle visibility of elements according to selected method
     switch ( m_Controls->m_ExtractionMethodBox->currentIndex() )
     {
     case 0:
         m_Controls->m_ExtactionFramePF->setVisible(true);
         break;
     case 1:
         m_Controls->m_MaskExtractionFrame->setVisible(true);
         break;
     }
 
     switch ( m_Controls->m_RemovalMethodBox->currentIndex() )
     {
     case 0:
         m_Controls->m_RemoveDirectionFrame->setVisible(true);
         if ( fibSelected )
             m_Controls->m_RemoveButton->setEnabled(true);
         break;
     case 1:
         m_Controls->m_RemoveLengthFrame->setVisible(true);
         if ( fibSelected )
             m_Controls->m_RemoveButton->setEnabled(true);
         break;
     case 2:
         m_Controls->m_RemoveCurvatureFrame->setVisible(true);
         if ( fibSelected )
             m_Controls->m_RemoveButton->setEnabled(true);
         break;
     case 3:
         break;
     case 4:
         break;
     }
 
     switch ( m_Controls->m_ModificationMethodBox->currentIndex() )
     {
     case 0:
         m_Controls->m_SmoothFibersFrame->setVisible(true);
         break;
     case 1:
         m_Controls->m_CompressFibersFrame->setVisible(true);
         break;
     case 2:
         m_Controls->m_ColorFibersFrame->setVisible(true);
         break;
     case 3:
         m_Controls->m_MirrorFibersFrame->setVisible(true);
         if (m_SelectedSurfaces.size()>0)
             m_Controls->m_ModifyButton->setEnabled(true);
         break;
     case 4:
         m_Controls->m_BundleWeightFrame->setVisible(true);
     }
 
     // are fiber bundles selected?
     if ( fibSelected )
     {
         m_Controls->m_CopyBundle->setEnabled(true);
         m_Controls->m_ModifyButton->setEnabled(true);
         m_Controls->m_PlanarFigureButtonsFrame->setEnabled(true);
         m_Controls->m_FibLabel->setText(QString(m_SelectedFB.at(0)->GetName().c_str()));
 
         // one bundle and one planar figure needed to extract fibers
         if (pfSelected && m_Controls->m_ExtractionMethodBox->currentIndex()==0)
         {
             m_Controls->m_InputData->setTitle("Input Data");
             m_Controls->m_PfLabel->setText(QString(m_SelectedPF.at(0)->GetName().c_str()));
             m_Controls->m_ExtractFibersButton->setEnabled(true);
         }
 
         // more than two bundles needed to join/subtract
         if (multipleFibsSelected)
         {
             m_Controls->m_FibLabel->setText("multiple bundles selected");
 
             m_Controls->m_JoinBundles->setEnabled(true);
             m_Controls->m_SubstractBundles->setEnabled(true);
         }
 
         if (maskSelected && m_Controls->m_ExtractionMethodBox->currentIndex()==1)
         {
             m_Controls->m_InputData->setTitle("Input Data");
             m_Controls->m_PfLabel->setText(QString(m_MaskImageNode->GetName().c_str()));
             m_Controls->m_ExtractFibersButton->setEnabled(true);
         }
 
         if (maskSelected && (m_Controls->m_RemovalMethodBox->currentIndex()==3 || m_Controls->m_RemovalMethodBox->currentIndex()==4) )
         {
             m_Controls->m_InputData->setTitle("Input Data");
             m_Controls->m_PfLabel->setText(QString(m_MaskImageNode->GetName().c_str()));
             m_Controls->m_RemoveButton->setEnabled(true);
         }
     }
 
     // are planar figures selected?
     if (pfSelected)
     {
         if ( fibSelected || m_SelectedImage.IsNotNull())
             m_Controls->m_GenerateRoiImage->setEnabled(true);
 
         if (m_SelectedPF.size() > 1)
         {
             m_Controls->PFCompoANDButton->setEnabled(true);
             m_Controls->PFCompoORButton->setEnabled(true);
         }
         else
             m_Controls->PFCompoNOTButton->setEnabled(true);
     }
 
     // is image selected
     if (imageSelected || maskSelected)
     {
         m_Controls->m_PlanarFigureButtonsFrame->setEnabled(true);
     }
 }
 
 void QmitkFiberProcessingView::NodeRemoved(const mitk::DataNode* node)
 {
-    std::vector<mitk::DataNode*> nodes;
-    OnSelectionChanged(nodes);
+    berry::IWorkbenchPart::Pointer nullPart;
+    QList<mitk::DataNode::Pointer> nodes;
+    OnSelectionChanged(nullPart, nodes);
 }
 
 void QmitkFiberProcessingView::NodeAdded(const mitk::DataNode* node)
 {
-    std::vector<mitk::DataNode*> nodes;
-    OnSelectionChanged(nodes);
+    berry::IWorkbenchPart::Pointer nullPart;
+    QList<mitk::DataNode::Pointer> nodes;
+    OnSelectionChanged(nullPart, nodes);
 }
 
-void QmitkFiberProcessingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
+void QmitkFiberProcessingView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
     //reset existing Vectors containing FiberBundles and PlanarFigures from a previous selection
     m_SelectedFB.clear();
     m_SelectedPF.clear();
     m_SelectedSurfaces.clear();
     m_SelectedImage = NULL;
     m_MaskImageNode = NULL;
 
-    for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
+    for (auto node: nodes)
     {
-        mitk::DataNode::Pointer node = *it;
         if ( dynamic_cast<mitk::FiberBundle*>(node->GetData()) )
             m_SelectedFB.push_back(node);
         else if (dynamic_cast<mitk::PlanarPolygon*>(node->GetData()) || dynamic_cast<mitk::PlanarFigureComposite*>(node->GetData()) || dynamic_cast<mitk::PlanarCircle*>(node->GetData()))
             m_SelectedPF.push_back(node);
         else if (dynamic_cast<mitk::Image*>(node->GetData()))
         {
             m_SelectedImage = dynamic_cast<mitk::Image*>(node->GetData());
             bool isBinary = false;
             node->GetPropertyValue<bool>("binary", isBinary);
             if (isBinary)
                 m_MaskImageNode = node;
         }
         else if (dynamic_cast<mitk::Surface*>(node->GetData()))
             m_SelectedSurfaces.push_back(dynamic_cast<mitk::Surface*>(node->GetData()));
     }
 
     if (m_SelectedFB.empty() && m_SelectedSurfaces.empty())
     {
         int maxLayer = 0;
-        itk::VectorContainer<unsigned int, mitk::DataNode::Pointer>::ConstPointer nodes = this->GetDefaultDataStorage()->GetAll();
+        itk::VectorContainer<unsigned int, mitk::DataNode::Pointer>::ConstPointer nodes = this->GetDataStorage()->GetAll();
         for (unsigned int i=0; i<nodes->Size(); i++)
             if (dynamic_cast<mitk::FiberBundle*>(nodes->at(i)->GetData()))
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer sources = GetDataStorage()->GetSources(nodes->at(i));
                 if (sources->Size()>0)
                     continue;
 
                 int layer = 0;
                 nodes->at(i)->GetPropertyValue("layer", layer);
                 if (layer>=maxLayer)
                 {
                     maxLayer = layer;
                     m_SelectedFB.clear();
                     m_SelectedFB.push_back(nodes->at(i));
                 }
             }
     }
 
     if (m_SelectedPF.empty())
     {
         int maxLayer = 0;
-        itk::VectorContainer<unsigned int, mitk::DataNode::Pointer>::ConstPointer nodes = this->GetDefaultDataStorage()->GetAll();
+        itk::VectorContainer<unsigned int, mitk::DataNode::Pointer>::ConstPointer nodes = this->GetDataStorage()->GetAll();
         for (unsigned int i=0; i<nodes->Size(); i++)
             if (dynamic_cast<mitk::PlanarPolygon*>(nodes->at(i)->GetData()) || dynamic_cast<mitk::PlanarFigureComposite*>(nodes->at(i)->GetData()) || dynamic_cast<mitk::PlanarCircle*>(nodes->at(i)->GetData()))
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer sources = GetDataStorage()->GetSources(nodes->at(i));
                 if (sources->Size()>0)
                     continue;
 
                 int layer = 0;
                 nodes->at(i)->GetPropertyValue("layer", layer);
                 if (layer>=maxLayer)
                 {
                     maxLayer = layer;
                     m_SelectedPF.clear();
                     m_SelectedPF.push_back(nodes->at(i));
                 }
             }
     }
 
     UpdateGui();
 }
 
 void QmitkFiberProcessingView::OnDrawPolygon()
 {
     mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
     figure->ClosedOn();
     this->AddFigureToDataStorage(figure, QString("Polygon%1").arg(++m_PolygonCounter));
 }
 
 void QmitkFiberProcessingView::OnDrawCircle()
 {
     mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
     this->AddFigureToDataStorage(figure, QString("Circle%1").arg(++m_CircleCounter));
 }
 
-void QmitkFiberProcessingView::Activated()
-{
-
-}
-
 void QmitkFiberProcessingView::AddFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name, const char *, mitk::BaseProperty* )
 {
     // initialize figure's geometry with empty geometry
     mitk::PlaneGeometry::Pointer emptygeometry = mitk::PlaneGeometry::New();
     figure->SetPlaneGeometry( emptygeometry );
 
     //set desired data to DataNode where Planarfigure is stored
     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
     newNode->SetName(name.toStdString());
     newNode->SetData(figure);
     newNode->SetBoolProperty("planarfigure.3drendering", true);
     newNode->SetBoolProperty("planarfigure.3drendering.fill", true);
 
     mitk::PlanarFigureInteractor::Pointer figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(newNode->GetDataInteractor().GetPointer());
     if(figureInteractor.IsNull())
     {
         figureInteractor = mitk::PlanarFigureInteractor::New();
         us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
         figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
         figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
         figureInteractor->SetDataNode(newNode);
     }
 
     // figure drawn on the topmost layer / image
     GetDataStorage()->Add(newNode );
 
     for(unsigned int i = 0; i < m_SelectedPF.size(); i++)
         m_SelectedPF[i]->SetSelected(false);
 
     newNode->SetSelected(true);
     m_SelectedPF.clear();
     m_SelectedPF.push_back(newNode);
     UpdateGui();
 }
 
 void QmitkFiberProcessingView::ExtractWithPlanarFigure()
 {
     if ( m_SelectedFB.empty() || m_SelectedPF.empty() ){
         QMessageBox::information( NULL, "Warning", "No fibe bundle selected!");
         return;
     }
 
     std::vector<mitk::DataNode::Pointer> fiberBundles = m_SelectedFB;
     mitk::DataNode::Pointer planarFigure = m_SelectedPF.at(0);
     for (unsigned int i=0; i<fiberBundles.size(); i++)
     {
         mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(fiberBundles.at(i)->GetData());
 
         mitk::FiberBundle::Pointer extFB = fib->ExtractFiberSubset(planarFigure, GetDataStorage());
         if (extFB->GetNumFibers()<=0)
         {
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
             continue;
         }
 
         mitk::DataNode::Pointer node;
         node = mitk::DataNode::New();
         node->SetData(extFB);
         QString name(fiberBundles.at(i)->GetName().c_str());
         name += "*";
         //name += planarFigure->GetName().c_str();
         node->SetName(name.toStdString());
         fiberBundles.at(i)->SetVisibility(false);
         GetDataStorage()->Add(node);
     }
 }
 
 void QmitkFiberProcessingView::GenerateAndComposite()
 {
     mitk::PlanarFigureComposite::Pointer PFCAnd = mitk::PlanarFigureComposite::New();
     PFCAnd->setOperationType(mitk::PlanarFigureComposite::AND);
 
     mitk::DataNode::Pointer newPFCNode;
     newPFCNode = mitk::DataNode::New();
     newPFCNode->SetName("AND");
     newPFCNode->SetData(PFCAnd);
 
     AddCompositeToDatastorage(newPFCNode, m_SelectedPF);
     m_SelectedPF.clear();
     m_SelectedPF.push_back(newPFCNode);
     UpdateGui();
 }
 
 void QmitkFiberProcessingView::GenerateOrComposite()
 {
     mitk::PlanarFigureComposite::Pointer PFCOr = mitk::PlanarFigureComposite::New();
     PFCOr->setOperationType(mitk::PlanarFigureComposite::OR);
 
     mitk::DataNode::Pointer newPFCNode;
     newPFCNode = mitk::DataNode::New();
     newPFCNode->SetName("OR");
     newPFCNode->SetData(PFCOr);
 
     AddCompositeToDatastorage(newPFCNode, m_SelectedPF);
     m_SelectedPF.clear();
     m_SelectedPF.push_back(newPFCNode);
     UpdateGui();
 }
 
 void QmitkFiberProcessingView::GenerateNotComposite()
 {
     mitk::PlanarFigureComposite::Pointer PFCNot = mitk::PlanarFigureComposite::New();
     PFCNot->setOperationType(mitk::PlanarFigureComposite::NOT);
 
     mitk::DataNode::Pointer newPFCNode;
     newPFCNode = mitk::DataNode::New();
     newPFCNode->SetName("NOT");
     newPFCNode->SetData(PFCNot);
 
     AddCompositeToDatastorage(newPFCNode, m_SelectedPF);
     m_SelectedPF.clear();
     m_SelectedPF.push_back(newPFCNode);
     UpdateGui();
 }
 
 void QmitkFiberProcessingView::AddCompositeToDatastorage(mitk::DataNode::Pointer pfc, std::vector<mitk::DataNode::Pointer> children, mitk::DataNode::Pointer parentNode )
 {
     pfc->SetSelected(true);
     if (parentNode.IsNotNull())
         GetDataStorage()->Add(pfc, parentNode);
     else
         GetDataStorage()->Add(pfc);
 
     for (auto child : children)
     {
         if (dynamic_cast<PlanarFigure*>(child->GetData()))
         {
             mitk::DataNode::Pointer newChild;
             newChild = mitk::DataNode::New();
             newChild->SetData(dynamic_cast<PlanarFigure*>(child->GetData()));
             newChild->SetName( child->GetName() );
             newChild->SetBoolProperty("planarfigure.3drendering", true);
             newChild->SetBoolProperty("planarfigure.3drendering.fill", true);
 
             GetDataStorage()->Add(newChild, pfc);
             GetDataStorage()->Remove(child);
         }
         else if (dynamic_cast<PlanarFigureComposite*>(child->GetData()))
         {
             mitk::DataNode::Pointer newChild;
             newChild = mitk::DataNode::New();
             newChild->SetData(dynamic_cast<PlanarFigureComposite*>(child->GetData()));
             newChild->SetName( child->GetName() );
 
             std::vector< mitk::DataNode::Pointer > grandChildVector;
             mitk::DataStorage::SetOfObjects::ConstPointer grandchildren = GetDataStorage()->GetDerivations(child);
             for( mitk::DataStorage::SetOfObjects::const_iterator it = grandchildren->begin(); it != grandchildren->end(); ++it )
                 grandChildVector.push_back(*it);
 
             AddCompositeToDatastorage(newChild, grandChildVector, pfc);
             GetDataStorage()->Remove(child);
         }
     }
     UpdateGui();
 }
 
 void QmitkFiberProcessingView::CopyBundles()
 {
     if ( m_SelectedFB.empty() ){
         QMessageBox::information( NULL, "Warning", "Select at least one fiber bundle!");
         MITK_WARN("QmitkFiberProcessingView") << "Select at least one fiber bundle!";
         return;
     }
 
     for (auto node : m_SelectedFB)
     {
         mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
         mitk::FiberBundle::Pointer newFib = fib->GetDeepCopy();
 
         node->SetVisibility(false);
         QString name("");
         name += QString(m_SelectedFB.at(0)->GetName().c_str());
         name += "_copy";
 
         mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
         fbNode->SetData(newFib);
         fbNode->SetName(name.toStdString());
         fbNode->SetVisibility(true);
         GetDataStorage()->Add(fbNode);
     }
     UpdateGui();
 }
 
 void QmitkFiberProcessingView::JoinBundles()
 {
     if ( m_SelectedFB.size()<2 ){
         QMessageBox::information( NULL, "Warning", "Select at least two fiber bundles!");
         MITK_WARN("QmitkFiberProcessingView") << "Select at least two fiber bundles!";
         return;
     }
 
     mitk::FiberBundle::Pointer newBundle = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(0)->GetData());
     m_SelectedFB.at(0)->SetVisibility(false);
     QString name("");
     name += QString(m_SelectedFB.at(0)->GetName().c_str());
     for (unsigned int i=1; i<m_SelectedFB.size(); i++)
     {
         newBundle = newBundle->AddBundle(dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(i)->GetData()));
         name += "+"+QString(m_SelectedFB.at(i)->GetName().c_str());
         m_SelectedFB.at(i)->SetVisibility(false);
     }
 
     mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
     fbNode->SetData(newBundle);
     fbNode->SetName(name.toStdString());
     fbNode->SetVisibility(true);
     GetDataStorage()->Add(fbNode);
     UpdateGui();
 }
 
 void QmitkFiberProcessingView::SubstractBundles()
 {
     if ( m_SelectedFB.size()<2 ){
         QMessageBox::information( NULL, "Warning", "Select at least two fiber bundles!");
         MITK_WARN("QmitkFiberProcessingView") << "Select at least two fiber bundles!";
         return;
     }
 
     mitk::FiberBundle::Pointer newBundle = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(0)->GetData());
     m_SelectedFB.at(0)->SetVisibility(false);
     QString name("");
     name += QString(m_SelectedFB.at(0)->GetName().c_str());
     for (unsigned int i=1; i<m_SelectedFB.size(); i++)
     {
         newBundle = newBundle->SubtractBundle(dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.at(i)->GetData()));
         if (newBundle.IsNull())
             break;
         name += "-"+QString(m_SelectedFB.at(i)->GetName().c_str());
         m_SelectedFB.at(i)->SetVisibility(false);
     }
     if (newBundle.IsNull())
     {
         QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers. Did you select the fiber bundles in the correct order? X-Y is not equal to Y-X!");
         return;
     }
 
     mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
     fbNode->SetData(newBundle);
     fbNode->SetName(name.toStdString());
     fbNode->SetVisibility(true);
     GetDataStorage()->Add(fbNode);
     UpdateGui();
 }
 
 void QmitkFiberProcessingView::ResampleSelectedBundles()
 {
     double factor = this->m_Controls->m_SmoothFibersBox->value();
     for (auto node : m_SelectedFB)
     {
         mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
         fib->ResampleSpline(factor);
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::CompressSelectedBundles()
 {
     double factor = this->m_Controls->m_ErrorThresholdBox->value();
     for (auto node : m_SelectedFB)
     {
         mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
         fib->Compress(factor);
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::DoImageColorCoding()
 {
     if (m_Controls->m_ColorMapBox->GetSelectedNode().IsNull())
     {
         QMessageBox::information(NULL, "Bundle coloring aborted:", "No image providing the scalar values for coloring the selected bundle available.");
         return;
     }
 
     for (auto node : m_SelectedFB)
     {
         mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
         fib->ColorFibersByScalarMap(dynamic_cast<mitk::Image*>(m_Controls->m_ColorMapBox->GetSelectedNode()->GetData()), m_Controls->m_FiberOpacityBox->isChecked());
     }
-    RenderingManager::GetInstance()->RequestUpdateAll();
+
+    if (auto renderWindowPart = this->GetRenderWindowPart())
+    {
+        renderWindowPart->RequestUpdate();
+    }
 }
 
 
 void QmitkFiberProcessingView::DoCurvatureColorCoding()
 {
     for (auto node : m_SelectedFB)
     {
         mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
         fib->ColorFibersByCurvature();
     }
-    RenderingManager::GetInstance()->RequestUpdateAll();
+
+    if (auto renderWindowPart = this->GetRenderWindowPart())
+    {
+        renderWindowPart->RequestUpdate();
+    }
 }
 
 void QmitkFiberProcessingView::MirrorFibers()
 {
     unsigned int axis = this->m_Controls->m_MirrorFibersBox->currentIndex();
     for (auto node : m_SelectedFB)
     {
         mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
         if (m_SelectedImage.IsNotNull())
             fib->SetReferenceGeometry(m_SelectedImage->GetGeometry());
         fib->MirrorFibers(axis);
     }
 
 
     for (auto surf : m_SelectedSurfaces)
     {
         vtkSmartPointer<vtkPolyData> poly = surf->GetVtkPolyData();
         vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
 
         for (int i=0; i<poly->GetNumberOfPoints(); i++)
         {
             double* point = poly->GetPoint(i);
             point[axis] *= -1;
             vtkNewPoints->InsertNextPoint(point);
         }
         poly->SetPoints(vtkNewPoints);
         surf->CalculateBoundingBox();
     }
 
-    RenderingManager::GetInstance()->RequestUpdateAll();
+    if (auto renderWindowPart = this->GetRenderWindowPart())
+    {
+        renderWindowPart->RequestUpdate();
+    }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.h
index 1bc6121983..131c93c34f 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.h
@@ -1,191 +1,188 @@
 /*===================================================================
 
 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 QmitkFiberProcessingView_h
 #define QmitkFiberProcessingView_h
 
-#include <QmitkFunctionality.h>
+#include <QmitkAbstractView.h>
 #include "ui_QmitkFiberProcessingViewControls.h"
 
 #include <mitkPlanarFigureComposite.h>
 #include <mitkFiberBundle.h>
 #include <mitkSurface.h>
 
 #include <itkCastImageFilter.h>
 #include <itkVTKImageImport.h>
 #include <itkVTKImageExport.h>
 #include <itkRegionOfInterestImageFilter.h>
 
 #include <vtkLinearExtrusionFilter.h>
 #include <vtkPolyDataToImageStencil.h>
 #include <vtkSelectEnclosedPoints.h>
 #include <vtkImageImport.h>
 #include <vtkImageExport.h>
 #include <vtkImageStencil.h>
 #include <vtkSmartPointer.h>
 #include <vtkSelection.h>
 #include <vtkSelectionNode.h>
 #include <vtkExtractSelectedThresholds.h>
 #include <vtkFloatArray.h>
 
 /*!
 \brief View to process fiber bundles. Supplies methods to extract fibers from the bundle, fiber resampling, mirroring, join and subtract bundles and much more.
-
-\sa QmitkFunctionality
-\ingroup Functionalities
 */
-class QmitkFiberProcessingView : public QmitkFunctionality
+class QmitkFiberProcessingView : public QmitkAbstractView
 {
   // 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:
 
   typedef itk::Image< unsigned char, 3 >    itkUCharImageType;
 
   static const std::string VIEW_ID;
 
   QmitkFiberProcessingView();
   virtual ~QmitkFiberProcessingView();
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
-  virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget) override;
-  virtual void StdMultiWidgetNotAvailable() override;
-  virtual void Activated() override;
+  ///
+  /// Sets the focus to an internal widget.
+  ///
+  virtual void SetFocus() override;
 
 protected slots:
 
   void OnDrawCircle();          ///< add circle interactors etc.
   void OnDrawPolygon();         ///< add circle interactors etc.
   void GenerateAndComposite();
   void GenerateOrComposite();
   void GenerateNotComposite();
 
   void CopyBundles();               ///< add copies of selected bundles to data storage
   void JoinBundles();               ///< merge selected fiber bundles
   void SubstractBundles();          ///< subtract bundle A from bundle B. Not commutative! Defined by order of selection.
   void GenerateRoiImage();          ///< generate binary image of selected planar figures.
 
   void Remove();
   void Extract();
   void Modify();
   void UpdateGui();     ///< update button activity etc. dpending on current datamanager selection
 
   virtual void AddFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name, const char *propertyKey = NULL, mitk::BaseProperty *property = NULL );
 
 protected:
 
   void MirrorFibers();              ///< mirror bundle on the specified plane
   void ResampleSelectedBundles();   ///< smooth fiber bundle using the specified number of sampling points per cm.
   void DoImageColorCoding();        ///< color fibers by selected scalar image
   void DoCurvatureColorCoding();    ///< color fibers by curvature
   void CompressSelectedBundles();   ///< remove points below certain error threshold
   void WeightFibers();
 
   void RemoveWithMask(bool removeInside);
   void RemoveDir();
   void ApplyCurvatureThreshold();   ///< remove/split fibers with a too high curvature threshold
   void PruneBundle();               ///< remove too short/too long fibers
 
   void ExtractWithMask(bool onlyEnds, bool invert);
   void ExtractWithPlanarFigure();
 
-  /// \brief called by QmitkFunctionality when DataManager's selection has changed
-  virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes ) override;
+  /// \brief called by QmitkAbstractView when DataManager's selection has changed
+  virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
   Ui::QmitkFiberProcessingViewControls* m_Controls;
-  QmitkStdMultiWidget* m_MultiWidget;
 
   /** Connection from VTK to ITK */
   template <typename VTK_Exporter, typename ITK_Importer>
       void ConnectPipelines(VTK_Exporter* exporter, ITK_Importer importer)
   {
     importer->SetUpdateInformationCallback(exporter->GetUpdateInformationCallback());
 
     importer->SetPipelineModifiedCallback(exporter->GetPipelineModifiedCallback());
     importer->SetWholeExtentCallback(exporter->GetWholeExtentCallback());
     importer->SetSpacingCallback(exporter->GetSpacingCallback());
     importer->SetOriginCallback(exporter->GetOriginCallback());
     importer->SetScalarTypeCallback(exporter->GetScalarTypeCallback());
 
     importer->SetNumberOfComponentsCallback(exporter->GetNumberOfComponentsCallback());
 
     importer->SetPropagateUpdateExtentCallback(exporter->GetPropagateUpdateExtentCallback());
     importer->SetUpdateDataCallback(exporter->GetUpdateDataCallback());
     importer->SetDataExtentCallback(exporter->GetDataExtentCallback());
     importer->SetBufferPointerCallback(exporter->GetBufferPointerCallback());
     importer->SetCallbackUserData(exporter->GetCallbackUserData());
   }
 
   template <typename ITK_Exporter, typename VTK_Importer>
       void ConnectPipelines(ITK_Exporter exporter, VTK_Importer* importer)
   {
     importer->SetUpdateInformationCallback(exporter->GetUpdateInformationCallback());
 
     importer->SetPipelineModifiedCallback(exporter->GetPipelineModifiedCallback());
     importer->SetWholeExtentCallback(exporter->GetWholeExtentCallback());
     importer->SetSpacingCallback(exporter->GetSpacingCallback());
     importer->SetOriginCallback(exporter->GetOriginCallback());
     importer->SetScalarTypeCallback(exporter->GetScalarTypeCallback());
 
     importer->SetNumberOfComponentsCallback(exporter->GetNumberOfComponentsCallback());
 
     importer->SetPropagateUpdateExtentCallback(exporter->GetPropagateUpdateExtentCallback());
     importer->SetUpdateDataCallback(exporter->GetUpdateDataCallback());
     importer->SetDataExtentCallback(exporter->GetDataExtentCallback());
     importer->SetBufferPointerCallback(exporter->GetBufferPointerCallback());
     importer->SetCallbackUserData(exporter->GetCallbackUserData());
   }
 
   template < typename TPixel, unsigned int VImageDimension >
       void InternalCalculateMaskFromPlanarFigure(
           itk::Image< TPixel, VImageDimension > *image, unsigned int axis, std::string nodeName );
 
   template < typename TPixel, unsigned int VImageDimension >
       void InternalReorientImagePlane(
         const itk::Image< TPixel, VImageDimension > *image, mitk::BaseGeometry* planegeo3D, int additionalIndex );
 
   int m_CircleCounter;                                      ///< used for data node naming
   int m_PolygonCounter;                                     ///< used for data node naming
   std::vector<mitk::DataNode::Pointer>  m_SelectedFB;       ///< selected fiber bundle nodes
   std::vector<mitk::DataNode::Pointer>  m_SelectedPF;       ///< selected planar figure nodes
   std::vector<mitk::Surface::Pointer>   m_SelectedSurfaces;
   mitk::Image::Pointer                  m_SelectedImage;
   mitk::Image::Pointer                  m_InternalImage;
   mitk::PlanarFigure::Pointer           m_PlanarFigure;
   itkUCharImageType::Pointer            m_InternalImageMask3D;
   itkUCharImageType::Pointer            m_PlanarFigureImage;
   float                                 m_UpsamplingFactor; ///< upsampling factor for all image generations
   mitk::DataNode::Pointer               m_MaskImageNode;
 
   void AddCompositeToDatastorage(mitk::DataNode::Pointer pfc, std::vector<mitk::DataNode::Pointer> children, mitk::DataNode::Pointer parentNode=NULL);
   void debugPFComposition(mitk::PlanarFigureComposite::Pointer , int );
   void WritePfToImage(mitk::DataNode::Pointer node, mitk::Image* image);
   mitk::DataNode::Pointer GenerateTractDensityImage(mitk::FiberBundle::Pointer fib, bool binary, bool absolute);
   mitk::DataNode::Pointer GenerateColorHeatmap(mitk::FiberBundle::Pointer fib);
   mitk::DataNode::Pointer GenerateFiberEndingsImage(mitk::FiberBundle::Pointer fib);
   mitk::DataNode::Pointer GenerateFiberEndingsPointSet(mitk::FiberBundle::Pointer fib);
 
   void NodeAdded( const mitk::DataNode* node ) override;
   void NodeRemoved(const mitk::DataNode* node) override;
 };
 
 
 
 #endif // _QMITKFIBERTRACKINGVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.cpp
index 238382f2a3..043dc6ce5e 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.cpp
@@ -1,494 +1,480 @@
 /*===================================================================
 
 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>
 
 // Qmitk
 #include "QmitkFiberQuantificationView.h"
-#include <QmitkStdMultiWidget.h>
 
 // Qt
 #include <QMessageBox>
 
 // MITK
 #include <mitkNodePredicateProperty.h>
 #include <mitkImageCast.h>
 #include <mitkPointSet.h>
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarPolygon.h>
 #include <mitkPlanarRectangle.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkDataNodeObject.h>
 #include <mitkTensorImage.h>
 
 // ITK
 #include <itkResampleImageFilter.h>
 #include <itkGaussianInterpolateImageFunction.h>
 #include <itkImageRegionIteratorWithIndex.h>
 #include <itkTractsToFiberEndingsImageFilter.h>
 #include <itkTractDensityImageFilter.h>
 #include <itkImageRegion.h>
 #include <itkTractsToRgbaImageFilter.h>
 #include <itkTractsToVectorImageFilter.h>
 
 #include <math.h>
 #include <boost/lexical_cast.hpp>
 
 const std::string QmitkFiberQuantificationView::VIEW_ID = "org.mitk.views.fiberquantification";
 const std::string id_DataManager = "org.mitk.views.datamanager";
 using namespace mitk;
 
 QmitkFiberQuantificationView::QmitkFiberQuantificationView()
-    : QmitkFunctionality()
+    : QmitkAbstractView()
     , m_Controls( 0 )
-    , m_MultiWidget( NULL )
     , m_UpsamplingFactor(5)
 {
 
 }
 
 // Destructor
 QmitkFiberQuantificationView::~QmitkFiberQuantificationView()
 {
 
 }
 
 void QmitkFiberQuantificationView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkFiberQuantificationViewControls;
         m_Controls->setupUi( parent );
 
         connect( m_Controls->m_ProcessFiberBundleButton, SIGNAL(clicked()), this, SLOT(ProcessSelectedBundles()) );
         connect( m_Controls->m_ExtractFiberPeaks, SIGNAL(clicked()), this, SLOT(CalculateFiberDirections()) );
     }
 }
 
-void QmitkFiberQuantificationView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
+void QmitkFiberQuantificationView::SetFocus()
 {
-    m_MultiWidget = &stdMultiWidget;
-}
-
-
-void QmitkFiberQuantificationView::StdMultiWidgetNotAvailable()
-{
-    m_MultiWidget = NULL;
+  m_Controls->m_ProcessFiberBundleButton->setFocus();
 }
 
 void QmitkFiberQuantificationView::CalculateFiberDirections()
 {
     typedef itk::Image<unsigned char, 3>                                            ItkUcharImgType;
     typedef itk::Image< itk::Vector< float, 3>, 3 >                                 ItkDirectionImage3DType;
     typedef itk::VectorContainer< unsigned int, ItkDirectionImage3DType::Pointer >  ItkDirectionImageContainerType;
 
     // load fiber bundle
     mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.back()->GetData());
 
     itk::TractsToVectorImageFilter<float>::Pointer fOdfFilter = itk::TractsToVectorImageFilter<float>::New();
     if (m_SelectedImage.IsNotNull())
     {
         ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
         mitk::CastToItkImage<ItkUcharImgType>(m_SelectedImage, itkMaskImage);
         fOdfFilter->SetMaskImage(itkMaskImage);
     }
 
     // extract directions from fiber bundle
     fOdfFilter->SetFiberBundle(inputTractogram);
     fOdfFilter->SetAngularThreshold(cos(m_Controls->m_AngularThreshold->value()*M_PI/180));
     fOdfFilter->SetNormalizeVectors(m_Controls->m_NormalizeDirectionsBox->isChecked());
     fOdfFilter->SetUseWorkingCopy(true);
     fOdfFilter->SetCreateDirectionImages(m_Controls->m_DirectionImagesBox->isChecked());
     fOdfFilter->SetSizeThreshold(m_Controls->m_PeakThreshold->value());
     fOdfFilter->SetMaxNumDirections(m_Controls->m_MaxNumDirections->value());
     fOdfFilter->Update();
 
     QString name = m_SelectedFB.back()->GetName().c_str();
 
     if (m_Controls->m_VectorFieldBox->isChecked())
     {
         float minSpacing = 1;
         if (m_SelectedImage.IsNotNull())
         {
             mitk::Vector3D outImageSpacing = m_SelectedImage->GetGeometry()->GetSpacing();
 
             if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
                 minSpacing = outImageSpacing[0];
             else if (outImageSpacing[1] < outImageSpacing[2])
                 minSpacing = outImageSpacing[1];
             else
                 minSpacing = outImageSpacing[2];
         }
 
         mitk::FiberBundle::Pointer directions = fOdfFilter->GetOutputFiberBundle();
         mitk::DataNode::Pointer node = mitk::DataNode::New();
         node->SetData(directions);
         node->SetName((name+"_vectorfield").toStdString().c_str());
         node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
         node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
         node->SetProperty("color", mitk::ColorProperty::New(1.0f, 1.0f, 1.0f));
 
-        GetDefaultDataStorage()->Add(node, m_SelectedFB.back());
+        GetDataStorage()->Add(node, m_SelectedFB.back());
     }
 
     if (m_Controls->m_NumDirectionsBox->isChecked())
     {
         mitk::Image::Pointer mitkImage = mitk::Image::New();
         mitkImage->InitializeByItk( fOdfFilter->GetNumDirectionsImage().GetPointer() );
         mitkImage->SetVolume( fOdfFilter->GetNumDirectionsImage()->GetBufferPointer() );
 
         mitk::DataNode::Pointer node = mitk::DataNode::New();
         node->SetData(mitkImage);
         node->SetName((name+"_numdirections").toStdString().c_str());
-        GetDefaultDataStorage()->Add(node, m_SelectedFB.back());
+        GetDataStorage()->Add(node, m_SelectedFB.back());
     }
 
     if (m_Controls->m_DirectionImagesBox->isChecked())
     {
         ItkDirectionImageContainerType::Pointer directionImageContainer = fOdfFilter->GetDirectionImageContainer();
         for (unsigned int i=0; i<directionImageContainer->Size(); i++)
         {
             itk::TractsToVectorImageFilter<float>::ItkDirectionImageType::Pointer itkImg = directionImageContainer->GetElement(i);
 
             if (itkImg.IsNull())
                 return;
 
             mitk::Image::Pointer mitkImage = mitk::Image::New();
             mitkImage->InitializeByItk( itkImg.GetPointer() );
             mitkImage->SetVolume( itkImg->GetBufferPointer() );
 
             mitk::DataNode::Pointer node = mitk::DataNode::New();
             node->SetData(mitkImage);
             node->SetName( (name+"_direction_"+boost::lexical_cast<std::string>(i).c_str()).toStdString().c_str());
             node->SetVisibility(false);
-            GetDefaultDataStorage()->Add(node, m_SelectedFB.back());
+            GetDataStorage()->Add(node, m_SelectedFB.back());
         }
     }
 }
 
 void QmitkFiberQuantificationView::UpdateGui()
 {
     m_Controls->m_ProcessFiberBundleButton->setEnabled(!m_SelectedFB.empty());
     m_Controls->m_ExtractFiberPeaks->setEnabled(!m_SelectedFB.empty());
 }
 
-void QmitkFiberQuantificationView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
+void QmitkFiberQuantificationView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
     //reset existing Vectors containing FiberBundles and PlanarFigures from a previous selection
     m_SelectedFB.clear();
     m_SelectedSurfaces.clear();
     m_SelectedImage = NULL;
 
-    for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
+    for (mitk::DataNode::Pointer node: nodes)
     {
-        mitk::DataNode::Pointer node = *it;
         if ( dynamic_cast<mitk::FiberBundle*>(node->GetData()) )
         {
             m_SelectedFB.push_back(node);
         }
         else if (dynamic_cast<mitk::Image*>(node->GetData()))
             m_SelectedImage = dynamic_cast<mitk::Image*>(node->GetData());
         else if (dynamic_cast<mitk::Surface*>(node->GetData()))
         {
             m_SelectedSurfaces.push_back(dynamic_cast<mitk::Surface*>(node->GetData()));
         }
     }
     UpdateGui();
     GenerateStats();
 }
 
-void QmitkFiberQuantificationView::Activated()
-{
-
-}
-
 void QmitkFiberQuantificationView::GenerateStats()
 {
     if ( m_SelectedFB.empty() )
         return;
 
     QString stats("");
 
     for( int i=0; i<m_SelectedFB.size(); i++ )
     {
         mitk::DataNode::Pointer node = m_SelectedFB[i];
         if (node.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(node->GetData()))
         {
             if (i>0)
                 stats += "\n-----------------------------\n";
             stats += QString(node->GetName().c_str()) + "\n";
             mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
             stats += "Number of fibers: "+ QString::number(fib->GetNumFibers()) + "\n";
             stats += "Number of points: "+ QString::number(fib->GetNumberOfPoints()) + "\n";
             stats += "Min. length:         "+ QString::number(fib->GetMinFiberLength(),'f',1) + " mm\n";
             stats += "Max. length:         "+ QString::number(fib->GetMaxFiberLength(),'f',1) + " mm\n";
             stats += "Mean length:         "+ QString::number(fib->GetMeanFiberLength(),'f',1) + " mm\n";
             stats += "Median length:       "+ QString::number(fib->GetMedianFiberLength(),'f',1) + " mm\n";
             stats += "Standard deviation:  "+ QString::number(fib->GetLengthStDev(),'f',1) + " mm\n";
 
             vtkSmartPointer<vtkFloatArray> weights = vtkFloatArray::SafeDownCast(fib->GetFiberPolyData()->GetCellData()->GetArray("FIBER_WEIGHTS"));
             if (weights!=NULL)
             {
                 stats += "Detected fiber weights:\n";
                 float weight=-1;
                 int c = 0;
                 for (int i=0; i<weights->GetSize(); i++)
                     if (!mitk::Equal(weights->GetValue(i),weight,0.00001))
                     {
                         c++;
                         if (weight>0)
                             stats += QString::number(i) + ":  "+ QString::number(weights->GetValue(i)) + "\n";
                         stats += QString::number(c) + ". Fibers " + QString::number(i+1) + "-";
                         weight = weights->GetValue(i);
                     }
                 stats += QString::number(weights->GetSize()) + ":  "+ QString::number(weight) + "\n";
             }
             else
                 stats += "No fiber weight array found.\n";
         }
     }
     this->m_Controls->m_StatsTextEdit->setText(stats);
 }
 
 void QmitkFiberQuantificationView::ProcessSelectedBundles()
 {
     if ( m_SelectedFB.empty() ){
         QMessageBox::information( NULL, "Warning", "No fibe bundle selected!");
         MITK_WARN("QmitkFiberQuantificationView") << "no fibe bundle selected";
         return;
     }
 
     int generationMethod = m_Controls->m_GenerationBox->currentIndex();
 
     for( int i=0; i<m_SelectedFB.size(); i++ )
     {
         mitk::DataNode::Pointer node = m_SelectedFB[i];
         if (node.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(node->GetData()))
         {
             mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
             QString name(node->GetName().c_str());
             DataNode::Pointer newNode = NULL;
             switch(generationMethod){
             case 0:
                 newNode = GenerateTractDensityImage(fib, false, true);
                 name += "_TDI";
                 break;
             case 1:
                 newNode = GenerateTractDensityImage(fib, false, false);
                 name += "_TDI";
                 break;
             case 2:
                 newNode = GenerateTractDensityImage(fib, true, false);
                 name += "_envelope";
                 break;
             case 3:
                 newNode = GenerateColorHeatmap(fib);
                 break;
             case 4:
                 newNode = GenerateFiberEndingsImage(fib);
                 name += "_fiber_endings";
                 break;
             case 5:
                 newNode = GenerateFiberEndingsPointSet(fib);
                 name += "_fiber_endings";
                 break;
             }
             if (newNode.IsNotNull())
             {
                 newNode->SetName(name.toStdString());
                 GetDataStorage()->Add(newNode);
             }
         }
     }
 }
 
 // generate pointset displaying the fiber endings
 mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateFiberEndingsPointSet(mitk::FiberBundle::Pointer fib)
 {
     mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
     vtkSmartPointer<vtkPolyData> fiberPolyData = fib->GetFiberPolyData();
     vtkSmartPointer<vtkCellArray> vLines = fiberPolyData->GetLines();
     vLines->InitTraversal();
 
     int count = 0;
     int numFibers = fib->GetNumFibers();
     for( int i=0; i<numFibers; i++ )
     {
         vtkIdType   numPoints(0);
         vtkIdType*  points(NULL);
         vLines->GetNextCell ( numPoints, points );
 
         if (numPoints>0)
         {
             double* point = fiberPolyData->GetPoint(points[0]);
             itk::Point<float,3> itkPoint;
             itkPoint[0] = point[0];
             itkPoint[1] = point[1];
             itkPoint[2] = point[2];
             pointSet->InsertPoint(count, itkPoint);
             count++;
         }
         if (numPoints>2)
         {
             double* point = fiberPolyData->GetPoint(points[numPoints-1]);
             itk::Point<float,3> itkPoint;
             itkPoint[0] = point[0];
             itkPoint[1] = point[1];
             itkPoint[2] = point[2];
             pointSet->InsertPoint(count, itkPoint);
             count++;
         }
     }
 
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData( pointSet );
     return node;
 }
 
 // generate image displaying the fiber endings
 mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateFiberEndingsImage(mitk::FiberBundle::Pointer fib)
 {
     typedef unsigned char OutPixType;
     typedef itk::Image<OutPixType,3> OutImageType;
 
     typedef itk::TractsToFiberEndingsImageFilter< OutImageType > ImageGeneratorType;
     ImageGeneratorType::Pointer generator = ImageGeneratorType::New();
     generator->SetFiberBundle(fib);
     generator->SetUpsamplingFactor(m_Controls->m_UpsamplingSpinBox->value());
     if (m_SelectedImage.IsNotNull())
     {
         OutImageType::Pointer itkImage = OutImageType::New();
         CastToItkImage(m_SelectedImage, itkImage);
         generator->SetInputImage(itkImage);
         generator->SetUseImageGeometry(true);
     }
     generator->Update();
 
     // get output image
     OutImageType::Pointer outImg = generator->GetOutput();
     mitk::Image::Pointer img = mitk::Image::New();
     img->InitializeByItk(outImg.GetPointer());
     img->SetVolume(outImg->GetBufferPointer());
 
     // init data node
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(img);
     return node;
 }
 
 // generate rgba heatmap from fiber bundle
 mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateColorHeatmap(mitk::FiberBundle::Pointer fib)
 {
     typedef itk::RGBAPixel<unsigned char> OutPixType;
     typedef itk::Image<OutPixType, 3> OutImageType;
     typedef itk::TractsToRgbaImageFilter< OutImageType > ImageGeneratorType;
     ImageGeneratorType::Pointer generator = ImageGeneratorType::New();
     generator->SetFiberBundle(fib);
     generator->SetUpsamplingFactor(m_Controls->m_UpsamplingSpinBox->value());
     if (m_SelectedImage.IsNotNull())
     {
         itk::Image<unsigned char, 3>::Pointer itkImage = itk::Image<unsigned char, 3>::New();
         CastToItkImage(m_SelectedImage, itkImage);
         generator->SetInputImage(itkImage);
         generator->SetUseImageGeometry(true);
     }
     generator->Update();
 
     // get output image
     typedef itk::Image<OutPixType,3> OutType;
     OutType::Pointer outImg = generator->GetOutput();
     mitk::Image::Pointer img = mitk::Image::New();
     img->InitializeByItk(outImg.GetPointer());
     img->SetVolume(outImg->GetBufferPointer());
 
     // init data node
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(img);
     return node;
 }
 
 // generate tract density image from fiber bundle
 mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateTractDensityImage(mitk::FiberBundle::Pointer fib, bool binary, bool absolute)
 {
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     if (binary)
     {
         typedef unsigned char OutPixType;
         typedef itk::Image<OutPixType, 3> OutImageType;
 
         itk::TractDensityImageFilter< OutImageType >::Pointer generator = itk::TractDensityImageFilter< OutImageType >::New();
         generator->SetFiberBundle(fib);
         generator->SetBinaryOutput(binary);
         generator->SetOutputAbsoluteValues(absolute);
         generator->SetUpsamplingFactor(m_Controls->m_UpsamplingSpinBox->value());
         if (m_SelectedImage.IsNotNull())
         {
             OutImageType::Pointer itkImage = OutImageType::New();
             CastToItkImage(m_SelectedImage, itkImage);
             generator->SetInputImage(itkImage);
             generator->SetUseImageGeometry(true);
 
         }
         generator->Update();
 
         // get output image
         typedef itk::Image<OutPixType,3> OutType;
         OutType::Pointer outImg = generator->GetOutput();
         mitk::Image::Pointer img = mitk::Image::New();
         img->InitializeByItk(outImg.GetPointer());
         img->SetVolume(outImg->GetBufferPointer());
 
         // init data node
         node->SetData(img);
     }
     else
     {
         typedef float OutPixType;
         typedef itk::Image<OutPixType, 3> OutImageType;
 
         itk::TractDensityImageFilter< OutImageType >::Pointer generator = itk::TractDensityImageFilter< OutImageType >::New();
         generator->SetFiberBundle(fib);
         generator->SetBinaryOutput(binary);
         generator->SetOutputAbsoluteValues(absolute);
         generator->SetUpsamplingFactor(m_Controls->m_UpsamplingSpinBox->value());
         if (m_SelectedImage.IsNotNull())
         {
             OutImageType::Pointer itkImage = OutImageType::New();
             CastToItkImage(m_SelectedImage, itkImage);
             generator->SetInputImage(itkImage);
             generator->SetUseImageGeometry(true);
 
         }
         generator->Update();
 
         // get output image
         typedef itk::Image<OutPixType,3> OutType;
         OutType::Pointer outImg = generator->GetOutput();
         mitk::Image::Pointer img = mitk::Image::New();
         img->InitializeByItk(outImg.GetPointer());
         img->SetVolume(outImg->GetBufferPointer());
 
         // init data node
         node->SetData(img);
     }
     return node;
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.h
index 1e2144ebdc..017a341f32 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberQuantificationView.h
@@ -1,150 +1,148 @@
 /*===================================================================
 
 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 QmitkFiberQuantificationView_h
 #define QmitkFiberQuantificationView_h
 
-#include <QmitkFunctionality.h>
+#include <QmitkAbstractView.h>
 #include "ui_QmitkFiberQuantificationViewControls.h"
 
 #include <mitkPlanarFigureComposite.h>
 #include <mitkFiberBundle.h>
 #include <mitkSurface.h>
 
 #include <itkCastImageFilter.h>
 #include <itkVTKImageImport.h>
 #include <itkVTKImageExport.h>
 #include <itkRegionOfInterestImageFilter.h>
 
 #include <vtkLinearExtrusionFilter.h>
 #include <vtkPolyDataToImageStencil.h>
 #include <vtkSelectEnclosedPoints.h>
 #include <vtkImageImport.h>
 #include <vtkImageExport.h>
 #include <vtkImageStencil.h>
 #include <vtkSmartPointer.h>
 #include <vtkSelection.h>
 #include <vtkSelectionNode.h>
 #include <vtkExtractSelectedThresholds.h>
 #include <vtkFloatArray.h>
 
 /*!
 \brief Generation of images from fiber bundles (TDI, envelopes, endpoint distribution) and extraction of principal fiber directions from tractograms.
 
-\sa QmitkFunctionality
-\ingroup Functionalities
 */
-class QmitkFiberQuantificationView : public QmitkFunctionality
+class QmitkFiberQuantificationView : public QmitkAbstractView
 {
   // 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:
 
   typedef itk::Image< unsigned char, 3 >    itkUCharImageType;
 
   static const std::string VIEW_ID;
 
   QmitkFiberQuantificationView();
   virtual ~QmitkFiberQuantificationView();
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
-  virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget) override;
-  virtual void StdMultiWidgetNotAvailable() override;
-  virtual void Activated() override;
+  ///
+  /// Sets the focus to an internal widget.
+  ///
+  virtual void SetFocus() override;
 
 protected slots:
 
   void ProcessSelectedBundles();    ///< start selected operation on fiber bundle (e.g. tract density image generation)
   void CalculateFiberDirections();  ///< Calculate main fiber directions from tractogram
 
 protected:
 
-  /// \brief called by QmitkFunctionality when DataManager's selection has changed
-  virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes ) override;
+  /// \brief called by QmitkAbstractView when DataManager's selection has changed
+  virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
   Ui::QmitkFiberQuantificationViewControls* m_Controls;
-  QmitkStdMultiWidget* m_MultiWidget;
 
   /** Connection from VTK to ITK */
   template <typename VTK_Exporter, typename ITK_Importer>
       void ConnectPipelines(VTK_Exporter* exporter, ITK_Importer importer)
   {
     importer->SetUpdateInformationCallback(exporter->GetUpdateInformationCallback());
 
     importer->SetPipelineModifiedCallback(exporter->GetPipelineModifiedCallback());
     importer->SetWholeExtentCallback(exporter->GetWholeExtentCallback());
     importer->SetSpacingCallback(exporter->GetSpacingCallback());
     importer->SetOriginCallback(exporter->GetOriginCallback());
     importer->SetScalarTypeCallback(exporter->GetScalarTypeCallback());
 
     importer->SetNumberOfComponentsCallback(exporter->GetNumberOfComponentsCallback());
 
     importer->SetPropagateUpdateExtentCallback(exporter->GetPropagateUpdateExtentCallback());
     importer->SetUpdateDataCallback(exporter->GetUpdateDataCallback());
     importer->SetDataExtentCallback(exporter->GetDataExtentCallback());
     importer->SetBufferPointerCallback(exporter->GetBufferPointerCallback());
     importer->SetCallbackUserData(exporter->GetCallbackUserData());
   }
 
   template <typename ITK_Exporter, typename VTK_Importer>
       void ConnectPipelines(ITK_Exporter exporter, VTK_Importer* importer)
   {
     importer->SetUpdateInformationCallback(exporter->GetUpdateInformationCallback());
 
     importer->SetPipelineModifiedCallback(exporter->GetPipelineModifiedCallback());
     importer->SetWholeExtentCallback(exporter->GetWholeExtentCallback());
     importer->SetSpacingCallback(exporter->GetSpacingCallback());
     importer->SetOriginCallback(exporter->GetOriginCallback());
     importer->SetScalarTypeCallback(exporter->GetScalarTypeCallback());
 
     importer->SetNumberOfComponentsCallback(exporter->GetNumberOfComponentsCallback());
 
     importer->SetPropagateUpdateExtentCallback(exporter->GetPropagateUpdateExtentCallback());
     importer->SetUpdateDataCallback(exporter->GetUpdateDataCallback());
     importer->SetDataExtentCallback(exporter->GetDataExtentCallback());
     importer->SetBufferPointerCallback(exporter->GetBufferPointerCallback());
     importer->SetCallbackUserData(exporter->GetCallbackUserData());
   }
 
   template < typename TPixel, unsigned int VImageDimension >
       void InternalCalculateMaskFromPlanarFigure(
           itk::Image< TPixel, VImageDimension > *image, unsigned int axis, std::string nodeName );
 
   template < typename TPixel, unsigned int VImageDimension >
       void InternalReorientImagePlane(
           const itk::Image< TPixel, VImageDimension > *image, mitk::Geometry3D* planegeo3D, int additionalIndex );
 
   void GenerateStats(); ///< generate statistics of selected fiber bundles
   void UpdateGui();     ///< update button activity etc. dpending on current datamanager selection
 
   std::vector<mitk::DataNode::Pointer>  m_SelectedFB;       ///< selected fiber bundle nodes
   mitk::Image::Pointer                  m_SelectedImage;
   float                                 m_UpsamplingFactor; ///< upsampling factor for all image generations
   std::vector<mitk::Surface::Pointer>   m_SelectedSurfaces;
 
   mitk::DataNode::Pointer GenerateTractDensityImage(mitk::FiberBundle::Pointer fib, bool binary, bool absolute);
   mitk::DataNode::Pointer GenerateColorHeatmap(mitk::FiberBundle::Pointer fib);
   mitk::DataNode::Pointer GenerateFiberEndingsImage(mitk::FiberBundle::Pointer fib);
   mitk::DataNode::Pointer GenerateFiberEndingsPointSet(mitk::FiberBundle::Pointer fib);
 };
 
 
 
 #endif // _QMITKFIBERTRACKINGVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
index 471d7d5bb1..21b1efaec9 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
@@ -1,2898 +1,2898 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //misc
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkFiberfoxView.h"
 
 // MITK
 #include <mitkImage.h>
 #include <mitkImageToItk.h>
 #include <mitkImageCast.h>
 #include <mitkProperties.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkDataStorage.h>
 #include <itkFibersFromPlanarFiguresFilter.h>
 #include <itkTractsToDWIImageFilter.h>
 #include <mitkTensorImage.h>
 #include <mitkILinkedRenderWindowPart.h>
 #include <mitkImageToItk.h>
 #include <mitkImageCast.h>
 #include <mitkImageGenerator.h>
 #include <mitkNodePredicateDataType.h>
 #include <itkScalableAffineTransform.h>
 #include <mitkLevelWindowProperty.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateIsDWI.h>
 #include <boost/property_tree/ptree.hpp>
 #define RAPIDXML_NO_EXCEPTIONS
 #include <boost/property_tree/xml_parser.hpp>
 #include <boost/foreach.hpp>
 #include <QFileDialog>
 #include <QMessageBox>
 #include "usModuleRegistry.h"
 #include <mitkChiSquareNoiseModel.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkIOUtil.h>
 #include <QScrollBar>
 #include <itkInvertIntensityImageFilter.h>
 #include <QDialogButtonBox>
 #include <itkAdcImageFilter.h>
 #include <itkShiftScaleImageFilter.h>
 #include <mitkITKImageImport.h>
 
 #include "mitkNodePredicateDataType.h"
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateOr.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 QmitkFiberfoxWorker::QmitkFiberfoxWorker(QmitkFiberfoxView* view)
   : m_View(view)
 {
 
 }
 
 void QmitkFiberfoxWorker::run()
 {
   try{
     m_View->m_TractsToDwiFilter->Update();
   }
   catch( ... )
   {
 
   }
   m_View->m_Thread.quit();
 }
 
 const std::string QmitkFiberfoxView::VIEW_ID = "org.mitk.views.fiberfoxview";
 
 QmitkFiberfoxView::QmitkFiberfoxView()
   : QmitkAbstractView()
   , m_Controls( 0 )
   , m_SelectedImageNode( NULL )
   , m_Worker(this)
   , m_ThreadIsRunning(false)
 {
   m_Worker.moveToThread(&m_Thread);
   connect(&m_Thread, SIGNAL(started()), this, SLOT(BeforeThread()));
   connect(&m_Thread, SIGNAL(started()), &m_Worker, SLOT(run()));
   connect(&m_Thread, SIGNAL(finished()), this, SLOT(AfterThread()));
   //    connect(&m_Thread, SIGNAL(terminated()), this, SLOT(AfterThread()));
   m_SimulationTimer = new QTimer(this);
 }
 
 void QmitkFiberfoxView::KillThread()
 {
   MITK_INFO << "Aborting DWI simulation.";
   m_TractsToDwiFilter->SetAbortGenerateData(true);
   m_Controls->m_AbortSimulationButton->setEnabled(false);
   m_Controls->m_AbortSimulationButton->setText("Aborting simulation ...");
 }
 
 void QmitkFiberfoxView::BeforeThread()
 {
   m_SimulationTime = QTime::currentTime();
   m_SimulationTimer->start(100);
   m_Controls->m_AbortSimulationButton->setVisible(true);
   m_Controls->m_GenerateImageButton->setVisible(false);
   m_Controls->m_SimulationStatusText->setVisible(true);
   m_ThreadIsRunning = true;
 }
 
 void QmitkFiberfoxView::AfterThread()
 {
   UpdateSimulationStatus();
   m_SimulationTimer->stop();
   m_Controls->m_AbortSimulationButton->setVisible(false);
   m_Controls->m_AbortSimulationButton->setEnabled(true);
   m_Controls->m_AbortSimulationButton->setText("Abort simulation");
   m_Controls->m_GenerateImageButton->setVisible(true);
   m_ThreadIsRunning = false;
 
   QString statusText;
   FiberfoxParameters<double> parameters;
   mitk::Image::Pointer mitkImage = mitk::Image::New();
 
   statusText = QString(m_TractsToDwiFilter->GetStatusText().c_str());
   if (m_TractsToDwiFilter->GetAbortGenerateData())
   {
     MITK_INFO << "Simulation aborted.";
     return;
   }
 
   parameters = m_TractsToDwiFilter->GetParameters();
 
   mitkImage = mitk::GrabItkImageMemory( m_TractsToDwiFilter->GetOutput() );
   mitkImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(),
                           mitk::GradientDirectionsProperty::New(  parameters.m_SignalGen.GetGradientDirections()  ));
   mitkImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(),
                           mitk::FloatProperty::New( parameters.m_SignalGen.m_Bvalue ));
   mitk::DiffusionPropertyHelper propertyHelper( mitkImage );
   propertyHelper.InitializeImage();
   parameters.m_Misc.m_ResultNode->SetData( mitkImage );
 
   GetDataStorage()->Add(parameters.m_Misc.m_ResultNode, parameters.m_Misc.m_ParentNode);
 
   parameters.m_Misc.m_ResultNode->SetProperty( "levelwindow", mitk::LevelWindowProperty::New(m_TractsToDwiFilter->GetLevelWindow()) );
 
   if (m_Controls->m_VolumeFractionsBox->isChecked())
   {
     std::vector< itk::TractsToDWIImageFilter< short >::ItkDoubleImgType::Pointer > volumeFractions = m_TractsToDwiFilter->GetVolumeFractions();
     for (unsigned int k=0; k<volumeFractions.size(); k++)
     {
       mitk::Image::Pointer image = mitk::Image::New();
       image->InitializeByItk(volumeFractions.at(k).GetPointer());
       image->SetVolume(volumeFractions.at(k)->GetBufferPointer());
 
       mitk::DataNode::Pointer node = mitk::DataNode::New();
       node->SetData( image );
       node->SetName("CompartmentVolume-"+QString::number(k).toStdString());
       GetDataStorage()->Add(node, parameters.m_Misc.m_ResultNode);
     }
 
     if (m_TractsToDwiFilter->GetPhaseImage().IsNotNull())
     {
       mitk::Image::Pointer phaseImage = mitk::Image::New();
       itk::TractsToDWIImageFilter< short >::DoubleDwiType::Pointer itkPhase = m_TractsToDwiFilter->GetPhaseImage();
       phaseImage = mitk::GrabItkImageMemory( itkPhase.GetPointer() );
       mitk::DataNode::Pointer phaseNode = mitk::DataNode::New();
       phaseNode->SetData( phaseImage );
       phaseNode->SetName("Phase Image");
       GetDataStorage()->Add(phaseNode, parameters.m_Misc.m_ResultNode);
     }
 
     if (m_TractsToDwiFilter->GetKspaceImage().IsNotNull())
     {
       mitk::Image::Pointer image = mitk::Image::New();
       itk::TractsToDWIImageFilter< short >::DoubleDwiType::Pointer itkImage = m_TractsToDwiFilter->GetKspaceImage();
       image = mitk::GrabItkImageMemory( itkImage.GetPointer() );
       mitk::DataNode::Pointer node = mitk::DataNode::New();
       node->SetData( image );
       node->SetName("k-Space");
       GetDataStorage()->Add(node, parameters.m_Misc.m_ResultNode);
     }
 
     {
       mitk::DataNode::Pointer node = mitk::DataNode::New();
       node->SetData(m_TractsToDwiFilter->GetCoilPointset());
       node->SetName("Coil Positions");
       node->SetProperty("pointsize", mitk::FloatProperty::New(parameters.m_SignalGen.m_ImageSpacing[0]/4));
       node->SetProperty("color", mitk::ColorProperty::New(0, 1, 0));
       GetDataStorage()->Add(node, parameters.m_Misc.m_ResultNode);
     }
   }
   m_TractsToDwiFilter = NULL;
 
   if (parameters.m_Misc.m_AfterSimulationMessage.size()>0)
     QMessageBox::information( NULL, "Warning", parameters.m_Misc.m_AfterSimulationMessage.c_str());
 
   mitk::BaseData::Pointer basedata = parameters.m_Misc.m_ResultNode->GetData();
   if (basedata.IsNotNull())
   {
     mitk::RenderingManager::GetInstance()->InitializeViews(
           basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 
   if (!parameters.m_Misc.m_OutputPath.empty())
   {
     try{
       QString outputFileName(parameters.m_Misc.m_OutputPath.c_str());
       outputFileName += parameters.m_Misc.m_ResultNode->GetName().c_str();
       outputFileName.replace(QString("."), QString("_"));
       SaveParameters(outputFileName+".ffp");
       outputFileName += ".dwi";
       QString status("Saving output image to ");
       status += outputFileName;
       m_Controls->m_SimulationStatusText->append(status);
       mitk::IOUtil::Save(mitkImage, outputFileName.toStdString());
       m_Controls->m_SimulationStatusText->append("File saved successfully.");
 
     }
     catch (itk::ExceptionObject &e)
     {
       QString status("Exception during DWI writing: ");
       status += e.GetDescription();
       m_Controls->m_SimulationStatusText->append(status);
     }
     catch (...)
     {
       m_Controls->m_SimulationStatusText->append("Unknown exception during DWI writing!");
     }
   }
   parameters.m_SignalGen.m_FrequencyMap = NULL;
 }
 
 void QmitkFiberfoxView::UpdateSimulationStatus()
 {
   QString statusText = QString(m_TractsToDwiFilter->GetStatusText().c_str());
 
   if (QString::compare(m_SimulationStatusText,statusText)!=0)
   {
     m_Controls->m_SimulationStatusText->clear();
     m_Controls->m_SimulationStatusText->setText(statusText);
     QScrollBar *vScrollBar = m_Controls->m_SimulationStatusText->verticalScrollBar();
     vScrollBar->triggerAction(QScrollBar::SliderToMaximum);
   }
 }
 
 // Destructor
 QmitkFiberfoxView::~QmitkFiberfoxView()
 {
   delete m_SimulationTimer;
 }
 
 void QmitkFiberfoxView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkFiberfoxViewControls;
     m_Controls->setupUi( parent );
 
     m_Controls->m_StickWidget1->setVisible(true);
     m_Controls->m_StickWidget2->setVisible(false);
     m_Controls->m_ZeppelinWidget1->setVisible(false);
     m_Controls->m_ZeppelinWidget2->setVisible(false);
     m_Controls->m_TensorWidget1->setVisible(false);
     m_Controls->m_TensorWidget2->setVisible(false);
 
     m_Controls->m_BallWidget1->setVisible(true);
     m_Controls->m_BallWidget2->setVisible(false);
     m_Controls->m_BallWidget2->SetT1(4500);
     m_Controls->m_AstrosticksWidget1->setVisible(false);
     m_Controls->m_AstrosticksWidget2->setVisible(false);
     m_Controls->m_AstrosticksWidget2->SetT1(4500);
     m_Controls->m_DotWidget1->setVisible(false);
     m_Controls->m_DotWidget2->setVisible(false);
     m_Controls->m_DotWidget2->SetT1(4500);
 
     m_Controls->m_PrototypeWidget1->setVisible(false);
     m_Controls->m_PrototypeWidget2->setVisible(false);
     m_Controls->m_PrototypeWidget3->setVisible(false);
     m_Controls->m_PrototypeWidget4->setVisible(false);
 
     m_Controls->m_PrototypeWidget3->SetMinFa(0.0);
     m_Controls->m_PrototypeWidget3->SetMaxFa(0.15);
     m_Controls->m_PrototypeWidget4->SetMinFa(0.0);
     m_Controls->m_PrototypeWidget4->SetMaxFa(0.15);
     m_Controls->m_PrototypeWidget3->SetMinAdc(0.0);
     m_Controls->m_PrototypeWidget3->SetMaxAdc(0.001);
     m_Controls->m_PrototypeWidget4->SetMinAdc(0.003);
     m_Controls->m_PrototypeWidget4->SetMaxAdc(0.004);
 
     m_Controls->m_Comp2FractionFrame->setVisible(false);
     m_Controls->m_Comp4FractionFrame->setVisible(false);
     m_Controls->m_DiffusionPropsMessage->setVisible(false);
     m_Controls->m_GeometryMessage->setVisible(false);
     m_Controls->m_AdvancedSignalOptionsFrame->setVisible(false);
     m_Controls->m_AdvancedFiberOptionsFrame->setVisible(false);
     m_Controls->m_VarianceBox->setVisible(false);
     m_Controls->m_NoiseFrame->setVisible(false);
     m_Controls->m_GhostFrame->setVisible(false);
     m_Controls->m_DistortionsFrame->setVisible(false);
     m_Controls->m_EddyFrame->setVisible(false);
     m_Controls->m_SpikeFrame->setVisible(false);
     m_Controls->m_AliasingFrame->setVisible(false);
     m_Controls->m_MotionArtifactFrame->setVisible(false);
     m_ParameterFile = QDir::currentPath()+"/param.ffp";
 
     m_Controls->m_AbortSimulationButton->setVisible(false);
     m_Controls->m_SimulationStatusText->setVisible(false);
 
     m_Controls->m_FrequencyMapBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_Comp1VolumeFraction->SetDataStorage(this->GetDataStorage());
     m_Controls->m_Comp2VolumeFraction->SetDataStorage(this->GetDataStorage());
     m_Controls->m_Comp3VolumeFraction->SetDataStorage(this->GetDataStorage());
     m_Controls->m_Comp4VolumeFraction->SetDataStorage(this->GetDataStorage());
     m_Controls->m_MaskComboBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_TemplateComboBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_FiberBundleComboBox->SetDataStorage(this->GetDataStorage());
 
     mitk::TNodePredicateDataType<mitk::FiberBundle>::Pointer isFiberBundle = mitk::TNodePredicateDataType<mitk::FiberBundle>::New();
     mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
     mitk::NodePredicateIsDWI::Pointer isDwi = mitk::NodePredicateIsDWI::New( );
     mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
     mitk::NodePredicateDataType::Pointer isQbi = mitk::NodePredicateDataType::New("QBallImage");
     mitk::NodePredicateOr::Pointer isDiffusionImage = mitk::NodePredicateOr::New(isDwi, isDti);
     isDiffusionImage = mitk::NodePredicateOr::New(isDiffusionImage, isQbi);
     mitk::NodePredicateNot::Pointer noDiffusionImage = mitk::NodePredicateNot::New(isDiffusionImage);
     mitk::NodePredicateAnd::Pointer isNonDiffMitkImage = mitk::NodePredicateAnd::New(isMitkImage, noDiffusionImage);
     mitk::NodePredicateProperty::Pointer isBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
     mitk::NodePredicateAnd::Pointer isBinaryMitkImage = mitk::NodePredicateAnd::New( isNonDiffMitkImage, isBinaryPredicate );
 
     m_Controls->m_FrequencyMapBox->SetPredicate(isNonDiffMitkImage);
     m_Controls->m_Comp1VolumeFraction->SetPredicate(isNonDiffMitkImage);
     m_Controls->m_Comp1VolumeFraction->SetZeroEntryText("--");
     m_Controls->m_Comp2VolumeFraction->SetPredicate(isNonDiffMitkImage);
     m_Controls->m_Comp2VolumeFraction->SetZeroEntryText("--");
     m_Controls->m_Comp3VolumeFraction->SetPredicate(isNonDiffMitkImage);
     m_Controls->m_Comp3VolumeFraction->SetZeroEntryText("--");
     m_Controls->m_Comp4VolumeFraction->SetPredicate(isNonDiffMitkImage);
     m_Controls->m_Comp4VolumeFraction->SetZeroEntryText("--");
     m_Controls->m_MaskComboBox->SetPredicate(isBinaryMitkImage);
     m_Controls->m_MaskComboBox->SetZeroEntryText("--");
     m_Controls->m_TemplateComboBox->SetPredicate(isMitkImage);
     m_Controls->m_TemplateComboBox->SetZeroEntryText("--");
     m_Controls->m_FiberBundleComboBox->SetPredicate(isFiberBundle);
     m_Controls->m_FiberBundleComboBox->SetZeroEntryText("--");
 
     QFont font;
     font.setFamily("Courier");
     font.setStyleHint(QFont::Monospace);
     font.setFixedPitch(true);
     font.setPointSize(8);
     m_Controls->m_SimulationStatusText->setFont(font);
 
     connect( m_SimulationTimer, SIGNAL(timeout()), this, SLOT(UpdateSimulationStatus()) );
     connect((QObject*) m_Controls->m_AbortSimulationButton, SIGNAL(clicked()), (QObject*) this, SLOT(KillThread()));
     connect((QObject*) m_Controls->m_GenerateImageButton, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateImage()));
     connect((QObject*) m_Controls->m_GenerateFibersButton, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateFibers()));
     connect((QObject*) m_Controls->m_CircleButton, SIGNAL(clicked()), (QObject*) this, SLOT(OnDrawROI()));
     connect((QObject*) m_Controls->m_FlipButton, SIGNAL(clicked()), (QObject*) this, SLOT(OnFlipButton()));
     connect((QObject*) m_Controls->m_JoinBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(JoinBundles()));
     connect((QObject*) m_Controls->m_VarianceBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnVarianceChanged(double)));
     connect((QObject*) m_Controls->m_DistributionBox, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(OnDistributionChanged(int)));
     connect((QObject*) m_Controls->m_FiberDensityBox, SIGNAL(valueChanged(int)), (QObject*) this, SLOT(OnFiberDensityChanged(int)));
     connect((QObject*) m_Controls->m_FiberSamplingBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnFiberSamplingChanged(double)));
     connect((QObject*) m_Controls->m_TensionBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnTensionChanged(double)));
     connect((QObject*) m_Controls->m_ContinuityBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnContinuityChanged(double)));
     connect((QObject*) m_Controls->m_BiasBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnBiasChanged(double)));
     connect((QObject*) m_Controls->m_AddNoise, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddNoise(int)));
     connect((QObject*) m_Controls->m_AddGhosts, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddGhosts(int)));
     connect((QObject*) m_Controls->m_AddDistortions, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddDistortions(int)));
     connect((QObject*) m_Controls->m_AddEddy, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddEddy(int)));
     connect((QObject*) m_Controls->m_AddSpikes, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddSpikes(int)));
     connect((QObject*) m_Controls->m_AddAliasing, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddAliasing(int)));
     connect((QObject*) m_Controls->m_AddMotion, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddMotion(int)));
 
     connect((QObject*) m_Controls->m_ConstantRadiusBox, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnConstantRadius(int)));
     connect((QObject*) m_Controls->m_CopyBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(CopyBundles()));
     connect((QObject*) m_Controls->m_TransformBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(ApplyTransform()));
     connect((QObject*) m_Controls->m_AlignOnGrid, SIGNAL(clicked()), (QObject*) this, SLOT(AlignOnGrid()));
 
     connect((QObject*) m_Controls->m_Compartment1Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp1ModelFrameVisibility(int)));
     connect((QObject*) m_Controls->m_Compartment2Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp2ModelFrameVisibility(int)));
     connect((QObject*) m_Controls->m_Compartment3Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp3ModelFrameVisibility(int)));
     connect((QObject*) m_Controls->m_Compartment4Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp4ModelFrameVisibility(int)));
 
     connect((QObject*) m_Controls->m_AdvancedOptionsBox, SIGNAL( stateChanged(int)), (QObject*) this, SLOT(ShowAdvancedOptions(int)));
     connect((QObject*) m_Controls->m_AdvancedOptionsBox_2, SIGNAL( stateChanged(int)), (QObject*) this, SLOT(ShowAdvancedOptions(int)));
 
     connect((QObject*) m_Controls->m_SaveParametersButton, SIGNAL(clicked()), (QObject*) this, SLOT(SaveParameters()));
     connect((QObject*) m_Controls->m_LoadParametersButton, SIGNAL(clicked()), (QObject*) this, SLOT(LoadParameters()));
     connect((QObject*) m_Controls->m_OutputPathButton, SIGNAL(clicked()), (QObject*) this, SLOT(SetOutputPath()));
 
     connect((QObject*) m_Controls->m_MaskComboBox, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(OnMaskSelected(int)));
     connect((QObject*) m_Controls->m_TemplateComboBox, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(OnTemplateSelected(int)));
     connect((QObject*) m_Controls->m_FiberBundleComboBox, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(OnFibSelected(int)));
   }
 }
 
 void QmitkFiberfoxView::OnMaskSelected(int value)
 {
   UpdateGui();
 }
 
 void QmitkFiberfoxView::OnTemplateSelected(int value)
 {
   UpdateGui();
 }
 
 void QmitkFiberfoxView::OnFibSelected(int value)
 {
   UpdateGui();
 }
 
 template< class ScalarType >
 FiberfoxParameters< ScalarType > QmitkFiberfoxView::UpdateImageParameters(bool all)
 {
   FiberfoxParameters< ScalarType > parameters;
   parameters.m_Misc.m_OutputPath = "";
   parameters.m_Misc.m_CheckAdvancedFiberOptionsBox = m_Controls->m_AdvancedOptionsBox->isChecked();
   parameters.m_Misc.m_CheckAdvancedSignalOptionsBox = m_Controls->m_AdvancedOptionsBox_2->isChecked();
   parameters.m_Misc.m_CheckOutputVolumeFractionsBox = m_Controls->m_VolumeFractionsBox->isChecked();
   parameters.m_Misc.m_AfterSimulationMessage = "";
 
   string outputPath = m_Controls->m_SavePathEdit->text().toStdString();
   if (outputPath.compare("-")!=0)
   {
     parameters.m_Misc.m_OutputPath = outputPath;
     parameters.m_Misc.m_OutputPath += "/";
   }
 
 
   switch(m_Controls->m_DistributionBox->currentIndex())
   {
     case 0:
       parameters.m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_UNIFORM;
     break;
     case 1:
       parameters.m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_GAUSSIAN;
     break;
     default:
       parameters.m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_UNIFORM;
   }
   parameters.m_FiberGen.m_Variance = m_Controls->m_VarianceBox->value();
   parameters.m_FiberGen.m_Density = m_Controls->m_FiberDensityBox->value();
   parameters.m_FiberGen.m_Sampling = m_Controls->m_FiberSamplingBox->value();
   parameters.m_FiberGen.m_Tension = m_Controls->m_TensionBox->value();
   parameters.m_FiberGen.m_Continuity = m_Controls->m_ContinuityBox->value();
   parameters.m_FiberGen.m_Bias = m_Controls->m_BiasBox->value();
   parameters.m_FiberGen.m_Rotation[0] = m_Controls->m_XrotBox->value();
   parameters.m_FiberGen.m_Rotation[1] = m_Controls->m_YrotBox->value();
   parameters.m_FiberGen.m_Rotation[2] = m_Controls->m_ZrotBox->value();
   parameters.m_FiberGen.m_Translation[0] = m_Controls->m_XtransBox->value();
   parameters.m_FiberGen.m_Translation[1] = m_Controls->m_YtransBox->value();
   parameters.m_FiberGen.m_Translation[2] = m_Controls->m_ZtransBox->value();
   parameters.m_FiberGen.m_Scale[0] = m_Controls->m_XscaleBox->value();
   parameters.m_FiberGen.m_Scale[1] = m_Controls->m_YscaleBox->value();
   parameters.m_FiberGen.m_Scale[2] = m_Controls->m_ZscaleBox->value();
 
   if (!all)
     return parameters;
 
   if (m_Controls->m_MaskComboBox->GetSelectedNode().IsNotNull())
   {
     mitk::Image::Pointer mitkMaskImage = dynamic_cast<mitk::Image*>(m_Controls->m_MaskComboBox->GetSelectedNode()->GetData());
     mitk::CastToItkImage<ItkUcharImgType>(mitkMaskImage, parameters.m_SignalGen.m_MaskImage);
     itk::ImageDuplicator<ItkUcharImgType>::Pointer duplicator = itk::ImageDuplicator<ItkUcharImgType>::New();
     duplicator->SetInputImage(parameters.m_SignalGen.m_MaskImage);
     duplicator->Update();
     parameters.m_SignalGen.m_MaskImage = duplicator->GetOutput();
   }
 
   if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull() && mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( m_Controls->m_TemplateComboBox->GetSelectedNode()))  // use parameters of selected DWI
   {
     mitk::Image::Pointer dwi = dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
 
     ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
     mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
     parameters.m_SignalGen.m_ImageRegion = itkVectorImagePointer->GetLargestPossibleRegion();
     parameters.m_SignalGen.m_ImageSpacing = itkVectorImagePointer->GetSpacing();
     parameters.m_SignalGen.m_ImageOrigin = itkVectorImagePointer->GetOrigin();
     parameters.m_SignalGen.m_ImageDirection = itkVectorImagePointer->GetDirection();
     parameters.m_SignalGen.m_Bvalue = static_cast<mitk::FloatProperty*>(dwi->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue();
     parameters.m_SignalGen.SetGradienDirections(static_cast<mitk::GradientDirectionsProperty*>( dwi->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer());
   }
   else if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull())   // use geometry of selected image
   {
     mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
     itk::Image< float, 3 >::Pointer itkImg = itk::Image< float, 3 >::New();
     CastToItkImage< itk::Image< float, 3 > >(img, itkImg);
 
     parameters.m_SignalGen.m_ImageRegion = itkImg->GetLargestPossibleRegion();
     parameters.m_SignalGen.m_ImageSpacing = itkImg->GetSpacing();
     parameters.m_SignalGen.m_ImageOrigin = itkImg->GetOrigin();
     parameters.m_SignalGen.m_ImageDirection = itkImg->GetDirection();
     parameters.m_SignalGen.SetNumWeightedVolumes(m_Controls->m_NumGradientsBox->value());
     parameters.m_SignalGen.m_Bvalue = m_Controls->m_BvalueBox->value();
   }
   else if (parameters.m_SignalGen.m_MaskImage.IsNotNull())   // use geometry of mask image
   {
     ItkUcharImgType::Pointer itkImg = parameters.m_SignalGen.m_MaskImage;
     parameters.m_SignalGen.m_ImageRegion = itkImg->GetLargestPossibleRegion();
     parameters.m_SignalGen.m_ImageSpacing = itkImg->GetSpacing();
     parameters.m_SignalGen.m_ImageOrigin = itkImg->GetOrigin();
     parameters.m_SignalGen.m_ImageDirection = itkImg->GetDirection();
     parameters.m_SignalGen.SetNumWeightedVolumes(m_Controls->m_NumGradientsBox->value());
     parameters.m_SignalGen.m_Bvalue = m_Controls->m_BvalueBox->value();
   }
   else    // use GUI parameters
   {
     parameters.m_SignalGen.m_ImageRegion.SetSize(0, m_Controls->m_SizeX->value());
     parameters.m_SignalGen.m_ImageRegion.SetSize(1, m_Controls->m_SizeY->value());
     parameters.m_SignalGen.m_ImageRegion.SetSize(2, m_Controls->m_SizeZ->value());
     parameters.m_SignalGen.m_ImageSpacing[0] = m_Controls->m_SpacingX->value();
     parameters.m_SignalGen.m_ImageSpacing[1] = m_Controls->m_SpacingY->value();
     parameters.m_SignalGen.m_ImageSpacing[2] = m_Controls->m_SpacingZ->value();
     parameters.m_SignalGen.m_ImageOrigin[0] = parameters.m_SignalGen.m_ImageSpacing[0]/2;
     parameters.m_SignalGen.m_ImageOrigin[1] = parameters.m_SignalGen.m_ImageSpacing[1]/2;
     parameters.m_SignalGen.m_ImageOrigin[2] = parameters.m_SignalGen.m_ImageSpacing[2]/2;
     parameters.m_SignalGen.m_ImageDirection.SetIdentity();
     parameters.m_SignalGen.SetNumWeightedVolumes(m_Controls->m_NumGradientsBox->value());
     parameters.m_SignalGen.m_Bvalue = m_Controls->m_BvalueBox->value();
     parameters.m_SignalGen.GenerateGradientHalfShell();
   }
 
   // signal relaxation
   parameters.m_SignalGen.m_DoSimulateRelaxation = false;
   if (m_Controls->m_RelaxationBox->isChecked() && m_Controls->m_FiberBundleComboBox->GetSelectedNode().IsNotNull() )
   {
     parameters.m_SignalGen.m_DoSimulateRelaxation = true;
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Relaxation", BoolProperty::New(true));
     parameters.m_Misc.m_ArtifactModelString += "_RELAX";
   }
   parameters.m_SignalGen.m_SimulateKspaceAcquisition = parameters.m_SignalGen.m_DoSimulateRelaxation;
 
   // N/2 ghosts
   parameters.m_Misc.m_CheckAddGhostsBox = m_Controls->m_AddGhosts->isChecked();
   if (m_Controls->m_AddGhosts->isChecked())
   {
     parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
     parameters.m_Misc.m_ArtifactModelString += "_GHOST";
     parameters.m_SignalGen.m_KspaceLineOffset = m_Controls->m_kOffsetBox->value();
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Ghost", DoubleProperty::New(parameters.m_SignalGen.m_KspaceLineOffset));
   }
   else
     parameters.m_SignalGen.m_KspaceLineOffset = 0;
 
   // Aliasing
   parameters.m_Misc.m_CheckAddAliasingBox = m_Controls->m_AddAliasing->isChecked();
   if (m_Controls->m_AddAliasing->isChecked())
   {
     parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
     parameters.m_Misc.m_ArtifactModelString += "_ALIASING";
     parameters.m_SignalGen.m_CroppingFactor = (100-m_Controls->m_WrapBox->value())/100;
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Aliasing", DoubleProperty::New(m_Controls->m_WrapBox->value()));
   }
 
   // Spikes
   parameters.m_Misc.m_CheckAddSpikesBox = m_Controls->m_AddSpikes->isChecked();
   if (m_Controls->m_AddSpikes->isChecked())
   {
     parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
     parameters.m_SignalGen.m_Spikes = m_Controls->m_SpikeNumBox->value();
     parameters.m_SignalGen.m_SpikeAmplitude = m_Controls->m_SpikeScaleBox->value();
     parameters.m_Misc.m_ArtifactModelString += "_SPIKES";
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Spikes.Number", IntProperty::New(parameters.m_SignalGen.m_Spikes));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Spikes.Amplitude", DoubleProperty::New(parameters.m_SignalGen.m_SpikeAmplitude));
   }
 
   // gibbs ringing
   parameters.m_SignalGen.m_DoAddGibbsRinging = m_Controls->m_AddGibbsRinging->isChecked();
   if (m_Controls->m_AddGibbsRinging->isChecked())
   {
     parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Ringing", BoolProperty::New(true));
     parameters.m_Misc.m_ArtifactModelString += "_RINGING";
   }
 
   // add distortions
   parameters.m_Misc.m_CheckAddDistortionsBox = m_Controls->m_AddDistortions->isChecked();
   if (m_Controls->m_AddDistortions->isChecked() && m_Controls->m_FrequencyMapBox->GetSelectedNode().IsNotNull())
   {
     mitk::DataNode::Pointer fMapNode = m_Controls->m_FrequencyMapBox->GetSelectedNode();
     mitk::Image* img = dynamic_cast<mitk::Image*>(fMapNode->GetData());
     ItkDoubleImgType::Pointer itkImg = ItkDoubleImgType::New();
     CastToItkImage< ItkDoubleImgType >(img, itkImg);
 
     if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNull())   // use geometry of frequency map
     {
       parameters.m_SignalGen.m_ImageRegion = itkImg->GetLargestPossibleRegion();
       parameters.m_SignalGen.m_ImageSpacing = itkImg->GetSpacing();
       parameters.m_SignalGen.m_ImageOrigin = itkImg->GetOrigin();
       parameters.m_SignalGen.m_ImageDirection = itkImg->GetDirection();
     }
 
     if (parameters.m_SignalGen.m_ImageRegion.GetSize(0)==itkImg->GetLargestPossibleRegion().GetSize(0) &&
         parameters.m_SignalGen.m_ImageRegion.GetSize(1)==itkImg->GetLargestPossibleRegion().GetSize(1) &&
         parameters.m_SignalGen.m_ImageRegion.GetSize(2)==itkImg->GetLargestPossibleRegion().GetSize(2))
     {
       parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
       itk::ImageDuplicator<ItkDoubleImgType>::Pointer duplicator = itk::ImageDuplicator<ItkDoubleImgType>::New();
       duplicator->SetInputImage(itkImg);
       duplicator->Update();
       parameters.m_SignalGen.m_FrequencyMap = duplicator->GetOutput();
       parameters.m_Misc.m_ArtifactModelString += "_DISTORTED";
       parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Distortions", BoolProperty::New(true));
     }
   }
 
   parameters.m_SignalGen.m_EddyStrength = 0;
   parameters.m_Misc.m_CheckAddEddyCurrentsBox = m_Controls->m_AddEddy->isChecked();
   if (m_Controls->m_AddEddy->isChecked())
   {
     parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
     parameters.m_SignalGen.m_EddyStrength = m_Controls->m_EddyGradientStrength->value();
     parameters.m_Misc.m_ArtifactModelString += "_EDDY";
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Eddy-strength", DoubleProperty::New(parameters.m_SignalGen.m_EddyStrength));
   }
 
   // Motion
   parameters.m_SignalGen.m_DoAddMotion = false;
   parameters.m_SignalGen.m_DoRandomizeMotion = m_Controls->m_RandomMotion->isChecked();
   parameters.m_SignalGen.m_Translation[0] = m_Controls->m_MaxTranslationBoxX->value();
   parameters.m_SignalGen.m_Translation[1] = m_Controls->m_MaxTranslationBoxY->value();
   parameters.m_SignalGen.m_Translation[2] = m_Controls->m_MaxTranslationBoxZ->value();
   parameters.m_SignalGen.m_Rotation[0] = m_Controls->m_MaxRotationBoxX->value();
   parameters.m_SignalGen.m_Rotation[1] = m_Controls->m_MaxRotationBoxY->value();
   parameters.m_SignalGen.m_Rotation[2] = m_Controls->m_MaxRotationBoxZ->value();
   parameters.m_SignalGen.m_MotionVolumes.clear();
   parameters.m_Misc.m_MotionVolumesBox = m_Controls->m_MotionVolumesBox->text().toStdString();
 
   if ( m_Controls->m_AddMotion->isChecked()
        && m_Controls->m_FiberBundleComboBox->GetSelectedNode().IsNotNull() )
   {
     parameters.m_SignalGen.m_DoAddMotion = true;
     parameters.m_Misc.m_ArtifactModelString += "_MOTION";
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Random", BoolProperty::New(parameters.m_SignalGen.m_DoRandomizeMotion));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Translation-x", DoubleProperty::New(parameters.m_SignalGen.m_Translation[0]));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Translation-y", DoubleProperty::New(parameters.m_SignalGen.m_Translation[1]));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Translation-z", DoubleProperty::New(parameters.m_SignalGen.m_Translation[2]));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Rotation-x", DoubleProperty::New(parameters.m_SignalGen.m_Rotation[0]));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Rotation-y", DoubleProperty::New(parameters.m_SignalGen.m_Rotation[1]));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Rotation-z", DoubleProperty::New(parameters.m_SignalGen.m_Rotation[2]));
 
     if ( parameters.m_Misc.m_MotionVolumesBox == "random" )
     {
       for ( size_t i=0; i < parameters.m_SignalGen.GetNumVolumes(); ++i )
       {
         parameters.m_SignalGen.m_MotionVolumes.push_back( bool( rand()%2 ) );
       }
       MITK_DEBUG << "QmitkFiberfoxView.cpp: Case m_Misc.m_MotionVolumesBox == \"random\".";
     }
 
     else if ( ! parameters.m_Misc.m_MotionVolumesBox.empty() )
     {
       stringstream stream( parameters.m_Misc.m_MotionVolumesBox );
       std::vector<int> numbers;
       int nummer = std::numeric_limits<int>::max();
       while( stream >> nummer )
       {
         if( nummer < std::numeric_limits<int>::max() )
         {
           numbers.push_back( nummer );
         }
       }
 
       // If a list of negative numbers is given:
       if(    *(std::min_element( numbers.begin(), numbers.end() )) < 0
           && *(std::max_element( numbers.begin(), numbers.end() )) <= 0 ) // cave: -0 == +0
       {
         for ( size_t i=0; i < parameters.m_SignalGen.GetNumVolumes(); ++i )
         {
           parameters.m_SignalGen.m_MotionVolumes.push_back( true );
         }
         // set all true except those given.
         for( auto iter = std::begin( numbers ); iter != std::end( numbers ); ++iter  )
         {
           if ( -(*iter) < parameters.m_SignalGen.GetNumVolumes() && -(*iter) >= 0 )
           {
             parameters.m_SignalGen.m_MotionVolumes.at( -(*iter) ) = false;
           }
         }
         MITK_DEBUG << "QmitkFiberfoxView.cpp: Case list of negative numbers.";
       }
 
       // If a list of positive numbers is given:
       else if(    *(std::min_element( numbers.begin(), numbers.end() )) >= 0
                && *(std::max_element( numbers.begin(), numbers.end() )) >= 0 )
       {
         for ( size_t i=0; i < parameters.m_SignalGen.GetNumVolumes(); ++i )
         {
           parameters.m_SignalGen.m_MotionVolumes.push_back( false );
         }
         // set all false except those given.
         for( auto iter = std::begin( numbers ); iter != std::end( numbers ); ++iter )
         {
           if ( *iter < parameters.m_SignalGen.GetNumVolumes() && *iter >= 0 )
           {
             parameters.m_SignalGen.m_MotionVolumes.at( *iter ) = true;
           }
         }
         MITK_DEBUG << "QmitkFiberfoxView.cpp: Case list of positive numbers.";
       }
 
       else
       {
         MITK_ERROR << "QmitkFiberfoxView.cpp: Inconsistent list of numbers in m_MotionVolumesBox.";
       }
     }
 
     else
     {
       MITK_WARN << "QmitkFiberfoxView.cpp: Unrecognised parameters.m_Misc.m_MotionVolumesBox: " << parameters.m_Misc.m_MotionVolumesBox;
       parameters.m_Misc.m_MotionVolumesBox = "random"; // set default.
       for (int i=0; i<parameters.m_SignalGen.GetNumVolumes(); i++)
       {
         parameters.m_SignalGen.m_MotionVolumes.push_back(rand()%2);
       }
     }
   }
 
   // other imaging parameters
   parameters.m_SignalGen.m_AcquisitionType = (SignalGenerationParameters::AcquisitionType)m_Controls->m_AcquisitionTypeBox->currentIndex();
   parameters.m_SignalGen.m_CoilSensitivityProfile = (SignalGenerationParameters::CoilSensitivityProfile)m_Controls->m_CoilSensBox->currentIndex();
   parameters.m_SignalGen.m_NumberOfCoils = m_Controls->m_NumCoilsBox->value();
   parameters.m_SignalGen.m_PartialFourier = m_Controls->m_PartialFourier->value();
   parameters.m_SignalGen.m_ReversePhase = m_Controls->m_ReversePhaseBox->isChecked();
   parameters.m_SignalGen.m_tLine = m_Controls->m_LineReadoutTimeBox->value();
   parameters.m_SignalGen.m_tInhom = m_Controls->m_T2starBox->value();
   parameters.m_SignalGen.m_tEcho = m_Controls->m_TEbox->value();
   parameters.m_SignalGen.m_tRep = m_Controls->m_TRbox->value();
   parameters.m_SignalGen.m_DoDisablePartialVolume = m_Controls->m_EnforcePureFiberVoxelsBox->isChecked();
   parameters.m_SignalGen.m_AxonRadius = m_Controls->m_FiberRadius->value();
   parameters.m_SignalGen.m_SignalScale = m_Controls->m_SignalScaleBox->value();
 
   double voxelVolume = parameters.m_SignalGen.m_ImageSpacing[0]
                        * parameters.m_SignalGen.m_ImageSpacing[1]
                        * parameters.m_SignalGen.m_ImageSpacing[2];
 
   if ( parameters.m_SignalGen.m_SignalScale*voxelVolume > itk::NumericTraits<short>::max()*0.75 )
   {
     parameters.m_SignalGen.m_SignalScale = itk::NumericTraits<short>::max()*0.75/voxelVolume;
     m_Controls->m_SignalScaleBox->setValue(parameters.m_SignalGen.m_SignalScale);
     QMessageBox::information( NULL, "Warning",
                               "Maximum signal exceeding data type limits. Automatically adjusted to "
                               + QString::number(parameters.m_SignalGen.m_SignalScale)
                               + " to obtain a maximum  signal of 75% of the data type maximum."
                                 " Relaxation and other effects that affect the signal intensities are not accounted for.");
   }
 
   // Noise
   parameters.m_Misc.m_CheckAddNoiseBox = m_Controls->m_AddNoise->isChecked();
   parameters.m_SignalGen.m_NoiseVariance = 0;
   if (m_Controls->m_AddNoise->isChecked())
   {
     double noiseVariance = m_Controls->m_NoiseLevel->value();
 
     switch (m_Controls->m_NoiseDistributionBox->currentIndex())
     {
       case 0:
       {
         if (noiseVariance>0)
         {
           parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
           parameters.m_Misc.m_ArtifactModelString += "_COMPLEX-GAUSSIAN-";
           parameters.m_SignalGen.m_NoiseVariance = m_Controls->m_NoiseLevel->value();
           parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Noise-Distribution", StringProperty::New("Complex Gaussian"));
         }
         break;
       }
       case 1:
       {
         if (noiseVariance>0)
         {
           parameters.m_NoiseModel = std::make_shared< mitk::RicianNoiseModel<ScalarType> >();
           parameters.m_Misc.m_ArtifactModelString += "_RICIAN-";
           parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Noise-Distribution", StringProperty::New("Rician"));
           parameters.m_NoiseModel->SetNoiseVariance(noiseVariance);
         }
         break;
       }
       case 2:
       {
         if (noiseVariance>0)
         {
           parameters.m_NoiseModel = std::make_shared< mitk::ChiSquareNoiseModel<ScalarType> >();
           parameters.m_Misc.m_ArtifactModelString += "_CHISQUARED-";
           parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Noise-Distribution", StringProperty::New("Chi-squared"));
           parameters.m_NoiseModel->SetNoiseVariance(noiseVariance);
         }
         break;
       }
       default:
       {
         if (noiseVariance>0)
         {
           parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
           parameters.m_Misc.m_ArtifactModelString += "_COMPLEX-GAUSSIAN-";
           parameters.m_SignalGen.m_NoiseVariance = m_Controls->m_NoiseLevel->value();
           parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Noise-Distribution", StringProperty::New("Complex Gaussian"));
         }
         break;
       }
     }
 
     if (noiseVariance>0)
     {
       parameters.m_Misc.m_ArtifactModelString += QString::number(noiseVariance).toStdString();
       parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Noise-Variance", DoubleProperty::New(noiseVariance));
     }
   }
 
   // signal models
   {
     // compartment 1
     switch (m_Controls->m_Compartment1Box->currentIndex())
     {
       case 0:
       {
         mitk::StickModel<ScalarType>* model = new mitk::StickModel<ScalarType>();
         model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
         model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
         model->SetDiffusivity(m_Controls->m_StickWidget1->GetD());
         model->SetT2(m_Controls->m_StickWidget1->GetT2());
         model->SetT1(m_Controls->m_StickWidget1->GetT1());
         model->m_CompartmentId = 1;
         parameters.m_FiberModelList.push_back(model);
         parameters.m_Misc.m_SignalModelString += "Stick";
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Stick") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D", DoubleProperty::New(m_Controls->m_StickWidget1->GetD()) );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(model->GetT2()) );
         break;
       }
       case 1:
       {
         mitk::TensorModel<ScalarType>* model = new mitk::TensorModel<ScalarType>();
         model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
         model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
         model->SetDiffusivity1(m_Controls->m_ZeppelinWidget1->GetD1());
         model->SetDiffusivity2(m_Controls->m_ZeppelinWidget1->GetD2());
         model->SetDiffusivity3(m_Controls->m_ZeppelinWidget1->GetD2());
         model->SetT2(m_Controls->m_ZeppelinWidget1->GetT2());
         model->SetT1(m_Controls->m_ZeppelinWidget1->GetT1());
         model->m_CompartmentId = 1;
         parameters.m_FiberModelList.push_back(model);
         parameters.m_Misc.m_SignalModelString += "Zeppelin";
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Zeppelin") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D1", DoubleProperty::New(m_Controls->m_ZeppelinWidget1->GetD1()) );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D2", DoubleProperty::New(m_Controls->m_ZeppelinWidget1->GetD2()) );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(model->GetT2()) );
         break;
       }
       case 2:
       {
         mitk::TensorModel<ScalarType>* model = new mitk::TensorModel<ScalarType>();
         model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
         model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
         model->SetDiffusivity1(m_Controls->m_TensorWidget1->GetD1());
         model->SetDiffusivity2(m_Controls->m_TensorWidget1->GetD2());
         model->SetDiffusivity3(m_Controls->m_TensorWidget1->GetD3());
         model->SetT2(m_Controls->m_TensorWidget1->GetT2());
         model->SetT1(m_Controls->m_TensorWidget1->GetT1());
         model->m_CompartmentId = 1;
         parameters.m_FiberModelList.push_back(model);
         parameters.m_Misc.m_SignalModelString += "Tensor";
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Tensor") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D1", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD1()) );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D2", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD2()) );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D3", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD3()) );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(model->GetT2()) );
         break;
       }
       case 3:
       {
         mitk::RawShModel<ScalarType>* model = new mitk::RawShModel<ScalarType>();
         parameters.m_SignalGen.m_DoSimulateRelaxation = false;
         model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
         model->SetMaxNumKernels(m_Controls->m_PrototypeWidget1->GetNumberOfSamples());
         model->SetFaRange(m_Controls->m_PrototypeWidget1->GetMinFa(), m_Controls->m_PrototypeWidget1->GetMaxFa());
         model->SetAdcRange(m_Controls->m_PrototypeWidget1->GetMinAdc(), m_Controls->m_PrototypeWidget1->GetMaxAdc());
         model->m_CompartmentId = 1;
         parameters.m_FiberModelList.push_back(model);
         parameters.m_Misc.m_SignalModelString += "Prototype";
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Prototype") );
         break;
       }
     }
     if (m_Controls->m_Comp1VolumeFraction->GetSelectedNode().IsNotNull())
     {
       mitk::DataNode::Pointer volumeNode = m_Controls->m_Comp1VolumeFraction->GetSelectedNode();
       ItkDoubleImgType::Pointer comp1VolumeImage = ItkDoubleImgType::New();
       mitk::Image* img = dynamic_cast<mitk::Image*>(volumeNode->GetData());
       CastToItkImage< ItkDoubleImgType >(img, comp1VolumeImage);
       parameters.m_FiberModelList.back()->SetVolumeFractionImage(comp1VolumeImage);
     }
 
     // compartment 2
     switch (m_Controls->m_Compartment2Box->currentIndex())
     {
       case 0:
       break;
       case 1:
       {
         mitk::StickModel<ScalarType>* model = new mitk::StickModel<ScalarType>();
         model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
         model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
         model->SetDiffusivity(m_Controls->m_StickWidget2->GetD());
         model->SetT2(m_Controls->m_StickWidget2->GetT2());
         model->SetT1(m_Controls->m_StickWidget2->GetT1());
         model->m_CompartmentId = 2;
         parameters.m_FiberModelList.push_back(model);
         parameters.m_Misc.m_SignalModelString += "Stick";
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Stick") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D", DoubleProperty::New(m_Controls->m_StickWidget2->GetD()) );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(model->GetT2()) );
         break;
       }
       case 2:
       {
         mitk::TensorModel<ScalarType>* model = new mitk::TensorModel<ScalarType>();
         model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
         model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
         model->SetDiffusivity1(m_Controls->m_ZeppelinWidget2->GetD1());
         model->SetDiffusivity2(m_Controls->m_ZeppelinWidget2->GetD2());
         model->SetDiffusivity3(m_Controls->m_ZeppelinWidget2->GetD2());
         model->SetT2(m_Controls->m_ZeppelinWidget2->GetT2());
         model->SetT1(m_Controls->m_ZeppelinWidget2->GetT1());
         model->m_CompartmentId = 2;
         parameters.m_FiberModelList.push_back(model);
         parameters.m_Misc.m_SignalModelString += "Zeppelin";
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Zeppelin") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D1", DoubleProperty::New(m_Controls->m_ZeppelinWidget2->GetD1()) );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D2", DoubleProperty::New(m_Controls->m_ZeppelinWidget2->GetD2()) );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(model->GetT2()) );
         break;
       }
       case 3:
       {
         mitk::TensorModel<ScalarType>* model = new mitk::TensorModel<ScalarType>();
         model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
         model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
         model->SetDiffusivity1(m_Controls->m_TensorWidget2->GetD1());
         model->SetDiffusivity2(m_Controls->m_TensorWidget2->GetD2());
         model->SetDiffusivity3(m_Controls->m_TensorWidget2->GetD3());
         model->SetT2(m_Controls->m_TensorWidget2->GetT2());
         model->SetT1(m_Controls->m_TensorWidget2->GetT1());
         model->m_CompartmentId = 2;
         parameters.m_FiberModelList.push_back(model);
         parameters.m_Misc.m_SignalModelString += "Tensor";
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Tensor") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D1", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD1()) );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D2", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD2()) );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D3", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD3()) );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(model->GetT2()) );
         break;
       }
     }
     if (m_Controls->m_Comp2VolumeFraction->GetSelectedNode().IsNotNull() && parameters.m_FiberModelList.size()==2)
     {
       mitk::DataNode::Pointer volumeNode = m_Controls->m_Comp2VolumeFraction->GetSelectedNode();
       ItkDoubleImgType::Pointer comp1VolumeImage = ItkDoubleImgType::New();
       mitk::Image* img = dynamic_cast<mitk::Image*>(volumeNode->GetData());
       CastToItkImage< ItkDoubleImgType >(img, comp1VolumeImage);
       parameters.m_FiberModelList.back()->SetVolumeFractionImage(comp1VolumeImage);
     }
 
     // compartment 3
     switch (m_Controls->m_Compartment3Box->currentIndex())
     {
       case 0:
       {
         mitk::BallModel<ScalarType>* model = new mitk::BallModel<ScalarType>();
         model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
         model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
         model->SetDiffusivity(m_Controls->m_BallWidget1->GetD());
         model->SetT2(m_Controls->m_BallWidget1->GetT2());
         model->SetT1(m_Controls->m_BallWidget1->GetT1());
         model->m_CompartmentId = 3;
         parameters.m_NonFiberModelList.push_back(model);
         parameters.m_Misc.m_SignalModelString += "Ball";
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Ball") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.D", DoubleProperty::New(m_Controls->m_BallWidget1->GetD()) );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(model->GetT2()) );
         break;
       }
       case 1:
       {
         mitk::AstroStickModel<ScalarType>* model = new mitk::AstroStickModel<ScalarType>();
         model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
         model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
         model->SetDiffusivity(m_Controls->m_AstrosticksWidget1->GetD());
         model->SetT2(m_Controls->m_AstrosticksWidget1->GetT2());
         model->SetT1(m_Controls->m_AstrosticksWidget1->GetT1());
         model->SetRandomizeSticks(m_Controls->m_AstrosticksWidget1->GetRandomizeSticks());
         model->m_CompartmentId = 3;
         parameters.m_NonFiberModelList.push_back(model);
         parameters.m_Misc.m_SignalModelString += "Astrosticks";
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Astrosticks") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.D", DoubleProperty::New(m_Controls->m_AstrosticksWidget1->GetD()) );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(model->GetT2()) );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.RandomSticks", BoolProperty::New(m_Controls->m_AstrosticksWidget1->GetRandomizeSticks()) );
         break;
       }
       case 2:
       {
         mitk::DotModel<ScalarType>* model = new mitk::DotModel<ScalarType>();
         model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
         model->SetT2(m_Controls->m_DotWidget1->GetT2());
         model->SetT1(m_Controls->m_DotWidget1->GetT1());
         model->m_CompartmentId = 3;
         parameters.m_NonFiberModelList.push_back(model);
         parameters.m_Misc.m_SignalModelString += "Dot";
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Dot") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(model->GetT2()) );
         break;
       }
       case 3:
       {
         mitk::RawShModel<ScalarType>* model = new mitk::RawShModel<ScalarType>();
         parameters.m_SignalGen.m_DoSimulateRelaxation = false;
         model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
         model->SetMaxNumKernels(m_Controls->m_PrototypeWidget3->GetNumberOfSamples());
         model->SetFaRange(m_Controls->m_PrototypeWidget3->GetMinFa(), m_Controls->m_PrototypeWidget3->GetMaxFa());
         model->SetAdcRange(m_Controls->m_PrototypeWidget3->GetMinAdc(), m_Controls->m_PrototypeWidget3->GetMaxAdc());
         model->m_CompartmentId = 3;
         parameters.m_NonFiberModelList.push_back(model);
         parameters.m_Misc.m_SignalModelString += "Prototype";
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Prototype") );
         break;
       }
     }
     if (m_Controls->m_Comp3VolumeFraction->GetSelectedNode().IsNotNull())
     {
       mitk::DataNode::Pointer volumeNode = m_Controls->m_Comp3VolumeFraction->GetSelectedNode();
       ItkDoubleImgType::Pointer comp1VolumeImage = ItkDoubleImgType::New();
       mitk::Image* img = dynamic_cast<mitk::Image*>(volumeNode->GetData());
       CastToItkImage< ItkDoubleImgType >(img, comp1VolumeImage);
       parameters.m_NonFiberModelList.back()->SetVolumeFractionImage(comp1VolumeImage);
     }
 
     switch (m_Controls->m_Compartment4Box->currentIndex())
     {
       case 0:
       break;
       case 1:
       {
         mitk::BallModel<ScalarType>* model = new mitk::BallModel<ScalarType>();
         model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
         model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
         model->SetDiffusivity(m_Controls->m_BallWidget2->GetD());
         model->SetT2(m_Controls->m_BallWidget2->GetT2());
         model->SetT1(m_Controls->m_BallWidget2->GetT1());
         model->m_CompartmentId = 4;
         parameters.m_NonFiberModelList.push_back(model);
         parameters.m_Misc.m_SignalModelString += "Ball";
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Ball") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.D", DoubleProperty::New(m_Controls->m_BallWidget2->GetD()) );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(model->GetT2()) );
         break;
       }
       case 2:
       {
         mitk::AstroStickModel<ScalarType>* model = new mitk::AstroStickModel<ScalarType>();
         model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
         model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
         model->SetDiffusivity(m_Controls->m_AstrosticksWidget2->GetD());
         model->SetT2(m_Controls->m_AstrosticksWidget2->GetT2());
         model->SetT1(m_Controls->m_AstrosticksWidget2->GetT1());
         model->SetRandomizeSticks(m_Controls->m_AstrosticksWidget2->GetRandomizeSticks());
         model->m_CompartmentId = 4;
         parameters.m_NonFiberModelList.push_back(model);
         parameters.m_Misc.m_SignalModelString += "Astrosticks";
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Astrosticks") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.D", DoubleProperty::New(m_Controls->m_AstrosticksWidget2->GetD()) );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(model->GetT2()) );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.RandomSticks", BoolProperty::New(m_Controls->m_AstrosticksWidget2->GetRandomizeSticks()) );
         break;
       }
       case 3:
       {
         mitk::DotModel<ScalarType>* model = new mitk::DotModel<ScalarType>();
         model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
         model->SetT2(m_Controls->m_DotWidget2->GetT2());
         model->SetT1(m_Controls->m_DotWidget2->GetT1());
         model->m_CompartmentId = 4;
         parameters.m_NonFiberModelList.push_back(model);
         parameters.m_Misc.m_SignalModelString += "Dot";
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Dot") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(model->GetT2()) );
         break;
       }
       case 4:
       {
         mitk::RawShModel<ScalarType>* model = new mitk::RawShModel<ScalarType>();
         parameters.m_SignalGen.m_DoSimulateRelaxation = false;
         model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
         model->SetMaxNumKernels(m_Controls->m_PrototypeWidget4->GetNumberOfSamples());
         model->SetFaRange(m_Controls->m_PrototypeWidget4->GetMinFa(), m_Controls->m_PrototypeWidget4->GetMaxFa());
         model->SetAdcRange(m_Controls->m_PrototypeWidget4->GetMinAdc(), m_Controls->m_PrototypeWidget4->GetMaxAdc());
         model->m_CompartmentId = 4;
         parameters.m_NonFiberModelList.push_back(model);
         parameters.m_Misc.m_SignalModelString += "Prototype";
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Prototype") );
         break;
       }
     }
     if (m_Controls->m_Comp4VolumeFraction->GetSelectedNode().IsNotNull() && parameters.m_NonFiberModelList.size()==2)
     {
       mitk::DataNode::Pointer volumeNode = m_Controls->m_Comp4VolumeFraction->GetSelectedNode();
       ItkDoubleImgType::Pointer compVolumeImage = ItkDoubleImgType::New();
       mitk::Image* img = dynamic_cast<mitk::Image*>(volumeNode->GetData());
       CastToItkImage< ItkDoubleImgType >(img, compVolumeImage);
       parameters.m_NonFiberModelList.back()->SetVolumeFractionImage(compVolumeImage);
     }
   }
 
   parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.SignalScale", IntProperty::New(parameters.m_SignalGen.m_SignalScale));
   parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.FiberRadius", IntProperty::New(parameters.m_SignalGen.m_AxonRadius));
   parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Tinhom", DoubleProperty::New(parameters.m_SignalGen.m_tInhom));
   parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Tline", DoubleProperty::New(parameters.m_SignalGen.m_tLine));
   parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.TE", DoubleProperty::New(parameters.m_SignalGen.m_tEcho));
   parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.b-value", DoubleProperty::New(parameters.m_SignalGen.m_Bvalue));
   parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.NoPartialVolume", BoolProperty::New(parameters.m_SignalGen.m_DoDisablePartialVolume));
   parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Relaxation", BoolProperty::New(parameters.m_SignalGen.m_DoSimulateRelaxation));
   parameters.m_Misc.m_ResultNode->AddProperty("binary", BoolProperty::New(false));
 
   parameters.m_Misc.m_CheckRealTimeFibersBox = m_Controls->m_RealTimeFibers->isChecked();
   parameters.m_Misc.m_CheckAdvancedFiberOptionsBox = m_Controls->m_AdvancedOptionsBox->isChecked();
   parameters.m_Misc.m_CheckIncludeFiducialsBox = m_Controls->m_IncludeFiducials->isChecked();
   parameters.m_Misc.m_CheckConstantRadiusBox = m_Controls->m_ConstantRadiusBox->isChecked();
 
   return parameters;
 }
 
 void QmitkFiberfoxView::SaveParameters(QString filename)
 {
   FiberfoxParameters<> ffParamaters = UpdateImageParameters<double>();
   bool ok = true;
   bool first = true;
   bool dosampling = false;
   mitk::Image::Pointer diffImg = NULL;
   itk::Image< itk::DiffusionTensor3D< double >, 3 >::Pointer tensorImage = NULL;
   const int shOrder = 2;
   typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,shOrder,QBALL_ODFSIZE> QballFilterType;
   QballFilterType::CoefficientImageType::Pointer itkFeatureImage = NULL;
   ItkDoubleImgType::Pointer adcImage = NULL;
 
   for (unsigned int i=0; i<ffParamaters.m_FiberModelList.size()+ffParamaters.m_NonFiberModelList.size(); i++)
   {
     mitk::RawShModel<>* model = nullptr;
     if (i<ffParamaters.m_FiberModelList.size())
     {
       model = dynamic_cast<  mitk::RawShModel<>* >(ffParamaters.m_FiberModelList.at(i));
     }
     else
     {
       model = dynamic_cast<  mitk::RawShModel<>* >(ffParamaters.m_NonFiberModelList.at(i-ffParamaters.m_FiberModelList.size()));
     }
 
     if ( model!=nullptr && model->GetNumberOfKernels() <= 0 )
     {
       if (first==true)
       {
         if ( QMessageBox::question(NULL, "Prototype signal sampling",
                                    "Do you want to sample prototype signals from the selected diffusion-weighted imag and save them?",
                                    QMessageBox::Yes, QMessageBox::No) == QMessageBox::Yes )
           dosampling = true;
 
         first = false;
         if ( dosampling && (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNull()
                             || !mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(
                               dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData()) ) ) )
         {
           QMessageBox::information(NULL, "Parameter file not saved", "No diffusion-weighted image selected to sample signal from.");
           return;
         }
         else if (dosampling)
         {
           diffImg = dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
 
           typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, double > TensorReconstructionImageFilterType;
           TensorReconstructionImageFilterType::Pointer filter = TensorReconstructionImageFilterType::New();
           ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
           mitk::CastToItkImage(diffImg, itkVectorImagePointer);
           filter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>
                                     ( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
                                     ->GetGradientDirectionsContainer(),
                                     itkVectorImagePointer );
           filter->SetBValue( static_cast<mitk::FloatProperty*>
                              ( diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str() ).GetPointer() )
                              ->GetValue() );
 
           filter->Update();
           tensorImage = filter->GetOutput();
 
           QballFilterType::Pointer qballfilter = QballFilterType::New();
           qballfilter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>
                                          ( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
                                          ->GetGradientDirectionsContainer(),
                                          itkVectorImagePointer );
           qballfilter->SetBValue( static_cast<mitk::FloatProperty*>
                                   ( diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
                                   ->GetValue() );
           qballfilter->SetLambda(0.006);
           qballfilter->SetNormalizationMethod(QballFilterType::QBAR_RAW_SIGNAL);
           qballfilter->Update();
           itkFeatureImage = qballfilter->GetCoefficientImage();
 
           itk::AdcImageFilter< short, double >::Pointer adcFilter = itk::AdcImageFilter< short, double >::New();
           adcFilter->SetInput( itkVectorImagePointer );
           adcFilter->SetGradientDirections( static_cast<mitk::GradientDirectionsProperty*>
                                             ( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
                                             ->GetGradientDirectionsContainer() );
           adcFilter->SetB_value( static_cast<mitk::FloatProperty*>
                                  (diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
                                  ->GetValue() );
           adcFilter->Update();
           adcImage = adcFilter->GetOutput();
         }
       }
 
 
       typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, double > TensorReconstructionImageFilterType;
       TensorReconstructionImageFilterType::Pointer filter = TensorReconstructionImageFilterType::New();
       ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
       mitk::CastToItkImage(diffImg, itkVectorImagePointer);
       filter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>
                                 ( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
                                 ->GetGradientDirectionsContainer(), itkVectorImagePointer );
       filter->SetBValue( static_cast<mitk::FloatProperty*>
                          (diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
                          ->GetValue() );
 
       filter->Update();
       tensorImage = filter->GetOutput();
 
       QballFilterType::Pointer qballfilter = QballFilterType::New();
       qballfilter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>
                                      ( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
                                      ->GetGradientDirectionsContainer(),
                                      itkVectorImagePointer );
       qballfilter->SetBValue( static_cast<mitk::FloatProperty*>
                               (diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
                               ->GetValue() );
       qballfilter->SetLambda(0.006);
       qballfilter->SetNormalizationMethod(QballFilterType::QBAR_RAW_SIGNAL);
       qballfilter->Update();
       itkFeatureImage = qballfilter->GetCoefficientImage();
 
       itk::AdcImageFilter< short, double >::Pointer adcFilter = itk::AdcImageFilter< short, double >::New();
       adcFilter->SetInput( itkVectorImagePointer );
       adcFilter->SetGradientDirections( static_cast<mitk::GradientDirectionsProperty*>
                                         ( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
                                         ->GetGradientDirectionsContainer() );
       adcFilter->SetB_value( static_cast<mitk::FloatProperty*>
                              (diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
                              ->GetValue() );
       adcFilter->Update();
       adcImage = adcFilter->GetOutput();
 
       if (dosampling && diffImg.IsNotNull())
       {
         ok = model->SampleKernels(diffImg, ffParamaters.m_SignalGen.m_MaskImage, tensorImage, itkFeatureImage, adcImage);
         if (!ok)
         {
           QMessageBox::information( NULL, "Parameter file not saved", "No valid prototype signals could be sampled.");
           return;
         }
       }
     }
   }
 
   ffParamaters.SaveParameters(filename.toStdString());
   m_ParameterFile = filename;
 }
 
 void QmitkFiberfoxView::SaveParameters()
 {
   QString filename = QFileDialog::getSaveFileName(
         0,
         tr("Save Parameters"),
         m_ParameterFile,
         tr("Fiberfox Parameters (*.ffp)") );
 
   SaveParameters(filename);
 }
 
 void QmitkFiberfoxView::LoadParameters()
 {
   QString filename = QFileDialog::getOpenFileName(0, tr("Load Parameters"), QString(itksys::SystemTools::GetFilenamePath(m_ParameterFile.toStdString()).c_str()), tr("Fiberfox Parameters (*.ffp)") );
   if(filename.isEmpty() || filename.isNull())
     return;
 
   m_ParameterFile = filename;
 
   FiberfoxParameters<> parameters = UpdateImageParameters<double>();
   parameters.LoadParameters(filename.toStdString());
 
   if (parameters.m_MissingTags.size()>0)
   {
     QString missing("Parameter file might be corrupted. The following parameters could not be read: ");
     missing += QString(parameters.m_MissingTags.c_str());
     missing += "\nDefault values have been assigned to the missing parameters.";
     QMessageBox::information( NULL, "Warning!", missing);
   }
 
   m_Controls->m_RealTimeFibers->setChecked(parameters.m_Misc.m_CheckRealTimeFibersBox);
   m_Controls->m_AdvancedOptionsBox->setChecked(parameters.m_Misc.m_CheckAdvancedFiberOptionsBox);
   m_Controls->m_IncludeFiducials->setChecked(parameters.m_Misc.m_CheckIncludeFiducialsBox);
   m_Controls->m_ConstantRadiusBox->setChecked(parameters.m_Misc.m_CheckConstantRadiusBox);
 
   m_Controls->m_DistributionBox->setCurrentIndex(parameters.m_FiberGen.m_Distribution);
   m_Controls->m_VarianceBox->setValue(parameters.m_FiberGen.m_Variance);
   m_Controls->m_FiberDensityBox->setValue(parameters.m_FiberGen.m_Density);
   m_Controls->m_FiberSamplingBox->setValue(parameters.m_FiberGen.m_Sampling);
   m_Controls->m_TensionBox->setValue(parameters.m_FiberGen.m_Tension);
   m_Controls->m_ContinuityBox->setValue(parameters.m_FiberGen.m_Continuity);
   m_Controls->m_BiasBox->setValue(parameters.m_FiberGen.m_Bias);
   m_Controls->m_XrotBox->setValue(parameters.m_FiberGen.m_Rotation[0]);
   m_Controls->m_YrotBox->setValue(parameters.m_FiberGen.m_Rotation[1]);
   m_Controls->m_ZrotBox->setValue(parameters.m_FiberGen.m_Rotation[2]);
   m_Controls->m_XtransBox->setValue(parameters.m_FiberGen.m_Translation[0]);
   m_Controls->m_YtransBox->setValue(parameters.m_FiberGen.m_Translation[1]);
   m_Controls->m_ZtransBox->setValue(parameters.m_FiberGen.m_Translation[2]);
   m_Controls->m_XscaleBox->setValue(parameters.m_FiberGen.m_Scale[0]);
   m_Controls->m_YscaleBox->setValue(parameters.m_FiberGen.m_Scale[1]);
   m_Controls->m_ZscaleBox->setValue(parameters.m_FiberGen.m_Scale[2]);
 
   // image generation parameters
   m_Controls->m_SizeX->setValue(parameters.m_SignalGen.m_ImageRegion.GetSize(0));
   m_Controls->m_SizeY->setValue(parameters.m_SignalGen.m_ImageRegion.GetSize(1));
   m_Controls->m_SizeZ->setValue(parameters.m_SignalGen.m_ImageRegion.GetSize(2));
   m_Controls->m_SpacingX->setValue(parameters.m_SignalGen.m_ImageSpacing[0]);
   m_Controls->m_SpacingY->setValue(parameters.m_SignalGen.m_ImageSpacing[1]);
   m_Controls->m_SpacingZ->setValue(parameters.m_SignalGen.m_ImageSpacing[2]);
   m_Controls->m_NumGradientsBox->setValue(parameters.m_SignalGen.GetNumWeightedVolumes());
   m_Controls->m_BvalueBox->setValue(parameters.m_SignalGen.m_Bvalue);
   m_Controls->m_SignalScaleBox->setValue(parameters.m_SignalGen.m_SignalScale);
   m_Controls->m_TEbox->setValue(parameters.m_SignalGen.m_tEcho);
   m_Controls->m_LineReadoutTimeBox->setValue(parameters.m_SignalGen.m_tLine);
   m_Controls->m_T2starBox->setValue(parameters.m_SignalGen.m_tInhom);
   m_Controls->m_FiberRadius->setValue(parameters.m_SignalGen.m_AxonRadius);
   m_Controls->m_RelaxationBox->setChecked(parameters.m_SignalGen.m_DoSimulateRelaxation);
   m_Controls->m_EnforcePureFiberVoxelsBox->setChecked(parameters.m_SignalGen.m_DoDisablePartialVolume);
   m_Controls->m_ReversePhaseBox->setChecked(parameters.m_SignalGen.m_ReversePhase);
   m_Controls->m_PartialFourier->setValue(parameters.m_SignalGen.m_PartialFourier);
   m_Controls->m_TRbox->setValue(parameters.m_SignalGen.m_tRep);
   m_Controls->m_NumCoilsBox->setValue(parameters.m_SignalGen.m_NumberOfCoils);
   m_Controls->m_CoilSensBox->setCurrentIndex(parameters.m_SignalGen.m_CoilSensitivityProfile);
   m_Controls->m_AcquisitionTypeBox->setCurrentIndex(parameters.m_SignalGen.m_AcquisitionType);
 
   if (parameters.m_NoiseModel!=NULL)
   {
     m_Controls->m_AddNoise->setChecked(parameters.m_Misc.m_CheckAddNoiseBox);
     if (dynamic_cast<mitk::RicianNoiseModel<double>*>(parameters.m_NoiseModel.get()))
     {
       m_Controls->m_NoiseDistributionBox->setCurrentIndex(0);
     }
     else if (dynamic_cast<mitk::ChiSquareNoiseModel<double>*>(parameters.m_NoiseModel.get()))
     {
       m_Controls->m_NoiseDistributionBox->setCurrentIndex(1);
     }
     m_Controls->m_NoiseLevel->setValue(parameters.m_NoiseModel->GetNoiseVariance());
   }
   else
   {
     m_Controls->m_AddNoise->setChecked(parameters.m_Misc.m_CheckAddNoiseBox);
     m_Controls->m_NoiseLevel->setValue(parameters.m_SignalGen.m_NoiseVariance);
   }
 
   m_Controls->m_VolumeFractionsBox->setChecked(parameters.m_Misc.m_CheckOutputVolumeFractionsBox);
   m_Controls->m_AdvancedOptionsBox_2->setChecked(parameters.m_Misc.m_CheckAdvancedSignalOptionsBox);
   m_Controls->m_AddGhosts->setChecked(parameters.m_Misc.m_CheckAddGhostsBox);
   m_Controls->m_AddAliasing->setChecked(parameters.m_Misc.m_CheckAddAliasingBox);
   m_Controls->m_AddDistortions->setChecked(parameters.m_Misc.m_CheckAddDistortionsBox);
   m_Controls->m_AddSpikes->setChecked(parameters.m_Misc.m_CheckAddSpikesBox);
   m_Controls->m_AddEddy->setChecked(parameters.m_Misc.m_CheckAddEddyCurrentsBox);
 
   m_Controls->m_kOffsetBox->setValue(parameters.m_SignalGen.m_KspaceLineOffset);
   m_Controls->m_WrapBox->setValue(100*(1-parameters.m_SignalGen.m_CroppingFactor));
   m_Controls->m_SpikeNumBox->setValue(parameters.m_SignalGen.m_Spikes);
   m_Controls->m_SpikeScaleBox->setValue(parameters.m_SignalGen.m_SpikeAmplitude);
   m_Controls->m_EddyGradientStrength->setValue(parameters.m_SignalGen.m_EddyStrength);
   m_Controls->m_AddGibbsRinging->setChecked(parameters.m_SignalGen.m_DoAddGibbsRinging);
   m_Controls->m_AddMotion->setChecked(parameters.m_SignalGen.m_DoAddMotion);
   m_Controls->m_RandomMotion->setChecked(parameters.m_SignalGen.m_DoRandomizeMotion);
   m_Controls->m_MotionVolumesBox->setText(QString(parameters.m_Misc.m_MotionVolumesBox.c_str()));
 
   m_Controls->m_MaxTranslationBoxX->setValue(parameters.m_SignalGen.m_Translation[0]);
   m_Controls->m_MaxTranslationBoxY->setValue(parameters.m_SignalGen.m_Translation[1]);
   m_Controls->m_MaxTranslationBoxZ->setValue(parameters.m_SignalGen.m_Translation[2]);
   m_Controls->m_MaxRotationBoxX->setValue(parameters.m_SignalGen.m_Rotation[0]);
   m_Controls->m_MaxRotationBoxY->setValue(parameters.m_SignalGen.m_Rotation[1]);
   m_Controls->m_MaxRotationBoxZ->setValue(parameters.m_SignalGen.m_Rotation[2]);
 
   m_Controls->m_Compartment1Box->setCurrentIndex(0);
   m_Controls->m_Compartment2Box->setCurrentIndex(0);
   m_Controls->m_Compartment3Box->setCurrentIndex(0);
   m_Controls->m_Compartment4Box->setCurrentIndex(0);
 
   for (unsigned int i=0; i<parameters.m_FiberModelList.size()+parameters.m_NonFiberModelList.size(); i++)
   {
     mitk::DiffusionSignalModel<ScalarType>* signalModel = NULL;
     if (i<parameters.m_FiberModelList.size())
       signalModel = parameters.m_FiberModelList.at(i);
     else
       signalModel = parameters.m_NonFiberModelList.at(i-parameters.m_FiberModelList.size());
 
     mitk::DataNode::Pointer compVolNode;
     if ( signalModel->GetVolumeFractionImage().IsNotNull() )
     {
       compVolNode = mitk::DataNode::New();
       mitk::Image::Pointer image = mitk::Image::New();
       image->InitializeByItk(signalModel->GetVolumeFractionImage().GetPointer());
       image->SetVolume(signalModel->GetVolumeFractionImage()->GetBufferPointer());
 
       compVolNode->SetData( image );
       compVolNode->SetName("Compartment volume "+QString::number(signalModel->m_CompartmentId).toStdString());
       GetDataStorage()->Add(compVolNode);
     }
 
     switch (signalModel->m_CompartmentId)
     {
       case 1:
       {
         if (compVolNode.IsNotNull())
           m_Controls->m_Comp1VolumeFraction->SetSelectedNode(compVolNode);
         if (dynamic_cast<mitk::StickModel<>*>(signalModel))
         {
           mitk::StickModel<>* model = dynamic_cast<mitk::StickModel<>*>(signalModel);
           m_Controls->m_StickWidget1->SetT2(model->GetT2());
           m_Controls->m_StickWidget1->SetT1(model->GetT1());
           m_Controls->m_StickWidget1->SetD(model->GetDiffusivity());
           m_Controls->m_Compartment1Box->setCurrentIndex(0);
           break;
         }
         else if (dynamic_cast<mitk::TensorModel<>*>(signalModel))
         {
           mitk::TensorModel<>* model = dynamic_cast<mitk::TensorModel<>*>(signalModel);
           m_Controls->m_TensorWidget1->SetT2(model->GetT2());
           m_Controls->m_TensorWidget1->SetT1(model->GetT1());
           m_Controls->m_TensorWidget1->SetD1(model->GetDiffusivity1());
           m_Controls->m_TensorWidget1->SetD2(model->GetDiffusivity2());
           m_Controls->m_TensorWidget1->SetD3(model->GetDiffusivity3());
           m_Controls->m_Compartment1Box->setCurrentIndex(2);
           break;
         }
         else if (dynamic_cast<mitk::RawShModel<>*>(signalModel))
         {
           mitk::RawShModel<>* model = dynamic_cast<mitk::RawShModel<>*>(signalModel);
           m_Controls->m_PrototypeWidget1->SetNumberOfSamples(model->GetMaxNumKernels());
           m_Controls->m_PrototypeWidget1->SetMinFa(model->GetFaRange().first);
           m_Controls->m_PrototypeWidget1->SetMaxFa(model->GetFaRange().second);
           m_Controls->m_PrototypeWidget1->SetMinAdc(model->GetAdcRange().first);
           m_Controls->m_PrototypeWidget1->SetMaxAdc(model->GetAdcRange().second);
           m_Controls->m_Compartment1Box->setCurrentIndex(3);
           break;
         }
         break;
       }
       case 2:
       {
         if (compVolNode.IsNotNull())
           m_Controls->m_Comp2VolumeFraction->SetSelectedNode(compVolNode);
         if (dynamic_cast<mitk::StickModel<>*>(signalModel))
         {
           mitk::StickModel<>* model = dynamic_cast<mitk::StickModel<>*>(signalModel);
           m_Controls->m_StickWidget2->SetT2(model->GetT2());
           m_Controls->m_StickWidget2->SetT1(model->GetT1());
           m_Controls->m_StickWidget2->SetD(model->GetDiffusivity());
           m_Controls->m_Compartment2Box->setCurrentIndex(1);
           break;
         }
         else if (dynamic_cast<mitk::TensorModel<>*>(signalModel))
         {
           mitk::TensorModel<>* model = dynamic_cast<mitk::TensorModel<>*>(signalModel);
           m_Controls->m_TensorWidget2->SetT2(model->GetT2());
           m_Controls->m_TensorWidget2->SetT1(model->GetT1());
           m_Controls->m_TensorWidget2->SetD1(model->GetDiffusivity1());
           m_Controls->m_TensorWidget2->SetD2(model->GetDiffusivity2());
           m_Controls->m_TensorWidget2->SetD3(model->GetDiffusivity3());
           m_Controls->m_Compartment2Box->setCurrentIndex(3);
           break;
         }
         break;
       }
       case 3:
       {
         if (compVolNode.IsNotNull())
           m_Controls->m_Comp3VolumeFraction->SetSelectedNode(compVolNode);
         if (dynamic_cast<mitk::BallModel<>*>(signalModel))
         {
           mitk::BallModel<>* model = dynamic_cast<mitk::BallModel<>*>(signalModel);
           m_Controls->m_BallWidget1->SetT2(model->GetT2());
           m_Controls->m_BallWidget1->SetT1(model->GetT1());
           m_Controls->m_BallWidget1->SetD(model->GetDiffusivity());
           m_Controls->m_Compartment3Box->setCurrentIndex(0);
           break;
         }
         else if (dynamic_cast<mitk::AstroStickModel<>*>(signalModel))
         {
           mitk::AstroStickModel<>* model = dynamic_cast<mitk::AstroStickModel<>*>(signalModel);
           m_Controls->m_AstrosticksWidget1->SetT2(model->GetT2());
           m_Controls->m_AstrosticksWidget1->SetT1(model->GetT1());
           m_Controls->m_AstrosticksWidget1->SetD(model->GetDiffusivity());
           m_Controls->m_AstrosticksWidget1->SetRandomizeSticks(model->GetRandomizeSticks());
           m_Controls->m_Compartment3Box->setCurrentIndex(1);
           break;
         }
         else if (dynamic_cast<mitk::DotModel<>*>(signalModel))
         {
           mitk::DotModel<>* model = dynamic_cast<mitk::DotModel<>*>(signalModel);
           m_Controls->m_DotWidget1->SetT2(model->GetT2());
           m_Controls->m_DotWidget1->SetT1(model->GetT1());
           m_Controls->m_Compartment3Box->setCurrentIndex(2);
           break;
         }
         else if (dynamic_cast<mitk::RawShModel<>*>(signalModel))
         {
           mitk::RawShModel<>* model = dynamic_cast<mitk::RawShModel<>*>(signalModel);
           m_Controls->m_PrototypeWidget3->SetNumberOfSamples(model->GetMaxNumKernels());
           m_Controls->m_PrototypeWidget3->SetMinFa(model->GetFaRange().first);
           m_Controls->m_PrototypeWidget3->SetMaxFa(model->GetFaRange().second);
           m_Controls->m_PrototypeWidget3->SetMinAdc(model->GetAdcRange().first);
           m_Controls->m_PrototypeWidget3->SetMaxAdc(model->GetAdcRange().second);
           m_Controls->m_Compartment3Box->setCurrentIndex(3);
           break;
         }
         break;
       }
       case 4:
       {
         if (compVolNode.IsNotNull())
           m_Controls->m_Comp4VolumeFraction->SetSelectedNode(compVolNode);
         if (dynamic_cast<mitk::BallModel<>*>(signalModel))
         {
           mitk::BallModel<>* model = dynamic_cast<mitk::BallModel<>*>(signalModel);
           m_Controls->m_BallWidget2->SetT2(model->GetT2());
           m_Controls->m_BallWidget2->SetT1(model->GetT1());
           m_Controls->m_BallWidget2->SetD(model->GetDiffusivity());
           m_Controls->m_Compartment4Box->setCurrentIndex(1);
           break;
         }
         else if (dynamic_cast<mitk::AstroStickModel<>*>(signalModel))
         {
           mitk::AstroStickModel<>* model = dynamic_cast<mitk::AstroStickModel<>*>(signalModel);
           m_Controls->m_AstrosticksWidget2->SetT2(model->GetT2());
           m_Controls->m_AstrosticksWidget2->SetT1(model->GetT1());
           m_Controls->m_AstrosticksWidget2->SetD(model->GetDiffusivity());
           m_Controls->m_AstrosticksWidget2->SetRandomizeSticks(model->GetRandomizeSticks());
           m_Controls->m_Compartment4Box->setCurrentIndex(2);
           break;
         }
         else if (dynamic_cast<mitk::DotModel<>*>(signalModel))
         {
           mitk::DotModel<>* model = dynamic_cast<mitk::DotModel<>*>(signalModel);
           m_Controls->m_DotWidget2->SetT2(model->GetT2());
           m_Controls->m_DotWidget2->SetT1(model->GetT1());
           m_Controls->m_Compartment4Box->setCurrentIndex(3);
           break;
         }
         else if (dynamic_cast<mitk::RawShModel<>*>(signalModel))
         {
           mitk::RawShModel<>* model = dynamic_cast<mitk::RawShModel<>*>(signalModel);
           m_Controls->m_PrototypeWidget4->SetNumberOfSamples(model->GetMaxNumKernels());
           m_Controls->m_PrototypeWidget4->SetMinFa(model->GetFaRange().first);
           m_Controls->m_PrototypeWidget4->SetMaxFa(model->GetFaRange().second);
           m_Controls->m_PrototypeWidget4->SetMinAdc(model->GetAdcRange().first);
           m_Controls->m_PrototypeWidget4->SetMaxAdc(model->GetAdcRange().second);
           m_Controls->m_Compartment4Box->setCurrentIndex(4);
           break;
         }
         break;
       }
     }
   }
 
   if ( parameters.m_SignalGen.m_MaskImage )
   {
     mitk::Image::Pointer image = mitk::Image::New();
     image->InitializeByItk(parameters.m_SignalGen.m_MaskImage.GetPointer());
     image->SetVolume(parameters.m_SignalGen.m_MaskImage->GetBufferPointer());
 
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData( image );
     node->SetName("Tissue mask");
     GetDataStorage()->Add(node);
     m_Controls->m_MaskComboBox->SetSelectedNode(node);
   }
 
   if ( parameters.m_SignalGen.m_FrequencyMap )
   {
     mitk::Image::Pointer image = mitk::Image::New();
     image->InitializeByItk(parameters.m_SignalGen.m_FrequencyMap.GetPointer());
     image->SetVolume(parameters.m_SignalGen.m_FrequencyMap->GetBufferPointer());
 
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData( image );
     node->SetName("Frequency map");
     GetDataStorage()->Add(node);
     m_Controls->m_FrequencyMapBox->SetSelectedNode(node);
   }
 }
 
 void QmitkFiberfoxView::ShowAdvancedOptions(int state)
 {
   if (state)
   {
     m_Controls->m_AdvancedFiberOptionsFrame->setVisible(true);
     m_Controls->m_AdvancedSignalOptionsFrame->setVisible(true);
     m_Controls->m_AdvancedOptionsBox->setChecked(true);
     m_Controls->m_AdvancedOptionsBox_2->setChecked(true);
   }
   else
   {
     m_Controls->m_AdvancedFiberOptionsFrame->setVisible(false);
     m_Controls->m_AdvancedSignalOptionsFrame->setVisible(false);
     m_Controls->m_AdvancedOptionsBox->setChecked(false);
     m_Controls->m_AdvancedOptionsBox_2->setChecked(false);
   }
 }
 
 void QmitkFiberfoxView::Comp1ModelFrameVisibility(int index)
 {
   m_Controls->m_StickWidget1->setVisible(false);
   m_Controls->m_ZeppelinWidget1->setVisible(false);
   m_Controls->m_TensorWidget1->setVisible(false);
   m_Controls->m_PrototypeWidget1->setVisible(false);
 
   switch (index)
   {
     case 0:
       m_Controls->m_StickWidget1->setVisible(true);
     break;
     case 1:
       m_Controls->m_ZeppelinWidget1->setVisible(true);
     break;
     case 2:
       m_Controls->m_TensorWidget1->setVisible(true);
     break;
     case 3:
       m_Controls->m_PrototypeWidget1->setVisible(true);
     break;
   }
 }
 
 void QmitkFiberfoxView::Comp2ModelFrameVisibility(int index)
 {
   m_Controls->m_StickWidget2->setVisible(false);
   m_Controls->m_ZeppelinWidget2->setVisible(false);
   m_Controls->m_TensorWidget2->setVisible(false);
   m_Controls->m_Comp2FractionFrame->setVisible(false);
 
   switch (index)
   {
     case 0:
     break;
     case 1:
       m_Controls->m_StickWidget2->setVisible(true);
       m_Controls->m_Comp2FractionFrame->setVisible(true);
     break;
     case 2:
       m_Controls->m_ZeppelinWidget2->setVisible(true);
       m_Controls->m_Comp2FractionFrame->setVisible(true);
     break;
     case 3:
       m_Controls->m_TensorWidget2->setVisible(true);
       m_Controls->m_Comp2FractionFrame->setVisible(true);
     break;
   }
 }
 
 void QmitkFiberfoxView::Comp3ModelFrameVisibility(int index)
 {
   m_Controls->m_BallWidget1->setVisible(false);
   m_Controls->m_AstrosticksWidget1->setVisible(false);
   m_Controls->m_DotWidget1->setVisible(false);
   m_Controls->m_PrototypeWidget3->setVisible(false);
 
   switch (index)
   {
     case 0:
       m_Controls->m_BallWidget1->setVisible(true);
     break;
     case 1:
       m_Controls->m_AstrosticksWidget1->setVisible(true);
     break;
     case 2:
       m_Controls->m_DotWidget1->setVisible(true);
     break;
     case 3:
       m_Controls->m_PrototypeWidget3->setVisible(true);
     break;
   }
 }
 
 void QmitkFiberfoxView::Comp4ModelFrameVisibility(int index)
 {
   m_Controls->m_BallWidget2->setVisible(false);
   m_Controls->m_AstrosticksWidget2->setVisible(false);
   m_Controls->m_DotWidget2->setVisible(false);
   m_Controls->m_PrototypeWidget4->setVisible(false);
   m_Controls->m_Comp4FractionFrame->setVisible(false);
 
   switch (index)
   {
     case 0:
     break;
     case 1:
       m_Controls->m_BallWidget2->setVisible(true);
       m_Controls->m_Comp4FractionFrame->setVisible(true);
     break;
     case 2:
       m_Controls->m_AstrosticksWidget2->setVisible(true);
       m_Controls->m_Comp4FractionFrame->setVisible(true);
     break;
     case 3:
       m_Controls->m_DotWidget2->setVisible(true);
       m_Controls->m_Comp4FractionFrame->setVisible(true);
     break;
     case 4:
       m_Controls->m_PrototypeWidget4->setVisible(true);
       m_Controls->m_Comp4FractionFrame->setVisible(true);
     break;
   }
 }
 
 void QmitkFiberfoxView::OnConstantRadius(int value)
 {
   if (value>0 && m_Controls->m_RealTimeFibers->isChecked())
     GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnAddMotion(int value)
 {
   if (value>0)
     m_Controls->m_MotionArtifactFrame->setVisible(true);
   else
     m_Controls->m_MotionArtifactFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddAliasing(int value)
 {
   if (value>0)
     m_Controls->m_AliasingFrame->setVisible(true);
   else
     m_Controls->m_AliasingFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddSpikes(int value)
 {
   if (value>0)
     m_Controls->m_SpikeFrame->setVisible(true);
   else
     m_Controls->m_SpikeFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddEddy(int value)
 {
   if (value>0)
     m_Controls->m_EddyFrame->setVisible(true);
   else
     m_Controls->m_EddyFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddDistortions(int value)
 {
   if (value>0)
     m_Controls->m_DistortionsFrame->setVisible(true);
   else
     m_Controls->m_DistortionsFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddGhosts(int value)
 {
   if (value>0)
     m_Controls->m_GhostFrame->setVisible(true);
   else
     m_Controls->m_GhostFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddNoise(int value)
 {
   if (value>0)
     m_Controls->m_NoiseFrame->setVisible(true);
   else
     m_Controls->m_NoiseFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnDistributionChanged(int value)
 {
   if (value==1)
     m_Controls->m_VarianceBox->setVisible(true);
   else
     m_Controls->m_VarianceBox->setVisible(false);
 
   if (m_Controls->m_RealTimeFibers->isChecked())
     GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnVarianceChanged(double)
 {
   if (m_Controls->m_RealTimeFibers->isChecked())
     GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnFiberDensityChanged(int)
 {
   if (m_Controls->m_RealTimeFibers->isChecked())
     GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnFiberSamplingChanged(double)
 {
   if (m_Controls->m_RealTimeFibers->isChecked())
     GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnTensionChanged(double)
 {
   if (m_Controls->m_RealTimeFibers->isChecked())
     GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnContinuityChanged(double)
 {
   if (m_Controls->m_RealTimeFibers->isChecked())
     GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnBiasChanged(double)
 {
   if (m_Controls->m_RealTimeFibers->isChecked())
     GenerateFibers();
 }
 
 void QmitkFiberfoxView::AlignOnGrid()
 {
   for (unsigned int i=0; i<m_SelectedFiducials.size(); i++)
   {
     mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(m_SelectedFiducials.at(i)->GetData());
     mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
 
     mitk::DataStorage::SetOfObjects::ConstPointer parentFibs = GetDataStorage()->GetSources(m_SelectedFiducials.at(i));
     for( mitk::DataStorage::SetOfObjects::const_iterator it = parentFibs->begin(); it != parentFibs->end(); ++it )
     {
       mitk::DataNode::Pointer pFibNode = *it;
       if ( pFibNode.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(pFibNode->GetData()) )
       {
         mitk::DataStorage::SetOfObjects::ConstPointer parentImgs = GetDataStorage()->GetSources(pFibNode);
         for( mitk::DataStorage::SetOfObjects::const_iterator it2 = parentImgs->begin(); it2 != parentImgs->end(); ++it2 )
         {
           mitk::DataNode::Pointer pImgNode = *it2;
           if ( pImgNode.IsNotNull() && dynamic_cast<mitk::Image*>(pImgNode->GetData()) )
           {
             mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(pImgNode->GetData());
             mitk::BaseGeometry::Pointer geom = img->GetGeometry();
             itk::Index<3> idx;
             geom->WorldToIndex(wc0, idx);
 
             mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
             mitk::Point3D world;
             geom->IndexToWorld(cIdx,world);
 
             mitk::Vector3D trans = world - wc0;
             pe->GetGeometry()->Translate(trans);
 
             break;
           }
         }
         break;
       }
     }
   }
 
   for(unsigned int i=0; i<m_SelectedBundles2.size(); i++ )
   {
     mitk::DataNode::Pointer fibNode = m_SelectedBundles2.at(i);
 
     mitk::DataStorage::SetOfObjects::ConstPointer sources = GetDataStorage()->GetSources(fibNode);
     for( mitk::DataStorage::SetOfObjects::const_iterator it = sources->begin(); it != sources->end(); ++it )
     {
       mitk::DataNode::Pointer imgNode = *it;
       if ( imgNode.IsNotNull() && dynamic_cast<mitk::Image*>(imgNode->GetData()) )
       {
         mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(fibNode);
         for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
         {
           mitk::DataNode::Pointer fiducialNode = *it2;
           if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
           {
             mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
             mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
 
             mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(imgNode->GetData());
             mitk::BaseGeometry::Pointer geom = img->GetGeometry();
             itk::Index<3> idx;
             geom->WorldToIndex(wc0, idx);
             mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
             mitk::Point3D world;
             geom->IndexToWorld(cIdx,world);
 
             mitk::Vector3D trans = world - wc0;
             pe->GetGeometry()->Translate(trans);
           }
         }
 
         break;
       }
     }
   }
 
   for(unsigned int i=0; i<m_SelectedImages.size(); i++ )
   {
     mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_SelectedImages.at(i)->GetData());
 
     mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(m_SelectedImages.at(i));
     for( mitk::DataStorage::SetOfObjects::const_iterator it = derivations->begin(); it != derivations->end(); ++it )
     {
       mitk::DataNode::Pointer fibNode = *it;
       if ( fibNode.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(fibNode->GetData()) )
       {
         mitk::DataStorage::SetOfObjects::ConstPointer derivations2 = GetDataStorage()->GetDerivations(fibNode);
         for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations2->begin(); it2 != derivations2->end(); ++it2 )
         {
           mitk::DataNode::Pointer fiducialNode = *it2;
           if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
           {
             mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
             mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
 
             mitk::BaseGeometry::Pointer geom = img->GetGeometry();
             itk::Index<3> idx;
             geom->WorldToIndex(wc0, idx);
             mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
             mitk::Point3D world;
             geom->IndexToWorld(cIdx,world);
 
             mitk::Vector3D trans = world - wc0;
             pe->GetGeometry()->Translate(trans);
           }
         }
       }
     }
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   if (m_Controls->m_RealTimeFibers->isChecked())
     GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnFlipButton()
 {
   if (m_SelectedFiducial.IsNull())
     return;
 
   std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(m_SelectedFiducial.GetPointer());
   if( it != m_DataNodeToPlanarFigureData.end() )
   {
     QmitkPlanarFigureData& data = it->second;
     data.m_Flipped += 1;
     data.m_Flipped %= 2;
   }
 
   if (m_Controls->m_RealTimeFibers->isChecked())
     GenerateFibers();
 }
 
 QmitkFiberfoxView::GradientListType QmitkFiberfoxView::GenerateHalfShell(int NPoints)
 {
   NPoints *= 2;
   GradientListType pointshell;
 
   int numB0 = NPoints/20;
   if (numB0==0)
     numB0=1;
   GradientType g;
   g.Fill(0.0);
   for (int i=0; i<numB0; i++)
     pointshell.push_back(g);
 
   if (NPoints==0)
     return pointshell;
 
   vnl_vector<double> theta; theta.set_size(NPoints);
   vnl_vector<double> phi; phi.set_size(NPoints);
   double C = sqrt(4*M_PI);
   phi(0) = 0.0;
   phi(NPoints-1) = 0.0;
   for(int i=0; i<NPoints; i++)
   {
     theta(i) = acos(-1.0+2.0*i/(NPoints-1.0)) - M_PI / 2.0;
     if( i>0 && i<NPoints-1)
     {
       phi(i) = (phi(i-1) + C /
                 sqrt(NPoints*(1-(-1.0+2.0*i/(NPoints-1.0))*(-1.0+2.0*i/(NPoints-1.0)))));
       // % (2*DIST_POINTSHELL_PI);
     }
   }
 
   for(int i=0; i<NPoints; i++)
   {
     g[2] = sin(theta(i));
     if (g[2]<0)
       continue;
     g[0] = cos(theta(i)) * cos(phi(i));
     g[1] = cos(theta(i)) * sin(phi(i));
     pointshell.push_back(g);
   }
 
   return pointshell;
 }
 
 template<int ndirs>
 std::vector<itk::Vector<double,3> > QmitkFiberfoxView::MakeGradientList()
 {
   std::vector<itk::Vector<double,3> > retval;
   vnl_matrix_fixed<double, 3, ndirs>* U =
       itk::PointShell<ndirs, vnl_matrix_fixed<double, 3, ndirs> >::DistributePointShell();
 
 
   // Add 0 vector for B0
   int numB0 = ndirs/10;
   if (numB0==0)
     numB0=1;
   itk::Vector<double,3> v;
   v.Fill(0.0);
   for (int i=0; i<numB0; i++)
   {
     retval.push_back(v);
   }
 
   for(int i=0; i<ndirs;i++)
   {
     itk::Vector<double,3> v;
     v[0] = U->get(0,i); v[1] = U->get(1,i); v[2] = U->get(2,i);
     retval.push_back(v);
   }
 
   return retval;
 }
 
 void QmitkFiberfoxView::OnAddBundle()
 {
   if (m_SelectedImageNode.IsNull())
     return;
 
   mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedImageNode);
 
   mitk::FiberBundle::Pointer bundle = mitk::FiberBundle::New();
   mitk::DataNode::Pointer node = mitk::DataNode::New();
   node->SetData( bundle );
   QString name = QString("Bundle_%1").arg(children->size());
   node->SetName(name.toStdString());
   m_SelectedBundles.push_back(node);
   UpdateGui();
 
   GetDataStorage()->Add(node, m_SelectedImageNode);
 }
 
 void QmitkFiberfoxView::OnDrawROI()
 {
   if (m_SelectedBundles.empty())
     OnAddBundle();
   if (m_SelectedBundles.empty())
     return;
 
   mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedBundles.at(0));
 
   mitk::PlanarEllipse::Pointer figure = mitk::PlanarEllipse::New();
 
   mitk::DataNode::Pointer node = mitk::DataNode::New();
   node->SetData( figure );
   node->SetBoolProperty("planarfigure.3drendering", true);
   node->SetBoolProperty("planarfigure.3drendering.fill", true);
 
   QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   for( int i=0; i<nodes.size(); i++)
     nodes.at(i)->SetSelected(false);
 
   m_SelectedFiducial = node;
 
   QString name = QString("Fiducial_%1").arg(children->size());
   node->SetName(name.toStdString());
   node->SetSelected(true);
 
   this->DisableCrosshairNavigation();
 
   mitk::PlanarFigureInteractor::Pointer figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
   if(figureInteractor.IsNull())
   {
     figureInteractor = mitk::PlanarFigureInteractor::New();
     us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
     figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
     figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
     figureInteractor->SetDataNode( node );
   }
 
   UpdateGui();
   GetDataStorage()->Add(node, m_SelectedBundles.at(0));
 }
 
 bool CompareLayer(mitk::DataNode::Pointer i,mitk::DataNode::Pointer j)
 {
   int li = -1;
   i->GetPropertyValue("layer", li);
   int lj = -1;
   j->GetPropertyValue("layer", lj);
   return li<lj;
 }
 
 void QmitkFiberfoxView::GenerateFibers()
 {
   if (m_SelectedBundles.empty())
   {
     if (m_SelectedFiducial.IsNull())
       return;
 
     mitk::DataStorage::SetOfObjects::ConstPointer parents = GetDataStorage()->GetSources(m_SelectedFiducial);
     for( mitk::DataStorage::SetOfObjects::const_iterator it = parents->begin(); it != parents->end(); ++it )
       if(dynamic_cast<mitk::FiberBundle*>((*it)->GetData()))
         m_SelectedBundles.push_back(*it);
 
     if (m_SelectedBundles.empty())
       return;
   }
 
   FiberfoxParameters<double> parameters = UpdateImageParameters<double>(false);
 
   for (unsigned int i=0; i<m_SelectedBundles.size(); i++)
   {
     mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedBundles.at(i));
     std::vector< mitk::DataNode::Pointer > childVector;
     for( mitk::DataStorage::SetOfObjects::const_iterator it = children->begin(); it != children->end(); ++it )
       childVector.push_back(*it);
     sort(childVector.begin(), childVector.end(), CompareLayer);
 
     vector< mitk::PlanarEllipse::Pointer > fib;
     vector< unsigned int > flip;
     float radius = 1;
     int count = 0;
     for( std::vector< mitk::DataNode::Pointer >::const_iterator it = childVector.begin(); it != childVector.end(); ++it )
     {
       mitk::DataNode::Pointer node = *it;
 
       if ( node.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(node->GetData()) )
       {
         mitk::PlanarEllipse* ellipse = dynamic_cast<mitk::PlanarEllipse*>(node->GetData());
         if (m_Controls->m_ConstantRadiusBox->isChecked())
         {
           ellipse->SetTreatAsCircle(true);
           mitk::Point2D c = ellipse->GetControlPoint(0);
           mitk::Point2D p = ellipse->GetControlPoint(1);
           mitk::Vector2D v = p-c;
           if (count==0)
           {
             radius = v.GetVnlVector().magnitude();
             ellipse->SetControlPoint(1, p);
             ellipse->Modified();
           }
           else
           {
             v.Normalize();
             v *= radius;
             ellipse->SetControlPoint(1, c+v);
             ellipse->Modified();
           }
         }
         fib.push_back(ellipse);
 
         std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(node.GetPointer());
         if( it != m_DataNodeToPlanarFigureData.end() )
         {
           QmitkPlanarFigureData& data = it->second;
           flip.push_back(data.m_Flipped);
         }
         else
           flip.push_back(0);
       }
       count++;
     }
     if (fib.size()>1)
     {
       parameters.m_FiberGen.m_Fiducials.push_back(fib);
       parameters.m_FiberGen.m_FlipList.push_back(flip);
     }
     else if (fib.size()>0)
       m_SelectedBundles.at(i)->SetData( mitk::FiberBundle::New() );
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 
   itk::FibersFromPlanarFiguresFilter::Pointer filter = itk::FibersFromPlanarFiguresFilter::New();
   filter->SetParameters(parameters.m_FiberGen);
   filter->Update();
   vector< mitk::FiberBundle::Pointer > fiberBundles = filter->GetFiberBundles();
 
   for (unsigned int i=0; i<fiberBundles.size(); i++)
   {
     m_SelectedBundles.at(i)->SetData( fiberBundles.at(i) );
     if (fiberBundles.at(i)->GetNumFibers()>50000)
       m_SelectedBundles.at(i)->SetVisibility(false);
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::GenerateImage()
 {
   if (m_Controls->m_FiberBundleComboBox->GetSelectedNode().IsNull() && !mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( m_Controls->m_TemplateComboBox->GetSelectedNode()))
   {
     mitk::Image::Pointer image = mitk::ImageGenerator::GenerateGradientImage<unsigned int>(
           m_Controls->m_SizeX->value(),
           m_Controls->m_SizeY->value(),
           m_Controls->m_SizeZ->value(),
           m_Controls->m_SpacingX->value(),
           m_Controls->m_SpacingY->value(),
           m_Controls->m_SpacingZ->value());
 
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData( image );
     node->SetName("Dummy");
     unsigned int window = m_Controls->m_SizeX->value()*m_Controls->m_SizeY->value()*m_Controls->m_SizeZ->value();
     unsigned int level = window/2;
     mitk::LevelWindow lw; lw.SetLevelWindow(level, window);
     node->SetProperty( "levelwindow", mitk::LevelWindowProperty::New( lw ) );
     GetDataStorage()->Add(node);
     m_SelectedImageNode = node;
 
     mitk::BaseData::Pointer basedata = node->GetData();
     if (basedata.IsNotNull())
     {
       mitk::RenderingManager::GetInstance()->InitializeViews( basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
     UpdateGui();
     QMessageBox::information(NULL, "Template image generated", "You have selected no fiber bundle or diffusion-weighted image, which can be used to simulate a new diffusion-weighted image. A template image with the specified geometry has been generated that can be used to draw artificial fibers (see tab 'Fiber Definition').");
   }
   else if (m_Controls->m_FiberBundleComboBox->GetSelectedNode().IsNotNull())
     SimulateImageFromFibers(m_Controls->m_FiberBundleComboBox->GetSelectedNode());
   else if ( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( m_Controls->m_TemplateComboBox->GetSelectedNode()) )
     SimulateForExistingDwi(m_Controls->m_TemplateComboBox->GetSelectedNode());
   else
     QMessageBox::information(NULL, "No image generated", "You have selected no fiber bundle or diffusion-weighted image, which can be used to simulate a new diffusion-weighted image.");
 }
 
 void QmitkFiberfoxView::SimulateForExistingDwi(mitk::DataNode* imageNode)
 {
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(imageNode->GetData())) );
   if ( !isDiffusionImage )
   {
     return;
   }
 
   FiberfoxParameters<double> parameters = UpdateImageParameters<double>();
 
   mitk::Image::Pointer diffImg = dynamic_cast<mitk::Image*>(imageNode->GetData());
   ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
   mitk::CastToItkImage(diffImg, itkVectorImagePointer);
 
   m_TractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
   parameters.m_Misc.m_ParentNode = imageNode;
   parameters.m_SignalGen.m_SignalScale = 1;
 
   parameters.m_Misc.m_ResultNode->SetName(parameters.m_Misc.m_ParentNode->GetName()
                                           +"_D"+QString::number(parameters.m_SignalGen.m_ImageRegion.GetSize(0)).toStdString()
                                           +"-"+QString::number(parameters.m_SignalGen.m_ImageRegion.GetSize(1)).toStdString()
                                           +"-"+QString::number(parameters.m_SignalGen.m_ImageRegion.GetSize(2)).toStdString()
                                           +"_S"+QString::number(parameters.m_SignalGen.m_ImageSpacing[0]).toStdString()
       +"-"+QString::number(parameters.m_SignalGen.m_ImageSpacing[1]).toStdString()
       +"-"+QString::number(parameters.m_SignalGen.m_ImageSpacing[2]).toStdString()
       +"_b"+QString::number(parameters.m_SignalGen.m_Bvalue).toStdString()
       +"_"+parameters.m_Misc.m_SignalModelString
       +parameters.m_Misc.m_ArtifactModelString);
 
   m_TractsToDwiFilter->SetParameters(parameters);
   m_TractsToDwiFilter->SetInputImage(itkVectorImagePointer);
   m_Thread.start(QThread::LowestPriority);
 }
 
 void QmitkFiberfoxView::SimulateImageFromFibers(mitk::DataNode* fiberNode)
 {
   mitk::FiberBundle::Pointer fiberBundle = dynamic_cast<mitk::FiberBundle*>(fiberNode->GetData());
   if (fiberBundle->GetNumFibers()<=0) { return; }
 
   FiberfoxParameters<double> parameters = UpdateImageParameters<double>();
 
   m_TractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
   parameters.m_Misc.m_ParentNode = fiberNode;
 
   parameters.m_Misc.m_ResultNode->SetName(parameters.m_Misc.m_ParentNode->GetName()
                                           +"_D"+QString::number(parameters.m_SignalGen.m_ImageRegion.GetSize(0)).toStdString()
                                           +"-"+QString::number(parameters.m_SignalGen.m_ImageRegion.GetSize(1)).toStdString()
                                           +"-"+QString::number(parameters.m_SignalGen.m_ImageRegion.GetSize(2)).toStdString()
                                           +"_S"+QString::number(parameters.m_SignalGen.m_ImageSpacing[0]).toStdString()
       +"-"+QString::number(parameters.m_SignalGen.m_ImageSpacing[1]).toStdString()
       +"-"+QString::number(parameters.m_SignalGen.m_ImageSpacing[2]).toStdString()
       +"_b"+QString::number(parameters.m_SignalGen.m_Bvalue).toStdString()
       +"_"+parameters.m_Misc.m_SignalModelString
       +parameters.m_Misc.m_ArtifactModelString);
 
   if ( m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull()
        && mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>
                                                                   (m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData()) ) )
   {
     bool first = true;
     bool ok = true;
     mitk::Image::Pointer diffImg = dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
     itk::Image< itk::DiffusionTensor3D< double >, 3 >::Pointer tensorImage = NULL;
     const int shOrder = 2;
     typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,shOrder,QBALL_ODFSIZE> QballFilterType;
     QballFilterType::CoefficientImageType::Pointer itkFeatureImage = NULL;
     ItkDoubleImgType::Pointer adcImage = NULL;
 
     for (unsigned int i=0; i<parameters.m_FiberModelList.size()+parameters.m_NonFiberModelList.size(); i++)
     {
       mitk::RawShModel<>* model = NULL;
       if (i<parameters.m_FiberModelList.size())
         model = dynamic_cast<  mitk::RawShModel<>* >(parameters.m_FiberModelList.at(i));
       else
         model = dynamic_cast<  mitk::RawShModel<>* >(parameters.m_NonFiberModelList.at(i-parameters.m_FiberModelList.size()));
 
       if (model!=0 && model->GetNumberOfKernels()<=0)
       {
         if (first==true)
         {
           ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
           mitk::CastToItkImage(diffImg, itkVectorImagePointer);
 
           typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, double > TensorReconstructionImageFilterType;
           TensorReconstructionImageFilterType::Pointer filter = TensorReconstructionImageFilterType::New();
           filter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>
                                     ( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
                                     ->GetGradientDirectionsContainer(),
                                     itkVectorImagePointer );
           filter->SetBValue( static_cast<mitk::FloatProperty*>
                              (diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
                              ->GetValue() );
           filter->Update();
           tensorImage = filter->GetOutput();
 
           QballFilterType::Pointer qballfilter = QballFilterType::New();
           qballfilter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>
                                          ( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
                                          ->GetGradientDirectionsContainer(),
                                          itkVectorImagePointer );
           qballfilter->SetBValue( static_cast<mitk::FloatProperty*>
                                   (diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
                                   ->GetValue() );
           qballfilter->SetLambda(0.006);
           qballfilter->SetNormalizationMethod(QballFilterType::QBAR_RAW_SIGNAL);
           qballfilter->Update();
           itkFeatureImage = qballfilter->GetCoefficientImage();
 
           itk::AdcImageFilter< short, double >::Pointer adcFilter = itk::AdcImageFilter< short, double >::New();
           adcFilter->SetInput( itkVectorImagePointer );
           adcFilter->SetGradientDirections( static_cast<mitk::GradientDirectionsProperty*>
                                             ( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
                                             ->GetGradientDirectionsContainer() );
           adcFilter->SetB_value( static_cast<mitk::FloatProperty*>
                                  (diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
                                  ->GetValue() );
           adcFilter->Update();
           adcImage = adcFilter->GetOutput();
         }
         ok = model->SampleKernels(diffImg, parameters.m_SignalGen.m_MaskImage, tensorImage, itkFeatureImage, adcImage);
         if (!ok)
           break;
       }
     }
 
     if (!ok)
     {
       QMessageBox::information( NULL, "Simulation cancelled", "No valid prototype signals could be sampled.");
       return;
     }
   }
   else if ( m_Controls->m_Compartment1Box->currentIndex()==3
             || m_Controls->m_Compartment3Box->currentIndex()==3
             || m_Controls->m_Compartment4Box->currentIndex()==4 )
   {
     QMessageBox::information( NULL, "Simulation cancelled",
                               "Prototype signal but no diffusion-weighted image selected to sample signal from.");
     return;
   }
 
   m_TractsToDwiFilter->SetParameters(parameters);
   m_TractsToDwiFilter->SetFiberBundle(fiberBundle);
   m_Thread.start(QThread::LowestPriority);
 }
 
 void QmitkFiberfoxView::ApplyTransform()
 {
   vector< mitk::DataNode::Pointer > selectedBundles;
   for(unsigned int i=0; i<m_SelectedImages.size(); i++ )
   {
     mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(m_SelectedImages.at(i));
     for( mitk::DataStorage::SetOfObjects::const_iterator it = derivations->begin(); it != derivations->end(); ++it )
     {
       mitk::DataNode::Pointer fibNode = *it;
       if ( fibNode.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(fibNode->GetData()) )
         selectedBundles.push_back(fibNode);
     }
   }
   if (selectedBundles.empty())
     selectedBundles = m_SelectedBundles2;
 
   if (!selectedBundles.empty())
   {
     for (std::vector<mitk::DataNode::Pointer>::const_iterator it = selectedBundles.begin(); it!=selectedBundles.end(); ++it)
     {
       mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>((*it)->GetData());
       fib->RotateAroundAxis(m_Controls->m_XrotBox->value(), m_Controls->m_YrotBox->value(), m_Controls->m_ZrotBox->value());
       fib->TranslateFibers(m_Controls->m_XtransBox->value(), m_Controls->m_YtransBox->value(), m_Controls->m_ZtransBox->value());
       fib->ScaleFibers(m_Controls->m_XscaleBox->value(), m_Controls->m_YscaleBox->value(), m_Controls->m_ZscaleBox->value());
 
       // handle child fiducials
       if (m_Controls->m_IncludeFiducials->isChecked())
       {
         mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(*it);
         for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
         {
           mitk::DataNode::Pointer fiducialNode = *it2;
           if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
           {
             mitk::PlanarEllipse* pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
             mitk::BaseGeometry* geom = pe->GetGeometry();
 
             // translate
             mitk::Vector3D world;
             world[0] = m_Controls->m_XtransBox->value();
             world[1] = m_Controls->m_YtransBox->value();
             world[2] = m_Controls->m_ZtransBox->value();
             geom->Translate(world);
 
             // calculate rotation matrix
             double x = m_Controls->m_XrotBox->value()*M_PI/180;
             double y = m_Controls->m_YrotBox->value()*M_PI/180;
             double z = m_Controls->m_ZrotBox->value()*M_PI/180;
 
             itk::Matrix< double, 3, 3 > rotX; rotX.SetIdentity();
             rotX[1][1] = cos(x);
             rotX[2][2] = rotX[1][1];
             rotX[1][2] = -sin(x);
             rotX[2][1] = -rotX[1][2];
 
             itk::Matrix< double, 3, 3 > rotY; rotY.SetIdentity();
             rotY[0][0] = cos(y);
             rotY[2][2] = rotY[0][0];
             rotY[0][2] = sin(y);
             rotY[2][0] = -rotY[0][2];
 
             itk::Matrix< double, 3, 3 > rotZ; rotZ.SetIdentity();
             rotZ[0][0] = cos(z);
             rotZ[1][1] = rotZ[0][0];
             rotZ[0][1] = -sin(z);
             rotZ[1][0] = -rotZ[0][1];
 
             itk::Matrix< double, 3, 3 > rot = rotZ*rotY*rotX;
 
             // transform control point coordinate into geometry translation
             geom->SetOrigin(pe->GetWorldControlPoint(0));
             mitk::Point2D cp; cp.Fill(0.0);
             pe->SetControlPoint(0, cp);
 
             // rotate fiducial
             geom->GetIndexToWorldTransform()->SetMatrix(rot*geom->GetIndexToWorldTransform()->GetMatrix());
 
             // implicit translation
             mitk::Vector3D trans;
             trans[0] = geom->GetOrigin()[0]-fib->GetGeometry()->GetCenter()[0];
             trans[1] = geom->GetOrigin()[1]-fib->GetGeometry()->GetCenter()[1];
             trans[2] = geom->GetOrigin()[2]-fib->GetGeometry()->GetCenter()[2];
             mitk::Vector3D newWc = rot*trans;
             newWc = newWc-trans;
             geom->Translate(newWc);
 
             pe->Modified();
           }
         }
       }
     }
   }
   else
   {
     for (unsigned int i=0; i<m_SelectedFiducials.size(); i++)
     {
       mitk::PlanarEllipse* pe = dynamic_cast<mitk::PlanarEllipse*>(m_SelectedFiducials.at(i)->GetData());
       mitk::BaseGeometry* geom = pe->GetGeometry();
 
       // translate
       mitk::Vector3D world;
       world[0] = m_Controls->m_XtransBox->value();
       world[1] = m_Controls->m_YtransBox->value();
       world[2] = m_Controls->m_ZtransBox->value();
       geom->Translate(world);
 
       // calculate rotation matrix
       double x = m_Controls->m_XrotBox->value()*M_PI/180;
       double y = m_Controls->m_YrotBox->value()*M_PI/180;
       double z = m_Controls->m_ZrotBox->value()*M_PI/180;
       itk::Matrix< double, 3, 3 > rotX; rotX.SetIdentity();
       rotX[1][1] = cos(x);
       rotX[2][2] = rotX[1][1];
       rotX[1][2] = -sin(x);
       rotX[2][1] = -rotX[1][2];
       itk::Matrix< double, 3, 3 > rotY; rotY.SetIdentity();
       rotY[0][0] = cos(y);
       rotY[2][2] = rotY[0][0];
       rotY[0][2] = sin(y);
       rotY[2][0] = -rotY[0][2];
       itk::Matrix< double, 3, 3 > rotZ; rotZ.SetIdentity();
       rotZ[0][0] = cos(z);
       rotZ[1][1] = rotZ[0][0];
       rotZ[0][1] = -sin(z);
       rotZ[1][0] = -rotZ[0][1];
       itk::Matrix< double, 3, 3 > rot = rotZ*rotY*rotX;
 
       // transform control point coordinate into geometry translation
       geom->SetOrigin(pe->GetWorldControlPoint(0));
       mitk::Point2D cp; cp.Fill(0.0);
       pe->SetControlPoint(0, cp);
 
       // rotate fiducial
       geom->GetIndexToWorldTransform()->SetMatrix(rot*geom->GetIndexToWorldTransform()->GetMatrix());
       pe->Modified();
     }
     if (m_Controls->m_RealTimeFibers->isChecked())
       GenerateFibers();
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::CopyBundles()
 {
   if ( m_SelectedBundles.size()<1 ){
     QMessageBox::information( NULL, "Warning", "Select at least one fiber bundle!");
     MITK_WARN("QmitkFiberFoxView") << "Select at least one fiber bundle!";
     return;
   }
 
   for (std::vector<mitk::DataNode::Pointer>::const_iterator it = m_SelectedBundles.begin(); it!=m_SelectedBundles.end(); ++it)
   {
     // find parent image
     mitk::DataNode::Pointer parentNode;
     mitk::DataStorage::SetOfObjects::ConstPointer parentImgs = GetDataStorage()->GetSources(*it);
     for( mitk::DataStorage::SetOfObjects::const_iterator it2 = parentImgs->begin(); it2 != parentImgs->end(); ++it2 )
     {
       mitk::DataNode::Pointer pImgNode = *it2;
       if ( pImgNode.IsNotNull() && dynamic_cast<mitk::Image*>(pImgNode->GetData()) )
       {
         parentNode = pImgNode;
         break;
       }
     }
 
     mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>((*it)->GetData());
     mitk::FiberBundle::Pointer newBundle = fib->GetDeepCopy();
     QString name((*it)->GetName().c_str());
     name += "_copy";
 
     mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
     fbNode->SetData(newBundle);
     fbNode->SetName(name.toStdString());
     fbNode->SetVisibility(true);
     if (parentNode.IsNotNull())
       GetDataStorage()->Add(fbNode, parentNode);
     else
       GetDataStorage()->Add(fbNode);
 
     // copy child fiducials
     if (m_Controls->m_IncludeFiducials->isChecked())
     {
       mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(*it);
       for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
       {
         mitk::DataNode::Pointer fiducialNode = *it2;
         if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
         {
           mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData())->Clone();
           mitk::DataNode::Pointer newNode = mitk::DataNode::New();
           newNode->SetData(pe);
           newNode->SetName(fiducialNode->GetName());
           newNode->SetBoolProperty("planarfigure.3drendering", true);
           GetDataStorage()->Add(newNode, fbNode);
 
         }
       }
     }
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::JoinBundles()
 {
   if ( m_SelectedBundles.size()<2 ){
     QMessageBox::information( NULL, "Warning", "Select at least two fiber bundles!");
     MITK_WARN("QmitkFiberFoxView") << "Select at least two fiber bundles!";
     return;
   }
 
   std::vector<mitk::DataNode::Pointer>::const_iterator it = m_SelectedBundles.begin();
   mitk::FiberBundle::Pointer newBundle = dynamic_cast<mitk::FiberBundle*>((*it)->GetData());
   QString name("");
   name += QString((*it)->GetName().c_str());
   ++it;
   for (; it!=m_SelectedBundles.end(); ++it)
   {
     newBundle = newBundle->AddBundle(dynamic_cast<mitk::FiberBundle*>((*it)->GetData()));
     name += "+"+QString((*it)->GetName().c_str());
   }
 
   mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
   fbNode->SetData(newBundle);
   fbNode->SetName(name.toStdString());
   fbNode->SetVisibility(true);
   GetDataStorage()->Add(fbNode);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::UpdateGui()
 {
   m_Controls->m_GeometryFrame->setEnabled(true);
   m_Controls->m_GeometryMessage->setVisible(false);
   m_Controls->m_DiffusionPropsMessage->setVisible(false);
   m_Controls->m_FiberGenMessage->setVisible(true);
 
   m_Controls->m_TransformBundlesButton->setEnabled(false);
   m_Controls->m_CopyBundlesButton->setEnabled(false);
   m_Controls->m_GenerateFibersButton->setEnabled(false);
   m_Controls->m_FlipButton->setEnabled(false);
   m_Controls->m_CircleButton->setEnabled(false);
   m_Controls->m_BvalueBox->setEnabled(true);
   m_Controls->m_NumGradientsBox->setEnabled(true);
   m_Controls->m_JoinBundlesButton->setEnabled(false);
   m_Controls->m_AlignOnGrid->setEnabled(false);
 
   // Fiber generation gui
   if (m_SelectedFiducial.IsNotNull())
   {
     m_Controls->m_TransformBundlesButton->setEnabled(true);
     m_Controls->m_FlipButton->setEnabled(true);
     m_Controls->m_AlignOnGrid->setEnabled(true);
   }
 
   if (m_SelectedImageNode.IsNotNull() || !m_SelectedBundles.empty())
   {
     m_Controls->m_CircleButton->setEnabled(true);
     m_Controls->m_FiberGenMessage->setVisible(false);
   }
   if (m_SelectedImageNode.IsNotNull() && !m_SelectedBundles.empty())
     m_Controls->m_AlignOnGrid->setEnabled(true);
 
   if (!m_SelectedBundles.empty())
   {
     m_Controls->m_TransformBundlesButton->setEnabled(true);
     m_Controls->m_CopyBundlesButton->setEnabled(true);
     m_Controls->m_GenerateFibersButton->setEnabled(true);
 
     if (m_SelectedBundles.size()>1)
       m_Controls->m_JoinBundlesButton->setEnabled(true);
   }
 
   // Signal generation gui
   if (m_Controls->m_MaskComboBox->GetSelectedNode().IsNotNull() || m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull())
   {
     m_Controls->m_GeometryMessage->setVisible(true);
     m_Controls->m_GeometryFrame->setEnabled(false);
   }
 
   if ( m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull()
        && mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(
          dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData()) ) )
   {
     m_Controls->m_DiffusionPropsMessage->setVisible(true);
     m_Controls->m_BvalueBox->setEnabled(false);
     m_Controls->m_NumGradientsBox->setEnabled(false);
     m_Controls->m_GeometryMessage->setVisible(true);
     m_Controls->m_GeometryFrame->setEnabled(false);
   }
 }
 
-void QmitkFiberfoxView::OnSelectionChanged( berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes )
+void QmitkFiberfoxView::OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes)
 {
   m_SelectedBundles2.clear();
   m_SelectedImages.clear();
   m_SelectedFiducials.clear();
   m_SelectedFiducial = NULL;
   m_SelectedBundles.clear();
   m_SelectedImageNode = NULL;
 
   // iterate all selected objects, adjust warning visibility
   for( int i=0; i<nodes.size(); i++)
   {
     mitk::DataNode::Pointer node = nodes.at(i);
 
     if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
     {
       m_SelectedImages.push_back(node);
       m_SelectedImageNode = node;
     }
     else if ( node.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(node->GetData()) )
     {
       m_SelectedBundles2.push_back(node);
       if (m_Controls->m_RealTimeFibers->isChecked())
       {
         m_SelectedBundles.push_back(node);
         mitk::FiberBundle::Pointer newFib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
         if (newFib->GetNumFibers()!=m_Controls->m_FiberDensityBox->value())
           GenerateFibers();
       }
       else
         m_SelectedBundles.push_back(node);
     }
     else if ( node.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(node->GetData()) )
     {
       m_SelectedFiducials.push_back(node);
       m_SelectedFiducial = node;
       m_SelectedBundles.clear();
       mitk::DataStorage::SetOfObjects::ConstPointer parents = GetDataStorage()->GetSources(node);
       for( mitk::DataStorage::SetOfObjects::const_iterator it = parents->begin(); it != parents->end(); ++it )
       {
         mitk::DataNode::Pointer pNode = *it;
         if ( pNode.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(pNode->GetData()) )
           m_SelectedBundles.push_back(pNode);
       }
     }
   }
   UpdateGui();
 }
 
 
 void QmitkFiberfoxView::EnableCrosshairNavigation()
 {
   if (m_Controls->m_RealTimeFibers->isChecked())
     GenerateFibers();
 }
 
 void QmitkFiberfoxView::DisableCrosshairNavigation()
 {
 }
 
 void QmitkFiberfoxView::NodeRemoved(const mitk::DataNode* node)
 {
   mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
   std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(nonConstNode);
 
   if (dynamic_cast<FiberBundle*>(node->GetData()))
   {
     m_SelectedBundles.clear();
     m_SelectedBundles2.clear();
   }
   else if (dynamic_cast<Image*>(node->GetData()))
     m_SelectedImages.clear();
 
   if( it != m_DataNodeToPlanarFigureData.end() )
   {
     QmitkPlanarFigureData& data = it->second;
 
     // remove observers
     data.m_Figure->RemoveObserver( data.m_EndPlacementObserverTag );
     data.m_Figure->RemoveObserver( data.m_SelectObserverTag );
     data.m_Figure->RemoveObserver( data.m_StartInteractionObserverTag );
     data.m_Figure->RemoveObserver( data.m_EndInteractionObserverTag );
 
     m_DataNodeToPlanarFigureData.erase( it );
   }
 }
 
 void QmitkFiberfoxView::NodeAdded( const mitk::DataNode* node )
 {
   // add observer for selection in renderwindow
   mitk::PlanarFigure* figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
   bool isPositionMarker (false);
   node->GetBoolProperty("isContourMarker", isPositionMarker);
   if( figure && !isPositionMarker )
   {
     MITK_DEBUG << "figure added. will add interactor if needed.";
     mitk::PlanarFigureInteractor::Pointer figureInteractor
         = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
 
     mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>( node );
     if(figureInteractor.IsNull())
     {
       figureInteractor = mitk::PlanarFigureInteractor::New();
       us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
       figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
       figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
       figureInteractor->SetDataNode( nonConstNode );
     }
 
     MITK_DEBUG << "will now add observers for planarfigure";
     QmitkPlanarFigureData data;
     data.m_Figure = figure;
 
     //        // add observer for event when figure has been placed
     typedef itk::SimpleMemberCommand< QmitkFiberfoxView > SimpleCommandType;
     //        SimpleCommandType::Pointer initializationCommand = SimpleCommandType::New();
     //        initializationCommand->SetCallbackFunction( this, &QmitkFiberfoxView::PlanarFigureInitialized );
     //        data.m_EndPlacementObserverTag = figure->AddObserver( mitk::EndPlacementPlanarFigureEvent(), initializationCommand );
 
     // add observer for event when figure is picked (selected)
     typedef itk::MemberCommand< QmitkFiberfoxView > MemberCommandType;
     MemberCommandType::Pointer selectCommand = MemberCommandType::New();
     selectCommand->SetCallbackFunction( this, &QmitkFiberfoxView::PlanarFigureSelected );
     data.m_SelectObserverTag = figure->AddObserver( mitk::SelectPlanarFigureEvent(), selectCommand );
 
     // add observer for event when interaction with figure starts
     SimpleCommandType::Pointer startInteractionCommand = SimpleCommandType::New();
     startInteractionCommand->SetCallbackFunction( this, &QmitkFiberfoxView::DisableCrosshairNavigation);
     data.m_StartInteractionObserverTag = figure->AddObserver( mitk::StartInteractionPlanarFigureEvent(), startInteractionCommand );
 
     // add observer for event when interaction with figure starts
     SimpleCommandType::Pointer endInteractionCommand = SimpleCommandType::New();
     endInteractionCommand->SetCallbackFunction( this, &QmitkFiberfoxView::EnableCrosshairNavigation);
     data.m_EndInteractionObserverTag = figure->AddObserver( mitk::EndInteractionPlanarFigureEvent(), endInteractionCommand );
 
     m_DataNodeToPlanarFigureData[nonConstNode] = data;
   }
 }
 
 void QmitkFiberfoxView::PlanarFigureSelected( itk::Object* object, const itk::EventObject& )
 {
   mitk::TNodePredicateDataType<mitk::PlanarFigure>::Pointer isPf = mitk::TNodePredicateDataType<mitk::PlanarFigure>::New();
 
   mitk::DataStorage::SetOfObjects::ConstPointer allPfs = this->GetDataStorage()->GetSubset( isPf );
   for ( mitk::DataStorage::SetOfObjects::const_iterator it = allPfs->begin(); it!=allPfs->end(); ++it)
   {
     mitk::DataNode* node = *it;
 
     if( node->GetData() == object )
     {
       node->SetSelected(true);
       m_SelectedFiducial = node;
     }
     else
       node->SetSelected(false);
   }
   UpdateGui();
   this->RequestRenderWindowUpdate();
 }
 
 void QmitkFiberfoxView::SetFocus()
 {
   m_Controls->m_CircleButton->setFocus();
 }
 
 
 void QmitkFiberfoxView::SetOutputPath()
 {
   // SELECT FOLDER DIALOG
 
   string outputPath = QFileDialog::getExistingDirectory(NULL, "Save images to...", QString(outputPath.c_str())).toStdString();
 
   if (outputPath.empty())
     m_Controls->m_SavePathEdit->setText("-");
   else
   {
     outputPath += "/";
     m_Controls->m_SavePathEdit->setText(QString(outputPath.c_str()));
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h
index fa3f2f52eb..4ca661ae96 100755
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h
@@ -1,217 +1,215 @@
 /*===================================================================
 
 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 <berryISelectionListener.h>
 #include <berryIStructuredSelection.h>
 
 #include <QmitkAbstractView.h>
 #include "ui_QmitkFiberfoxViewControls.h"
 #include <itkVectorImage.h>
 #include <itkVectorContainer.h>
 #include <itkOrientationDistributionFunction.h>
 
 #ifndef Q_MOC_RUN
 #include <mitkFiberBundle.h>
 #include <mitkPlanarEllipse.h>
 #include <mitkDiffusionNoiseModel.h>
 #include <mitkDiffusionSignalModel.h>
 #include <mitkRicianNoiseModel.h>
 #include <itkTractsToDWIImageFilter.h>
 #include <mitkTensorModel.h>
 #include <mitkBallModel.h>
 #include <mitkStickModel.h>
 #include <mitkAstroStickModel.h>
 #include <mitkDotModel.h>
 #include <mitkFiberfoxParameters.h>
 #include <itkStatisticsImageFilter.h>
 #include <mitkDiffusionPropertyHelper.h>
 #endif
 
 #include <QThread>
 #include <QObject>
 #include <QTimer>
 #include <QTime>
 
 /*!
 \brief View for fiber based diffusion software phantoms (Fiberfox). See "Fiberfox: Facilitating the creation of realistic white matter software phantoms" (DOI: 10.1002/mrm.25045) for details.
-\sa QmitkFunctionality
-\ingroup Functionalities
 */
 
 // Forward Qt class declarations
 
 using namespace std;
 
 class QmitkFiberfoxView;
 
 class QmitkFiberfoxWorker : public QObject
 {
     Q_OBJECT
 
 public:
 
     QmitkFiberfoxWorker(QmitkFiberfoxView* view);
 
 public slots:
 
     void run();
 
 private:
 
     QmitkFiberfoxView*                  m_View;
 };
 
 class QmitkFiberfoxView : public QmitkAbstractView
 {
 
     // 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:
 
     static const string VIEW_ID;
 
     QmitkFiberfoxView();
     virtual ~QmitkFiberfoxView();
 
     virtual void CreateQtPartControl(QWidget *parent) override;
     void SetFocus() override;
 
     typedef mitk::DiffusionPropertyHelper::GradientDirectionType            GradientDirectionType;
     typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType  GradientDirectionContainerType;
     typedef itk::Vector<double,3>           GradientType;
     typedef vector<GradientType>            GradientListType;
     typedef itk::VectorImage< short, 3 >    ItkDwiType;
     typedef itk::Image<double, 3>           ItkDoubleImgType;
     typedef itk::Image<float, 3>            ItkFloatImgType;
     typedef itk::Image<unsigned char, 3>    ItkUcharImgType;
 
     template<int ndirs> vector<itk::Vector<double,3> > MakeGradientList();
 
 protected slots:
 
     void SetOutputPath();           ///< path where image is automatically saved to after the simulation is finished
     void LoadParameters();          ///< load fiberfox parameters
     void SaveParameters();          ///< save fiberfox parameters
 
     void BeforeThread();
     void AfterThread();
     void KillThread();              ///< abort simulation
     void UpdateSimulationStatus();  ///< print simulation progress and satus messages
 
     void OnDrawROI();               ///< adds new ROI, handles interactors etc.
     void OnAddBundle();             ///< adds new fiber bundle to datastorage
     void OnFlipButton();            ///< negate one coordinate of the fiber waypoints in the selcted planar figure. needed in case of unresolvable twists
     void GenerateFibers();          ///< generate fibers from the selected ROIs
     void GenerateImage();           ///< start image simulation
     void JoinBundles();             ///< merges selcted fiber bundles into one
     void CopyBundles();             ///< add copy of the selected bundle to the datamanager
     void ApplyTransform();          ///< rotate and shift selected bundles
     void AlignOnGrid();             ///< shift selected fiducials to nearest voxel center
     void Comp1ModelFrameVisibility(int index);  ///< only show parameters of selected signal model for compartment 1
     void Comp2ModelFrameVisibility(int index);  ///< only show parameters of selected signal model for compartment 2
     void Comp3ModelFrameVisibility(int index);  ///< only show parameters of selected signal model for compartment 3
     void Comp4ModelFrameVisibility(int index);  ///< only show parameters of selected signal model for compartment 4
     void ShowAdvancedOptions(int state);
 
     /** update fibers if any parameter changes */
     void OnFiberDensityChanged(int value);
     void OnFiberSamplingChanged(double value);
     void OnTensionChanged(double value);
     void OnContinuityChanged(double value);
     void OnBiasChanged(double value);
     void OnVarianceChanged(double value);
     void OnDistributionChanged(int value);
     void OnConstantRadius(int value);
 
     /** update GUI elements */
     void OnAddNoise(int value);
     void OnAddGhosts(int value);
     void OnAddDistortions(int value);
     void OnAddEddy(int value);
     void OnAddSpikes(int value);
     void OnAddAliasing(int value);
     void OnAddMotion(int value);
     void OnMaskSelected(int value);
     void OnFibSelected(int value);
     void OnTemplateSelected(int value);
 
 protected:
 
-    /// \brief called by QmitkFunctionality when DataManager's selection has changed
-    virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>&) override;
+    /// \brief called by QmitkAbstractView when DataManager's selection has changed
+    virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
     GradientListType GenerateHalfShell(int NPoints);    ///< generate vectors distributed over the halfsphere
 
     Ui::QmitkFiberfoxViewControls* m_Controls;
 
     void SimulateForExistingDwi(mitk::DataNode* imageNode);     ///< add artifacts to existing diffusion weighted image
     void SimulateImageFromFibers(mitk::DataNode* fiberNode);    ///< simulate new diffusion weighted image
     template< class ScalarType > FiberfoxParameters< ScalarType > UpdateImageParameters(bool all=true);  ///< update fiberfox paramater object (template parameter defines noise model type)
     void UpdateGui();                                           ///< enable/disbale buttons etc. according to current datamanager selection
     void PlanarFigureSelected( itk::Object* object, const itk::EventObject& );
     void EnableCrosshairNavigation();               ///< enable crosshair navigation if planar figure interaction ends
     void DisableCrosshairNavigation();              ///< disable crosshair navigation if planar figure interaction starts
     void NodeAdded( const mitk::DataNode* node ) override;   ///< add observers
     void NodeRemoved(const mitk::DataNode* node) override;   ///< remove observers
     void SaveParameters(QString filename);
 
     /** structure to keep track of planar figures and observers */
     struct QmitkPlanarFigureData
     {
         QmitkPlanarFigureData()
             : m_Figure(0)
             , m_EndPlacementObserverTag(0)
             , m_SelectObserverTag(0)
             , m_StartInteractionObserverTag(0)
             , m_EndInteractionObserverTag(0)
             , m_Flipped(0)
         {
         }
         mitk::PlanarFigure* m_Figure;
         unsigned int m_EndPlacementObserverTag;
         unsigned int m_SelectObserverTag;
         unsigned int m_StartInteractionObserverTag;
         unsigned int m_EndInteractionObserverTag;
         unsigned int m_Flipped;
     };
 
     std::map<mitk::DataNode*, QmitkPlanarFigureData>    m_DataNodeToPlanarFigureData;   ///< map each planar figure uniquely to a QmitkPlanarFigureData
     mitk::DataNode::Pointer                             m_SelectedFiducial;             ///< selected planar ellipse
     mitk::DataNode::Pointer                             m_SelectedImageNode;
     vector< mitk::DataNode::Pointer >                   m_SelectedBundles;
     vector< mitk::DataNode::Pointer >                   m_SelectedBundles2;
     vector< mitk::DataNode::Pointer >                   m_SelectedFiducials;
     vector< mitk::DataNode::Pointer >                   m_SelectedImages;
 
     QString m_ParameterFile;    ///< parameter file name
 
     // GUI thread
     QmitkFiberfoxWorker     m_Worker;   ///< runs filter
     QThread                 m_Thread;   ///< worker thread
     bool                    m_ThreadIsRunning;
     QTimer*                 m_SimulationTimer;
     QTime                   m_SimulationTime;
     QString                 m_SimulationStatusText;
 
     /** Image filters that do all the simulations. */
     itk::TractsToDWIImageFilter< short >::Pointer           m_TractsToDwiFilter;
 
     friend class QmitkFiberfoxWorker;
 };
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFieldmapGeneratorView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFieldmapGeneratorView.cpp
index 36cc39d848..359a34e83f 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFieldmapGeneratorView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFieldmapGeneratorView.cpp
@@ -1,299 +1,298 @@
 /*===================================================================
 
 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>
 
 // MITK
 #include "QmitkFieldmapGeneratorView.h"
-#include <QmitkStdMultiWidget.h>
 #include <QmitkDataStorageComboBox.h>
 #include <mitkNodePredicateDataType.h>
 #include <itkFieldmapGeneratorFilter.h>
 #include <mitkImage.h>
+#include <mitkSliceNavigationController.h>
+#include <QmitkRenderWindow.h>
 
 const std::string QmitkFieldmapGeneratorView::VIEW_ID = "org.mitk.views.fieldmapgenerator";
 
 QmitkFieldmapGeneratorView::QmitkFieldmapGeneratorView()
-    : QmitkFunctionality()
+    : QmitkAbstractView()
     , m_Controls( 0 )
-    , m_MultiWidget( NULL )
 {
 
 }
 
 QmitkFieldmapGeneratorView::~QmitkFieldmapGeneratorView()
 {
 
 }
 
 void QmitkFieldmapGeneratorView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkFieldmapGeneratorViewControls;
         m_Controls->setupUi( parent );
 
         m_Controls->m_SelectedImageBox->SetDataStorage(this->GetDataStorage());
         mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
         m_Controls->m_SelectedImageBox->SetPredicate(isMitkImage);
 
         connect((QObject*) m_Controls->m_GenerateFieldmap, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateFieldmap()));
         connect((QObject*) m_Controls->m_PlaceFieldSource, SIGNAL(clicked()), (QObject*) this, SLOT(PlaceFieldSource()));
         connect((QObject*) m_Controls->m_SourceVarianceBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnVarianceChanged(double)));
         connect((QObject*) m_Controls->m_SourceHeightBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnHeightChanged(double)));
 
     }
 }
 
+void QmitkFieldmapGeneratorView::SetFocus()
+{
+  m_Controls->m_SelectedImageBox->setFocus();
+}
+
 void QmitkFieldmapGeneratorView::OnVarianceChanged(double value)
 {
     if (m_SelectedSource.IsNotNull())
     {
         m_SelectedSource->SetProperty("pointsize", mitk::FloatProperty::New(value));
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 }
 
 void QmitkFieldmapGeneratorView::OnHeightChanged(double value)
 {
     if (m_SelectedSource.IsNotNull())
     {
         m_SelectedSource->SetProperty("color", mitk::ColorProperty::New(0, 0, value/100.0));
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 }
 
 void QmitkFieldmapGeneratorView::PlaceFieldSource()
 {
-    if (m_Controls->m_SelectedImageBox->GetSelectedNode().IsNull() || !m_MultiWidget)
+    if (m_Controls->m_SelectedImageBox->GetSelectedNode().IsNull() || !this->GetRenderWindowPart())
     {
         m_Controls->m_WorldPosLabel->setText("-");
         m_Controls->m_IndexLabel->setText("-");
         return;
     }
 
     mitk::Point3D index;
     mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_Controls->m_SelectedImageBox->GetSelectedNode()->GetData());
     mitk::BaseGeometry* geom = img->GetGeometry();
 
     if ( geom->IsInside(m_WorldPoint) )
     {
         img->GetGeometry()->WorldToIndex(m_WorldPoint, index);
         mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
         pointSet->InsertPoint(0, m_WorldPoint);
 
 
         mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_Controls->m_SelectedImageBox->GetSelectedNode());
 
         mitk::DataNode::Pointer node = mitk::DataNode::New();
         node->SetData(pointSet);
         QString name = QString("FieldSource_%1").arg(children->size());
         node->SetName(name.toStdString());
         node->SetVisibility(true);
 
         float minSpacing;
         if(geom->GetSpacing()[0]<geom->GetSpacing()[1] && geom->GetSpacing()[0]<geom->GetSpacing()[2])
             minSpacing = geom->GetSpacing()[0];
         else if (geom->GetSpacing()[1] < geom->GetSpacing()[2])
             minSpacing = geom->GetSpacing()[1];
         else
             minSpacing = geom->GetSpacing()[2];
 
         node->SetProperty("pointsize", mitk::FloatProperty::New(minSpacing*5));
         node->SetProperty("color", mitk::ColorProperty::New(0, 0, 1));
 
         GetDataStorage()->Add(node, m_Controls->m_SelectedImageBox->GetSelectedNode());
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 }
 
 void QmitkFieldmapGeneratorView::GenerateFieldmap()
 {
     if (m_Controls->m_SelectedImageBox->GetSelectedNode().IsNull())
         return;
 
     mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_Controls->m_SelectedImageBox->GetSelectedNode()->GetData());
     mitk::BaseGeometry* geom = img->GetGeometry();
 
     typedef itk::Image< double, 3 > FieldMapType;
     itk::Vector<double>                 spacing;              ///< output image spacing
     mitk::Point3D                       origin;               ///< output image origin
     itk::FieldmapGeneratorFilter< FieldMapType >::MatrixType                directionMatrix;      ///< output image rotation
     itk::FieldmapGeneratorFilter< FieldMapType >::OutputImageRegionType     imageRegion;          ///< output image size
 
     spacing = geom->GetSpacing();
     origin = geom->GetOrigin();
     imageRegion.SetSize(0, img->GetDimension(0));
     imageRegion.SetSize(1, img->GetDimension(1));
     imageRegion.SetSize(2, img->GetDimension(2));
     for (int r=0; r<3; r++)
         for (int c=0; c<3; c++)
             directionMatrix[r][c]=geom->GetMatrixColumn(c)[r]/spacing[c];
 
     std::vector< double >               variances;
     std::vector< double >               heights;
     std::vector< mitk::Point3D >        worldPositions;
 
     mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_Controls->m_SelectedImageBox->GetSelectedNode());
     for( mitk::DataStorage::SetOfObjects::const_iterator it = children->begin(); it != children->end(); ++it )
         if(dynamic_cast<mitk::PointSet*>((*it)->GetData()))
         {
             float var = 0; (*it)->GetPropertyValue("pointsize", var); variances.push_back(var);
             float color[3]; (*it)->GetColor(color); heights.push_back(color[2]*100);
             mitk::PointSet* ps = dynamic_cast<mitk::PointSet*>((*it)->GetData());
             mitk::Point3D point;
             ps->GetPointIfExists(0, &point);
             worldPositions.push_back(point);
         }
 
     vnl_vector_fixed< double, 3 > gradient, offset;
     gradient[0] = m_Controls->m_xGradientBox->value();
     gradient[1] = m_Controls->m_yGradientBox->value();
     gradient[2] = m_Controls->m_zGradientBox->value();
     offset[0] = m_Controls->m_xOffsetBox->value();
     offset[1] = m_Controls->m_yOffsetBox->value();
     offset[2] = m_Controls->m_zOffsetBox->value();
 
     itk::FieldmapGeneratorFilter< FieldMapType >::Pointer filter = itk::FieldmapGeneratorFilter< FieldMapType >::New();
     filter->SetHeights(heights);
     filter->SetVariances(variances);
     filter->SetWorldPositions(worldPositions);
     filter->SetSpacing(spacing);
     filter->SetOrigin(origin);
     filter->SetDirectionMatrix(directionMatrix);
     filter->SetImageRegion(imageRegion);
     filter->SetGradient(gradient);
     filter->SetOffset(offset);
     filter->Update();
 
     mitk::DataNode::Pointer resultNode = mitk::DataNode::New();
     mitk::Image::Pointer image = mitk::Image::New();
     image->InitializeByItk(filter->GetOutput(0));
     image->SetVolume(filter->GetOutput(0)->GetBufferPointer());
     resultNode->SetData( image );
     resultNode->SetName(m_Controls->m_SelectedImageBox->GetSelectedNode()->GetName()+"_Fieldmap");
     GetDataStorage()->Add(resultNode);
 }
 
-void QmitkFieldmapGeneratorView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
+void QmitkFieldmapGeneratorView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
-    m_MultiWidget = &stdMultiWidget;
-
     {
-        mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
+        mitk::SliceNavigationController* slicer = renderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController();
         itk::ReceptorMemberCommand<QmitkFieldmapGeneratorView>::Pointer command = itk::ReceptorMemberCommand<QmitkFieldmapGeneratorView>::New();
         command->SetCallbackFunction( this, &QmitkFieldmapGeneratorView::OnSliceChanged );
         m_SliceObserverTag1 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
     }
 
     {
-        mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
+        mitk::SliceNavigationController* slicer = renderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController();
         itk::ReceptorMemberCommand<QmitkFieldmapGeneratorView>::Pointer command = itk::ReceptorMemberCommand<QmitkFieldmapGeneratorView>::New();
         command->SetCallbackFunction( this, &QmitkFieldmapGeneratorView::OnSliceChanged );
         m_SliceObserverTag2 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
     }
 
     {
-        mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
+        mitk::SliceNavigationController* slicer = renderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController();
         itk::ReceptorMemberCommand<QmitkFieldmapGeneratorView>::Pointer command = itk::ReceptorMemberCommand<QmitkFieldmapGeneratorView>::New();
         command->SetCallbackFunction( this, &QmitkFieldmapGeneratorView::OnSliceChanged );
         m_SliceObserverTag3 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
     }
 }
 
-void QmitkFieldmapGeneratorView::StdMultiWidgetNotAvailable()
+void QmitkFieldmapGeneratorView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart)
 {
 
     {
-        mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
+        mitk::SliceNavigationController* slicer = renderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController();
         slicer->RemoveObserver( m_SliceObserverTag1 );
     }
 
     {
-        mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
+        mitk::SliceNavigationController* slicer = renderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController();
         slicer->RemoveObserver( m_SliceObserverTag2 );
     }
 
     {
-        mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
+        mitk::SliceNavigationController* slicer = renderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController();
         slicer->RemoveObserver( m_SliceObserverTag3 );
     }
-
-    m_MultiWidget = NULL;
 }
 
-void QmitkFieldmapGeneratorView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
+void QmitkFieldmapGeneratorView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
     if (m_Controls->m_SelectedImageBox->GetSelectedNode().IsNotNull())
         m_Controls->m_SelectedImageBox->GetSelectedNode()->RemoveObserver( m_PropertyObserverTag );
 
     m_Controls->m_InputData->setTitle("Please Select Reference Image");
     m_SelectedSource = NULL;
 
     // iterate selection
-    for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
+    for (mitk::DataNode::Pointer node: nodes)
     {
-        mitk::DataNode::Pointer node = *it;
-
         if ( node.IsNotNull() && (dynamic_cast<mitk::PointSet*>(node->GetData())) )
         {
             m_Controls->m_SourceNameLabel->setText(node->GetName().c_str());
             m_SelectedSource = node;
             float variance = 0; node->GetPropertyValue("pointsize", variance);
             m_Controls->m_SourceVarianceBox->setValue(variance);
 
             float color[3]; node->GetColor(color);
             m_Controls->m_SourceHeightBox->setValue(color[2]*100);
         }
     }
 
     if (m_Controls->m_SelectedImageBox->GetSelectedNode().IsNotNull())
     {
         itk::ReceptorMemberCommand<QmitkFieldmapGeneratorView>::Pointer command = itk::ReceptorMemberCommand<QmitkFieldmapGeneratorView>::New();
         command->SetCallbackFunction( this, &QmitkFieldmapGeneratorView::OnSliceChanged );
         m_PropertyObserverTag = m_Controls->m_SelectedImageBox->GetSelectedNode()->AddObserver( itk::ModifiedEvent(), command );
 
         m_Controls->m_InputData->setTitle("Reference Image");
     }
 }
 
 void QmitkFieldmapGeneratorView::OnSliceChanged(const itk::EventObject& /*e*/)
 {
-    if (m_Controls->m_SelectedImageBox->GetSelectedNode().IsNull() || !m_MultiWidget)
+    if (m_Controls->m_SelectedImageBox->GetSelectedNode().IsNull() || !this->GetRenderWindowPart())
     {
         m_Controls->m_WorldPosLabel->setText("-");
         m_Controls->m_IndexLabel->setText("-");
         return;
     }
 
-    m_WorldPoint = m_MultiWidget->GetCrossPosition();
+    m_WorldPoint = this->GetRenderWindowPart()->GetSelectedPosition();
     QString posSting = QString::number(m_WorldPoint[0]); posSting += ", "; posSting += QString::number(m_WorldPoint[1]); posSting += ", "; posSting += QString::number(m_WorldPoint[2]);
     m_Controls->m_WorldPosLabel->setText(posSting.toStdString().c_str());
 
     mitk::Point3D index;
     mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_Controls->m_SelectedImageBox->GetSelectedNode()->GetData());
 
     if ( m_Controls->m_SelectedImageBox->GetSelectedNode()->GetData()->GetGeometry()->IsInside(m_WorldPoint) )
     {
         img->GetGeometry()->WorldToIndex(m_WorldPoint, index);
         posSting = QString::number(index[0]); posSting += ", "; posSting += QString::number(index[1]); posSting += ", "; posSting += QString::number(index[2]);
          m_Controls->m_IndexLabel->setText(posSting.toStdString().c_str());
     }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFieldmapGeneratorView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFieldmapGeneratorView.h
index 233e40f792..2bf1c6f532 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFieldmapGeneratorView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFieldmapGeneratorView.h
@@ -1,82 +1,84 @@
 /*===================================================================
 
 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 _QMITKQmitkFieldmapGeneratorView_H_INCLUDED
 #define _QMITKQmitkFieldmapGeneratorView_H_INCLUDED
 
 #include <berryISelectionListener.h>
-#include <QmitkFunctionality.h>
+#include <QmitkAbstractView.h>
+#include <mitkIRenderWindowPartListener.h>
 #include "ui_QmitkFieldmapGeneratorViewControls.h"
 #include <mitkPointSet.h>
 #include <itkImage.h>
 
 /*!
   \brief Generate float image with artificial frequency maps used by Fiberfox. Simulates additional frequencies at (possibly multiple) positions based on 3D gaussians with the specified variance and amplitude and/or as a linear gradient in the image.
 * See "Fiberfox: Facilitating the creation of realistic white matter software phantoms" (DOI: 10.1002/mrm.25045) for details.
-
-  \sa QmitkFunctionality
-  \ingroup Functionalities
 */
 
-class QmitkFieldmapGeneratorView : public QmitkFunctionality
+class QmitkFieldmapGeneratorView : 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:
 
     static const std::string VIEW_ID;
 
     QmitkFieldmapGeneratorView();
     virtual ~QmitkFieldmapGeneratorView();
 
     virtual void CreateQtPartControl(QWidget *parent) override;
 
-    virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget) override;
-    virtual void StdMultiWidgetNotAvailable() override;
+    ///
+    /// Sets the focus to an internal widget.
+    ///
+    virtual void SetFocus() override;
+
+    virtual void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart) override;
+    virtual void RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart) override;
 
     void OnSliceChanged(const itk::EventObject& e);
 
 protected slots:
 
     void GenerateFieldmap();
     void PlaceFieldSource();
     void OnVarianceChanged(double value);
     void OnHeightChanged(double value);
 
 protected:
 
-    /// \brief called by QmitkFunctionality when DataManager's selection has changed
-    virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes ) override;
+    /// \brief called by QmitkAbstractView when DataManager's selection has changed
+    virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
     Ui::QmitkFieldmapGeneratorViewControls* m_Controls;
-    QmitkStdMultiWidget*                    m_MultiWidget;
 
     /** observer flags */
     int m_SliceObserverTag1;
     int m_SliceObserverTag2;
     int m_SliceObserverTag3;
     int m_PropertyObserverTag;
 
     mitk::Point3D               m_WorldPoint;
     mitk::DataNode::Pointer     m_SelectedSource;
 };
 
 
 
 #endif // _QmitkFieldmapGeneratorView_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.cpp
index b4234588dd..68aeb52ba3 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.cpp
@@ -1,648 +1,636 @@
 /*===================================================================
 
 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>
 
 // Qmitk
 #include "QmitkGibbsTrackingView.h"
-#include <QmitkStdMultiWidget.h>
 
 // Qt
 #include <QMessageBox>
 #include <QFileDialog>
 #include <QDir>
+#include <QTimer>
 
 // MITK
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkProgressBar.h>
 #include <mitkIOUtil.h>
 
 // ITK
 #include <itkGibbsTrackingFilter.h>
 #include <itkResampleImageFilter.h>
 #include <itksys/SystemTools.hxx>
 
 // MISC
 #include <tinyxml.h>
 
 
 
 
 QmitkTrackingWorker::QmitkTrackingWorker(QmitkGibbsTrackingView* view)
     : m_View(view)
 {
 }
 
 void QmitkTrackingWorker::run()
 {
     m_View->m_GlobalTracker = QmitkGibbsTrackingView::GibbsTrackingFilterType::New();
 
     m_View->m_GlobalTracker->SetQBallImage(m_View->m_ItkQBallImage);
     m_View->m_GlobalTracker->SetTensorImage(m_View->m_ItkTensorImage);
     m_View->m_GlobalTracker->SetMaskImage(m_View->m_MaskImage);
     m_View->m_GlobalTracker->SetStartTemperature((float)m_View->m_Controls->m_StartTempSlider->value()/100);
     m_View->m_GlobalTracker->SetEndTemperature((float)m_View->m_Controls->m_EndTempSlider->value()/10000);
     m_View->m_GlobalTracker->SetIterations(m_View->m_Controls->m_IterationsBox->text().toDouble());
     m_View->m_GlobalTracker->SetParticleWeight((float)m_View->m_Controls->m_ParticleWeightSlider->value()/10000);
     m_View->m_GlobalTracker->SetParticleWidth((float)(m_View->m_Controls->m_ParticleWidthSlider->value())/10);
     m_View->m_GlobalTracker->SetParticleLength((float)(m_View->m_Controls->m_ParticleLengthSlider->value())/10);
     m_View->m_GlobalTracker->SetInexBalance((float)m_View->m_Controls->m_InExBalanceSlider->value()/10);
     m_View->m_GlobalTracker->SetMinFiberLength(m_View->m_Controls->m_FiberLengthSlider->value());
     m_View->m_GlobalTracker->SetCurvatureThreshold(cos((float)m_View->m_Controls->m_CurvatureThresholdSlider->value()*M_PI/180));
     m_View->m_GlobalTracker->SetRandomSeed(m_View->m_Controls->m_RandomSeedSlider->value());
     try{
         m_View->m_GlobalTracker->Update();
     }
     catch( mitk::Exception e )
     {
         MITK_ERROR << "Internal error occured: " <<  e.what() << "\nAborting";
     }
     m_View->m_TrackingThread.quit();
 }
 
 const std::string QmitkGibbsTrackingView::VIEW_ID = "org.mitk.views.gibbstracking";
 
 QmitkGibbsTrackingView::QmitkGibbsTrackingView()
-    : QmitkFunctionality()
+    : QmitkAbstractView()
     , m_Controls( 0 )
-    , m_MultiWidget(NULL)
     , m_FiberBundle(NULL)
     , m_MaskImage(NULL)
     , m_TensorImage(NULL)
     , m_QBallImage(NULL)
     , m_ItkQBallImage(NULL)
     , m_ItkTensorImage(NULL)
     , m_ImageNode(NULL)
     , m_MaskImageNode(NULL)
     , m_FiberBundleNode(NULL)
     , m_ThreadIsRunning(false)
     , m_ElapsedTime(0)
     , m_GlobalTracker(NULL)
     , m_TrackingWorker(this)
     , m_TrackingNode(NULL)
 {
     m_TrackingWorker.moveToThread(&m_TrackingThread);
     connect(&m_TrackingThread, SIGNAL(started()), this, SLOT(BeforeThread()));
     connect(&m_TrackingThread, SIGNAL(started()), &m_TrackingWorker, SLOT(run()));
     connect(&m_TrackingThread, SIGNAL(finished()), this, SLOT(AfterThread()));
     connect(&m_TrackingThread, SIGNAL(terminated()), this, SLOT(AfterThread()));
     m_TrackingTimer = new QTimer(this);
 }
 
 QmitkGibbsTrackingView::~QmitkGibbsTrackingView()
 {
   if (m_GlobalTracker.IsNull())
       return;
 
   m_GlobalTracker->SetAbortTracking(true);
   m_TrackingThread.wait();
 }
 
 // update tracking status and generate fiber bundle
 void QmitkGibbsTrackingView::TimerUpdate()
 {
     UpdateTrackingStatus();
     GenerateFiberBundle();
 }
 
 // tell global tractography filter to stop after current step
 void QmitkGibbsTrackingView::StopGibbsTracking()
 {
     if (m_GlobalTracker.IsNull())
         return;
 
     m_GlobalTracker->SetAbortTracking(true);
     m_Controls->m_TrackingStop->setEnabled(false);
     m_Controls->m_TrackingStop->setText("Stopping Tractography ...");
     m_TrackingNode = NULL;
 }
 
 // update gui elements and generate fiber bundle after tracking is finished
 void QmitkGibbsTrackingView::AfterThread()
 {
     m_ThreadIsRunning = false;
     m_TrackingTimer->stop();
 
     UpdateGUI();
 
     if( !m_GlobalTracker->GetIsInValidState() )
     {
         QMessageBox::critical( NULL, "Gibbs Tracking", "An internal error occured. Tracking aborted.\n Please check the log for details." );
         m_FiberBundleNode = NULL;
         return;
     }
     UpdateTrackingStatus();
 
     if(m_Controls->m_ParticleWeightSlider->value()==0)
     {
         m_Controls->m_ParticleWeightLabel->setText(QString::number(m_GlobalTracker->GetParticleWeight()));
         m_Controls->m_ParticleWeightSlider->setValue(m_GlobalTracker->GetParticleWeight()*10000);
     }
     if(m_Controls->m_ParticleWidthSlider->value()==0)
     {
         m_Controls->m_ParticleWidthLabel->setText(QString::number(m_GlobalTracker->GetParticleWidth()));
         m_Controls->m_ParticleWidthSlider->setValue(m_GlobalTracker->GetParticleWidth()*10);
     }
     if(m_Controls->m_ParticleLengthSlider->value()==0)
     {
         m_Controls->m_ParticleLengthLabel->setText(QString::number(m_GlobalTracker->GetParticleLength()));
         m_Controls->m_ParticleLengthSlider->setValue(m_GlobalTracker->GetParticleLength()*10);
     }
 
     GenerateFiberBundle();
     m_FiberBundleNode = 0;
     m_GlobalTracker = 0;
 
     // images not needed anymore ( relevant only for computation )
     // we need to release them to remove the memory access block created through CastToItk<> calls
     this->m_ItkQBallImage = 0;
     this->m_ItkTensorImage = 0;
 }
 
 // start tracking timer and update gui elements before tracking is started
 void QmitkGibbsTrackingView::BeforeThread()
 {
     m_ThreadIsRunning = true;
     m_TrackingTime = QTime::currentTime();
     m_ElapsedTime = 0;
     m_TrackingTimer->start(1000);
 
     UpdateGUI();
 }
 
 // setup gui elements and signal/slot connections
 void QmitkGibbsTrackingView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkGibbsTrackingViewControls;
         m_Controls->setupUi( parent );
 
         AdvancedSettings();
 
         connect( m_TrackingTimer, SIGNAL(timeout()), this, SLOT(TimerUpdate()) );
         connect( m_Controls->m_TrackingStop, SIGNAL(clicked()), this, SLOT(StopGibbsTracking()) );
         connect( m_Controls->m_TrackingStart, SIGNAL(clicked()), this, SLOT(StartGibbsTracking()) );
         connect( m_Controls->m_AdvancedSettingsCheckbox, SIGNAL(clicked()), this, SLOT(AdvancedSettings()) );
         connect( m_Controls->m_SaveTrackingParameters, SIGNAL(clicked()), this, SLOT(SaveTrackingParameters()) );
         connect( m_Controls->m_LoadTrackingParameters, SIGNAL(clicked()), this, SLOT(LoadTrackingParameters()) );
         connect( m_Controls->m_ParticleWidthSlider, SIGNAL(valueChanged(int)), this, SLOT(SetParticleWidth(int)) );
         connect( m_Controls->m_ParticleLengthSlider, SIGNAL(valueChanged(int)), this, SLOT(SetParticleLength(int)) );
         connect( m_Controls->m_InExBalanceSlider, SIGNAL(valueChanged(int)), this, SLOT(SetInExBalance(int)) );
         connect( m_Controls->m_FiberLengthSlider, SIGNAL(valueChanged(int)), this, SLOT(SetFiberLength(int)) );
         connect( m_Controls->m_ParticleWeightSlider, SIGNAL(valueChanged(int)), this, SLOT(SetParticleWeight(int)) );
         connect( m_Controls->m_StartTempSlider, SIGNAL(valueChanged(int)), this, SLOT(SetStartTemp(int)) );
         connect( m_Controls->m_EndTempSlider, SIGNAL(valueChanged(int)), this, SLOT(SetEndTemp(int)) );
         connect( m_Controls->m_CurvatureThresholdSlider, SIGNAL(valueChanged(int)), this, SLOT(SetCurvatureThreshold(int)) );
         connect( m_Controls->m_RandomSeedSlider, SIGNAL(valueChanged(int)), this, SLOT(SetRandomSeed(int)) );
         connect( m_Controls->m_OutputFileButton, SIGNAL(clicked()), this, SLOT(SetOutputFile()) );
     }
 }
 
+void QmitkGibbsTrackingView::SetFocus()
+{
+  m_Controls->m_TrackingStart->setFocus();
+}
+
 void QmitkGibbsTrackingView::SetInExBalance(int value)
 {
     m_Controls->m_InExBalanceLabel->setText(QString::number((float)value/10));
 }
 
 void QmitkGibbsTrackingView::SetFiberLength(int value)
 {
     m_Controls->m_FiberLengthLabel->setText(QString::number(value)+"mm");
 }
 
 void QmitkGibbsTrackingView::SetRandomSeed(int value)
 {
     if (value>=0)
         m_Controls->m_RandomSeedLabel->setText(QString::number(value));
     else
         m_Controls->m_RandomSeedLabel->setText("auto");
 }
 
 void QmitkGibbsTrackingView::SetParticleWeight(int value)
 {
     if (value>0)
         m_Controls->m_ParticleWeightLabel->setText(QString::number((float)value/10000));
     else
         m_Controls->m_ParticleWeightLabel->setText("auto");
 }
 
 void QmitkGibbsTrackingView::SetStartTemp(int value)
 {
     m_Controls->m_StartTempLabel->setText(QString::number((float)value/100));
 }
 
 void QmitkGibbsTrackingView::SetEndTemp(int value)
 {
     m_Controls->m_EndTempLabel->setText(QString::number((float)value/10000));
 }
 
 void QmitkGibbsTrackingView::SetParticleWidth(int value)
 {
     if (value>0)
         m_Controls->m_ParticleWidthLabel->setText(QString::number((float)value/10)+" mm");
     else
         m_Controls->m_ParticleWidthLabel->setText("auto");
 }
 
 void QmitkGibbsTrackingView::SetParticleLength(int value)
 {
     if (value>0)
         m_Controls->m_ParticleLengthLabel->setText(QString::number((float)value/10)+" mm");
     else
         m_Controls->m_ParticleLengthLabel->setText("auto");
 }
 
 void QmitkGibbsTrackingView::SetCurvatureThreshold(int value)
 {
     m_Controls->m_CurvatureThresholdLabel->setText(QString::number(value)+"°");
 }
 
-void QmitkGibbsTrackingView::StdMultiWidgetAvailable(QmitkStdMultiWidget &stdMultiWidget)
-{
-    m_MultiWidget = &stdMultiWidget;
-}
-
-void QmitkGibbsTrackingView::StdMultiWidgetNotAvailable()
-{
-    m_MultiWidget = NULL;
-}
-
 // called if datamanager selection changes
-void QmitkGibbsTrackingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
+void QmitkGibbsTrackingView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
     if (m_ThreadIsRunning)
         return;
 
     m_ImageNode = NULL;
     m_MaskImageNode = NULL;
 
     // iterate all selected objects
-    for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
+    for (mitk::DataNode::Pointer node: nodes)
     {
-        mitk::DataNode::Pointer node = *it;
-
         if( node.IsNotNull() && dynamic_cast<mitk::QBallImage*>(node->GetData()) )
             m_ImageNode = node;
         else if( node.IsNotNull() && dynamic_cast<mitk::TensorImage*>(node->GetData()) )
             m_ImageNode = node;
         else if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
             mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(node->GetData());
             if (img->GetPixelType().GetPixelType()==itk::ImageIOBase::SCALAR)
                 m_MaskImageNode = node;
         }
     }
 
     UpdateGUI();
 }
 
 
 void QmitkGibbsTrackingView::NodeRemoved(const mitk::DataNode * node)
 {
   if (m_ThreadIsRunning)
   {
     if (node==m_TrackingNode.GetPointer())
     {
       StopGibbsTracking();
     }
   }
 }
 
 // update gui elements displaying trackings status
 void QmitkGibbsTrackingView::UpdateTrackingStatus()
 {
     if (m_GlobalTracker.IsNull())
         return;
 
     m_ElapsedTime += m_TrackingTime.elapsed()/1000;
     m_TrackingTime.restart();
     unsigned long hours = m_ElapsedTime/3600;
     unsigned long minutes = (m_ElapsedTime%3600)/60;
     unsigned long seconds = m_ElapsedTime%60;
 
     m_Controls->m_ProposalAcceptance->setText(QString::number(m_GlobalTracker->GetProposalAcceptance()*100)+"%");
 
     m_Controls->m_TrackingTimeLabel->setText( QString::number(hours)+QString("h ")+QString::number(minutes)+QString("m ")+QString::number(seconds)+QString("s") );
     m_Controls->m_NumConnectionsLabel->setText( QString::number(m_GlobalTracker->GetNumConnections()) );
     m_Controls->m_NumParticlesLabel->setText( QString::number(m_GlobalTracker->GetNumParticles()) );
     m_Controls->m_CurrentStepLabel->setText( QString::number(100*m_GlobalTracker->GetCurrentIteration()/m_GlobalTracker->GetIterations())+"%" );
     m_Controls->m_AcceptedFibersLabel->setText( QString::number(m_GlobalTracker->GetNumAcceptedFibers()) );
 }
 
 // update gui elements (enable/disable elements and set tooltips)
 void QmitkGibbsTrackingView::UpdateGUI()
 {
     if (m_ImageNode.IsNotNull())
     {
         m_Controls->m_QballImageLabel->setText(m_ImageNode->GetName().c_str());
         m_Controls->m_DataFrame->setTitle("Input Data");
     }
     else
     {
         m_Controls->m_QballImageLabel->setText("<font color='red'>mandatory</font>");
         m_Controls->m_DataFrame->setTitle("Please Select Input Data");
     }
     if (m_MaskImageNode.IsNotNull())
         m_Controls->m_MaskImageLabel->setText(m_MaskImageNode->GetName().c_str());
     else
         m_Controls->m_MaskImageLabel->setText("<font color='grey'>optional</font>");
 
     if (!m_ThreadIsRunning && m_ImageNode.IsNotNull())
     {
         m_Controls->m_TrackingStop->setEnabled(false);
         m_Controls->m_TrackingStart->setEnabled(true);
         m_Controls->m_LoadTrackingParameters->setEnabled(true);
         m_Controls->m_IterationsBox->setEnabled(true);
         m_Controls->m_AdvancedFrame->setEnabled(true);
         m_Controls->m_TrackingStop->setText("Stop Tractography");
         m_Controls->m_TrackingStart->setToolTip("Start tractography. No further change of parameters possible.");
         m_Controls->m_TrackingStop->setToolTip("");
     }
     else if (!m_ThreadIsRunning)
     {
         m_Controls->m_TrackingStop->setEnabled(false);
         m_Controls->m_TrackingStart->setEnabled(false);
         m_Controls->m_LoadTrackingParameters->setEnabled(true);
         m_Controls->m_IterationsBox->setEnabled(true);
         m_Controls->m_AdvancedFrame->setEnabled(true);
         m_Controls->m_TrackingStop->setText("Stop Tractography");
         m_Controls->m_TrackingStart->setToolTip("No Q-Ball image selected.");
         m_Controls->m_TrackingStop->setToolTip("");
     }
     else
     {
         m_Controls->m_TrackingStop->setEnabled(true);
         m_Controls->m_TrackingStart->setEnabled(false);
         m_Controls->m_LoadTrackingParameters->setEnabled(false);
         m_Controls->m_IterationsBox->setEnabled(false);
         m_Controls->m_AdvancedFrame->setEnabled(false);
         m_Controls->m_AdvancedFrame->setVisible(false);
         m_Controls->m_AdvancedSettingsCheckbox->setChecked(false);
         m_Controls->m_TrackingStart->setToolTip("Tracking in progress.");
         m_Controls->m_TrackingStop->setToolTip("Stop tracking and display results.");
     }
 }
 
 // show/hide advanced settings frame
 void QmitkGibbsTrackingView::AdvancedSettings()
 {
     m_Controls->m_AdvancedFrame->setVisible(m_Controls->m_AdvancedSettingsCheckbox->isChecked());
 }
 
 // set mask image data node
 void QmitkGibbsTrackingView::SetMask()
 {
-    std::vector<mitk::DataNode*> nodes = GetDataManagerSelection();
+    QList<mitk::DataNode::Pointer> nodes = GetDataManagerSelection();
     if (nodes.empty())
     {
         m_MaskImageNode = NULL;
         m_Controls->m_MaskImageLabel->setText("-");
         return;
     }
 
-    for( std::vector<mitk::DataNode*>::iterator it = nodes.begin();
-         it != nodes.end();
-         ++it )
+    for (auto node: nodes)
     {
-        mitk::DataNode::Pointer node = *it;
-
         if (node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()))
         {
             m_MaskImageNode = node;
             m_Controls->m_MaskImageLabel->setText(node->GetName().c_str());
             return;
         }
     }
 }
 
 // check for mask and qbi and start tracking thread
 void QmitkGibbsTrackingView::StartGibbsTracking()
 {
     if(m_ThreadIsRunning)
     {
         MITK_WARN("QmitkGibbsTrackingView")<<"Thread already running!";
         return;
     }
     m_GlobalTracker = NULL;
 
     if (m_ImageNode.IsNull())
     {
         QMessageBox::information( NULL, "Warning", "Please load and select a qball image before starting image processing.");
         return;
     }
 
     if (dynamic_cast<mitk::QBallImage*>(m_ImageNode->GetData()))
         m_QBallImage = dynamic_cast<mitk::QBallImage*>(m_ImageNode->GetData());
     else if (dynamic_cast<mitk::TensorImage*>(m_ImageNode->GetData()))
         m_TensorImage = dynamic_cast<mitk::TensorImage*>(m_ImageNode->GetData());
 
     if (m_QBallImage.IsNull() && m_TensorImage.IsNull())
         return;
 
     // cast qbi to itk
     m_TrackingNode = m_ImageNode;
     m_ItkTensorImage = NULL;
     m_ItkQBallImage = NULL;
     m_MaskImage = NULL;
 
     if (m_QBallImage.IsNotNull())
     {
         m_ItkQBallImage = ItkQBallImgType::New();
         mitk::CastToItkImage(m_QBallImage, m_ItkQBallImage);
     }
     else
     {
         m_ItkTensorImage = ItkTensorImage::New();
         mitk::CastToItkImage(m_TensorImage, m_ItkTensorImage);
     }
 
     // mask image found?
     // catch exceptions thrown by the itkAccess macros
     try{
         if(m_MaskImageNode.IsNotNull())
         {
             if (dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData()))
                 mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData()), m_MaskImage);
         }
     }
     catch(...){};
 
     // start worker thread
     m_TrackingThread.start(QThread::LowestPriority);
 }
 
 // generate mitkFiberBundle from tracking filter output
 void QmitkGibbsTrackingView::GenerateFiberBundle()
 {
     if (m_GlobalTracker.IsNull() || (!(m_Controls->m_VisualizationCheckbox->isChecked() || m_Controls->m_VisualizeOnceButton->isChecked()) && m_ThreadIsRunning))
         return;
 
     if (m_Controls->m_VisualizeOnceButton->isChecked())
         m_Controls->m_VisualizeOnceButton->setChecked(false);
 
     vtkSmartPointer<vtkPolyData> fiberBundle = m_GlobalTracker->GetFiberBundle();
     if ( m_GlobalTracker->GetNumAcceptedFibers()==0 )
         return;
     m_FiberBundle = mitk::FiberBundle::New(fiberBundle);
     m_FiberBundle->SetReferenceGeometry(dynamic_cast<mitk::Image*>(m_ImageNode->GetData())->GetGeometry());
 
     if (m_FiberBundleNode.IsNotNull()){
-        GetDefaultDataStorage()->Remove(m_FiberBundleNode);
+        GetDataStorage()->Remove(m_FiberBundleNode);
         m_FiberBundleNode = 0;
     }
     m_FiberBundleNode = mitk::DataNode::New();
     m_FiberBundleNode->SetData(m_FiberBundle);
 
     QString name("FiberBundle_");
     name += m_ImageNode->GetName().c_str();
     name += "_Gibbs";
     m_FiberBundleNode->SetName(name.toStdString());
     m_FiberBundleNode->SetVisibility(true);
 
 
     if (!m_OutputFileName.isEmpty() && !m_ThreadIsRunning)
     {
         try
         {
           mitk::IOUtil::Save(m_FiberBundle.GetPointer(),m_OutputFileName.toStdString());
           QMessageBox::information(NULL, "Fiber bundle saved to", m_OutputFileName);
         }
         catch (itk::ExceptionObject &ex)
         {
             QMessageBox::information(NULL, "Fiber bundle could not be saved", QString("%1\n%2\n%3\n%4\n%5\n%6").arg(ex.GetNameOfClass()).arg(ex.GetFile()).arg(ex.GetLine()).arg(ex.GetLocation()).arg(ex.what()).arg(ex.GetDescription()));
         }
     }
     if(m_ImageNode.IsNull())
         GetDataStorage()->Add(m_FiberBundleNode);
     else
         GetDataStorage()->Add(m_FiberBundleNode, m_ImageNode);
 }
 
 void QmitkGibbsTrackingView::SetOutputFile()
 {
     // SELECT FOLDER DIALOG
     m_OutputFileName = QFileDialog::getSaveFileName(0,
                                                     tr("Set file name"),
                                                     QDir::currentPath()+"/FiberBundle.fib",
                                                     tr("Fiber Bundle (*.fib)") );
     if (m_OutputFileName.isEmpty())
         m_Controls->m_OutputFileLabel->setText("N/A");
     else
         m_Controls->m_OutputFileLabel->setText(m_OutputFileName);
 }
 
 // save current tracking paramters as xml file (.gtp)
 void QmitkGibbsTrackingView::SaveTrackingParameters()
 {
     TiXmlDocument documentXML;
     TiXmlDeclaration* declXML = new TiXmlDeclaration( "1.0", "", "" );
     documentXML.LinkEndChild( declXML );
 
     TiXmlElement* mainXML = new TiXmlElement("global_tracking_parameter_file");
     mainXML->SetAttribute("file_version",  "0.1");
     documentXML.LinkEndChild(mainXML);
 
     TiXmlElement* paramXML = new TiXmlElement("parameter_set");
     paramXML->SetAttribute("iterations", m_Controls->m_IterationsBox->text().toStdString());
     paramXML->SetAttribute("particle_length", QString::number((float)m_Controls->m_ParticleLengthSlider->value()/10).toStdString());
     paramXML->SetAttribute("particle_width", QString::number((float)m_Controls->m_ParticleWidthSlider->value()/10).toStdString());
     paramXML->SetAttribute("particle_weight", QString::number((float)m_Controls->m_ParticleWeightSlider->value()/10000).toStdString());
     paramXML->SetAttribute("temp_start", QString::number((float)m_Controls->m_StartTempSlider->value()/100).toStdString());
     paramXML->SetAttribute("temp_end", QString::number((float)m_Controls->m_EndTempSlider->value()/10000).toStdString());
     paramXML->SetAttribute("inexbalance", QString::number((float)m_Controls->m_InExBalanceSlider->value()/10).toStdString());
     paramXML->SetAttribute("fiber_length", QString::number(m_Controls->m_FiberLengthSlider->value()).toStdString());
     paramXML->SetAttribute("curvature_threshold", QString::number(m_Controls->m_CurvatureThresholdSlider->value()).toStdString());
     mainXML->LinkEndChild(paramXML);
     QString filename = QFileDialog::getSaveFileName(
                 0,
                 tr("Save Parameters"),
                 QDir::currentPath()+"/param.gtp",
                 tr("Global Tracking Parameters (*.gtp)") );
 
     if(filename.isEmpty() || filename.isNull())
         return;
     if(!filename.endsWith(".gtp"))
         filename += ".gtp";
     documentXML.SaveFile( filename.toStdString() );
 }
 
 // load current tracking paramters from xml file (.gtp)
 void QmitkGibbsTrackingView::LoadTrackingParameters()
 {
     QString filename = QFileDialog::getOpenFileName(0, tr("Load Parameters"), QDir::currentPath(), tr("Global Tracking Parameters (*.gtp)") );
     if(filename.isEmpty() || filename.isNull())
         return;
 
     TiXmlDocument doc( filename.toStdString() );
     doc.LoadFile();
 
     TiXmlHandle hDoc(&doc);
     TiXmlElement* pElem;
     TiXmlHandle hRoot(0);
 
     pElem = hDoc.FirstChildElement().Element();
     hRoot = TiXmlHandle(pElem);
     pElem = hRoot.FirstChildElement("parameter_set").Element();
 
     QString iterations(pElem->Attribute("iterations"));
     m_Controls->m_IterationsBox->setText(iterations);
 
     QString particleLength(pElem->Attribute("particle_length"));
     float pLength = particleLength.toFloat();
     QString particleWidth(pElem->Attribute("particle_width"));
     float pWidth = particleWidth.toFloat();
 
     if (pLength==0)
         m_Controls->m_ParticleLengthLabel->setText("auto");
     else
         m_Controls->m_ParticleLengthLabel->setText(particleLength+" mm");
     if (pWidth==0)
         m_Controls->m_ParticleWidthLabel->setText("auto");
     else
         m_Controls->m_ParticleWidthLabel->setText(particleWidth+" mm");
 
     m_Controls->m_ParticleWidthSlider->setValue(pWidth*10);
     m_Controls->m_ParticleLengthSlider->setValue(pLength*10);
 
     QString partWeight(pElem->Attribute("particle_weight"));
     m_Controls->m_ParticleWeightSlider->setValue(partWeight.toFloat()*10000);
     m_Controls->m_ParticleWeightLabel->setText(partWeight);
 
     QString startTemp(pElem->Attribute("temp_start"));
     m_Controls->m_StartTempSlider->setValue(startTemp.toFloat()*100);
     m_Controls->m_StartTempLabel->setText(startTemp);
 
     QString endTemp(pElem->Attribute("temp_end"));
     m_Controls->m_EndTempSlider->setValue(endTemp.toFloat()*10000);
     m_Controls->m_EndTempLabel->setText(endTemp);
 
     QString inExBalance(pElem->Attribute("inexbalance"));
     m_Controls->m_InExBalanceSlider->setValue(inExBalance.toFloat()*10);
     m_Controls->m_InExBalanceLabel->setText(inExBalance);
 
     QString fiberLength(pElem->Attribute("fiber_length"));
     m_Controls->m_FiberLengthSlider->setValue(fiberLength.toInt());
     m_Controls->m_FiberLengthLabel->setText(fiberLength+"mm");
 
     QString curvThres(pElem->Attribute("curvature_threshold"));
     m_Controls->m_CurvatureThresholdSlider->setValue(curvThres.toInt());
     m_Controls->m_CurvatureThresholdLabel->setText(curvThres+"°");
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.h
index bddb82499c..cb1163d8d1 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.h
@@ -1,164 +1,163 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef QmitkGibbsTrackingView_h
 #define QmitkGibbsTrackingView_h
 
 #include <berryISelectionListener.h>
 
-#include <QmitkFunctionality.h>
+#include <QmitkAbstractView.h>
 
 #include "ui_QmitkGibbsTrackingViewControls.h"
 
 #include <mitkQBallImage.h>
 #include <QThread>
 #include <mitkFiberBundle.h>
 #include <QTime>
 #include <itkImage.h>
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <itkDiffusionTensor3D.h>
 #include <mitkTensorImage.h>
 
 class QmitkGibbsTrackingView;
 
 class QmitkTrackingWorker : public QObject
 {
   Q_OBJECT
 
 public:
 
   QmitkTrackingWorker(QmitkGibbsTrackingView* view);
 
 public slots:
 
   void run();
 
 private:
 
   QmitkGibbsTrackingView* m_View;
 };
 
 /*!
   \brief View for global fiber tracking (Gibbs tracking)
-
-  \sa QmitkFunctionality
-  \ingroup Functionalities
 */
 typedef itk::Image< float, 3 >            FloatImageType;
 
 namespace itk
 {
 template<class X>
 class GibbsTrackingFilter;
 }
 
-class QmitkGibbsTrackingView : public QmitkFunctionality
+class QmitkGibbsTrackingView : public QmitkAbstractView
 {
   // 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:
 
   typedef itk::Image<float,3>                               ItkFloatImageType;
   typedef itk::Vector<float, QBALL_ODFSIZE>                 OdfVectorType;
   typedef itk::Image<OdfVectorType, 3>                      ItkQBallImgType;
   typedef itk::Image< itk::DiffusionTensor3D<float>, 3 >    ItkTensorImage;
   typedef itk::GibbsTrackingFilter< ItkQBallImgType >       GibbsTrackingFilterType;
 
   static const std::string VIEW_ID;
 
   QmitkGibbsTrackingView();
   virtual ~QmitkGibbsTrackingView();
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
-  virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget) override;
-  virtual void StdMultiWidgetNotAvailable() override;
+  ///
+  /// Sets the focus to an internal widget.
+  ///
+  virtual void SetFocus() override;
 
 signals:
 
 protected slots:
 
   void StartGibbsTracking();
   void StopGibbsTracking();
   void AfterThread();                       ///< update gui etc. after tracking has finished
   void BeforeThread();                      ///< start timer etc.
   void TimerUpdate();
   void SetMask();
   void AdvancedSettings();                  ///< show/hide advanced tracking options
   void SaveTrackingParameters();            ///< save tracking parameters to xml file
   void LoadTrackingParameters();            ///< load tracking parameters from xml file
 
   /** update labels if parameters have changed */
   void SetParticleWidth(int value);
   void SetParticleLength(int value);
   void SetInExBalance(int value);
   void SetFiberLength(int value);
   void SetParticleWeight(int value);
   void SetStartTemp(int value);
   void SetEndTemp(int value);
   void SetCurvatureThreshold(int value);
   void SetRandomSeed(int value);
   void SetOutputFile();
 
 private:
 
   // Visualization & GUI
   void GenerateFiberBundle();   ///< generate fiber bundle from tracking output and add to datanode
   void UpdateGUI();             ///< update button activity etc. dpending on current datamanager selection
   void UpdateTrackingStatus();  ///< update textual status display of the tracking process
 
-  /// \brief called by QmitkFunctionality when DataManager's selection has changed
-  virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes ) override;
+  /// \brief called by QmitkAbstractView when DataManager's selection has changed
+  virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
+
   /// \brief called when DataNode is removed to stop gibbs tracking after node is removed
   virtual void NodeRemoved(const mitk::DataNode * node) override;
 
   void UpdateIteraionsGUI(unsigned long iterations);    ///< update iterations label text
 
   Ui::QmitkGibbsTrackingViewControls* m_Controls;
-  QmitkStdMultiWidget* m_MultiWidget;
 
   /** data objects */
   mitk::DataNode::Pointer       m_TrackingNode;     ///< actual node that is tracked
   mitk::FiberBundle::Pointer    m_FiberBundle;      ///< tracking output
   ItkFloatImageType::Pointer    m_MaskImage;        ///< used to reduce the algorithms search space. tracking only inside of the mask.
   mitk::TensorImage::Pointer    m_TensorImage;      ///< actual image that is tracked
   mitk::QBallImage::Pointer     m_QBallImage;       ///< actual image that is tracked
   ItkQBallImgType::Pointer      m_ItkQBallImage;    ///< actual image that is tracked
   ItkTensorImage::Pointer       m_ItkTensorImage;   ///< actual image that is tracked
 
   /** data nodes */
   mitk::DataNode::Pointer m_ImageNode;
   mitk::DataNode::Pointer m_MaskImageNode;
   mitk::DataNode::Pointer m_FiberBundleNode;
 
   /** flags etc. */
   bool            m_ThreadIsRunning;
   QTimer*         m_TrackingTimer;
   QTime           m_TrackingTime;
   unsigned long   m_ElapsedTime;
   QString         m_OutputFileName;
 
   /** global tracker and friends */
   itk::SmartPointer<GibbsTrackingFilterType> m_GlobalTracker;
   QmitkTrackingWorker m_TrackingWorker;
   QThread m_TrackingThread;
   friend class QmitkTrackingWorker;
 };
 
 #endif // _QMITKGibbsTrackingVIEW_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.cpp
index 0872515184..09dfb8bde3 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.cpp
@@ -1,1008 +1,1016 @@
 /*===================================================================
 
 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>
 
 // Qmitk
 #include "QmitkIVIMView.h"
-#include "QmitkStdMultiWidget.h"
 
 // qt
 #include "qmessagebox.h"
 #include "qclipboard.h"
 
 // mitk
 #include "mitkImage.h"
 #include "mitkImageCast.h"
 
 #include "mitkLookupTable.h"
 #include "mitkLookupTableProperty.h"
+#include <mitkSliceNavigationController.h>
+#include <QmitkRenderWindow.h>
 
 // itk
 #include "itkScalarImageToHistogramGenerator.h"
 #include "itkRegionOfInterestImageFilter.h"
 #include "itkImageRegionConstIteratorWithIndex.h"
 
 // itk/mitk
 #include "itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.h"
 #include "itkRegularizedIVIMReconstructionFilter.h"
 #include "mitkImageCast.h"
 
 const std::string QmitkIVIMView::VIEW_ID = "org.mitk.views.ivim";
 
 QmitkIVIMView::QmitkIVIMView()
-    : QmitkFunctionality()
+    : QmitkAbstractView()
     , m_Controls( 0 )
-    , m_MultiWidget( NULL )
     , m_SliceObserverTag1(0), m_SliceObserverTag2(0), m_SliceObserverTag3(0)
     , m_DiffusionImageNode(NULL)
     , m_MaskImageNode(NULL)
     , m_Active(false)
+    , m_Visible(false)
     , m_HoldUpdate(false)
 {
 }
 
 QmitkIVIMView::~QmitkIVIMView()
 {
 }
 
 void QmitkIVIMView::CreateQtPartControl( QWidget *parent )
 {
   // hold update untill all elements are set
   this->m_HoldUpdate = true;
 
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkIVIMViewControls;
         m_Controls->setupUi( parent );
 
         connect( m_Controls->m_ButtonStart, SIGNAL(clicked()), this, SLOT(FittIVIMStart()) );
         connect( m_Controls->m_ButtonAutoThres, SIGNAL(clicked()), this, SLOT(AutoThreshold()) );
 
         connect( m_Controls->m_MethodCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(MethodCombo(int)) );
 
         connect( m_Controls->m_DStarSlider, SIGNAL(valueChanged(int)), this, SLOT(DStarSlider(int)) );
         connect( m_Controls->m_BThreshSlider, SIGNAL(valueChanged(int)), this, SLOT(BThreshSlider(int)) );
         connect( m_Controls->m_S0ThreshSlider, SIGNAL(valueChanged(int)), this, SLOT(S0ThreshSlider(int)) );
         connect( m_Controls->m_NumItSlider, SIGNAL(valueChanged(int)), this, SLOT(NumItsSlider(int)) );
         connect( m_Controls->m_LambdaSlider, SIGNAL(valueChanged(int)), this, SLOT(LambdaSlider(int)) );
 
         connect( m_Controls->m_CheckDStar, SIGNAL(clicked()), this, SLOT(Checkbox()) );
         connect( m_Controls->m_CheckD, SIGNAL(clicked()), this, SLOT(Checkbox()) );
         connect( m_Controls->m_Checkf, SIGNAL(clicked()), this, SLOT(Checkbox()) );
 
         connect( m_Controls->m_ChooseMethod, SIGNAL(clicked()), this, SLOT(ChooseMethod()) );
         connect( m_Controls->m_CurveClipboard, SIGNAL(clicked()), this, SLOT(ClipboardCurveButtonClicked()) );
         connect( m_Controls->m_ValuesClipboard, SIGNAL(clicked()), this, SLOT(ClipboardStatisticsButtonClicked()) );
 
         // connect all kurtosis actions to a recompute
         connect( m_Controls->m_KurtosisRangeWidget, SIGNAL( rangeChanged(double, double)), this, SLOT(OnKurtosisParamsChanged() ) );
         //connect( m_Controls->m_MaximalBValueWidget, SIGNAL( valueChanged(double)), this, SLOT( OnKurtosisParamsChanged() ) );
         connect( m_Controls->m_OmitBZeroCB, SIGNAL( stateChanged(int) ), this, SLOT( OnKurtosisParamsChanged() ) );
         connect( m_Controls->m_KurtosisFitScale, SIGNAL( currentIndexChanged(int)), this, SLOT( OnKurtosisParamsChanged() ) );
         connect( m_Controls->m_UseKurtosisBoundsCB, SIGNAL(clicked() ), this, SLOT( OnKurtosisParamsChanged() ) );
     }
 
     QString dstar = QString::number(m_Controls->m_DStarSlider->value()/1000.0);
     m_Controls->m_DStarLabel->setText(dstar);
 
     QString bthresh = QString::number(m_Controls->m_BThreshSlider->value()*5.0);
     m_Controls->m_BThreshLabel->setText(bthresh);
 
     QString s0thresh = QString::number(m_Controls->m_S0ThreshSlider->value()*0.5);
     m_Controls->m_S0ThreshLabel->setText(s0thresh);
 
     QString numits = QString::number(m_Controls->m_NumItSlider->value());
     m_Controls->m_NumItsLabel->setText(numits);
 
     QString lambda = QString::number(m_Controls->m_LambdaSlider->value()*.00001);
     m_Controls->m_LambdaLabel->setText(lambda);
 
     m_Controls->m_MethodCombo->setVisible(m_Controls->m_ChooseMethod->isChecked());
     m_Controls->m_Warning->setVisible(false);
 
     MethodCombo(m_Controls->m_MethodCombo->currentIndex());
 
     m_Controls->m_KurtosisRangeWidget->setSingleStep(0.1);
     m_Controls->m_KurtosisRangeWidget->setRange( 0.0, 10.0 );
     m_Controls->m_KurtosisRangeWidget->setMaximumValue( 5.0 );
 
     // LogScale not working yet, have to fix that first
     // m_Controls->m_KurtosisFitScale->setEnabled(false);
 
 
     //m_Controls->m_MaximalBValueWidget->setVisible( false );
 
     // release update block after the UI-elements were all set
     this->m_HoldUpdate = false;
 
 }
 
+void QmitkIVIMView::SetFocus()
+{
+  m_Controls->m_ButtonAutoThres->setFocus();
+}
+
 void QmitkIVIMView::Checkbox()
 {
     itk::StartEvent dummy;
     OnSliceChanged(dummy);
 }
 
 void QmitkIVIMView::MethodCombo(int val)
 {
     switch(val)
     {
     case 0:
         m_Controls->m_DstarFrame->setVisible(false);
         m_Controls->m_NeglSiFrame->setVisible(true);
         m_Controls->m_NeglBframe->setVisible(false);
         m_Controls->m_IterationsFrame->setVisible(false);
         m_Controls->m_LambdaFrame->setVisible(false);
         break;
     case 1:
         m_Controls->m_DstarFrame->setVisible(true);
         m_Controls->m_NeglSiFrame->setVisible(true);
         m_Controls->m_NeglBframe->setVisible(false);
         m_Controls->m_IterationsFrame->setVisible(false);
         m_Controls->m_LambdaFrame->setVisible(false);
         break;
     case 2:
         m_Controls->m_DstarFrame->setVisible(false);
         m_Controls->m_NeglSiFrame->setVisible(true);
         m_Controls->m_NeglBframe->setVisible(true);
         m_Controls->m_IterationsFrame->setVisible(false);
         m_Controls->m_LambdaFrame->setVisible(false);
         break;
     case 3:
         m_Controls->m_DstarFrame->setVisible(false);
         m_Controls->m_NeglSiFrame->setVisible(true);
         m_Controls->m_NeglBframe->setVisible(true);
         m_Controls->m_IterationsFrame->setVisible(false);
         m_Controls->m_LambdaFrame->setVisible(false);
         break;
     case 4:
         m_Controls->m_DstarFrame->setVisible(false);
         m_Controls->m_NeglSiFrame->setVisible(false);
         m_Controls->m_NeglBframe->setVisible(false);
         m_Controls->m_IterationsFrame->setVisible(false);
         m_Controls->m_LambdaFrame->setVisible(false);
         break;
     }
 
     itk::StartEvent dummy;
     OnSliceChanged(dummy);
 }
 
 void QmitkIVIMView::DStarSlider (int val)
 {
     QString sval = QString::number(val/1000.0);
     m_Controls->m_DStarLabel->setText(sval);
 
     itk::StartEvent dummy;
     OnSliceChanged(dummy);
 }
 
 void QmitkIVIMView::BThreshSlider (int val)
 {
     QString sval = QString::number(val*5.0);
     m_Controls->m_BThreshLabel->setText(sval);
 
     itk::StartEvent dummy;
     OnSliceChanged(dummy);
 }
 
 void QmitkIVIMView::S0ThreshSlider (int val)
 {
     QString sval = QString::number(val*0.5);
     m_Controls->m_S0ThreshLabel->setText(sval);
 
     itk::StartEvent dummy;
     OnSliceChanged(dummy);
 }
 
 void QmitkIVIMView::NumItsSlider (int val)
 {
     QString sval = QString::number(val);
     m_Controls->m_NumItsLabel->setText(sval);
 
     itk::StartEvent dummy;
     OnSliceChanged(dummy);
 }
 
 void QmitkIVIMView::LambdaSlider (int val)
 {
     QString sval = QString::number(val*.00001);
     m_Controls->m_LambdaLabel->setText(sval);
 
     itk::StartEvent dummy;
     OnSliceChanged(dummy);
 }
 
-void QmitkIVIMView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
+void QmitkIVIMView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
-    m_MultiWidget = &stdMultiWidget;
-
     {
-        mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
+        mitk::SliceNavigationController* slicer = renderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController();
         itk::ReceptorMemberCommand<QmitkIVIMView>::Pointer command = itk::ReceptorMemberCommand<QmitkIVIMView>::New();
         command->SetCallbackFunction( this, &QmitkIVIMView::OnSliceChanged );
         m_SliceObserverTag1 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
     }
 
     {
-        mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
+        mitk::SliceNavigationController* slicer = renderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController();
         itk::ReceptorMemberCommand<QmitkIVIMView>::Pointer command = itk::ReceptorMemberCommand<QmitkIVIMView>::New();
         command->SetCallbackFunction( this, &QmitkIVIMView::OnSliceChanged );
         m_SliceObserverTag2 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
     }
 
     {
-        mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
+        mitk::SliceNavigationController* slicer = renderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController();
         itk::ReceptorMemberCommand<QmitkIVIMView>::Pointer command = itk::ReceptorMemberCommand<QmitkIVIMView>::New();
         command->SetCallbackFunction( this, &QmitkIVIMView::OnSliceChanged );
         m_SliceObserverTag3 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
     }
-
 }
 
-void QmitkIVIMView::StdMultiWidgetNotAvailable()
+void QmitkIVIMView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart)
 {
-
     {
-        mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
+        mitk::SliceNavigationController* slicer = renderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController();
         slicer->RemoveObserver( m_SliceObserverTag1 );
     }
 
     {
-        mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
+        mitk::SliceNavigationController* slicer = renderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController();
         slicer->RemoveObserver( m_SliceObserverTag2 );
     }
 
     {
-        mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
+        mitk::SliceNavigationController* slicer = renderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController();
         slicer->RemoveObserver( m_SliceObserverTag3 );
     }
-
-    m_MultiWidget = NULL;
 }
 
-void QmitkIVIMView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
+void QmitkIVIMView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
     bool foundOneDiffusionImage = false;
     m_Controls->m_InputData->setTitle("Please Select Input Data");
     m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_MaskImageLabel->setText("<font color='grey'>optional</font>");
     m_MaskImageNode = NULL;
     m_DiffusionImageNode = NULL;
 
     // iterate all selected objects, adjust warning visibility
-    for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
+    for (auto node: nodes)
     {
-        mitk::DataNode::Pointer node = *it;
-
         if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
           bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
 
             if( isDiffusionImage )
             {
                 m_DiffusionImageNode = node;
                 foundOneDiffusionImage = true;
                 m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
             }
             else
             {
                 bool isBinary = false;
                 node->GetPropertyValue<bool>("binary", isBinary);
                 if (isBinary)
                 {
                     m_MaskImageNode = node;
                     m_Controls->m_MaskImageLabel->setText(node->GetName().c_str());
                 }
             }
         }
     }
 
     if (m_DiffusionImageNode.IsNotNull())
     {
         m_Controls->m_VisualizeResultsWidget->setVisible(true);
         m_Controls->m_KurtosisVisualizationWidget->setVisible(true);
         m_Controls->m_InputData->setTitle("Input Data");
 
         m_HoldUpdate = false;
     }
     else
     {
         m_Controls->m_VisualizeResultsWidget->setVisible(false);
         m_Controls->m_KurtosisVisualizationWidget->setVisible(false);
         m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
     }
 
     m_Controls->m_ButtonStart->setEnabled( foundOneDiffusionImage );
     m_Controls->m_ButtonAutoThres->setEnabled( foundOneDiffusionImage );
 
     m_Controls->m_ControlsFrame->setEnabled( foundOneDiffusionImage );
     m_Controls->m_BottomControlsFrame->setEnabled( foundOneDiffusionImage );
 
     itk::StartEvent dummy;
     OnSliceChanged(dummy);
 }
 
 void QmitkIVIMView::AutoThreshold()
 {
-    std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
+    QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
     if (nodes.empty()) return;
 
     if (!nodes.front())
     {
         // Nothing selected. Inform the user and return
         QMessageBox::information( NULL, "Template", "Please load and select a diffusion image before starting image processing.");
         return;
     }
 
     mitk::Image* dimg = dynamic_cast<mitk::Image*>(nodes.front()->GetData());
 
     if (!dimg)
     {
         // Nothing selected. Inform the user and return
         QMessageBox::information( NULL, "Template", "No valid diffusion image was found.");
         return;
     }
 
     // find bzero index
     int index = -1;
     DirContainerType::Pointer directions = static_cast<mitk::GradientDirectionsProperty*>( dimg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
     for(DirContainerType::ConstIterator it = directions->Begin();
         it != directions->End(); ++it)
     {
         index++;
         GradientDirectionType g = it.Value();
         if(g[0] == 0 && g[1] == 0 && g[2] == 0 )
             break;
     }
 
     VecImgType::Pointer vecimg = VecImgType::New();
     mitk::CastToItkImage(dimg, vecimg);
 
     int vecLength = vecimg->GetVectorLength();
     index = index > vecLength-1 ? vecLength-1 : index;
 
     MITK_INFO << "Performing Histogram Analysis on Channel" << index;
 
     typedef itk::Image<short,3> ImgType;
     ImgType::Pointer img = ImgType::New();
     mitk::CastToItkImage(dimg, img);
 
     itk::ImageRegionIterator<ImgType> itw (img, img->GetLargestPossibleRegion() );
     itw.GoToBegin();
 
     itk::ImageRegionConstIterator<VecImgType> itr (vecimg, vecimg->GetLargestPossibleRegion() );
     itr.GoToBegin();
 
     while(!itr.IsAtEnd())
     {
         itw.Set(itr.Get().GetElement(index));
         ++itr;
         ++itw;
     }
 
     typedef itk::Statistics::ScalarImageToHistogramGenerator< ImgType >
             HistogramGeneratorType;
     typedef HistogramGeneratorType::HistogramType HistogramType;
 
     HistogramGeneratorType::Pointer histogramGenerator = HistogramGeneratorType::New();
     histogramGenerator->SetInput( img );
     histogramGenerator->SetMarginalScale( 10 ); // Defines y-margin width of histogram
     histogramGenerator->SetNumberOfBins( 100 ); // CT range [-1024, +2048] --> bin size 4 values
     histogramGenerator->SetHistogramMin(  dimg->GetScalarValueMin() );
     histogramGenerator->SetHistogramMax(  dimg->GetScalarValueMax() * .5 );
     histogramGenerator->Compute();
 
     HistogramType::ConstIterator iter = histogramGenerator->GetOutput()->Begin();
     float maxFreq = 0;
     float maxValue = 0;
     while ( iter != histogramGenerator->GetOutput()->End() )
     {
         if(iter.GetFrequency() > maxFreq)
         {
             maxFreq = iter.GetFrequency();
             maxValue = iter.GetMeasurementVector()[0];
         }
         ++iter;
     }
 
     maxValue *= 2;
 
     int sliderPos = maxValue * 2;
     m_Controls->m_S0ThreshSlider->setValue(sliderPos);
     S0ThreshSlider(sliderPos);
 }
 
 void QmitkIVIMView::FittIVIMStart()
 {
-    std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
+    QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
 
     mitk::Image* img = 0;
     for ( unsigned int i=0; i<nodes.size(); i++ )
     {
         img = dynamic_cast<mitk::Image*>(nodes.at(i)->GetData());
 
         bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(nodes.at(i)->GetData())) );
 
         if (img && isDiffusionImage)
             break;
     }
 
     if (!img)
     {
         QMessageBox::information( NULL, "Template", "No valid diffusion image was found.");
         return;
     }
 
 
     VecImgType::Pointer vecimg = VecImgType::New();
     mitk::CastToItkImage(img, vecimg);
 
     OutImgType::IndexType dummy;
 
     if( m_Controls->m_ModelTabSelectionWidget->currentIndex() )
     {
       // KURTOSIS
       KurtosisFilterType::Pointer filter = KurtosisFilterType::New();
       filter->SetInput(vecimg);
       filter->SetReferenceBValue( static_cast<mitk::FloatProperty*>(img->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
       filter->SetGradientDirections( static_cast<mitk::GradientDirectionsProperty*>( img->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
       filter->SetSmoothingSigma( this->m_Controls->m_SigmaSpinBox->value() );
 
       if( this->m_Controls->m_UseKurtosisBoundsCB->isChecked() )
         filter->SetBoundariesForKurtosis( this->m_Controls->m_KurtosisRangeWidget->minimumValue(), this->m_Controls->m_KurtosisRangeWidget->maximumValue() );
 
       filter->SetFittingScale( static_cast<itk::FitScale>(this->m_Controls->m_KurtosisFitScale->currentIndex() ) );
 
       if( m_MaskImageNode.IsNotNull() )
       {
         mitk::Image::Pointer maskImg = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
         typedef itk::Image<short, 3> MaskImgType;
 
         MaskImgType::Pointer maskItk;
         CastToItkImage( maskImg, maskItk );
 
         filter->SetImageMask( maskItk );
       }
 
       filter->Update();
 
       mitk::LookupTable::Pointer kurt_map_lut = mitk::LookupTable::New();
       kurt_map_lut->SetType( mitk::LookupTable::JET_TRANSPARENT );
       mitk::LookupTableProperty::Pointer kurt_lut_prop =
           mitk::LookupTableProperty::New();
       kurt_lut_prop->SetLookupTable( kurt_map_lut );
 
       mitk::Image::Pointer dimage = mitk::Image::New();
       dimage->InitializeByItk( filter->GetOutput(0) );
       dimage->SetVolume( filter->GetOutput(0)->GetBufferPointer());
 
       mitk::Image::Pointer kimage = mitk::Image::New();
       kimage->InitializeByItk( filter->GetOutput(1) );
       kimage->SetVolume( filter->GetOutput(1)->GetBufferPointer());
 
       QString basename(nodes.front()->GetName().c_str());
       QString new_dname = basename; new_dname = new_dname.append("KurtFit_DMap");
 
       QString new_kname = basename; new_kname = new_kname.append("KurtFit_KMap");
 
       if( this->m_Controls->m_CheckKurtD->isChecked() )
       {
         mitk::DataNode::Pointer dnode = mitk::DataNode::New();
         dnode->SetData( dimage );
         dnode->SetName(new_dname.toLatin1());
         dnode->SetProperty("LookupTable", kurt_lut_prop );
-        GetDefaultDataStorage()->Add(dnode);
+        GetDataStorage()->Add(dnode);
       }
 
       if( this->m_Controls->m_CheckKurtK->isChecked() )
       {
         mitk::DataNode::Pointer knode = mitk::DataNode::New();
         knode->SetData( kimage );
         knode->SetName(new_kname.toLatin1());
         knode->SetProperty("LookupTable", kurt_lut_prop );
-        GetDefaultDataStorage()->Add(knode);
+        GetDataStorage()->Add(knode);
       }
 
     }
     else
     {
       FittIVIM(vecimg,
              static_cast<mitk::GradientDirectionsProperty*>( img->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(),
              static_cast<mitk::FloatProperty*>(img->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue(),
              true,
              dummy);
 
       OutputToDatastorage(nodes);
     }
 }
 
 void QmitkIVIMView::OnKurtosisParamsChanged()
 {
   itk::StartEvent dummy;
   OnSliceChanged(dummy);
 }
 
 void QmitkIVIMView::OnSliceChanged(const itk::EventObject& /*e*/)
 {
     if(!m_Visible)
         return;
 
     if(m_HoldUpdate)
       return;
 
     m_Controls->m_Warning->setVisible(false);
     if(!m_Controls || m_DiffusionImageNode.IsNull())
         return;
 
     m_Controls->m_VisualizeResultsWidget->setVisible(false);
     m_Controls->m_KurtosisVisualizationWidget->setVisible(false);
 
     mitk::Image::Pointer diffusionImg = dynamic_cast<mitk::Image*>(m_DiffusionImageNode->GetData());
     mitk::Image::Pointer maskImg = NULL;
     if (m_MaskImageNode.IsNotNull())
         maskImg = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
 
-    if (!m_MultiWidget) return;
+    if (!this->GetRenderWindowPart()) return;
 
     VecImgType::Pointer vecimg = VecImgType::New();
     mitk::CastToItkImage(diffusionImg, vecimg);
 
     VecImgType::Pointer roiImage = VecImgType::New();
 
     bool success = false;
     if(maskImg.IsNull())
     {
         int roisize = 0;
         if(m_Controls->m_MethodCombo->currentIndex() == 4)
             roisize = 5;
 
-        mitk::Point3D pos = m_MultiWidget->GetCrossPosition();
+        mitk::Point3D pos = this->GetRenderWindowPart()->GetSelectedPosition();
 
         VecImgType::IndexType crosspos;
         diffusionImg->GetGeometry()->WorldToIndex(pos, crosspos);
         if (!vecimg->GetLargestPossibleRegion().IsInside(crosspos))
         {
             m_Controls->m_Warning->setText(QString("Crosshair position not inside of selected diffusion weighted image. Reinit needed!"));
             m_Controls->m_Warning->setVisible(true);
             return;
         }
         else
             m_Controls->m_Warning->setVisible(false);
 
         VecImgType::IndexType index;
         index[0] = crosspos[0] - roisize; index[0] = index[0] < 0 ? 0 : index[0];
         index[1] = crosspos[1] - roisize; index[1] = index[1] < 0 ? 0 : index[1];
         index[2] = crosspos[2] - roisize; index[2] = index[2] < 0 ? 0 : index[2];
 
         VecImgType::SizeType size;
         size[0] = roisize*2+1;
         size[1] = roisize*2+1;
         size[2] = roisize*2+1;
 
         VecImgType::SizeType maxSize = vecimg->GetLargestPossibleRegion().GetSize();
         size[0] = index[0]+size[0] > maxSize[0] ? maxSize[0]-index[0] : size[0];
         size[1] = index[1]+size[1] > maxSize[1] ? maxSize[1]-index[1] : size[1];
         size[2] = index[2]+size[2] > maxSize[2] ? maxSize[2]-index[2] : size[2];
 
         VecImgType::RegionType region;
         region.SetSize( size );
         region.SetIndex( index );
         vecimg->SetRequestedRegion( region );
 
         VecImgType::IndexType  newstart;
         newstart.Fill(0);
 
         VecImgType::RegionType newregion;
         newregion.SetSize( size );
         newregion.SetIndex( newstart );
 
         roiImage->CopyInformation( vecimg );
         roiImage->SetRegions( newregion );
         roiImage->SetOrigin( pos );
         roiImage->Allocate();
         roiImage->SetPixel(newstart, vecimg->GetPixel(index));
 
         if( m_Controls->m_ModelTabSelectionWidget->currentIndex() )
         {
             success = FitKurtosis(roiImage,
                              static_cast<mitk::GradientDirectionsProperty*>( diffusionImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(),
                              static_cast<mitk::FloatProperty*>(diffusionImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue(),
                              newstart);
         }
         else
         {
             success = FittIVIM(roiImage,
                              static_cast<mitk::GradientDirectionsProperty*>( diffusionImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(),
                              static_cast<mitk::FloatProperty*>(diffusionImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue(),
                              false,
                              crosspos);
         }
     }
     else
     {
         typedef itk::Image<float,3> MaskImgType;
 
         MaskImgType::Pointer maskItk;
         CastToItkImage( maskImg, maskItk );
 
         mitk::Point3D pos;
         pos[0] = 0;
         pos[1] = 0;
         pos[2] = 0;
 
         VecImgType::IndexType index;
         index[0] = 0;
         index[1] = 0;
         index[2] = 0;
 
         VecImgType::SizeType size;
         size[0] = 1;
         size[1] = 1;
         size[2] = 1;
 
         VecImgType::RegionType region;
         region.SetSize( size );
         region.SetIndex( index );
         vecimg->SetRequestedRegion( region );
 
         // iterators over output and input
         itk::ImageRegionConstIteratorWithIndex<VecImgType>
                 vecit(vecimg, vecimg->GetLargestPossibleRegion());
 
         itk::VariableLengthVector<double> avg(vecimg->GetVectorLength());
         avg.Fill(0);
 
         float numPixels = 0;
         while ( ! vecit.IsAtEnd() )
         {
             VecImgType::PointType point;
             vecimg->TransformIndexToPhysicalPoint(vecit.GetIndex(), point);
 
             MaskImgType::IndexType index;
             maskItk->TransformPhysicalPointToIndex(point, index);
 
             if(maskItk->GetPixel(index) != 0)
             {
                 avg += vecit.Get();
                 numPixels += 1.0;
             }
 
             // update iterators
             ++vecit;
 
         }
 
         avg /= numPixels;
 
         m_Controls->m_Warning->setText(QString("Averaging ")+QString::number((int)numPixels)+QString(" voxels!"));
         m_Controls->m_Warning->setVisible(true);
 
         roiImage->CopyInformation( vecimg );
         roiImage->SetRegions( region );
         roiImage->SetOrigin( pos );
         roiImage->Allocate();
         roiImage->SetPixel(index, avg);
 
         if( m_Controls->m_ModelTabSelectionWidget->currentIndex() )
         {
             success = FitKurtosis(roiImage,
                              static_cast<mitk::GradientDirectionsProperty*>( diffusionImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(),
                              static_cast<mitk::FloatProperty*>(diffusionImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue(),
                              index);
         }
         else
         {
             success = FittIVIM(roiImage,
                              static_cast<mitk::GradientDirectionsProperty*>( diffusionImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(),
                              static_cast<mitk::FloatProperty*>(diffusionImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue(),
                              false,
                              index);
         }
 
         // do not update until selection changed, the values will remain the same as long as the mask is selected!
         m_HoldUpdate = true;
 
     }
 
     vecimg->SetRegions( vecimg->GetLargestPossibleRegion() );
 
     if (success)
     {
         // 0 - IVIM, 1 - Kurtosis
         if( m_Controls->m_ModelTabSelectionWidget->currentIndex() )
         {
            m_Controls->m_KurtosisVisualizationWidget->setVisible(true);
            m_Controls->m_KurtosisVisualizationWidget->SetData(m_KurtosisSnap);
         }
         else
         {
            m_Controls->m_VisualizeResultsWidget->setVisible(true);
            m_Controls->m_VisualizeResultsWidget->SetParameters(m_Snap);
         }
     }
 }
 
 bool QmitkIVIMView::FitKurtosis( itk::VectorImage<short, 3> *vecimg, DirContainerType *dirs, float bval, OutImgType::IndexType &crosspos )
 {
   KurtosisFilterType::Pointer filter = KurtosisFilterType::New();
 
   itk::KurtosisFitConfiguration fit_config;
   fit_config.omit_bzero =  this->m_Controls->m_OmitBZeroCB->isChecked();
   if( this->m_Controls->m_UseKurtosisBoundsCB->isChecked() )
   {
     fit_config.use_K_limits = true;
     vnl_vector_fixed<double, 2> k_limits;
     k_limits[0] = this->m_Controls->m_KurtosisRangeWidget->minimumValue();
     k_limits[1] = this->m_Controls->m_KurtosisRangeWidget->maximumValue();
 
     fit_config.K_limits = k_limits;
 
   }
   fit_config.fit_scale = static_cast<itk::FitScale>(this->m_Controls->m_KurtosisFitScale->currentIndex() );
 
   m_KurtosisSnap = filter->GetSnapshot( vecimg->GetPixel( crosspos ), dirs, bval, fit_config );
 
   return true;
 }
 
 
 bool QmitkIVIMView::FittIVIM(itk::VectorImage<short,3>* vecimg, DirContainerType* dirs, float bval, bool multivoxel, OutImgType::IndexType &crosspos)
 {
     IVIMFilterType::Pointer filter = IVIMFilterType::New();
     filter->SetInput(vecimg);
     filter->SetGradientDirections(dirs);
     filter->SetBValue(bval);
 
     switch(m_Controls->m_MethodCombo->currentIndex())
     {
 
     case 0:
         filter->SetMethod(IVIMFilterType::IVIM_FIT_ALL);
         filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
         break;
 
     case 1:
         filter->SetMethod(IVIMFilterType::IVIM_DSTAR_FIX);
         filter->SetDStar(m_Controls->m_DStarLabel->text().toDouble());
         filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
         break;
 
     case 2:
         filter->SetMethod(IVIMFilterType::IVIM_D_THEN_DSTAR);
         filter->SetBThres(m_Controls->m_BThreshLabel->text().toDouble());
         filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
         filter->SetFitDStar(m_Controls->m_CheckDStar->isChecked());
         break;
 
     case 3:
         filter->SetMethod(IVIMFilterType::IVIM_LINEAR_D_THEN_F);
         filter->SetBThres(m_Controls->m_BThreshLabel->text().toDouble());
         filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
         filter->SetFitDStar(m_Controls->m_CheckDStar->isChecked());
         break;
 
     case 4:
         filter->SetMethod(IVIMFilterType::IVIM_REGULARIZED);
         filter->SetBThres(m_Controls->m_BThreshLabel->text().toDouble());
         filter->SetS0Thres(m_Controls->m_S0ThreshLabel->text().toDouble());
         filter->SetNumberIterations(m_Controls->m_NumItsLabel->text().toInt());
         filter->SetLambda(m_Controls->m_LambdaLabel->text().toDouble());
         filter->SetFitDStar(m_Controls->m_CheckDStar->isChecked());
         break;
     }
 
     if(!multivoxel)
     {
         filter->SetFitDStar(true);
     }
 
     filter->SetNumberOfThreads(1);
     filter->SetVerbose(false);
     filter->SetCrossPosition(crosspos);
 
     try{
         filter->Update();
         m_Snap = filter->GetSnapshot();
         m_DStarMap = filter->GetOutput(2);
         m_DMap = filter->GetOutput(1);
         m_fMap = filter->GetOutput();
     }
     catch (itk::ExceptionObject &ex)
     {
         MITK_INFO << ex ;
         m_Controls->m_Warning->setText(QString("IVIM fit not possible: ")+ex.GetDescription());
         m_Controls->m_Warning->setVisible(true);
         return false;
     }
     return true;
 }
 
-void QmitkIVIMView::OutputToDatastorage(std::vector<mitk::DataNode*> nodes)
+void QmitkIVIMView::OutputToDatastorage(const QList<mitk::DataNode::Pointer>& nodes)
 {
     // Outputs to Datastorage
     QString basename(nodes.front()->GetName().c_str());
 
     if(m_Controls->m_CheckDStar->isChecked())
     {
         mitk::Image::Pointer dstarimage = mitk::Image::New();
         dstarimage->InitializeByItk(m_DStarMap.GetPointer());
         dstarimage->SetVolume(m_DStarMap->GetBufferPointer());
         QString newname2 = basename; newname2 = newname2.append("_DStarMap_%1").arg(m_Controls->m_MethodCombo->currentText());
         mitk::DataNode::Pointer node2=mitk::DataNode::New();
         node2->SetData( dstarimage );
         node2->SetName(newname2.toLatin1());
-        GetDefaultDataStorage()->Add(node2);
+        GetDataStorage()->Add(node2);
     }
 
     if(m_Controls->m_CheckD->isChecked())
     {
         mitk::Image::Pointer dimage = mitk::Image::New();
         dimage->InitializeByItk(m_DMap.GetPointer());
         dimage->SetVolume(m_DMap->GetBufferPointer());
         QString newname1 = basename; newname1 = newname1.append("_DMap_%1").arg(m_Controls->m_MethodCombo->currentText());
         mitk::DataNode::Pointer node1=mitk::DataNode::New();
         node1->SetData( dimage );
         node1->SetName(newname1.toLatin1());
-        GetDefaultDataStorage()->Add(node1);
+        GetDataStorage()->Add(node1);
     }
 
     if(m_Controls->m_Checkf->isChecked())
     {
         mitk::Image::Pointer image = mitk::Image::New();
         image->InitializeByItk(m_fMap.GetPointer());
         image->SetVolume(m_fMap->GetBufferPointer());
         QString newname0 = basename; newname0 = newname0.append("_fMap_%1").arg(m_Controls->m_MethodCombo->currentText());
         mitk::DataNode::Pointer node=mitk::DataNode::New();
         node->SetData( image );
         node->SetName(newname0.toLatin1());
-        GetDefaultDataStorage()->Add(node);
+        GetDataStorage()->Add(node);
     }
 
-    m_MultiWidget->RequestUpdate();
+    this->GetRenderWindowPart()->RequestUpdate();
 
     // reset the data node labels, the selection in DataManager is lost after adding
     // a new node -> we cannot directly proceed twice, the DWI ( and MASK) image have to be selected again
     m_Controls->m_InputData->setTitle("Please Select Input Data");
     m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_MaskImageLabel->setText("<font color='grey'>optional</font>");
     m_MaskImageNode = NULL;
     m_DiffusionImageNode = NULL;
 
 }
 
 void QmitkIVIMView::ChooseMethod()
 {
     m_Controls->m_MethodCombo->setVisible(m_Controls->m_ChooseMethod->isChecked());
 }
 
 void QmitkIVIMView::ClipboardCurveButtonClicked()
 {
   // Kurtosis
     if ( m_Controls->m_ModelTabSelectionWidget->currentIndex() )
     {
       std::stringstream ss;
       QString clipboard("Measurement Points\n");
 
       ss << m_KurtosisSnap.bvalues << "\n" << m_KurtosisSnap.measurements << "\n\n";
       ss << "Fitted Values ( D  K  [b_0] ) \n" << m_KurtosisSnap.m_D << " " << m_KurtosisSnap.m_K;
       if( m_KurtosisSnap.m_fittedBZero )
         ss << " " << m_KurtosisSnap.m_BzeroFit;
 
       ss << "\n\n";
       clipboard.append( QString( ss.str().c_str() ));
 
       ss.str( std::string() );
       ss.clear();
 
       QApplication::clipboard()->setText(
                   clipboard, QClipboard::Clipboard );
     }
     else
     {
 
         QString clipboard("Measurement Points\n");
         for ( unsigned int i=0; i<m_Snap.bvalues.size(); i++)
         {
             clipboard = clipboard.append( "%L1 \t" )
                     .arg( m_Snap.bvalues[i], 0, 'f', 2 );
         }
         clipboard = clipboard.append( "\n" );
 
         for ( unsigned int i=0; i<m_Snap.allmeas.size(); i++)
         {
             clipboard = clipboard.append( "%L1 \t" )
                     .arg( m_Snap.allmeas[i], 0, 'f', 2 );
         }
         clipboard = clipboard.append( "\n" );
 
 
         clipboard = clipboard.append( "1st Linear Fit of D and f \n" );
         double maxb = m_Snap.bvalues.max_value();
         clipboard = clipboard.append( "%L1 \t %L2 \n %L3 \t %L4 \n" )
                 .arg( (float) 0, 0, 'f', 2 )
                 .arg( maxb, 0, 'f', 2 )
                 .arg(1-m_Snap.currentFunceiled, 0, 'f', 2 )
                 .arg((1-m_Snap.currentFunceiled)*exp(-maxb * m_Snap.currentD), 0, 'f', 2 );
 
 
         int nsampling = 50;
         double f = 1-m_Snap.currentFunceiled;
         clipboard = clipboard.append("Final Model\n");
         for(int i=0; i<nsampling; i++)
         {
             double x = (((1.0)*i)/(1.0*nsampling))*maxb;
             clipboard = clipboard.append( "%L1 \t" )
                     .arg( x, 0, 'f', 2 );
         }
         clipboard = clipboard.append( "\n" );
 
         for(int i=0; i<nsampling; i++)
         {
             double x = (((1.0)*i)/(1.0*nsampling))*maxb;
             double y = f*exp(- x * m_Snap.currentD) + (1-f)*exp(- x * (m_Snap.currentD+m_Snap.currentDStar));
             clipboard = clipboard.append( "%L1 \t" )
                     .arg( y, 0, 'f', 2 );
         }
         clipboard = clipboard.append( "\n" );
 
         QApplication::clipboard()->setText(
                     clipboard, QClipboard::Clipboard );
     }
 }
 
 
 void QmitkIVIMView::ClipboardStatisticsButtonClicked()
 {
     // Kurtosis
     if ( m_Controls->m_ModelTabSelectionWidget->currentIndex() )
     {
 
         QString clipboard( "D \t K \n" );
         clipboard = clipboard.append( "%L1 \t %L2" )
                 .arg( m_KurtosisSnap.m_D, 0, 'f', 10 )
                 .arg( m_KurtosisSnap.m_K, 0, 'f', 10 ) ;
 
         QApplication::clipboard()->setText(
                     clipboard, QClipboard::Clipboard );
     }
     else
     {
       QString clipboard( "f \t D \t D* \n" );
       clipboard = clipboard.append( "%L1 \t %L2 \t %L3" )
               .arg( m_Snap.currentF, 0, 'f', 10 )
               .arg( m_Snap.currentD, 0, 'f', 10 )
               .arg( m_Snap.currentDStar, 0, 'f', 10 ) ;
 
       QApplication::clipboard()->setText(
                   clipboard, QClipboard::Clipboard );
     }
 }
 
 void QmitkIVIMView::Activated()
 {
     m_Active = true;
 }
 
 void QmitkIVIMView::Deactivated()
 {
     m_Active = false;
 }
+
+void QmitkIVIMView::Visible()
+{
+    m_Visible = true;
+}
+
+void QmitkIVIMView::Hidden()
+{
+    m_Visible = false;
+}
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.h
index 0f147d7c43..acaa7086e1 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkIVIMView.h
@@ -1,127 +1,133 @@
 /*===================================================================
 
 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 _QMITKIVIMVIEW_H_INCLUDED
 #define _QMITKIVIMVIEW_H_INCLUDED
 
 #include <berryISelectionListener.h>
 
-#include <QmitkFunctionality.h>
+#include <QmitkAbstractView.h>
+#include <mitkILifecycleAwarePart.h>
+#include <mitkIRenderWindowPartListener.h>
 
 #include "ui_QmitkIVIMViewControls.h"
 
 #include "itkVectorImage.h"
 #include "itkImage.h"
 
 #include <mitkDiffusionPropertyHelper.h>
 #include "itkDiffusionIntravoxelIncoherentMotionReconstructionImageFilter.h"
 #include "itkDiffusionKurtosisReconstructionImageFilter.h"
 
 /*!
   \brief QmitkIVIMView
 
   \warning  This application module is not yet documented. Use "svn blame/praise/annotate" and ask the author to provide basic documentation.
-
-  \sa QmitkFunctionality
-  \ingroup Functionalities
 */
 
-class QmitkIVIMView : public QmitkFunctionality
+class QmitkIVIMView : public QmitkAbstractView, public mitk::ILifecycleAwarePart,  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:
 
   static const std::string VIEW_ID;
 
   QmitkIVIMView();
   virtual ~QmitkIVIMView();
 
   typedef mitk::DiffusionPropertyHelper::GradientDirectionType GradientDirectionType;
   typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType DirContainerType;
   typedef itk::DiffusionIntravoxelIncoherentMotionReconstructionImageFilter<short, float> IVIMFilterType;
   typedef itk::DiffusionKurtosisReconstructionImageFilter<short, float> KurtosisFilterType;
   typedef itk::VectorImage<short,3> VecImgType;
   typedef itk::Image<float,3> OutImgType;
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
-  virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget) override;
-  virtual void StdMultiWidgetNotAvailable() override;
+  ///
+  /// Sets the focus to an internal widget.
+  ///
+  virtual void SetFocus() override;
+
+  virtual void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart) override;
+  virtual void RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart) override;
 
   void OnSliceChanged(const itk::EventObject& e);
-  void OutputToDatastorage(std::vector<mitk::DataNode*> nodes);
+  void OutputToDatastorage(const QList<mitk::DataNode::Pointer>& nodes);
   bool FittIVIM(itk::VectorImage<short,3>* vecimg, DirContainerType* dirs, float bval, bool multivoxel, OutImgType::IndexType &crosspos);
 
   void Activated() override;
   void Deactivated() override;
+  void Visible() override;
+  void Hidden() override;
 
 protected slots:
 
   /// \brief Called when the user clicks the GUI button
   void FittIVIMStart();
   void AutoThreshold();
 
   void MethodCombo(int val);
   void Checkbox();
 
   void DStarSlider(int val);
   void BThreshSlider(int val);
   void S0ThreshSlider(int val);
   void NumItsSlider(int val);
   void LambdaSlider(int val);
   void ChooseMethod();
   void ClipboardStatisticsButtonClicked();
   void ClipboardCurveButtonClicked();
 
   void OnKurtosisParamsChanged();
 
 protected:
 
-  /// \brief called by QmitkFunctionality when DataManager's selection has changed
-  virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes ) override;
+  /// \brief called by QmitkAbstractView when DataManager's selection has changed
+  virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
   bool FitKurtosis( itk::VectorImage<short, 3> *vecimg, DirContainerType *dirs, float bval, OutImgType::IndexType &crosspos);
 
   Ui::QmitkIVIMViewControls* m_Controls;
 
-  QmitkStdMultiWidget* m_MultiWidget;
   int m_SliceObserverTag1;
   int m_SliceObserverTag2;
   int m_SliceObserverTag3;
 
   OutImgType::Pointer m_DStarMap;
   OutImgType::Pointer m_DMap;
   OutImgType::Pointer m_fMap;
 
   IVIMFilterType::IVIMSnapshot m_Snap;
   KurtosisFilterType::KurtosisSnapshot m_KurtosisSnap;
 
   mitk::DataNode::Pointer m_DiffusionImageNode;
   mitk::DataNode::Pointer m_MaskImageNode;
 
   bool m_Active;
+  bool m_Visible;
 
   bool m_HoldUpdate;
 
 };
 
 
 
 #endif // _QMITKIVIMVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkMLBTView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkMLBTView.cpp
index 5c80118200..6014e8e9f4 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkMLBTView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkMLBTView.cpp
@@ -1,430 +1,417 @@
 /*===================================================================
 
 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>
 
 // Qmitk
 #include "QmitkMLBTView.h"
-#include "QmitkStdMultiWidget.h"
 
 // Qt
 #include <QMessageBox>
 #include <QFileDialog>
 #include <QString>
 
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkImageCast.h>
 #include <mitkEnumerationProperty.h>
 #include <mitkPointSetShapeProperty.h>
 #include <mitkPointSet.h>
 #include <mitkNodePredicateIsDWI.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 const std::string QmitkMLBTView::VIEW_ID = "org.mitk.views.mlbtview";
 using namespace berry;
 
 QmitkMLBTView::QmitkMLBTView()
-    : QmitkFunctionality()
+    : QmitkAbstractView()
     , m_Controls( 0 )
-    , m_MultiWidget( NULL )
 {
     m_TrackingTimer = std::make_shared<QTimer>(this);
     m_LastLoadedForestName = "(none)";
 }
 
 // Destructor
 QmitkMLBTView::~QmitkMLBTView()
 {
 
 }
 
 void QmitkMLBTView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkMLBTViewControls;
         m_Controls->setupUi( parent );
 
         connect( m_Controls->m_StartTrainingButton, SIGNAL ( clicked() ), this, SLOT( StartTrainingThread() ) );
         connect( &m_TrainingWatcher, SIGNAL ( finished() ), this, SLOT( OnTrainingThreadStop() ) );
         connect( m_Controls->m_StartTrackingButton, SIGNAL ( clicked() ), this, SLOT( StartTrackingThread() ) );
         connect( &m_TrackingWatcher, SIGNAL ( finished() ), this, SLOT( OnTrackingThreadStop() ) );
         connect( m_Controls->m_SaveForestButton, SIGNAL ( clicked() ), this, SLOT( SaveForest() ) );
         connect( m_Controls->m_LoadForestButton, SIGNAL ( clicked() ), this, SLOT( LoadForest() ) );
         connect( m_TrackingTimer.get(), SIGNAL(timeout()), this, SLOT(BuildFibers()) );
         connect( m_Controls->m_TimerIntervalBox, SIGNAL(valueChanged(int)), this, SLOT( ChangeTimerInterval(int) ));
         connect( m_Controls->m_DemoModeBox, SIGNAL(stateChanged(int)), this, SLOT( ToggleDemoMode(int) ));
         connect( m_Controls->m_PauseTrackingButton, SIGNAL ( clicked() ), this, SLOT( PauseTracking() ) );
         connect( m_Controls->m_AbortTrackingButton, SIGNAL ( clicked() ), this, SLOT( AbortTracking() ) );
         connect( m_Controls->m_AddTwButton, SIGNAL ( clicked() ), this, SLOT( AddTrainingWidget() ) );
         connect( m_Controls->m_RemoveTwButton, SIGNAL ( clicked() ), this, SLOT( RemoveTrainingWidget() ) );
 
         m_Controls->m_TrackingMaskImageBox->SetDataStorage(this->GetDataStorage());
         m_Controls->m_TrackingSeedImageBox->SetDataStorage(this->GetDataStorage());
         m_Controls->m_TrackingStopImageBox->SetDataStorage(this->GetDataStorage());
         m_Controls->m_TrackingRawImageBox->SetDataStorage(this->GetDataStorage());
 
         mitk::NodePredicateIsDWI::Pointer isDiffusionImage = mitk::NodePredicateIsDWI::New();
 
         mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
         mitk::NodePredicateNot::Pointer noDiffusionImage = mitk::NodePredicateNot::New(isDiffusionImage);
         mitk::NodePredicateAnd::Pointer finalPredicate = mitk::NodePredicateAnd::New(isMitkImage, noDiffusionImage);
         mitk::NodePredicateProperty::Pointer isBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
         finalPredicate = mitk::NodePredicateAnd::New(finalPredicate, isBinaryPredicate);
         m_Controls->m_TrackingMaskImageBox->SetPredicate(finalPredicate);
         m_Controls->m_TrackingSeedImageBox->SetPredicate(finalPredicate);
         m_Controls->m_TrackingStopImageBox->SetPredicate(finalPredicate);
         m_Controls->m_TrackingRawImageBox->SetPredicate(isDiffusionImage);
 
         m_Controls->m_TrackingMaskImageBox->SetZeroEntryText("--");
         m_Controls->m_TrackingSeedImageBox->SetZeroEntryText("--");
         m_Controls->m_TrackingStopImageBox->SetZeroEntryText("--");
         AddTrainingWidget();
 
         UpdateGui();
     }
 }
 
 void QmitkMLBTView::AddTrainingWidget()
 {
     std::shared_ptr<QmitkMlbstTrainingDataWidget> tw = std::make_shared<QmitkMlbstTrainingDataWidget>();
     tw->SetDataStorage(this->GetDataStorage());
     m_Controls->m_TwFrame->layout()->addWidget(tw.get());
     m_TrainingWidgets.push_back(tw);
 }
 
 void QmitkMLBTView::RemoveTrainingWidget()
 {
     if(m_TrainingWidgets.size()>1)
     {
         m_TrainingWidgets.back().reset();
         m_TrainingWidgets.pop_back();
     }
 }
 
 void QmitkMLBTView::UpdateGui()
 {
     if (m_ForestHandler.IsForestValid())
     {
         std::string label_text="Random forest available: "+m_LastLoadedForestName;
         m_Controls->statusLabel->setText( QString(label_text.c_str()) );
         m_Controls->m_SaveForestButton->setEnabled(true);
         m_Controls->m_StartTrackingButton->setEnabled(true);
     }
     else
     {
         m_Controls->statusLabel->setText("Please load or train random forest!");
         m_Controls->m_SaveForestButton->setEnabled(false);
         m_Controls->m_StartTrackingButton->setEnabled(false);
     }
 }
 
+void QmitkMLBTView::SetFocus()
+{
+  m_Controls->toolBox->setFocus();
+}
+
 void QmitkMLBTView::AbortTracking()
 {
     if (tracker.IsNotNull())
     {
         tracker->m_AbortTracking = true;
     }
 }
 
 void QmitkMLBTView::PauseTracking()
 {
     if (tracker.IsNotNull())
     {
         tracker->m_PauseTracking = !tracker->m_PauseTracking;
     }
 }
 
 void QmitkMLBTView::ChangeTimerInterval(int value)
 {
     m_TrackingTimer->setInterval(value);
 }
 
 void QmitkMLBTView::ToggleDemoMode(int state)
 {
     if (tracker.IsNotNull())
     {
         tracker->SetDemoMode(m_Controls->m_DemoModeBox->isChecked());
         tracker->m_Stop = false;
     }
 }
 
 void QmitkMLBTView::BuildFibers()
 {
     if (m_Controls->m_DemoModeBox->isChecked() && tracker.IsNotNull() && tracker->m_BuildFibersFinished)
     {
         vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
         mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
         outFib->SetFiberColors(255,255,255);
         m_TractogramNode->SetData(outFib);
 
         m_SamplingPointsNode->SetData(tracker->m_SamplingPointset);
         m_AlternativePointsNode->SetData(tracker->m_AlternativePointset);
 
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
         tracker->m_BuildFibersFinished = false;
         tracker->m_BuildFibersReady = 0;
         tracker->m_Stop = false;
     }
 }
 
 void QmitkMLBTView::LoadForest()
 {
 
     QString filename = QFileDialog::getOpenFileName(0, tr("Load Forest"), QDir::currentPath(), tr("HDF5 random forest file (*.rf)") );
     if(filename.isEmpty() || filename.isNull())
         return;
 
     m_ForestHandler.LoadForest( filename.toStdString() );
     QFileInfo fi( filename );
     m_LastLoadedForestName = QString( fi.baseName() + "." + fi.completeSuffix() ).toStdString();
 
     UpdateGui();
 }
 
 void QmitkMLBTView::StartTrackingThread()
 {
     m_TractogramNode = mitk::DataNode::New();
     m_TractogramNode->SetName("MLBT Result");
     m_TractogramNode->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(20));
     m_TractogramNode->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
     m_TractogramNode->SetProperty("LineWidth", mitk::IntProperty::New(2));
     m_TractogramNode->SetProperty("color",mitk::ColorProperty::New(0, 1, 1));
     this->GetDataStorage()->Add(m_TractogramNode);
 
     m_SamplingPointsNode = mitk::DataNode::New();
     m_SamplingPointsNode->SetName("SamplingPoints");
     m_SamplingPointsNode->SetProperty("pointsize", mitk::FloatProperty::New(0.2));
     m_SamplingPointsNode->SetProperty("color", mitk::ColorProperty::New(1,1,1));
     mitk::PointSetShapeProperty::Pointer bla = mitk::PointSetShapeProperty::New(); bla->SetValue(8);
     m_SamplingPointsNode->SetProperty("Pointset.2D.shape", bla);
     m_SamplingPointsNode->SetProperty("Pointset.2D.distance to plane", mitk::FloatProperty::New(1.5));
     m_SamplingPointsNode->SetProperty("point 2D size", mitk::FloatProperty::New(0.1));
     m_SamplingPointsNode->SetProperty("Pointset.2D.fill shape", mitk::BoolProperty::New(true));
     this->GetDataStorage()->Add(m_SamplingPointsNode);
 
     m_AlternativePointsNode = mitk::DataNode::New();
     m_AlternativePointsNode->SetName("AlternativePoints");
     m_AlternativePointsNode->SetProperty("pointsize", mitk::FloatProperty::New(0.2));
     m_AlternativePointsNode->SetProperty("color", mitk::ColorProperty::New(1,0,0));
     m_AlternativePointsNode->SetProperty("Pointset.2D.shape", bla);
     m_AlternativePointsNode->SetProperty("Pointset.2D.distance to plane", mitk::FloatProperty::New(1.5));
     m_AlternativePointsNode->SetProperty("point 2D size", mitk::FloatProperty::New(0.1));
     m_AlternativePointsNode->SetProperty("Pointset.2D.fill shape", mitk::BoolProperty::New(true));
     this->GetDataStorage()->Add(m_AlternativePointsNode);
 
     QFuture<void> future = QtConcurrent::run( this, &QmitkMLBTView::StartTracking );
     m_TrackingWatcher.setFuture(future);
     m_TrackingThreadIsRunning = true;
     m_Controls->m_StartTrackingButton->setEnabled(false);
     m_TrackingTimer->start(m_Controls->m_TimerIntervalBox->value());
 }
 
 void QmitkMLBTView::OnTrackingThreadStop()
 {
     m_TrackingThreadIsRunning = false;
     m_Controls->m_StartTrackingButton->setEnabled(true);
 
     vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
     mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
     m_TractogramNode->SetData(outFib);
     m_TractogramNode->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(1));
     if (m_Controls->m_DemoModeBox->isChecked())
     {
         m_SamplingPointsNode->SetData(tracker->m_SamplingPointset);
         m_AlternativePointsNode->SetData(tracker->m_AlternativePointset);
     }
 
     tracker = NULL;
     m_TrackingTimer->stop();
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkMLBTView::StartTracking()
 {
     if ( m_Controls->m_TrackingRawImageBox->GetSelectedNode().IsNull() || !m_ForestHandler.IsForestValid())
         return;
 
     mitk::Image::Pointer dwi = dynamic_cast<mitk::Image*>(m_Controls->m_TrackingRawImageBox->GetSelectedNode()->GetData());
     m_ForestHandler.AddRawData(dwi);
 
 //    int numThread = itk::MultiThreader::GetGlobalDefaultNumberOfThreads();
 
     tracker = TrackerType::New();
     tracker->SetInput(0,  mitk::DiffusionPropertyHelper::GetItkVectorImage(dwi) );
     tracker->SetDemoMode(m_Controls->m_DemoModeBox->isChecked());
     if (m_Controls->m_DemoModeBox->isChecked())
         tracker->SetNumberOfThreads(1);
     if (m_Controls->m_TrackingMaskImageBox->GetSelectedNode().IsNotNull())
     {
         mitk::Image::Pointer mask = dynamic_cast<mitk::Image*>(m_Controls->m_TrackingMaskImageBox->GetSelectedNode()->GetData());
         ItkUcharImgType::Pointer itkMask = ItkUcharImgType::New();
         mitk::CastToItkImage(mask, itkMask);
         tracker->SetMaskImage(itkMask);
     }
     if (m_Controls->m_TrackingSeedImageBox->GetSelectedNode().IsNotNull())
     {
         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_Controls->m_TrackingSeedImageBox->GetSelectedNode()->GetData());
         ItkUcharImgType::Pointer itkImg = ItkUcharImgType::New();
         mitk::CastToItkImage(img, itkImg);
         tracker->SetSeedImage(itkImg);
     }
     if (m_Controls->m_TrackingStopImageBox->GetSelectedNode().IsNotNull())
     {
         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_Controls->m_TrackingStopImageBox->GetSelectedNode()->GetData());
         ItkUcharImgType::Pointer itkImg = ItkUcharImgType::New();
         mitk::CastToItkImage(img, itkImg);
         tracker->SetStoppingRegions(itkImg);
     }
     tracker->SetSeedsPerVoxel(m_Controls->m_NumberOfSeedsBox->value());
     tracker->SetStepSize(m_Controls->m_TrackingStepSizeBox->value());
     tracker->SetMinTractLength(m_Controls->m_MinLengthBox->value());
     tracker->SetMaxTractLength(m_Controls->m_MaxLengthBox->value());
     tracker->SetAposterioriCurvCheck(m_Controls->m_Curvcheck2->isChecked());
     tracker->SetRemoveWmEndFibers(false);
     tracker->SetAvoidStop(m_Controls->m_AvoidStop->isChecked());
     tracker->SetForestHandler(m_ForestHandler);
     tracker->SetSamplingDistance(m_Controls->m_SamplingDistanceBox->value());
     tracker->SetNumberOfSamples(m_Controls->m_NumSamplesBox->value());
     tracker->SetRandomSampling(m_Controls->m_RandomSampling->isChecked());
     tracker->Update();
 }
 
 void QmitkMLBTView::SaveForest()
 {
     if (!m_ForestHandler.IsForestValid())
     {
         UpdateGui();
         return;
     }
     QString filename = QFileDialog::getSaveFileName(0, tr("Save Forest"), QDir::currentPath()+"/forest.rf", tr("HDF5 random forest file (*.rf)") );
 
     if(filename.isEmpty() || filename.isNull())
         return;
     if(!filename.endsWith(".rf"))
         filename += ".rf";
 
     m_ForestHandler.SaveForest( filename.toStdString() );
 }
 
 void QmitkMLBTView::StartTrainingThread()
 {
     if (!this->IsTrainingInputValid())
     {
         QMessageBox::warning(nullptr, "Training aborted", "Training could not be started. Not all necessary datasets were selected.");
         return;
     }
 
     QFuture<void> future = QtConcurrent::run( this, &QmitkMLBTView::StartTraining );
     m_TrainingWatcher.setFuture(future);
     m_Controls->m_StartTrainingButton->setEnabled(false);
     m_Controls->m_SaveForestButton->setEnabled(false);
     m_Controls->m_LoadForestButton->setEnabled(false);
 }
 
 void QmitkMLBTView::OnTrainingThreadStop()
 {
     m_Controls->m_StartTrainingButton->setEnabled(true);
     m_Controls->m_SaveForestButton->setEnabled(true);
     m_Controls->m_LoadForestButton->setEnabled(true);
     UpdateGui();
 }
 
 void QmitkMLBTView::StartTraining()
 {
     std::vector< mitk::Image::Pointer > m_SelectedDiffImages;
     std::vector< mitk::FiberBundle::Pointer > m_SelectedFB;
     std::vector< ItkUcharImgType::Pointer > m_MaskImages;
     std::vector< ItkUcharImgType::Pointer > m_WhiteMatterImages;
 
     for (auto w : m_TrainingWidgets)
     {
         m_SelectedDiffImages.push_back(dynamic_cast<mitk::Image*>(w->GetImage()->GetData()));
         m_SelectedFB.push_back(dynamic_cast<mitk::FiberBundle*>(w->GetFibers()->GetData()));
 
         if (w->GetMask().IsNotNull())
         {
             mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(w->GetMask()->GetData());
             ItkUcharImgType::Pointer itkMask = ItkUcharImgType::New();
             mitk::CastToItkImage(img, itkMask);
             m_MaskImages.push_back(itkMask);
         }
         else
             m_MaskImages.push_back(nullptr);
 
         if (w->GetWhiteMatter().IsNotNull())
         {
             mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(w->GetWhiteMatter()->GetData());
             ItkUcharImgType::Pointer itkMask = ItkUcharImgType::New();
             mitk::CastToItkImage(img, itkMask);
             m_WhiteMatterImages.push_back(itkMask);
         }
         else
             m_WhiteMatterImages.push_back(nullptr);
     }
 
     m_ForestHandler.SetRawData(m_SelectedDiffImages);
     m_ForestHandler.SetTractograms(m_SelectedFB);
     m_ForestHandler.SetMaskImages(m_MaskImages);
     m_ForestHandler.SetWhiteMatterImages(m_WhiteMatterImages);
     m_ForestHandler.SetNumTrees(m_Controls->m_NumTreesBox->value());
     m_ForestHandler.SetMaxTreeDepth(m_Controls->m_MaxDepthBox->value());
     m_ForestHandler.SetGrayMatterSamplesPerVoxel(m_Controls->m_GmSamplingBox->value());
     m_ForestHandler.SetSampleFraction(m_Controls->m_SampleFractionBox->value());
     m_ForestHandler.SetStepSize(m_Controls->m_TrainingStepSizeBox->value());
     m_ForestHandler.StartTraining();
 }
 
-void QmitkMLBTView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
-{
-    m_MultiWidget = &stdMultiWidget;
-}
-
-
-void QmitkMLBTView::StdMultiWidgetNotAvailable()
-{
-    m_MultiWidget = NULL;
-}
-
-void QmitkMLBTView::Activated()
-{
-
-}
-
 bool QmitkMLBTView::IsTrainingInputValid(void) const
 {
   for (auto widget : m_TrainingWidgets)
   {
     if (widget->GetImage().IsNull() || widget->GetFibers().IsNull())
     {
       return false;
     }
   }
 
   return true;
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkMLBTView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkMLBTView.h
index 4b34f9b68b..3afb666216 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkMLBTView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkMLBTView.h
@@ -1,112 +1,112 @@
 /*===================================================================
 
 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 <QmitkFunctionality.h>
+#include <QmitkAbstractView.h>
 #include "ui_QmitkMLBTViewControls.h"
 
 #ifndef Q_MOC_RUN
 #include "mitkDataStorage.h"
 #include "mitkDataStorageSelection.h"
 #include <mitkTrackingForestHandler.h>
 #include <itkMLBSTrackingFilter.h>
 #endif
 
 #include <QtConcurrentRun>
 #include <QFutureWatcher>
 #include <QTimer>
 #include <QmitkMlbstTrainingDataWidget.h>
 #include <memory>
 #include <QGridLayout>
 
 /*!
 \brief View to perform machine learning based fiber tractography. Includes training of the random forst classifier as well as the actual tractography.
 */
 
 // Forward Qt class declarations
 
 
-class QmitkMLBTView : public QmitkFunctionality
+class QmitkMLBTView : public QmitkAbstractView
 {
 
 
   // 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:
 
   static const std::string VIEW_ID;
 
   typedef itk::Image<unsigned char, 3>      ItkUcharImgType;
   typedef itk::MLBSTrackingFilter<>         TrackerType;
 
   QmitkMLBTView();
   virtual ~QmitkMLBTView();
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
-  virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget) override;
-  virtual void StdMultiWidgetNotAvailable() override;
-  virtual void Activated() override;
+  ///
+  /// Sets the focus to an internal widget.
+  ///
+  virtual void SetFocus() override;
 
   protected slots:
 
   void StartTrackingThread();
   void OnTrackingThreadStop();
   void StartTrainingThread();
   void OnTrainingThreadStop();
   void SaveForest();
   void LoadForest();
   void BuildFibers();
   void ChangeTimerInterval(int value);
   void ToggleDemoMode(int state);
   void PauseTracking();
   void AbortTracking();
   void AddTrainingWidget();
   void RemoveTrainingWidget();
 
 protected:
 
   void StartTracking();
   void StartTraining();
   void UpdateGui();
 
   Ui::QmitkMLBTViewControls* m_Controls;
-  QmitkStdMultiWidget* m_MultiWidget;
 
   mitk::TrackingForestHandler<> m_ForestHandler;
 
   QFutureWatcher<void> m_TrainingWatcher;
   QFutureWatcher<void> m_TrackingWatcher;
   bool m_TrackingThreadIsRunning;
   TrackerType::Pointer tracker;
   std::shared_ptr<QTimer>   m_TrackingTimer;
   mitk::DataNode::Pointer m_TractogramNode;
   mitk::DataNode::Pointer m_SamplingPointsNode;
   mitk::DataNode::Pointer m_AlternativePointsNode;
 
   std::vector< std::shared_ptr<QmitkMlbstTrainingDataWidget> > m_TrainingWidgets;
 
 private:
 
   bool IsTrainingInputValid(void) const;
 
   std::string m_LastLoadedForestName;
 
  };
 
 
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.cpp
index 5732a7fb54..d12f9e02a1 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.cpp
@@ -1,377 +1,375 @@
 /*===================================================================
 
 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>
 
 // Qmitk
 #include "QmitkODFDetailsView.h"
 #include <QTableWidgetItem>
 #include <vtkFloatArray.h>
 #include <vtkPointData.h>
 #include <vtkCellData.h>
 #include <vtkLookupTable.h>
 #include <mitkOdfNormalizationMethodProperty.h>
 #include <QTextEdit>
 #include <mitkTensorImage.h>
 #include <QMessageBox>
 #include <QmitkRenderingManager.h>
 
 #include <mitkImageReadAccessor.h>
 
 #include <vtkRenderWindowInteractor.h>
 
 const std::string QmitkODFDetailsView::VIEW_ID = "org.mitk.views.odfdetails";
 
 QmitkODFDetailsView::QmitkODFDetailsView()
   : QmitkAbstractView()
   , m_Controls( 0 )
   , m_OdfNormalization(0)
   , m_ImageNode(NULL)
 {
   m_VtkActor = vtkActor::New();
   m_VtkMapper = vtkPolyDataMapper::New();
   m_Renderer = vtkRenderer::New();
   m_VtkRenderWindow = vtkRenderWindow::New();
   m_RenderWindowInteractor = vtkRenderWindowInteractor::New();
   m_Camera = vtkCamera::New();
   m_VtkRenderWindow->SetSize(300,300);
 
 }
 
 QmitkODFDetailsView::~QmitkODFDetailsView()
 {
   if (m_ImageNode.IsNotNull())
     m_ImageNode->RemoveObserver( m_PropertyObserverTag );
 }
 
+void QmitkODFDetailsView::Activated()
+{
+}
+
+void QmitkODFDetailsView::Deactivated()
+{
+}
+
 void QmitkODFDetailsView::Visible()
 {
   mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart();
 
   if (renderWindow)
   {
     {
       mitk::SliceNavigationController* slicer = renderWindow->GetQmitkRenderWindow(QString("axial"))->GetSliceNavigationController();
       itk::ReceptorMemberCommand<QmitkODFDetailsView>::Pointer command = itk::ReceptorMemberCommand<QmitkODFDetailsView>::New();
       command->SetCallbackFunction( this, &QmitkODFDetailsView::OnSliceChanged );
       m_SliceObserverTag1 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
     }
 
     {
       mitk::SliceNavigationController* slicer = renderWindow->GetQmitkRenderWindow(QString("sagittal"))->GetSliceNavigationController();
       itk::ReceptorMemberCommand<QmitkODFDetailsView>::Pointer command = itk::ReceptorMemberCommand<QmitkODFDetailsView>::New();
       command->SetCallbackFunction( this, &QmitkODFDetailsView::OnSliceChanged );
       m_SliceObserverTag2 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
     }
 
     {
       mitk::SliceNavigationController* slicer = renderWindow->GetQmitkRenderWindow(QString("coronal"))->GetSliceNavigationController();
       itk::ReceptorMemberCommand<QmitkODFDetailsView>::Pointer command = itk::ReceptorMemberCommand<QmitkODFDetailsView>::New();
       command->SetCallbackFunction( this, &QmitkODFDetailsView::OnSliceChanged );
       m_SliceObserverTag3 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
     }
   }
 }
 
 void QmitkODFDetailsView::Hidden()
 {
   mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart();
 
   if (renderWindow)
   {
     mitk::SliceNavigationController* slicer = renderWindow->GetQmitkRenderWindow(QString("axial"))->GetSliceNavigationController();
     slicer->RemoveObserver(m_SliceObserverTag1);
     slicer = renderWindow->GetQmitkRenderWindow(QString("sagittal"))->GetSliceNavigationController();
     slicer->RemoveObserver(m_SliceObserverTag2);
     slicer = renderWindow->GetQmitkRenderWindow(QString("coronal"))->GetSliceNavigationController();
     slicer->RemoveObserver(m_SliceObserverTag3);
   }
 }
 
-void QmitkODFDetailsView::Activated()
-{
-}
-
-void QmitkODFDetailsView::Deactivated()
-{
-}
-
 void QmitkODFDetailsView::SetFocus()
 {
-  this->m_Controls->m_ODFRenderWidget->setFocus();
+  this->m_Controls->m_OverviewTextEdit->setFocus();
 }
 
 void QmitkODFDetailsView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkODFDetailsViewControls;
     m_Controls->setupUi( parent );
     m_Controls->m_OdfBox->setVisible(false);
     m_Controls->m_ODFRenderWidget->setVisible(false);
   }
 }
 
-void QmitkODFDetailsView::OnSelectionChanged( berry::IWorkbenchPart::Pointer source,
-    const QList<mitk::DataNode::Pointer>& nodes )
+void QmitkODFDetailsView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
   if (m_ImageNode.IsNotNull())
     m_ImageNode->RemoveObserver( m_PropertyObserverTag );
 
   m_Controls->m_InputData->setTitle("Please Select Input Data");
   m_Controls->m_InputImageLabel->setText("<font color='red'>mandatory</font>");
 
   m_ImageNode = NULL;
 
   // iterate selection
-  foreach( mitk::DataNode::Pointer node, nodes )
+  for (mitk::DataNode::Pointer node: nodes)
   {
-
     if( node.IsNotNull() && (dynamic_cast<mitk::QBallImage*>(node->GetData()) || dynamic_cast<mitk::TensorImage*>(node->GetData())) )
     {
       m_Controls->m_InputImageLabel->setText(node->GetName().c_str());
       m_ImageNode = node;
     }
   }
 
   UpdateOdf();
   if (m_ImageNode.IsNotNull())
   {
     itk::ReceptorMemberCommand<QmitkODFDetailsView>::Pointer command = itk::ReceptorMemberCommand<QmitkODFDetailsView>::New();
     command->SetCallbackFunction( this, &QmitkODFDetailsView::OnSliceChanged );
     m_PropertyObserverTag = m_ImageNode->AddObserver( itk::ModifiedEvent(), command );
 
     m_Controls->m_InputData->setTitle("Input Data");
   }
 }
 
 void QmitkODFDetailsView::UpdateOdf()
 {
   try
   {
     m_Controls->m_OverviewBox->setVisible(true);
     if (m_ImageNode.IsNull() || !this->GetRenderWindowPart())
     {
       m_Controls->m_ODFRenderWidget->setVisible(false);
       m_Controls->m_OdfBox->setVisible(false);
       m_Controls->m_OverviewBox->setVisible(false);
       return;
     }
 
     // restore the input image label ( needed in case the last run resulted into an exception )
     m_Controls->m_InputImageLabel->setText(m_ImageNode->GetName().c_str());
 
     // ODF Normalization Property
     mitk::OdfNormalizationMethodProperty* nmp = dynamic_cast<mitk::OdfNormalizationMethodProperty*>(m_ImageNode->GetProperty( "Normalization" ));
     if(nmp)
       m_OdfNormalization = nmp->GetNormalization();
 
     m_TemplateOdf = itk::OrientationDistributionFunction<float,QBALL_ODFSIZE>::GetBaseMesh();
     m_OdfTransform = vtkSmartPointer<vtkTransform>::New();
     m_OdfTransform->Identity();
     m_OdfVals = vtkSmartPointer<vtkDoubleArray>::New();
     m_OdfSource = vtkSmartPointer<vtkOdfSource>::New();
     itk::OrientationDistributionFunction<double, QBALL_ODFSIZE> odf;
 
     mitk::Point3D world = this->GetRenderWindowPart()->GetSelectedPosition();
     mitk::Point3D index;
     mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_ImageNode->GetData());
     unsigned int *img_dimension = img->GetDimensions();
     img->GetGeometry()->WorldToIndex(world, index);
 
     float sum = 0;
     float max = itk::NumericTraits<float>::NonpositiveMin();
     float min = itk::NumericTraits<float>::max();
     QString values;
     QString overviewText;
 
     // check if dynamic_cast successfull and if the crosshair position is inside of the geometry of the ODF data
     // otherwise possible crash for a scenario with multiple nodes
     if (dynamic_cast<mitk::QBallImage*>(m_ImageNode->GetData()) && ( m_ImageNode->GetData()->GetGeometry()->IsInside(world) ) )
     {
       m_Controls->m_ODFRenderWidget->setVisible(true);
       m_Controls->m_OdfBox->setVisible(true);
 
       try
       {
         const mitk::QBallImage* qball_image = dynamic_cast< mitk::QBallImage* >( m_ImageNode->GetData() );
 
         // get access to the qball image data with explicitely allowing exceptions if memory locked
         mitk::ImageReadAccessor readAccess( qball_image, qball_image->GetVolumeData(0), mitk::ImageAccessorBase::ExceptionIfLocked );
         const float* qball_cPtr = static_cast< const float*>(readAccess.GetData());
 
         OdfVectorImgType::IndexType ind;
         ind[0] = (int)(index[0]+0.5);
         ind[1] = (int)(index[1]+0.5);
         ind[2] = (int)(index[2]+0.5);
 
         // pixel size = QBALL_ODFSIZE
         // position offset = standard offset
         unsigned int offset_to_data = QBALL_ODFSIZE * (ind[2] * img_dimension[1] * img_dimension[0] + ind[1] * img_dimension[0] + ind[0]);
         const float *pixel_data = qball_cPtr + offset_to_data;
 
         for (int i=0; i<QBALL_ODFSIZE; i++)
         {
           float val = pixel_data[i];
           odf.SetNthComponent(i, val);
           values += QString::number(i)+": "+QString::number(val)+"\n";
           sum += val;
           if (val>max)
             max = val;
           if (val<min)
             min = val;
         }
         float mean = sum/QBALL_ODFSIZE;
 
         QString pos = QString::number(ind[0])+", "+QString::number(ind[1])+", "+QString::number(ind[2]);
         overviewText += "Coordinates: "+pos+"\n";
         overviewText += "GFA: "+QString::number(odf.GetGeneralizedFractionalAnisotropy())+"\n";
         overviewText += "Sum: "+QString::number(sum)+"\n";
         overviewText += "Mean: "+QString::number(mean)+"\n";
         overviewText += "Min: "+QString::number(min)+"\n";
         overviewText += "Max: "+QString::number(max)+"\n";
         vnl_vector_fixed<double, 3> pd = odf.GetDirection(odf.GetPrincipleDiffusionDirection());
         overviewText += "Main Diffusion:\n     "+QString::number(pd[0])+"\n     "+QString::number(pd[1])+"\n     "+QString::number(pd[2])+"\n";
 
         m_Controls->m_OdfValuesTextEdit->setText(values);
         m_Controls->m_OverviewTextEdit->setVisible(true);
       }
       catch( mitk::Exception &e )
       {
         MITK_WARN << "LOCKED : " << e.what();
         m_Controls->m_ODFRenderWidget->setVisible(false);
         m_Controls->m_OdfBox->setVisible(false);
         m_Controls->m_OverviewTextEdit->setVisible(false);
 
         // reset the selection
         m_Controls->m_InputImageLabel->setText("<font color='green'>Click image to restore rendering!</font>");
       }
     }
     else if (dynamic_cast<mitk::TensorImage*>(m_ImageNode->GetData()) && ( m_ImageNode->GetData()->GetGeometry()->IsInside(world) ) )
     {
       m_Controls->m_ODFRenderWidget->setVisible(true);
       m_Controls->m_OdfBox->setVisible(false);
 
 
       const mitk::TensorImage* qball_image = dynamic_cast< mitk::TensorImage*>(m_ImageNode->GetData());
 
       // pixel access block
       try
       {
         // get access to the qball image data with explicitely allowing exceptions if memory locked
         mitk::ImageReadAccessor readAccess( qball_image, qball_image->GetVolumeData(0), mitk::ImageAccessorBase::ExceptionIfLocked );
         const float* qball_cPtr = static_cast< const float*>(readAccess.GetData());
 
         TensorImageType::IndexType ind;
         ind[0] = (int)(index[0]+0.5);
         ind[1] = (int)(index[1]+0.5);
         ind[2] = (int)(index[2]+0.5);
 
         // 6 - tensorsize
         // remaining computation - standard offset
         unsigned int offset_to_data = 6 * (ind[2] * img_dimension[1] * img_dimension[0] + ind[1] * img_dimension[0] + ind[0]);
         const float *pixel_data = qball_cPtr + offset_to_data;
 
         float tensorelems[6] = {
           *(pixel_data    ),
           *(pixel_data + 1),
           *(pixel_data + 2),
           *(pixel_data + 3),
           *(pixel_data + 4),
           *(pixel_data + 5),
         };
 
         itk::DiffusionTensor3D<float> tensor(tensorelems);
         odf.InitFromTensor(tensor);
 
         /** Array of eigen-values. */
         typedef itk::FixedArray<float, 3> EigenValuesArrayType;
         /** Matrix of eigen-vectors. */
         typedef itk::Matrix<float, 3, 3> MatrixType;
         typedef itk::Matrix<float, 3, 3> EigenVectorsMatrixType;
 
         EigenValuesArrayType eigenValues;
         EigenVectorsMatrixType eigenvectors;
 
         QString pos = QString::number(ind[0])+", "+QString::number(ind[1])+", "+QString::number(ind[2]);
         overviewText += "Coordinates: "+pos+"\n";
         overviewText += "FA: "+QString::number(tensor.GetFractionalAnisotropy())+"\n";
         overviewText += "RA: "+QString::number(tensor.GetRelativeAnisotropy())+"\n";
         overviewText += "Trace: "+QString::number(tensor.GetTrace())+"\n";
         tensor.ComputeEigenAnalysis(eigenValues,eigenvectors);
         overviewText += "Eigenvalues:\n     "+QString::number(eigenValues[2])+"\n     "+QString::number(eigenValues[1])+"\n     "+QString::number(eigenValues[0])+"\n";
         overviewText += "Main Diffusion:\n     "+QString::number(eigenvectors(2, 0))+"\n     "+QString::number(eigenvectors(2, 1))+"\n     "+QString::number(eigenvectors(2, 2))+"\n";
         overviewText += "Values:\n     "+QString::number(tensorelems[0])+"\n     "+QString::number(tensorelems[1])+"\n     "+QString::number(tensorelems[2])+"\n     "+QString::number(tensorelems[3])+"\n     "+QString::number(tensorelems[4])+"\n     "+QString::number(tensorelems[5])+"\n     "+"\n";
         m_Controls->m_OverviewTextEdit->setVisible(true);
       }
       // end pixel access block
       catch(mitk::Exception &e )
       {
         MITK_WARN << "LOCKED : " << e.what();
         m_Controls->m_ODFRenderWidget->setVisible(false);
         m_Controls->m_OdfBox->setVisible(false);
         m_Controls->m_OverviewTextEdit->setVisible(false);
 
         // reset the selection
         m_Controls->m_InputImageLabel->setText("<font color='green'>Click image to restore rendering!</font>");
       }
     }
     else
     {
       m_Controls->m_ODFRenderWidget->setVisible(false);
       m_Controls->m_OdfBox->setVisible(false);
       overviewText += "Please reinit image geometry.\n";
     }
 
     // proceed only if the render widget is visible which indicates that the
     // predecessing computations were successfull
     if( m_Controls->m_ODFRenderWidget->isVisible() )
     {
       m_Controls->m_ODFDetailsWidget->SetParameters(odf);
 
       switch(m_OdfNormalization)
       {
       case 0:
         odf = odf.MinMaxNormalize();
         break;
       case 1:
         odf = odf.MaxNormalize();
         break;
       case 2:
         odf = odf.MaxNormalize();
         break;
       default:
         odf = odf.MinMaxNormalize();
       }
 
       m_Controls->m_ODFRenderWidget->GenerateODF(odf);
       m_Controls->m_OverviewTextEdit->setText(overviewText.toStdString().c_str());
     }
   }
   catch(...)
   {
     QMessageBox::critical(0, "Error", "Data could not be analyzed. The image might be corrupted.");
   }
 }
 
 void QmitkODFDetailsView::OnSliceChanged(const itk::EventObject& /*e*/)
 {
   UpdateOdf();
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.h
index d221c196f2..edbacbe82d 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkODFDetailsView.h
@@ -1,118 +1,115 @@
 /*===================================================================
 
 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 _QMITKQmitkODFDetailsView_H_INCLUDED
 #define _QMITKQmitkODFDetailsView_H_INCLUDED
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 #include "mitkILifecycleAwarePart.h"
 
 #include "ui_QmitkODFDetailsViewControls.h"
 
 #include <itkVectorImage.h>
 #include <itkImage.h>
 #include <itkOrientationDistributionFunction.h>
 #include <mitkQBallImage.h>
 #include <vtkTransform.h>
 #include <vtkDoubleArray.h>
 #include <vtkOdfSource.h>
 #include <vtkSmartPointer.h>
 #include <QmitkRenderWindow.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkRenderer.h>
 #include <vtkCamera.h>
 #include <itkDiffusionTensor3D.h>
 
 /*!
   \brief View displaying details of the orientation distribution function in the voxel at the current crosshair position.
-
-  \sa QmitkFunctionality
-  \ingroup Functionalities
 */
 
 class QmitkODFDetailsView : public QmitkAbstractView, public mitk::ILifecycleAwarePart
 {
   // 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:
 
   static const std::string VIEW_ID;
 
   QmitkODFDetailsView();
   virtual ~QmitkODFDetailsView();
 
   typedef float TOdfPixelType;
   typedef itk::Vector<TOdfPixelType,QBALL_ODFSIZE> OdfVectorType;
   typedef itk::Image<OdfVectorType,3> OdfVectorImgType;
 
   typedef itk::DiffusionTensor3D< TOdfPixelType >  TensorPixelType;
   typedef itk::Image< TensorPixelType, 3 >         TensorImageType;
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
   void OnSliceChanged(const itk::EventObject& e);
 
 protected slots:
 
 protected:
 
-  /// \brief called by QmitkFunctionality when DataManager's selection has changed
-  virtual void OnSelectionChanged( berry::IWorkbenchPart::Pointer source,
-    const QList<mitk::DataNode::Pointer>& nodes ) override;
+  /// \brief called by QmitkAbstractView when DataManager's selection has changed
+  virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
   virtual void SetFocus() override;
-  void Visible() override;
-  void Hidden() override;
-  void Activated() override;
-  void Deactivated() override;
+
+  virtual void Activated() override;
+  virtual void Deactivated() override;
+  virtual void Visible() override;
+  virtual void Hidden() override;
 
   void UpdateOdf(); ///< called if slice position or datamanager selection has changed
 
   Ui::QmitkODFDetailsViewControls*  m_Controls;
 
   /** observer flags */
   int m_SliceObserverTag1;
   int m_SliceObserverTag2;
   int m_SliceObserverTag3;
   int m_PropertyObserverTag;
 
   /** ODF related variables like mesh structure, values etc. */
   vtkPolyData*                      m_TemplateOdf;  ///< spherical base mesh
   vtkSmartPointer<vtkTransform>     m_OdfTransform;
   vtkSmartPointer<vtkDoubleArray>   m_OdfVals;
   vtkSmartPointer<vtkOdfSource>     m_OdfSource;
 
   int                               m_OdfNormalization; ///< normalization method defined in the visualization view
 
   /** rendering of the ODF */
   vtkActor*                     m_VtkActor;
   vtkPolyDataMapper*            m_VtkMapper;
   vtkRenderer*                  m_Renderer;
   vtkRenderWindow*              m_VtkRenderWindow;
   vtkRenderWindowInteractor*    m_RenderWindowInteractor;
   vtkCamera*                    m_Camera;
 
   mitk::DataNode::Pointer m_ImageNode;
 };
 
 
 
 #endif // _QmitkODFDetailsView_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.cpp
index 15fd3e614c..8dc92acec0 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.cpp
@@ -1,778 +1,770 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //misc
 #define _USE_MATH_DEFINES
 #include <math.h>
 #include <QFileDialog>
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkOdfMaximaExtractionView.h"
 
 // MITK
 #include <mitkImageCast.h>
 #include <mitkFiberBundle.h>
 #include <mitkImage.h>
 #include <mitkImageToItk.h>
 #include <mitkTensorImage.h>
 
 // ITK
 #include <itkVectorImage.h>
 #include <itkOdfMaximaExtractionFilter.h>
 #include <itkFiniteDiffOdfMaximaExtractionFilter.h>
 #include <itkMrtrixPeakImageConverter.h>
 #include <itkFslPeakImageConverter.h>
 #include <itkShCoefficientImageImporter.h>
 #include <itkDiffusionTensorPrincipalDirectionImageFilter.h>
 
 // Qt
 #include <QMessageBox>
 
 const std::string QmitkOdfMaximaExtractionView::VIEW_ID = "org.mitk.views.odfmaximaextractionview";
 using namespace mitk;
 
 QmitkOdfMaximaExtractionView::QmitkOdfMaximaExtractionView()
-    : QmitkFunctionality()
+    : QmitkAbstractView()
     , m_Controls( 0 )
-    , m_MultiWidget( NULL )
 {
 
 }
 
 // Destructor
 QmitkOdfMaximaExtractionView::~QmitkOdfMaximaExtractionView()
 {
 
 }
 
 
 void QmitkOdfMaximaExtractionView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkOdfMaximaExtractionViewControls;
         m_Controls->setupUi( parent );
 
         connect((QObject*) m_Controls->m_StartTensor, SIGNAL(clicked()), (QObject*) this, SLOT(StartTensor()));
         connect((QObject*) m_Controls->m_StartFiniteDiff, SIGNAL(clicked()), (QObject*) this, SLOT(StartFiniteDiff()));
         connect((QObject*) m_Controls->m_GenerateImageButton, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateImage()));
         connect((QObject*) m_Controls->m_ImportPeaks, SIGNAL(clicked()), (QObject*) this, SLOT(ConvertPeaks()));
         connect((QObject*) m_Controls->m_ImportShCoeffs, SIGNAL(clicked()), (QObject*) this, SLOT(ConvertShCoeffs()));
     }
 }
 
+void QmitkOdfMaximaExtractionView::SetFocus()
+{
+  m_Controls->m_GenerateImageButton->setFocus();
+}
+
 void QmitkOdfMaximaExtractionView::UpdateGui()
 {
     m_Controls->m_GenerateImageButton->setEnabled(false);
     m_Controls->m_StartFiniteDiff->setEnabled(false);
     m_Controls->m_StartTensor->setEnabled(false);
     m_Controls->m_CoeffImageFrame->setEnabled(false);
 
     if (!m_ImageNodes.empty() || !m_TensorImageNodes.empty())
     {
         m_Controls->m_InputData->setTitle("Input Data");
 
         if (!m_TensorImageNodes.empty())
         {
             m_Controls->m_DwiFibLabel->setText(m_TensorImageNodes.front()->GetName().c_str());
             m_Controls->m_StartTensor->setEnabled(true);
         }
         else
         {
             m_Controls->m_DwiFibLabel->setText(m_ImageNodes.front()->GetName().c_str());
             m_Controls->m_StartFiniteDiff->setEnabled(true);
             m_Controls->m_GenerateImageButton->setEnabled(true);
             m_Controls->m_CoeffImageFrame->setEnabled(true);
             m_Controls->m_ShOrderBox->setEnabled(true);
             m_Controls->m_MaxNumPeaksBox->setEnabled(true);
             m_Controls->m_PeakThresholdBox->setEnabled(true);
             m_Controls->m_AbsoluteThresholdBox->setEnabled(true);
         }
     }
     else
         m_Controls->m_DwiFibLabel->setText("<font color='red'>mandatory</font>");
 
 
     if (m_ImageNodes.empty())
     {
         m_Controls->m_ImportPeaks->setEnabled(false);
         m_Controls->m_ImportShCoeffs->setEnabled(false);
     }
     else
     {
         m_Controls->m_ImportPeaks->setEnabled(true);
         m_Controls->m_ImportShCoeffs->setEnabled(true);
     }
 
     if (!m_BinaryImageNodes.empty())
     {
         m_Controls->m_MaskLabel->setText(m_BinaryImageNodes.front()->GetName().c_str());
     }
     else
     {
         m_Controls->m_MaskLabel->setText("<font color='grey'>optional</font>");
     }
 }
 
 template<int shOrder>
 void QmitkOdfMaximaExtractionView::TemplatedConvertShCoeffs(mitk::Image* mitkImg)
 {
     typedef itk::ShCoefficientImageImporter< float, shOrder > FilterType;
     typedef mitk::ImageToItk< itk::Image< float, 4 > > CasterType;
     CasterType::Pointer caster = CasterType::New();
     caster->SetInput(mitkImg);
     caster->Update();
 
     typename FilterType::Pointer filter = FilterType::New();
 
     switch (m_Controls->m_ToolkitBox->currentIndex())
     {
     case 0:
         filter->SetToolkit(FilterType::FSL);
         break;
     case 1:
         filter->SetToolkit(FilterType::MRTRIX);
         break;
     default:
         filter->SetToolkit(FilterType::FSL);
     }
 
     filter->SetInputImage(caster->GetOutput());
     filter->GenerateData();
     typename FilterType::QballImageType::Pointer itkQbi = filter->GetQballImage();
     typename FilterType::CoefficientImageType::Pointer itkCi = filter->GetCoefficientImage();
 
     {
         mitk::Image::Pointer img = mitk::Image::New();
         img->InitializeByItk( itkCi.GetPointer() );
         img->SetVolume( itkCi->GetBufferPointer() );
         DataNode::Pointer node = DataNode::New();
         node->SetData(img);
         node->SetName("_ShCoefficientImage");
         node->SetVisibility(false);
         GetDataStorage()->Add(node);
     }
 
     {
         mitk::QBallImage::Pointer img = mitk::QBallImage::New();
         img->InitializeByItk( itkQbi.GetPointer() );
         img->SetVolume( itkQbi->GetBufferPointer() );
         DataNode::Pointer node = DataNode::New();
         node->SetData(img);
         node->SetName("_QballImage");
         GetDataStorage()->Add(node);
     }
 }
 
 void QmitkOdfMaximaExtractionView::ConvertShCoeffs()
 {
     if (m_ImageNodes.empty())
         return;
     mitk::Image::Pointer mitkImg = dynamic_cast<mitk::Image*>(m_ImageNodes.at(0)->GetData());
     if (mitkImg->GetDimension()!=4)
     {
         MITK_INFO << "wrong image type (need 4 dimensions)";
         return;
     }
 
     int nrCoeffs = mitkImg->GetLargestPossibleRegion().GetSize()[3];
     // solve bx² + cx + d = 0 = shOrder² + 2*shOrder + 2-2*neededCoeffs;
     int c=3, d=2-2*nrCoeffs;
     double D = c*c-4*d;
     int shOrder;
     if (D>0)
     {
         shOrder = (-c+sqrt(D))/2.0;
         if (shOrder<0)
             shOrder = (-c-sqrt(D))/2.0;
     }
     else if (D==0)
         shOrder = -c/2.0;
 
     MITK_INFO << "using SH-order " << shOrder;
 
     switch (shOrder)
     {
     case 2:
         TemplatedConvertShCoeffs<2>(mitkImg);
         break;
     case 4:
         TemplatedConvertShCoeffs<4>(mitkImg);
         break;
     case 6:
         TemplatedConvertShCoeffs<6>(mitkImg);
         break;
     case 8:
         TemplatedConvertShCoeffs<8>(mitkImg);
         break;
     case 10:
         TemplatedConvertShCoeffs<10>(mitkImg);
         break;
     case 12:
         TemplatedConvertShCoeffs<12>(mitkImg);
         break;
     default:
         MITK_INFO << "SH-order " << shOrder << " not supported";
     }
 }
 
 void QmitkOdfMaximaExtractionView::ConvertPeaks()
 {
     if (m_ImageNodes.empty())
         return;
 
     switch (m_Controls->m_ToolkitBox->currentIndex())
     {
     case 0:
     {
         typedef itk::Image< float, 4 > ItkImageType;
         typedef itk::FslPeakImageConverter< float > FilterType;
         FilterType::Pointer filter = FilterType::New();
         FilterType::InputType::Pointer inputVec = FilterType::InputType::New();
         mitk::BaseGeometry::Pointer geom;
 
         for (int i=0; i<m_ImageNodes.size(); i++)
         {
             mitk::Image::Pointer mitkImg = dynamic_cast<mitk::Image*>(m_ImageNodes.at(i)->GetData());
             geom = mitkImg->GetGeometry();
             typedef mitk::ImageToItk< FilterType::InputImageType > CasterType;
             CasterType::Pointer caster = CasterType::New();
             caster->SetInput(mitkImg);
             caster->Update();
             FilterType::InputImageType::Pointer itkImg = caster->GetOutput();
             inputVec->InsertElement(inputVec->Size(), itkImg);
         }
 
         filter->SetInputImages(inputVec);
         filter->GenerateData();
 
         mitk::Vector3D outImageSpacing = geom->GetSpacing();
         float maxSpacing = 1;
         if(outImageSpacing[0]>outImageSpacing[1] && outImageSpacing[0]>outImageSpacing[2])
             maxSpacing = outImageSpacing[0];
         else if (outImageSpacing[1] > outImageSpacing[2])
             maxSpacing = outImageSpacing[1];
         else
             maxSpacing = outImageSpacing[2];
 
         mitk::FiberBundle::Pointer directions = filter->GetOutputFiberBundle();
         // directions->SetGeometry(geom);
         DataNode::Pointer node = DataNode::New();
         node->SetData(directions);
         node->SetName("_VectorField");
         node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(maxSpacing));
         node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
         GetDataStorage()->Add(node);
 
         typedef FilterType::DirectionImageContainerType DirectionImageContainerType;
         DirectionImageContainerType::Pointer container = filter->GetDirectionImageContainer();
         for (int i=0; i<container->Size(); i++)
         {
             ItkDirectionImage3DType::Pointer itkImg = container->GetElement(i);
             mitk::Image::Pointer img = mitk::Image::New();
             img->InitializeByItk( itkImg.GetPointer() );
             img->SetVolume( itkImg->GetBufferPointer() );
             DataNode::Pointer node = DataNode::New();
             node->SetData(img);
             QString name(m_ImageNodes.at(i)->GetName().c_str());
             name += "_Direction";
             name += QString::number(i+1);
             node->SetName(name.toStdString().c_str());
             node->SetVisibility(false);
             GetDataStorage()->Add(node);
         }
         break;
     }
     case 1:
     {
         typedef itk::Image< float, 4 > ItkImageType;
         typedef itk::MrtrixPeakImageConverter< float > FilterType;
         FilterType::Pointer filter = FilterType::New();
 
         // cast to itk
         mitk::Image::Pointer mitkImg = dynamic_cast<mitk::Image*>(m_ImageNodes.at(0)->GetData());
         mitk::BaseGeometry::Pointer geom = mitkImg->GetGeometry();
         typedef mitk::ImageToItk< FilterType::InputImageType > CasterType;
         CasterType::Pointer caster = CasterType::New();
         caster->SetInput(mitkImg);
         caster->Update();
         FilterType::InputImageType::Pointer itkImg = caster->GetOutput();
 
         filter->SetInputImage(itkImg);
         filter->GenerateData();
 
         mitk::Vector3D outImageSpacing = geom->GetSpacing();
         float maxSpacing = 1;
         if(outImageSpacing[0]>outImageSpacing[1] && outImageSpacing[0]>outImageSpacing[2])
             maxSpacing = outImageSpacing[0];
         else if (outImageSpacing[1] > outImageSpacing[2])
             maxSpacing = outImageSpacing[1];
         else
             maxSpacing = outImageSpacing[2];
 
         mitk::FiberBundle::Pointer directions = filter->GetOutputFiberBundle();
         //directions->SetGeometry(geom);
         DataNode::Pointer node = DataNode::New();
         node->SetData(directions);
         QString name(m_ImageNodes.at(0)->GetName().c_str());
         name += "_VectorField";
         node->SetName(name.toStdString().c_str());
         node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(maxSpacing));
         node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
         GetDataStorage()->Add(node);
 
         {
             ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
             mitk::Image::Pointer image2 = mitk::Image::New();
             image2->InitializeByItk( numDirImage.GetPointer() );
             image2->SetVolume( numDirImage->GetBufferPointer() );
             DataNode::Pointer node2 = DataNode::New();
             node2->SetData(image2);
             QString name(m_ImageNodes.at(0)->GetName().c_str());
             name += "_NumDirections";
             node2->SetName(name.toStdString().c_str());
             GetDataStorage()->Add(node2);
         }
 
         typedef FilterType::DirectionImageContainerType DirectionImageContainerType;
         DirectionImageContainerType::Pointer container = filter->GetDirectionImageContainer();
         for (int i=0; i<container->Size(); i++)
         {
             ItkDirectionImage3DType::Pointer itkImg = container->GetElement(i);
             mitk::Image::Pointer img = mitk::Image::New();
             img->InitializeByItk( itkImg.GetPointer() );
             img->SetVolume( itkImg->GetBufferPointer() );
             DataNode::Pointer node = DataNode::New();
             node->SetData(img);
             QString name(m_ImageNodes.at(0)->GetName().c_str());
             name += "_Direction";
             name += QString::number(i+1);
             node->SetName(name.toStdString().c_str());
             node->SetVisibility(false);
             GetDataStorage()->Add(node);
         }
         break;
     }
     }
 }
 
 void QmitkOdfMaximaExtractionView::GenerateImage()
 {
     if (!m_ImageNodes.empty())
         GenerateDataFromDwi();
 }
 
 void QmitkOdfMaximaExtractionView::StartTensor()
 {
     if (m_TensorImageNodes.empty())
         return;
 
     typedef itk::DiffusionTensorPrincipalDirectionImageFilter< float, float > MaximaExtractionFilterType;
     MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
 
     mitk::BaseGeometry::Pointer geometry;
     try{
         TensorImage::Pointer img = dynamic_cast<TensorImage*>(m_TensorImageNodes.at(0)->GetData());
         ItkTensorImage::Pointer itkImage = ItkTensorImage::New();
         CastToItkImage(img, itkImage);
         filter->SetInput(itkImage);
         geometry = img->GetGeometry();
     }
     catch(itk::ExceptionObject &e)
     {
         MITK_INFO << "wrong image type: " << e.what();
         QMessageBox::warning( NULL, "Wrong pixel type", "Could not perform Tensor Principal Direction Extraction due to Image has wrong pixel type.", QMessageBox::Ok );
         return;
         //throw e;
     }
 
     if (!m_BinaryImageNodes.empty())
     {
         ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
         Image::Pointer mitkMaskImg = dynamic_cast<Image*>(m_BinaryImageNodes.at(0)->GetData());
         CastToItkImage(mitkMaskImg, itkMaskImage);
         filter->SetMaskImage(itkMaskImage);
     }
 
     if (m_Controls->m_NormalizationBox->currentIndex()==0)
         filter->SetNormalizeVectors(false);
 
     filter->Update();
 
     if (m_Controls->m_OutputDirectionImagesBox->isChecked())
     {
         MaximaExtractionFilterType::OutputImageType::Pointer itkImg = filter->GetOutput();
         mitk::Image::Pointer img = mitk::Image::New();
         img->InitializeByItk( itkImg.GetPointer() );
         img->SetVolume( itkImg->GetBufferPointer() );
         DataNode::Pointer node = DataNode::New();
         node->SetData(img);
         QString name(m_TensorImageNodes.at(0)->GetName().c_str());
         name += "_PrincipalDirection";
         node->SetName(name.toStdString().c_str());
         node->SetVisibility(false);
         GetDataStorage()->Add(node);
     }
 
     if (m_Controls->m_OutputNumDirectionsBox->isChecked())
     {
         ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
         mitk::Image::Pointer image2 = mitk::Image::New();
         image2->InitializeByItk( numDirImage.GetPointer() );
         image2->SetVolume( numDirImage->GetBufferPointer() );
         DataNode::Pointer node2 = DataNode::New();
         node2->SetData(image2);
         QString name(m_TensorImageNodes.at(0)->GetName().c_str());
         name += "_NumDirections";
         node2->SetName(name.toStdString().c_str());
         GetDataStorage()->Add(node2);
     }
 
     if (m_Controls->m_OutputVectorFieldBox->isChecked())
     {
         mitk::Vector3D outImageSpacing = geometry->GetSpacing();
         float minSpacing = 1;
         if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
             minSpacing = outImageSpacing[0];
         else if (outImageSpacing[1] < outImageSpacing[2])
             minSpacing = outImageSpacing[1];
         else
             minSpacing = outImageSpacing[2];
 
         mitk::FiberBundle::Pointer directions = filter->GetOutputFiberBundle();
         // directions->SetGeometry(geometry);
         DataNode::Pointer node = DataNode::New();
         node->SetData(directions);
         QString name(m_TensorImageNodes.at(0)->GetName().c_str());
         name += "_VectorField";
         node->SetName(name.toStdString().c_str());
         node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
         node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
         GetDataStorage()->Add(node);
     }
 }
 
 template<int shOrder>
 void QmitkOdfMaximaExtractionView::StartMaximaExtraction()
 {
     typedef itk::FiniteDiffOdfMaximaExtractionFilter< float, shOrder, 20242 > MaximaExtractionFilterType;
     typename MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
 
     switch (m_Controls->m_ToolkitBox->currentIndex())
     {
     case 0:
         filter->SetToolkit(MaximaExtractionFilterType::FSL);
         break;
     case 1:
         filter->SetToolkit(MaximaExtractionFilterType::MRTRIX);
         break;
     default:
         filter->SetToolkit(MaximaExtractionFilterType::FSL);
     }
 
     mitk::BaseGeometry::Pointer geometry;
     try{
         Image::Pointer img = dynamic_cast<Image*>(m_ImageNodes.at(0)->GetData());
         typedef ImageToItk< typename MaximaExtractionFilterType::CoefficientImageType > CasterType;
         typename CasterType::Pointer caster = CasterType::New();
         caster->SetInput(img);
         caster->Update();
         filter->SetInput(caster->GetOutput());
         geometry = img->GetGeometry();
     }
     catch(itk::ExceptionObject &e)
     {
         MITK_INFO << "wrong image type: " << e.what();
         QMessageBox::warning( NULL, "Wrong pixel type", "Could not perform Finite Differences Extraction due to Image has wrong pixel type.", QMessageBox::Ok );
         return;
         //throw;
     }
 
     filter->SetAngularThreshold(cos((float)m_Controls->m_AngularThreshold->value()*M_PI/180));
     filter->SetClusteringThreshold(cos((float)m_Controls->m_ClusteringAngleBox->value()*M_PI/180));
     filter->SetMaxNumPeaks(m_Controls->m_MaxNumPeaksBox->value());
     filter->SetPeakThreshold(m_Controls->m_PeakThresholdBox->value());
     filter->SetAbsolutePeakThreshold(m_Controls->m_AbsoluteThresholdBox->value());
 
     if (!m_BinaryImageNodes.empty())
     {
         ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
         Image::Pointer mitkMaskImg = dynamic_cast<Image*>(m_BinaryImageNodes.at(0)->GetData());
         CastToItkImage(mitkMaskImg, itkMaskImage);
         filter->SetMaskImage(itkMaskImage);
     }
 
     switch (m_Controls->m_NormalizationBox->currentIndex())
     {
     case 0:
         filter->SetNormalizationMethod(MaximaExtractionFilterType::NO_NORM);
         break;
     case 1:
         filter->SetNormalizationMethod(MaximaExtractionFilterType::MAX_VEC_NORM);
         break;
     case 2:
         filter->SetNormalizationMethod(MaximaExtractionFilterType::SINGLE_VEC_NORM);
         break;
     }
 
     filter->Update();
 
     if (m_Controls->m_OutputDirectionImagesBox->isChecked())
     {
         typedef typename MaximaExtractionFilterType::ItkDirectionImageContainer ItkDirectionImageContainer;
         typename ItkDirectionImageContainer::Pointer container = filter->GetDirectionImageContainer();
         for (int i=0; i<container->Size(); i++)
         {
             typename MaximaExtractionFilterType::ItkDirectionImage::Pointer itkImg = container->GetElement(i);
             mitk::Image::Pointer img = mitk::Image::New();
             img->InitializeByItk( itkImg.GetPointer() );
             img->SetVolume( itkImg->GetBufferPointer() );
             DataNode::Pointer node = DataNode::New();
             node->SetData(img);
             QString name(m_ImageNodes.at(0)->GetName().c_str());
             name += "_Direction";
             name += QString::number(i+1);
             node->SetName(name.toStdString().c_str());
             node->SetVisibility(false);
             GetDataStorage()->Add(node);
         }
     }
 
     if (m_Controls->m_OutputNumDirectionsBox->isChecked())
     {
         ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
         mitk::Image::Pointer image2 = mitk::Image::New();
         image2->InitializeByItk( numDirImage.GetPointer() );
         image2->SetVolume( numDirImage->GetBufferPointer() );
         DataNode::Pointer node2 = DataNode::New();
         node2->SetData(image2);
         QString name(m_ImageNodes.at(0)->GetName().c_str());
         name += "_NumDirections";
         node2->SetName(name.toStdString().c_str());
         GetDataStorage()->Add(node2);
     }
 
     if (m_Controls->m_OutputVectorFieldBox->isChecked())
     {
         mitk::Vector3D outImageSpacing = geometry->GetSpacing();
         float minSpacing = 1;
         if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
             minSpacing = outImageSpacing[0];
         else if (outImageSpacing[1] < outImageSpacing[2])
             minSpacing = outImageSpacing[1];
         else
             minSpacing = outImageSpacing[2];
 
         mitk::FiberBundle::Pointer directions = filter->GetOutputFiberBundle();
         // directions->SetGeometry(geometry);
         DataNode::Pointer node = DataNode::New();
         node->SetData(directions);
         QString name(m_ImageNodes.at(0)->GetName().c_str());
         name += "_VectorField";
         node->SetName(name.toStdString().c_str());
         node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
         node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
         GetDataStorage()->Add(node);
     }
 }
 
 void QmitkOdfMaximaExtractionView::StartFiniteDiff()
 {
     if (m_ImageNodes.empty())
         return;
 
     switch (m_Controls->m_ShOrderBox->currentIndex())
     {
     case 0:
         StartMaximaExtraction<2>();
         break;
     case 1:
         StartMaximaExtraction<4>();
         break;
     case 2:
         StartMaximaExtraction<6>();
         break;
     case 3:
         StartMaximaExtraction<8>();
         break;
     case 4:
         StartMaximaExtraction<10>();
         break;
     case 5:
         StartMaximaExtraction<12>();
         break;
     }
 }
 
 void QmitkOdfMaximaExtractionView::GenerateDataFromDwi()
 {
     typedef itk::OdfMaximaExtractionFilter< float > MaximaExtractionFilterType;
     MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
 
     mitk::BaseGeometry::Pointer geometry;
     if (!m_ImageNodes.empty())
     {
         try{
             Image::Pointer img = dynamic_cast<Image*>(m_ImageNodes.at(0)->GetData());
             typedef ImageToItk< MaximaExtractionFilterType::CoefficientImageType > CasterType;
             CasterType::Pointer caster = CasterType::New();
             caster->SetInput(img);
             caster->Update();
             filter->SetShCoeffImage(caster->GetOutput());
             geometry = img->GetGeometry();
         }
         catch(itk::ExceptionObject &e)
         {
             MITK_INFO << "wrong image type: " << e.what();
             return;
         }
     }
     else
         return;
 
     filter->SetMaxNumPeaks(m_Controls->m_MaxNumPeaksBox->value());
     filter->SetPeakThreshold(m_Controls->m_PeakThresholdBox->value());
 
     if (!m_BinaryImageNodes.empty())
     {
         ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
         Image::Pointer mitkMaskImg = dynamic_cast<Image*>(m_BinaryImageNodes.at(0)->GetData());
         CastToItkImage(mitkMaskImg, itkMaskImage);
         filter->SetMaskImage(itkMaskImage);
     }
 
     switch (m_Controls->m_NormalizationBox->currentIndex())
     {
     case 0:
         filter->SetNormalizationMethod(MaximaExtractionFilterType::NO_NORM);
         break;
     case 1:
         filter->SetNormalizationMethod(MaximaExtractionFilterType::MAX_VEC_NORM);
         break;
     case 2:
         filter->SetNormalizationMethod(MaximaExtractionFilterType::SINGLE_VEC_NORM);
         break;
     }
 
     filter->GenerateData();
 
     ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
 
     if (m_Controls->m_OutputDirectionImagesBox->isChecked())
     {
         typedef MaximaExtractionFilterType::ItkDirectionImageContainer ItkDirectionImageContainer;
         ItkDirectionImageContainer::Pointer container = filter->GetDirectionImageContainer();
         for (int i=0; i<container->Size(); i++)
         {
             MaximaExtractionFilterType::ItkDirectionImage::Pointer itkImg = container->GetElement(i);
             mitk::Image::Pointer img = mitk::Image::New();
             img->InitializeByItk( itkImg.GetPointer() );
             img->SetVolume( itkImg->GetBufferPointer() );
             DataNode::Pointer node = DataNode::New();
             node->SetData(img);
             QString name(m_ImageNodes.at(0)->GetName().c_str());
             name += "_Direction";
             name += QString::number(i+1);
             node->SetName(name.toStdString().c_str());
             GetDataStorage()->Add(node);
         }
     }
 
     if (m_Controls->m_OutputNumDirectionsBox->isChecked())
     {
         mitk::Image::Pointer image2 = mitk::Image::New();
         image2->InitializeByItk( numDirImage.GetPointer() );
         image2->SetVolume( numDirImage->GetBufferPointer() );
         DataNode::Pointer node = DataNode::New();
         node->SetData(image2);
         QString name(m_ImageNodes.at(0)->GetName().c_str());
         name += "_NumDirections";
         node->SetName(name.toStdString().c_str());
         GetDataStorage()->Add(node);
     }
 
     if (m_Controls->m_OutputVectorFieldBox->isChecked())
     {
         mitk::Vector3D outImageSpacing = geometry->GetSpacing();
         float minSpacing = 1;
         if(outImageSpacing[0]<outImageSpacing[1] && outImageSpacing[0]<outImageSpacing[2])
             minSpacing = outImageSpacing[0];
         else if (outImageSpacing[1] < outImageSpacing[2])
             minSpacing = outImageSpacing[1];
         else
             minSpacing = outImageSpacing[2];
 
         mitk::FiberBundle::Pointer directions = filter->GetOutputFiberBundle();
         // directions->SetGeometry(geometry);
         DataNode::Pointer node = DataNode::New();
         node->SetData(directions);
         QString name(m_ImageNodes.at(0)->GetName().c_str());
         name += "_VectorField";
         node->SetName(name.toStdString().c_str());
         node->SetProperty("Fiber2DSliceThickness", mitk::FloatProperty::New(minSpacing));
         node->SetProperty("Fiber2DfadeEFX", mitk::BoolProperty::New(false));
         GetDataStorage()->Add(node);
     }
 }
 
-void QmitkOdfMaximaExtractionView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
-{
-    m_MultiWidget = &stdMultiWidget;
-}
-
-void QmitkOdfMaximaExtractionView::StdMultiWidgetNotAvailable()
-{
-    m_MultiWidget = NULL;
-}
-
-void QmitkOdfMaximaExtractionView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
+void QmitkOdfMaximaExtractionView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
     m_Controls->m_InputData->setTitle("Please Select Input Data");
     m_Controls->m_DwiFibLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_MaskLabel->setText("<font color='grey'>optional</font>");
 
     m_BinaryImageNodes.clear();
     m_ImageNodes.clear();
     m_TensorImageNodes.clear();
 
     // iterate all selected objects, adjust warning visibility
-    for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
+    for (mitk::DataNode::Pointer node: nodes)
     {
-        mitk::DataNode::Pointer node = *it;
-
         if ( node.IsNotNull() && dynamic_cast<mitk::TensorImage*>(node->GetData()) )
         {
             m_TensorImageNodes.push_back(node);
         }
         else if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
             bool isBinary = false;
             node->GetPropertyValue<bool>("binary", isBinary);
             if (isBinary)
                 m_BinaryImageNodes.push_back(node);
             else
                 m_ImageNodes.push_back(node);
         }
     }
 
     UpdateGui();
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.h
index 859d00b90f..74a5d880d5 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkOdfMaximaExtractionView.h
@@ -1,91 +1,89 @@
 /*===================================================================
 
 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 <berryISelectionListener.h>
 #include <berryIStructuredSelection.h>
 
-#include <QmitkFunctionality.h>
+#include <QmitkAbstractView.h>
 #include "ui_QmitkOdfMaximaExtractionViewControls.h"
 #include <itkVectorImage.h>
 #include <itkVectorContainer.h>
 #include <itkOrientationDistributionFunction.h>
 
 /*!
 \brief View providing several methods to extract peaks from the spherical harmonic representation of ODFs or from tensors
-
-\sa QmitkFunctionality
-\ingroup Functionalities
 */
 
 // Forward Qt class declarations
 
 
-class QmitkOdfMaximaExtractionView : public QmitkFunctionality
+class QmitkOdfMaximaExtractionView : public QmitkAbstractView
 {
 
   // 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:
 
   static const std::string VIEW_ID;
 
   QmitkOdfMaximaExtractionView();
   virtual ~QmitkOdfMaximaExtractionView();
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
-  virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget) override;
-  virtual void StdMultiWidgetNotAvailable() override;
+  ///
+  /// Sets the focus to an internal widget.
+  ///
+  virtual void SetFocus() override;
 
   typedef itk::Image<unsigned char, 3>                                  ItkUcharImgType;
   typedef itk::Image< itk::DiffusionTensor3D< float >, 3 >              ItkTensorImage;
   typedef itk::Image< itk::Vector< float, 3>, 3 >                       ItkDirectionImage3DType;    ///< contains a 3D vector in each voxel
 
   protected slots:
 
   void ConvertShCoeffs();           ///< convert spherical harmonic coefficients to the according mitk datatype
   void ConvertPeaks();              ///< convert peak files from other toolkits to the according mitk datatype
   void GenerateImage();             ///< semicontinuous ODF maxima extraction
   void StartFiniteDiff();           ///< ODF maxima extraction using finite differences on the densely sampled sphere
   void StartTensor();               ///< extract principal eigenvectors from tensor image
 
 protected:
 
-  /// \brief called by QmitkFunctionality when DataManager's selection has changed
-  virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes ) override;
+  /// \brief called by QmitkAbstractView when DataManager's selection has changed
+  virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
   Ui::QmitkOdfMaximaExtractionViewControls* m_Controls;
-  QmitkStdMultiWidget* m_MultiWidget;
 
   std::vector< mitk::DataNode::Pointer > m_BinaryImageNodes;    ///< mask images
   std::vector< mitk::DataNode::Pointer > m_ImageNodes;
   std::vector< mitk::DataNode::Pointer > m_TensorImageNodes;
 
   void UpdateGui();             ///< update button activity etc. dpending on current datamanager selection
   void GenerateDataFromDwi();   ///< semicontinuous ODF maxima extraction
   template<int shOrder> void TemplatedConvertShCoeffs(mitk::Image* mitkImg);
   template<int shOrder> void StartMaximaExtraction();   ///< ODF maxima extraction using finite differences on the densely sampled sphere
 
 private:
 
  };
 
 
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.cpp
index e9a63dc0ff..94669f7a42 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.cpp
@@ -1,2197 +1,2169 @@
 /*===================================================================
 
 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 "QmitkPartialVolumeAnalysisView.h"
 
 #include <limits>
 
 #include <qlabel.h>
 #include <qspinbox.h>
 #include <qpushbutton.h>
 #include <qcheckbox.h>
 #include <qgroupbox.h>
 #include <qradiobutton.h>
 #include <qlineedit.h>
 #include <qclipboard.h>
 #include <qfiledialog.h>
 
 #include <berryIEditorPart.h>
 #include <berryIWorkbenchPage.h>
 #include <berryPlatform.h>
 
 
-#include "QmitkStdMultiWidget.h"
-#include "QmitkStdMultiWidgetEditor.h"
 #include "QmitkSliderNavigatorWidget.h"
 #include <QMessageBox>
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkNodePredicateOr.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkProperties.h"
 #include "mitkProgressBar.h"
 #include "mitkImageCast.h"
 #include "mitkImageToItk.h"
 #include "mitkITKImageImport.h"
 #include "mitkDataNodeObject.h"
 #include "mitkNodePredicateData.h"
 #include "mitkPlanarFigureInteractor.h"
 #include "mitkTensorImage.h"
 #include "mitkPlanarCircle.h"
 #include "mitkPlanarRectangle.h"
 #include "mitkPlanarPolygon.h"
 #include "mitkPartialVolumeAnalysisClusteringCalculator.h"
 #include "usModuleRegistry.h"
 
 #include <itkVectorImage.h>
 #include "itkTensorDerivedMeasurementsFilter.h"
 #include "itkDiffusionTensor3D.h"
 #include "itkCartesianToPolarVectorImageFilter.h"
 #include "itkPolarToCartesianVectorImageFilter.h"
 #include "itkBinaryThresholdImageFilter.h"
 #include "itkMaskImageFilter.h"
 #include "itkCastImageFilter.h"
 #include "itkImageMomentsCalculator.h"
 #include <itkResampleImageFilter.h>
 #include <itkGaussianInterpolateImageFunction.h>
 #include <itkNearestNeighborInterpolateImageFunction.h>
 #include <itkImageDuplicator.h>
 
 #include <vnl/vnl_vector.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 #define PVA_PI M_PI
 
 const std::string QmitkPartialVolumeAnalysisView::VIEW_ID =
         "org.mitk.views.partialvolumeanalysisview";
 
 class QmitkRequestStatisticsUpdateEvent : public QEvent
 {
 public:
     enum Type
     {
         StatisticsUpdateRequest = QEvent::MaxUser - 1025
     };
 
     QmitkRequestStatisticsUpdateEvent()
         : QEvent( (QEvent::Type) StatisticsUpdateRequest ) {};
 };
 
 
 
 typedef itk::Image<short, 3>                 ImageType;
 typedef itk::Image<float, 3>                 FloatImageType;
 typedef itk::Image<itk::Vector<float,3>, 3>  VectorImageType;
 
 inline bool my_isnan(float x)
 {
     volatile float d = x;
 
     if(d!=d)
         return true;
 
     if(d==d)
         return false;
     return d != d;
 
 }
 
 QmitkPartialVolumeAnalysisView::QmitkPartialVolumeAnalysisView(QObject * /*parent*/, const char * /*name*/)
-    : //QmitkFunctionality(),
+    : QmitkAbstractView(),
       m_Controls( NULL ),
       m_TimeStepperAdapter( NULL ),
       m_MeasurementInfoRenderer(0),
       m_MeasurementInfoAnnotation(0),
       m_SelectedImageNodes(  ),
       m_SelectedImage( NULL ),
       m_SelectedMaskNode( NULL ),
       m_SelectedImageMask( NULL ),
       m_SelectedPlanarFigureNodes(0),
       m_SelectedPlanarFigure( NULL ),
       m_IsTensorImage(false),
       m_FAImage(0),
       m_RDImage(0),
       m_ADImage(0),
       m_MDImage(0),
       m_CAImage(0),
       //  m_DirectionImage(0),
       m_DirectionComp1Image(0),
       m_DirectionComp2Image(0),
       m_AngularErrorImage(0),
       m_SelectedRenderWindow(NULL),
       m_LastRenderWindow(NULL),
       m_ImageObserverTag( -1 ),
       m_ImageMaskObserverTag( -1 ),
       m_PlanarFigureObserverTag( -1 ),
       m_CurrentStatisticsValid( false ),
       m_StatisticsUpdatePending( false ),
       m_GaussianSigmaChangedSliding(false),
       m_NumberBinsSliding(false),
       m_UpsamplingChangedSliding(false),
       m_ClusteringResult(NULL),
       m_EllipseCounter(0),
       m_RectangleCounter(0),
       m_PolygonCounter(0),
       m_CurrentFigureNodeInitialized(false),
       m_QuantifyClass(2),
       m_IconTexOFF(new QIcon(":/QmitkPartialVolumeAnalysisView/texIntOFFIcon.png")),
       m_IconTexON(new QIcon(":/QmitkPartialVolumeAnalysisView/texIntONIcon.png")),
       m_TexIsOn(true),
       m_Visible(false)
 {
 
 }
 
 
 QmitkPartialVolumeAnalysisView::~QmitkPartialVolumeAnalysisView()
 {
     if ( m_SelectedImage.IsNotNull() )
         m_SelectedImage->RemoveObserver( m_ImageObserverTag );
     if ( m_SelectedImageMask.IsNotNull() )
         m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
     if ( m_SelectedPlanarFigure.IsNotNull() )
     {
         m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
         m_SelectedPlanarFigure->RemoveObserver( m_InitializedObserverTag );
     }
 
     this->GetDataStorage()->AddNodeEvent -= mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
             , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeAddedInDataStorage );
 
     m_SelectedPlanarFigureNodes->NodeChanged.RemoveListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                              , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeChanged ) );
 
     m_SelectedPlanarFigureNodes->NodeRemoved.RemoveListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                              , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeRemoved ) );
 
     m_SelectedPlanarFigureNodes->PropertyChanged.RemoveListener( mitk::MessageDelegate2<QmitkPartialVolumeAnalysisView
                                                                  , const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkPartialVolumeAnalysisView::PropertyChanged ) );
 
     m_SelectedImageNodes->NodeChanged.RemoveListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                       , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeChanged ) );
 
     m_SelectedImageNodes->NodeRemoved.RemoveListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                       , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeRemoved ) );
 
     m_SelectedImageNodes->PropertyChanged.RemoveListener( mitk::MessageDelegate2<QmitkPartialVolumeAnalysisView
                                                           , const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkPartialVolumeAnalysisView::PropertyChanged ) );
 }
 
 
 void QmitkPartialVolumeAnalysisView::CreateQtPartControl(QWidget *parent)
 {
     if (m_Controls == NULL)
     {
         m_Controls = new Ui::QmitkPartialVolumeAnalysisViewControls;
         m_Controls->setupUi(parent);
         this->CreateConnections();
     }
 
     SetHistogramVisibility();
 
     m_Controls->m_TextureIntON->setIcon(*m_IconTexON);
 
     m_Controls->m_SimilarAnglesFrame->setVisible(false);
     m_Controls->m_SimilarAnglesLabel->setVisible(false);
 
     vtkTextProperty *textProp = vtkTextProperty::New();
     textProp->SetColor(1.0, 1.0, 1.0);
 
     m_MeasurementInfoAnnotation = vtkCornerAnnotation::New();
     m_MeasurementInfoAnnotation->SetMaximumFontSize(12);
     m_MeasurementInfoAnnotation->SetTextProperty(textProp);
 
     m_MeasurementInfoRenderer = vtkRenderer::New();
     m_MeasurementInfoRenderer->AddActor(m_MeasurementInfoAnnotation);
 
     m_SelectedPlanarFigureNodes = mitk::DataStorageSelection::New(this->GetDataStorage(), false);
 
     m_SelectedPlanarFigureNodes->NodeChanged.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                           , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeChanged ) );
 
     m_SelectedPlanarFigureNodes->NodeRemoved.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                           , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeRemoved ) );
 
     m_SelectedPlanarFigureNodes->PropertyChanged.AddListener( mitk::MessageDelegate2<QmitkPartialVolumeAnalysisView
                                                               , const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkPartialVolumeAnalysisView::PropertyChanged ) );
 
     m_SelectedImageNodes = mitk::DataStorageSelection::New(this->GetDataStorage(), false);
 
     m_SelectedImageNodes->PropertyChanged.AddListener( mitk::MessageDelegate2<QmitkPartialVolumeAnalysisView
                                                        , const mitk::DataNode*, const mitk::BaseProperty*>( this, &QmitkPartialVolumeAnalysisView::PropertyChanged ) );
 
     m_SelectedImageNodes->NodeChanged.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                    , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeChanged ) );
 
     m_SelectedImageNodes->NodeRemoved.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                    , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeRemoved ) );
 
     this->GetDataStorage()->AddNodeEvent.AddListener( mitk::MessageDelegate1<QmitkPartialVolumeAnalysisView
                                                       , const mitk::DataNode*>( this, &QmitkPartialVolumeAnalysisView::NodeAddedInDataStorage ) );
 
     Select(NULL,true,true);
 
     SetAdvancedVisibility();
 }
 
+void QmitkPartialVolumeAnalysisView::SetFocus()
+{
+  m_Controls->m_CircleButton->setFocus();
+}
+
 void QmitkPartialVolumeAnalysisView::SetHistogramVisibility()
 {
     m_Controls->m_HistogramWidget->setVisible(m_Controls->m_DisplayHistogramCheckbox->isChecked());
 }
 
 void QmitkPartialVolumeAnalysisView::SetAdvancedVisibility()
 {
     m_Controls->frame_7->setVisible(m_Controls->m_AdvancedCheckbox->isChecked());
 }
 
 void QmitkPartialVolumeAnalysisView::CreateConnections()
 {
     if ( m_Controls )
     {
 
         connect( m_Controls->m_DisplayHistogramCheckbox, SIGNAL( clicked() )
                  , this, SLOT( SetHistogramVisibility() ) );
 
         connect( m_Controls->m_AdvancedCheckbox, SIGNAL( clicked() )
                  , this, SLOT( SetAdvancedVisibility() ) );
 
 
         connect( m_Controls->m_NumberBinsSlider, SIGNAL( sliderReleased () ),
                  this, SLOT( NumberBinsReleasedSlider( ) ) );
         connect( m_Controls->m_UpsamplingSlider, SIGNAL( sliderReleased(  ) ),
                  this, SLOT( UpsamplingReleasedSlider( ) ) );
         connect( m_Controls->m_GaussianSigmaSlider, SIGNAL( sliderReleased(  ) ),
                  this, SLOT( GaussianSigmaReleasedSlider(  ) ) );
         connect( m_Controls->m_SimilarAnglesSlider, SIGNAL( sliderReleased(  ) ),
                  this, SLOT( SimilarAnglesReleasedSlider(  ) ) );
 
         connect( m_Controls->m_NumberBinsSlider, SIGNAL( valueChanged (int) ),
                  this, SLOT( NumberBinsChangedSlider( int ) ) );
         connect( m_Controls->m_UpsamplingSlider, SIGNAL( valueChanged( int ) ),
                  this, SLOT( UpsamplingChangedSlider( int ) ) );
         connect( m_Controls->m_GaussianSigmaSlider, SIGNAL( valueChanged( int ) ),
                  this, SLOT( GaussianSigmaChangedSlider( int ) ) );
         connect( m_Controls->m_SimilarAnglesSlider, SIGNAL( valueChanged( int ) ),
                  this, SLOT( SimilarAnglesChangedSlider(int) ) );
 
         connect( m_Controls->m_OpacitySlider, SIGNAL( valueChanged( int ) ),
                  this, SLOT( OpacityChangedSlider(int) ) );
 
         connect( (QObject*)(m_Controls->m_ButtonCopyHistogramToClipboard), SIGNAL(clicked()),(QObject*) this, SLOT(ToClipBoard()));
 
         connect( m_Controls->m_CircleButton, SIGNAL( clicked() )
                  , this, SLOT( ActionDrawEllipseTriggered() ) );
 
         connect( m_Controls->m_RectangleButton, SIGNAL( clicked() )
                  , this, SLOT( ActionDrawRectangleTriggered() ) );
 
         connect( m_Controls->m_PolygonButton, SIGNAL( clicked() )
                  , this, SLOT( ActionDrawPolygonTriggered() ) );
 
         connect( m_Controls->m_GreenRadio, SIGNAL( clicked(bool) )
                  , this, SLOT( GreenRadio(bool) ) );
 
         connect( m_Controls->m_PartialVolumeRadio, SIGNAL( clicked(bool) )
                  , this, SLOT( PartialVolumeRadio(bool) ) );
 
         connect( m_Controls->m_BlueRadio, SIGNAL( clicked(bool) )
                  , this, SLOT( BlueRadio(bool) ) );
 
         connect( m_Controls->m_AllRadio, SIGNAL( clicked(bool) )
                  , this, SLOT( AllRadio(bool) ) );
 
         connect( m_Controls->m_EstimateCircle, SIGNAL( clicked() )
                  , this, SLOT( EstimateCircle() ) );
 
         connect( (QObject*)(m_Controls->m_TextureIntON), SIGNAL(clicked()), this, SLOT(TextIntON()) );
 
         connect( m_Controls->m_ExportClusteringResultsButton, SIGNAL(clicked()), this, SLOT(ExportClusteringResults()));
     }
 }
 
 void QmitkPartialVolumeAnalysisView::ExportClusteringResults()
 {
     if (m_ClusteringResult.IsNull() || m_SelectedImage.IsNull())
         return;
 
     mitk::BaseGeometry* geometry = m_SelectedImage->GetGeometry();
 
     itk::Image< short, 3>::Pointer referenceImage = itk::Image< short, 3>::New();
 
     itk::Vector<double,3> newSpacing = geometry->GetSpacing();
     mitk::Point3D newOrigin = geometry->GetOrigin();
     mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
     newOrigin[0] += bounds.GetElement(0);
     newOrigin[1] += bounds.GetElement(2);
     newOrigin[2] += bounds.GetElement(4);
     itk::Matrix<double, 3, 3> newDirection;
     itk::ImageRegion<3> imageRegion;
     for (int i=0; i<3; i++)
         for (int j=0; j<3; j++)
             newDirection[j][i] = geometry->GetMatrixColumn(i)[j]/newSpacing[j];
     imageRegion.SetSize(0, geometry->GetExtent(0));
     imageRegion.SetSize(1, geometry->GetExtent(1));
     imageRegion.SetSize(2, geometry->GetExtent(2));
 
     // apply new image parameters
     referenceImage->SetSpacing( newSpacing );
     referenceImage->SetOrigin( newOrigin );
     referenceImage->SetDirection( newDirection );
     referenceImage->SetRegions( imageRegion );
     referenceImage->Allocate();
 
     typedef itk::Image< float, 3 > OutType;
     mitk::Image::Pointer mitkInImage = dynamic_cast<mitk::Image*>(m_ClusteringResult->GetData());
 
     typedef itk::Image< itk::RGBAPixel<unsigned char>, 3 > ItkRgbaImageType;
     typedef mitk::ImageToItk< ItkRgbaImageType > CasterType;
 
     CasterType::Pointer caster = CasterType::New();
     caster->SetInput(mitkInImage);
     caster->Update();
     ItkRgbaImageType::Pointer itkInImage = caster->GetOutput();
 
     typedef itk::ExtractChannelFromRgbaImageFilter< itk::Image< short, 3>, OutType > ExtractionFilterType;
     ExtractionFilterType::Pointer filter = ExtractionFilterType::New();
     filter->SetInput(itkInImage);
     filter->SetChannel(ExtractionFilterType::ALPHA);
     filter->SetReferenceImage(referenceImage);
     filter->Update();
     OutType::Pointer outImg = filter->GetOutput();
 
     mitk::Image::Pointer img = mitk::Image::New();  img->InitializeByItk(outImg.GetPointer());
     img->SetVolume(outImg->GetBufferPointer());
 
     // init data node
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(img);
     node->SetName("Clustering Result");
     GetDataStorage()->Add(node);
 }
 
 void QmitkPartialVolumeAnalysisView::EstimateCircle()
 {
     typedef itk::Image<unsigned char, 3> SegImageType;
     SegImageType::Pointer mask_itk = SegImageType::New();
 
     typedef mitk::ImageToItk<SegImageType> CastType;
     CastType::Pointer caster = CastType::New();
     caster->SetInput(m_SelectedImageMask);
     caster->Update();
 
     typedef itk::ImageMomentsCalculator< SegImageType > MomentsType;
     MomentsType::Pointer momentsCalc = MomentsType::New();
     momentsCalc->SetImage(caster->GetOutput());
     momentsCalc->Compute();
     MomentsType::VectorType cog = momentsCalc->GetCenterOfGravity();
     MomentsType::MatrixType axes = momentsCalc->GetPrincipalAxes();
     MomentsType::VectorType moments = momentsCalc->GetPrincipalMoments();
 
     // moments-coord conversion
     // third coordinate min oder max?
 
     // max-min = extent
 
     MomentsType::AffineTransformPointer trafo = momentsCalc->GetPhysicalAxesToPrincipalAxesTransform();
 
     itk::ImageRegionIterator<SegImageType>
             itimage(caster->GetOutput(), caster->GetOutput()->GetLargestPossibleRegion());
     itimage = itimage.Begin();
 
     double max = -9999999999.0;
     double min =  9999999999.0;
 
     while( !itimage.IsAtEnd() )
     {
         if(itimage.Get())
         {
             ImageType::IndexType index = itimage.GetIndex();
 
             itk::Point<float,3> point;
             caster->GetOutput()->TransformIndexToPhysicalPoint(index,point);
 
             itk::Point<float,3> newPoint;
             newPoint = trafo->TransformPoint(point);
 
             if(newPoint[2]<min)
                 min = newPoint[2];
 
             if(newPoint[2]>max)
                 max = newPoint[2];
         }
         ++itimage;
     }
 
     double extent = max - min;
     MITK_DEBUG << "EXTENT = " << extent;
 
     mitk::Point3D origin;
     mitk::Vector3D right, bottom, normal;
 
     double factor = 1000.0;
     mitk::FillVector3D(origin, cog[0]-factor*axes[1][0]-factor*axes[2][0],
                        cog[1]-factor*axes[1][1]-factor*axes[2][1],
                        cog[2]-factor*axes[1][2]-factor*axes[2][2]);
     //          mitk::FillVector3D(normal, axis[0][0],axis[0][1],axis[0][2]);
     mitk::FillVector3D(bottom, 2*factor*axes[1][0], 2*factor*axes[1][1], 2*factor*axes[1][2]);
     mitk::FillVector3D(right,  2*factor*axes[2][0], 2*factor*axes[2][1], 2*factor*axes[2][2]);
 
     mitk::PlaneGeometry::Pointer planegeometry = mitk::PlaneGeometry::New();
     planegeometry->InitializeStandardPlane(right.Get_vnl_vector(), bottom.Get_vnl_vector());
     planegeometry->SetOrigin(origin);
 
     double len1 = sqrt(axes[1][0]*axes[1][0] + axes[1][1]*axes[1][1] + axes[1][2]*axes[1][2]);
     double len2 = sqrt(axes[2][0]*axes[2][0] + axes[2][1]*axes[2][1] + axes[2][2]*axes[2][2]);
 
     mitk::Point2D point1;
     point1[0] = factor*len1;
     point1[1] = factor*len2;
 
     mitk::Point2D point2;
     point2[0] = factor*len1+extent*.5;
     point2[1] = factor*len2;
 
     mitk::PlanarCircle::Pointer circle = mitk::PlanarCircle::New();
     circle->SetPlaneGeometry(planegeometry);
     circle->PlaceFigure( point1 );
     circle->SetControlPoint(0,point1);
     circle->SetControlPoint(1,point2);
     //circle->SetCurrentControlPoint( point2 );
 
     mitk::PlanarFigure::PolyLineType polyline = circle->GetPolyLine( 0 );
     MITK_DEBUG << "SIZE of planar figure polyline: " << polyline.size();
 
     AddFigureToDataStorage(circle, "Circle");
 
 }
 
 bool QmitkPartialVolumeAnalysisView::AssertDrawingIsPossible(bool checked)
 {
     if (m_SelectedImageNodes->GetNode().IsNull())
     {
         checked = false;
         this->HandleException("Please select an image!", dynamic_cast<QWidget *>(this->parent()), true);
         return false;
     }
 
-    //this->GetActiveStdMultiWidget()->SetWidgetPlanesVisibility(false);
+    //this->GetRenderWindowPart(OPEN)->EnableSlicingPlanes(false);
 
     return checked;
 }
 
 void QmitkPartialVolumeAnalysisView::ActionDrawEllipseTriggered()
 {
     bool checked = m_Controls->m_CircleButton->isChecked();
     if(!this->AssertDrawingIsPossible(checked))
         return;
 
     mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
     // using PV_ prefix for planar figures from this view
     // to distinguish them from that ones created throught the measurement view
     this->AddFigureToDataStorage(figure, QString("PV_Circle%1").arg(++m_EllipseCounter));
 
     MITK_DEBUG << "PlanarCircle created ...";
 }
 
 void QmitkPartialVolumeAnalysisView::ActionDrawRectangleTriggered()
 {
     bool checked = m_Controls->m_RectangleButton->isChecked();
     if(!this->AssertDrawingIsPossible(checked))
         return;
 
     mitk::PlanarRectangle::Pointer figure = mitk::PlanarRectangle::New();
     // using PV_ prefix for planar figures from this view
     // to distinguish them from that ones created throught the measurement view
     this->AddFigureToDataStorage(figure, QString("PV_Rectangle%1").arg(++m_RectangleCounter));
 
     MITK_DEBUG << "PlanarRectangle created ...";
 }
 
 void QmitkPartialVolumeAnalysisView::ActionDrawPolygonTriggered()
 {
     bool checked = m_Controls->m_PolygonButton->isChecked();
     if(!this->AssertDrawingIsPossible(checked))
         return;
 
     mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
     figure->ClosedOn();
     // using PV_ prefix for planar figures from this view
     // to distinguish them from that ones created throught the measurement view
     this->AddFigureToDataStorage(figure, QString("PV_Polygon%1").arg(++m_PolygonCounter));
 
     MITK_DEBUG << "PlanarPolygon created ...";
 }
 
 void QmitkPartialVolumeAnalysisView::AddFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name,
                                                             const char *propertyKey, mitk::BaseProperty *property )
 {
 
     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
     newNode->SetName(name.toStdString());
     newNode->SetData(figure);
 
     // Add custom property, if available
     if ( (propertyKey != NULL) && (property != NULL) )
     {
         newNode->AddProperty( propertyKey, property );
     }
 
     // figure drawn on the topmost layer / image
     this->GetDataStorage()->Add(newNode, m_SelectedImageNodes->GetNode() );
 
     QList<mitk::DataNode::Pointer> selectedNodes = this->GetDataManagerSelection();
     for(unsigned int i = 0; i < selectedNodes.size(); i++)
     {
         selectedNodes[i]->SetSelected(false);
     }
 
     std::vector<mitk::DataNode *> selectedPFNodes = m_SelectedPlanarFigureNodes->GetNodes();
     for(unsigned int i = 0; i < selectedPFNodes.size(); i++)
     {
         selectedPFNodes[i]->SetSelected(false);
     }
     newNode->SetSelected(true);
 
     Select(newNode);
 }
 
 void QmitkPartialVolumeAnalysisView::PlanarFigureInitialized()
 {
     if(m_SelectedPlanarFigureNodes->GetNode().IsNull())
         return;
 
     m_CurrentFigureNodeInitialized = true;
 
     this->Select(m_SelectedPlanarFigureNodes->GetNode());
 
     m_Controls->m_CircleButton->setChecked(false);
     m_Controls->m_RectangleButton->setChecked(false);
     m_Controls->m_PolygonButton->setChecked(false);
 
-    //this->GetActiveStdMultiWidget()->SetWidgetPlanesVisibility(true);
+    //this->GetRenderWindowPart(OPEN)->EnableSlicingPlanes(true);
     this->RequestStatisticsUpdate();
 
 }
 
 void QmitkPartialVolumeAnalysisView::PlanarFigureFocus(mitk::DataNode* node)
 {
     mitk::PlanarFigure* _PlanarFigure = 0;
     _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (node->GetData());
 
     if (_PlanarFigure)
     {
 
         FindRenderWindow(node);
 
         const mitk::PlaneGeometry* _PlaneGeometry = _PlanarFigure->GetPlaneGeometry();
 
         // make node visible
         if (m_SelectedRenderWindow)
         {
             mitk::Point3D centerP = _PlaneGeometry->GetOrigin();
             m_SelectedRenderWindow->GetSliceNavigationController()->ReorientSlices(
                         centerP, _PlaneGeometry->GetNormal());
             m_SelectedRenderWindow->GetSliceNavigationController()->SelectSliceByPoint(
                         centerP);
         }
     }
 }
 
 void QmitkPartialVolumeAnalysisView::FindRenderWindow(mitk::DataNode* node)
 {
     if (node && dynamic_cast<mitk::PlanarFigure*> (node->GetData()))
     {
         m_SelectedRenderWindow = 0;
         bool PlanarFigureInitializedWindow = false;
 
         foreach(QmitkRenderWindow * window, this->GetRenderWindowPart()->GetQmitkRenderWindows().values())
         {
             if (!m_SelectedRenderWindow && node->GetBoolProperty("PlanarFigureInitializedWindow", PlanarFigureInitializedWindow, window->GetRenderer()))
             {
                 m_SelectedRenderWindow = window;
             }
         }
     }
 }
 
 
 void QmitkPartialVolumeAnalysisView::OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer> &nodes)
 {
     m_Controls->m_InputData->setTitle("Please Select Input Data");
 
     if (!m_Visible)
         return;
 
     if ( nodes.empty() )
     {
         if (m_ClusteringResult.IsNotNull())
         {
             this->GetDataStorage()->Remove(m_ClusteringResult);
             mitk::RenderingManager::GetInstance()->RequestUpdateAll();
         }
 
         Select(NULL, true, true);
     }
 
     for (int i=0; i<nodes.size(); i++)
         Select(nodes.at(i));
 }
 
 void QmitkPartialVolumeAnalysisView::Select( mitk::DataNode::Pointer node, bool clearMaskOnFirstArgNULL, bool clearImageOnFirstArgNULL )
 {
     // Clear any unreferenced images
     this->RemoveOrphanImages();
 
     bool somethingChanged = false;
     if(node.IsNull())
     {
         somethingChanged = true;
 
         if(clearMaskOnFirstArgNULL)
         {
             if ( (m_SelectedImageMask.IsNotNull()) && (m_ImageMaskObserverTag >= 0) )
             {
                 m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
                 m_ImageMaskObserverTag = -1;
             }
 
             if ( (m_SelectedPlanarFigure.IsNotNull()) && (m_PlanarFigureObserverTag >= 0) )
             {
                 m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
                 m_PlanarFigureObserverTag = -1;
             }
 
             if ( (m_SelectedPlanarFigure.IsNotNull()) && (m_InitializedObserverTag >= 0) )
             {
                 m_SelectedPlanarFigure->RemoveObserver( m_InitializedObserverTag );
                 m_InitializedObserverTag = -1;
             }
 
             m_SelectedPlanarFigure = NULL;
             m_SelectedPlanarFigureNodes->RemoveAllNodes();
             m_CurrentFigureNodeInitialized = false;
             m_SelectedRenderWindow = 0;
 
             m_SelectedMaskNode = NULL;
             m_SelectedImageMask = NULL;
 
         }
 
         if(clearImageOnFirstArgNULL)
         {
             if ( (m_SelectedImage.IsNotNull()) && (m_ImageObserverTag >= 0) )
             {
                 m_SelectedImage->RemoveObserver( m_ImageObserverTag );
                 m_ImageObserverTag = -1;
             }
 
             m_SelectedImageNodes->RemoveAllNodes();
             m_SelectedImage = NULL;
 
             m_IsTensorImage = false;
             m_FAImage = NULL;
             m_RDImage = NULL;
             m_ADImage = NULL;
             m_MDImage = NULL;
             m_CAImage = NULL;
             m_DirectionComp1Image = NULL;
             m_DirectionComp2Image = NULL;
             m_AngularErrorImage = NULL;
 
             m_Controls->m_SimilarAnglesFrame->setVisible(false);
             m_Controls->m_SimilarAnglesLabel->setVisible(false);
         }
     }
     else
     {
         typedef itk::SimpleMemberCommand< QmitkPartialVolumeAnalysisView > ITKCommandType;
         ITKCommandType::Pointer changeListener;
         changeListener = ITKCommandType::New();
         changeListener->SetCallbackFunction( this, &QmitkPartialVolumeAnalysisView::RequestStatisticsUpdate );
 
         // Get selected element
         mitk::TensorImage *selectedTensorImage = dynamic_cast< mitk::TensorImage * >( node->GetData() );
         mitk::Image *selectedImage = dynamic_cast< mitk::Image * >( node->GetData() );
         mitk::PlanarFigure *selectedPlanar = dynamic_cast< mitk::PlanarFigure * >( node->GetData() );
 
         bool isMask = false;
         bool isImage = false;
         bool isPlanar = false;
         bool isTensorImage = false;
 
         if (selectedTensorImage != NULL)
         {
             isTensorImage = true;
         }
         else if(selectedImage != NULL)
         {
             node->GetPropertyValue("binary", isMask);
             isImage = !isMask;
         }
         else if ( (selectedPlanar != NULL) )
         {
             isPlanar = true;
         }
 
         // image
         if(isImage && selectedImage->GetDimension()==3)
         {
             if(selectedImage != m_SelectedImage.GetPointer())
             {
                 somethingChanged = true;
 
                 if ( (m_SelectedImage.IsNotNull()) && (m_ImageObserverTag >= 0) )
                 {
                     m_SelectedImage->RemoveObserver( m_ImageObserverTag );
                     m_ImageObserverTag = -1;
                 }
 
                 *m_SelectedImageNodes = node;
                 m_SelectedImage = selectedImage;
                 m_IsTensorImage = false;
                 m_FAImage = NULL;
                 m_RDImage = NULL;
                 m_ADImage = NULL;
                 m_MDImage = NULL;
                 m_CAImage = NULL;
                 m_DirectionComp1Image = NULL;
                 m_DirectionComp2Image = NULL;
                 m_AngularErrorImage = NULL;
 
                 // Add change listeners to selected objects
                 m_ImageObserverTag = m_SelectedImage->AddObserver(
                             itk::ModifiedEvent(), changeListener );
 
                 m_Controls->m_SimilarAnglesFrame->setVisible(false);
                 m_Controls->m_SimilarAnglesLabel->setVisible(false);
 
                 m_Controls->m_SelectedImageLabel->setText( m_SelectedImageNodes->GetNode()->GetName().c_str() );
             }
         }
 
         //planar
         if(isPlanar)
         {
             if(selectedPlanar != m_SelectedPlanarFigure.GetPointer())
             {
                 MITK_DEBUG << "Planar selection changed";
                 somethingChanged = true;
 
                 // Possibly previous change listeners
                 if ( (m_SelectedPlanarFigure.IsNotNull()) && (m_PlanarFigureObserverTag >= 0) )
                 {
                     m_SelectedPlanarFigure->RemoveObserver( m_PlanarFigureObserverTag );
                     m_PlanarFigureObserverTag = -1;
                 }
 
                 if ( (m_SelectedPlanarFigure.IsNotNull()) && (m_InitializedObserverTag >= 0) )
                 {
                     m_SelectedPlanarFigure->RemoveObserver( m_InitializedObserverTag );
                     m_InitializedObserverTag = -1;
                 }
 
                 m_SelectedPlanarFigure = selectedPlanar;
                 *m_SelectedPlanarFigureNodes = node;
                 m_CurrentFigureNodeInitialized = selectedPlanar->IsPlaced();
 
                 m_SelectedMaskNode = NULL;
                 m_SelectedImageMask = NULL;
 
                 m_PlanarFigureObserverTag = m_SelectedPlanarFigure->AddObserver(
                             mitk::EndInteractionPlanarFigureEvent(), changeListener );
 
                 if(!m_CurrentFigureNodeInitialized)
                 {
                     typedef itk::SimpleMemberCommand< QmitkPartialVolumeAnalysisView > ITKCommandType;
                     ITKCommandType::Pointer initializationCommand;
                     initializationCommand = ITKCommandType::New();
 
                     // set the callback function of the member command
                     initializationCommand->SetCallbackFunction( this, &QmitkPartialVolumeAnalysisView::PlanarFigureInitialized );
 
                     // add an observer
                     m_InitializedObserverTag = selectedPlanar->AddObserver( mitk::EndPlacementPlanarFigureEvent(), initializationCommand );
 
                 }
 
                 m_Controls->m_SelectedMaskLabel->setText( m_SelectedPlanarFigureNodes->GetNode()->GetName().c_str() );
                 PlanarFigureFocus(node);
             }
         }
 
         //mask
         this->m_Controls->m_EstimateCircle->setEnabled(isMask && selectedImage->GetDimension()==3);
         if(isMask && selectedImage->GetDimension()==3)
         {
             if(selectedImage != m_SelectedImage.GetPointer())
             {
                 somethingChanged = true;
 
                 if ( (m_SelectedImageMask.IsNotNull()) && (m_ImageMaskObserverTag >= 0) )
                 {
                     m_SelectedImageMask->RemoveObserver( m_ImageMaskObserverTag );
                     m_ImageMaskObserverTag = -1;
                 }
 
                 m_SelectedMaskNode = node;
                 m_SelectedImageMask = selectedImage;
                 m_SelectedPlanarFigure = NULL;
                 m_SelectedPlanarFigureNodes->RemoveAllNodes();
 
                 m_ImageMaskObserverTag = m_SelectedImageMask->AddObserver(
                             itk::ModifiedEvent(), changeListener );
 
                 m_Controls->m_SelectedMaskLabel->setText( m_SelectedMaskNode->GetName().c_str() );
 
             }
         }
 
         //tensor image
         if(isTensorImage && selectedTensorImage->GetDimension()==3)
         {
             if(selectedImage != m_SelectedImage.GetPointer())
             {
                 somethingChanged = true;
 
                 if ( (m_SelectedImage.IsNotNull()) && (m_ImageObserverTag >= 0) )
                 {
                     m_SelectedImage->RemoveObserver( m_ImageObserverTag );
                     m_ImageObserverTag = -1;
                 }
 
                 *m_SelectedImageNodes = node;
                 m_SelectedImage = selectedImage;
 
                 m_IsTensorImage = true;
 
                 ExtractTensorImages(selectedImage);
 
                 // Add change listeners to selected objects
                 m_ImageObserverTag = m_SelectedImage->AddObserver(
                             itk::ModifiedEvent(), changeListener );
 
                 m_Controls->m_SimilarAnglesFrame->setVisible(true);
                 m_Controls->m_SimilarAnglesLabel->setVisible(true);
 
                 m_Controls->m_SelectedImageLabel->setText( m_SelectedImageNodes->GetNode()->GetName().c_str() );
             }
         }
     }
 
     if(somethingChanged)
     {
         this->SetMeasurementInfoToRenderWindow("");
 
         if(m_SelectedPlanarFigure.IsNull() && m_SelectedImageMask.IsNull() )
         {
             m_Controls->m_SelectedMaskLabel->setText("<font color='red'>mandatory</font>");
             m_Controls->m_ResampleOptionsFrame->setEnabled(false);
             m_Controls->m_HistogramWidget->setEnabled(false);
             m_Controls->m_ClassSelector->setEnabled(false);
             m_Controls->m_DisplayHistogramCheckbox->setEnabled(false);
             m_Controls->m_AdvancedCheckbox->setEnabled(false);
             m_Controls->frame_7->setEnabled(false);
         }
         else
         {
             m_Controls->m_ResampleOptionsFrame->setEnabled(true);
             m_Controls->m_HistogramWidget->setEnabled(true);
             m_Controls->m_ClassSelector->setEnabled(true);
             m_Controls->m_DisplayHistogramCheckbox->setEnabled(true);
             m_Controls->m_AdvancedCheckbox->setEnabled(true);
             m_Controls->frame_7->setEnabled(true);
         }
 
         // Clear statistics / histogram GUI if nothing is selected
         if ( m_SelectedImage.IsNull() )
         {
             m_Controls->m_PlanarFigureButtonsFrame->setEnabled(false);
             m_Controls->m_OpacityFrame->setEnabled(false);
             m_Controls->m_SelectedImageLabel->setText("<font color='red'>mandatory</font>");
         }
         else
         {
             m_Controls->m_PlanarFigureButtonsFrame->setEnabled(true);
             m_Controls->m_OpacityFrame->setEnabled(true);
         }
 
         if( !m_Visible || m_SelectedImage.IsNull()
                 || (m_SelectedPlanarFigure.IsNull() && m_SelectedImageMask.IsNull()) )
         {
             m_Controls->m_InputData->setTitle("Please Select Input Data");
             m_Controls->m_HistogramWidget->ClearItemModel();
             m_CurrentStatisticsValid = false;
         }
         else
         {
             m_Controls->m_InputData->setTitle("Input Data");
             this->RequestStatisticsUpdate();
         }
     }
 }
 
 
 void QmitkPartialVolumeAnalysisView::ShowClusteringResults()
 {
 
     typedef itk::Image<unsigned char, 3> MaskImageType;
     mitk::Image::Pointer mask = 0;
     MaskImageType::Pointer itkmask = 0;
 
     if(m_IsTensorImage && m_Controls->m_SimilarAnglesSlider->value() != 0)
     {
         typedef itk::Image<float, 3> AngularErrorImageType;
         typedef mitk::ImageToItk<AngularErrorImageType> CastType;
         CastType::Pointer caster = CastType::New();
         caster->SetInput(m_AngularErrorImage);
         caster->Update();
 
         typedef itk::BinaryThresholdImageFilter< AngularErrorImageType, MaskImageType > ThreshType;
         ThreshType::Pointer thresh = ThreshType::New();
         thresh->SetUpperThreshold((90-m_Controls->m_SimilarAnglesSlider->value())*(PVA_PI/180.0));
         thresh->SetInsideValue(1.0);
         thresh->SetInput(caster->GetOutput());
         thresh->Update();
         itkmask = thresh->GetOutput();
 
         mask = mitk::Image::New();
         mask->InitializeByItk(itkmask.GetPointer());
         mask->SetVolume(itkmask->GetBufferPointer());
 
-        //    GetDefaultDataStorage()->Remove(m_newnode);
+        //    GetDataStorage()->Remove(m_newnode);
         //    m_newnode = mitk::DataNode::New();
         //    m_newnode->SetData(mask);
         //    m_newnode->SetName("masking node");
         //    m_newnode->SetIntProperty( "layer", 1002 );
-        //    GetDefaultDataStorage()->Add(m_newnode, m_SelectedImageNodes->GetNode());
+        //    GetDataStorage()->Add(m_newnode, m_SelectedImageNodes->GetNode());
 
     }
 
     mitk::Image::Pointer clusteredImage;
     ClusteringType::Pointer clusterer = ClusteringType::New();
 
     if(m_QuantifyClass==3)
     {
 
         if(m_IsTensorImage)
         {
             double *green_fa, *green_rd, *green_ad, *green_md;
             //double *greengray_fa, *greengray_rd, *greengray_ad, *greengray_md;
             double *gray_fa, *gray_rd, *gray_ad, *gray_md;
             //double *redgray_fa, *redgray_rd, *redgray_ad, *redgray_md;
             double *red_fa, *red_rd, *red_ad, *red_md;
 
             mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(0);
             mitk::Image::ConstPointer imgToCluster = tmpImg;
 
             red_fa   = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->r, mask);
             green_fa = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->g, mask);
             gray_fa  = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->b, mask);
 
             tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(3);
             mitk::Image::ConstPointer imgToCluster3 = tmpImg;
 
             red_rd   = clusterer->PerformQuantification(imgToCluster3, m_CurrentRGBClusteringResults->rgbChannels->r, mask);
             green_rd = clusterer->PerformQuantification(imgToCluster3, m_CurrentRGBClusteringResults->rgbChannels->g, mask);
             gray_rd  = clusterer->PerformQuantification(imgToCluster3, m_CurrentRGBClusteringResults->rgbChannels->b, mask);
 
             tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(4);
             mitk::Image::ConstPointer imgToCluster4 = tmpImg;
 
             red_ad   = clusterer->PerformQuantification(imgToCluster4, m_CurrentRGBClusteringResults->rgbChannels->r, mask);
             green_ad = clusterer->PerformQuantification(imgToCluster4, m_CurrentRGBClusteringResults->rgbChannels->g, mask);
             gray_ad  = clusterer->PerformQuantification(imgToCluster4, m_CurrentRGBClusteringResults->rgbChannels->b, mask);
 
             tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(5);
             mitk::Image::ConstPointer imgToCluster5 = tmpImg;
 
             red_md   = clusterer->PerformQuantification(imgToCluster5, m_CurrentRGBClusteringResults->rgbChannels->r, mask);
             green_md = clusterer->PerformQuantification(imgToCluster5, m_CurrentRGBClusteringResults->rgbChannels->g, mask);
             gray_md  = clusterer->PerformQuantification(imgToCluster5, m_CurrentRGBClusteringResults->rgbChannels->b, mask);
 
             // clipboard
             QString clipboardText("FA\t%1\t%2\t\t%3\t%4\t\t%5\t%6\t");
             clipboardText = clipboardText
                     .arg(red_fa[0]).arg(red_fa[1])
                     .arg(gray_fa[0]).arg(gray_fa[1])
                     .arg(green_fa[0]).arg(green_fa[1]);
             QString clipboardText3("RD\t%1\t%2\t\t%3\t%4\t\t%5\t%6\t");
             clipboardText3 = clipboardText3
                     .arg(red_rd[0]).arg(red_rd[1])
                     .arg(gray_rd[0]).arg(gray_rd[1])
                     .arg(green_rd[0]).arg(green_rd[1]);
             QString clipboardText4("AD\t%1\t%2\t\t%3\t%4\t\t%5\t%6\t");
             clipboardText4 = clipboardText4
                     .arg(red_ad[0]).arg(red_ad[1])
                     .arg(gray_ad[0]).arg(gray_ad[1])
                     .arg(green_ad[0]).arg(green_ad[1]);
             QString clipboardText5("MD\t%1\t%2\t\t%3\t%4\t\t%5\t%6");
             clipboardText5 = clipboardText5
                     .arg(red_md[0]).arg(red_md[1])
                     .arg(gray_md[0]).arg(gray_md[1])
                     .arg(green_md[0]).arg(green_md[1]);
 
             QApplication::clipboard()->setText(clipboardText+clipboardText3+clipboardText4+clipboardText5, QClipboard::Clipboard);
 
             // now paint infos also on renderwindow
             QString plainInfoText("%1  %2  %3        \n");
             plainInfoText = plainInfoText
                     .arg("Red  ", 20)
                     .arg("Gray ", 20)
                     .arg("Green", 20);
 
             QString plainInfoText0("FA:%1 ± %2%3 ± %4%5 ± %6\n");
             plainInfoText0 = plainInfoText0
                     .arg(red_fa[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(red_fa[1], -10, 'g', 2, QLatin1Char( ' ' ))
                     .arg(gray_fa[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(gray_fa[1], -10, 'g', 2, QLatin1Char( ' ' ))
                     .arg(green_fa[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(green_fa[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
             QString plainInfoText3("RDx10³:%1 ± %2%3 ± %4%5 ± %6\n");
             plainInfoText3 = plainInfoText3
                     .arg(1000.0 * red_rd[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_rd[1], -10, 'g', 2, QLatin1Char( ' ' ))
                     .arg(1000.0 * gray_rd[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * gray_rd[1], -10, 'g', 2, QLatin1Char( ' ' ))
                     .arg(1000.0 * green_rd[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * green_rd[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
             QString plainInfoText4("ADx10³:%1 ± %2%3 ± %4%5 ± %6\n");
             plainInfoText4 = plainInfoText4
                     .arg(1000.0 * red_ad[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_ad[1], -10, 'g', 2, QLatin1Char( ' ' ))
                     .arg(1000.0 * gray_ad[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * gray_ad[1], -10, 'g', 2, QLatin1Char( ' ' ))
                     .arg(1000.0 * green_ad[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * green_ad[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
             QString plainInfoText5("MDx10³:%1 ± %2%3 ± %4%5 ± %6");
             plainInfoText5 = plainInfoText5
                     .arg(1000.0 * red_md[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_md[1], -10, 'g', 2, QLatin1Char( ' ' ))
                     .arg(1000.0 * gray_md[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * gray_md[1], -10, 'g', 2, QLatin1Char( ' ' ))
                     .arg(1000.0 * green_md[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * green_md[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
             this->SetMeasurementInfoToRenderWindow(plainInfoText+plainInfoText0+plainInfoText3+plainInfoText4+plainInfoText5);
 
         }
         else
         {
             double* green;
             double* gray;
             double* red;
 
             mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalImage();
             mitk::Image::ConstPointer imgToCluster = tmpImg;
 
             red = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->r);
             green = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->g);
             gray = clusterer->PerformQuantification(imgToCluster, m_CurrentRGBClusteringResults->rgbChannels->b);
 
             // clipboard
             QString clipboardText("%1\t%2\t\t%3\t%4\t\t%5\t%6");
             clipboardText = clipboardText.arg(red[0]).arg(red[1])
                     .arg(gray[0]).arg(gray[1])
                     .arg(green[0]).arg(green[1]);
             QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
 
             // now paint infos also on renderwindow
             QString plainInfoText("Red: %1 ± %2\nGray: %3 ± %4\nGreen: %5 ± %6");
             plainInfoText = plainInfoText.arg(red[0]).arg(red[1])
                     .arg(gray[0]).arg(gray[1])
                     .arg(green[0]).arg(green[1]);
 
             this->SetMeasurementInfoToRenderWindow(plainInfoText);
 
         }
 
 
         clusteredImage = m_CurrentRGBClusteringResults->rgb;
 
     }
     else
     {
         if(m_IsTensorImage)
         {
             double *red_fa, *red_rd, *red_ad, *red_md;
 
             mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(0);
             mitk::Image::ConstPointer imgToCluster = tmpImg;
             red_fa = clusterer->PerformQuantification(imgToCluster, m_CurrentPerformClusteringResults->clusteredImage, mask);
 
             tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(3);
             mitk::Image::ConstPointer imgToCluster3 = tmpImg;
             red_rd = clusterer->PerformQuantification(imgToCluster3, m_CurrentPerformClusteringResults->clusteredImage, mask);
 
             tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(4);
             mitk::Image::ConstPointer imgToCluster4 = tmpImg;
             red_ad = clusterer->PerformQuantification(imgToCluster4, m_CurrentPerformClusteringResults->clusteredImage, mask);
 
             tmpImg = m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(5);
             mitk::Image::ConstPointer imgToCluster5 = tmpImg;
             red_md = clusterer->PerformQuantification(imgToCluster5, m_CurrentPerformClusteringResults->clusteredImage, mask);
 
             // clipboard
             QString clipboardText("FA\t%1\t%2\t");
             clipboardText = clipboardText
                     .arg(red_fa[0]).arg(red_fa[1]);
             QString clipboardText3("RD\t%1\t%2\t");
             clipboardText3 = clipboardText3
                     .arg(red_rd[0]).arg(red_rd[1]);
             QString clipboardText4("AD\t%1\t%2\t");
             clipboardText4 = clipboardText4
                     .arg(red_ad[0]).arg(red_ad[1]);
             QString clipboardText5("MD\t%1\t%2\t");
             clipboardText5 = clipboardText5
                     .arg(red_md[0]).arg(red_md[1]);
 
             QApplication::clipboard()->setText(clipboardText+clipboardText3+clipboardText4+clipboardText5, QClipboard::Clipboard);
 
             // now paint infos also on renderwindow
             QString plainInfoText("%1        \n");
             plainInfoText = plainInfoText
                     .arg("Red  ", 20);
 
             QString plainInfoText0("FA:%1 ± %2\n");
             plainInfoText0 = plainInfoText0
                     .arg(red_fa[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(red_fa[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
             QString plainInfoText3("RDx10³:%1 ± %2\n");
             plainInfoText3 = plainInfoText3
                     .arg(1000.0 * red_rd[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_rd[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
             QString plainInfoText4("ADx10³:%1 ± %2\n");
             plainInfoText4 = plainInfoText4
                     .arg(1000.0 * red_ad[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_ad[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
             QString plainInfoText5("MDx10³:%1 ± %2");
             plainInfoText5 = plainInfoText5
                     .arg(1000.0 * red_md[0], 10, 'g', 2, QLatin1Char( ' ' )).arg(1000.0 * red_md[1], -10, 'g', 2, QLatin1Char( ' ' ));
 
             this->SetMeasurementInfoToRenderWindow(plainInfoText+plainInfoText0+plainInfoText3+plainInfoText4+plainInfoText5);
 
         }
         else
         {
             double* quant;
 
             mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalImage();
             mitk::Image::ConstPointer imgToCluster = tmpImg;
             quant = clusterer->PerformQuantification(imgToCluster, m_CurrentPerformClusteringResults->clusteredImage);
 
             // clipboard
             QString clipboardText("%1\t%2");
             clipboardText = clipboardText.arg(quant[0]).arg(quant[1]);
             QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
 
             // now paint infos also on renderwindow
             QString plainInfoText("Measurement: %1 ± %2");
             plainInfoText = plainInfoText.arg(quant[0]).arg(quant[1]);
 
             this->SetMeasurementInfoToRenderWindow(plainInfoText);
         }
 
         clusteredImage = m_CurrentPerformClusteringResults->displayImage;
 
     }
 
     if(mask.IsNotNull())
     {
         typedef itk::Image<itk::RGBAPixel<unsigned char>,3> RGBImageType;
         typedef mitk::ImageToItk<RGBImageType> ClusterCasterType;
         ClusterCasterType::Pointer clCaster = ClusterCasterType::New();
         clCaster->SetInput(clusteredImage);
         clCaster->Update();
         clCaster->GetOutput();
 
         typedef itk::MaskImageFilter< RGBImageType, MaskImageType, RGBImageType > MaskType;
         MaskType::Pointer masker = MaskType::New();
         masker->SetInput1(clCaster->GetOutput());
         masker->SetInput2(itkmask);
         masker->Update();
 
         clusteredImage = mitk::Image::New();
         clusteredImage->InitializeByItk(masker->GetOutput());
         clusteredImage->SetVolume(masker->GetOutput()->GetBufferPointer());
     }
 
     if(m_ClusteringResult.IsNotNull())
     {
         this->GetDataStorage()->Remove(m_ClusteringResult);
     }
 
     m_ClusteringResult = mitk::DataNode::New();
     m_ClusteringResult->SetBoolProperty("helper object", true);
     m_ClusteringResult->SetIntProperty( "layer", 1000 );
     m_ClusteringResult->SetBoolProperty("texture interpolation", m_TexIsOn);
     m_ClusteringResult->SetData(clusteredImage);
     m_ClusteringResult->SetName("Clusterprobs");
     this->GetDataStorage()->Add(m_ClusteringResult, m_SelectedImageNodes->GetNode());
 
     if(m_SelectedPlanarFigure.IsNotNull() && m_SelectedPlanarFigureNodes->GetNode().IsNotNull())
     {
         m_SelectedPlanarFigureNodes->GetNode()->SetIntProperty( "layer", 1001 );
     }
 
     this->RequestRenderWindowUpdate();
 
 }
 
 
 void QmitkPartialVolumeAnalysisView::UpdateStatistics()
 {
     if(!m_CurrentFigureNodeInitialized && m_SelectedPlanarFigure.IsNotNull())
     {
         MITK_DEBUG << "Selected planar figure not initialized. No stats calculation performed.";
         return;
     }
 
     // Remove any cached images that are no longer referenced elsewhere
     this->RemoveOrphanImages();
 
-
-    QmitkStdMultiWidget *multiWidget = 0;
-    QmitkStdMultiWidgetEditor * multiWidgetEdit = 0;
-
-    multiWidgetEdit = dynamic_cast<QmitkStdMultiWidgetEditor *>(this->GetRenderWindowPart());
-    if(multiWidgetEdit){
-        multiWidget = multiWidgetEdit->GetStdMultiWidget();
-    }
-
-    if ( multiWidget == NULL )
-    {
-        return;
-    }
-
     if ( m_SelectedImage.IsNotNull() )
     {
         // Check if a the selected image is a multi-channel image. If yes, statistics
         // cannot be calculated currently.
         if ( !m_IsTensorImage && m_SelectedImage->GetPixelType().GetNumberOfComponents() > 1 )
         {
             QMessageBox::information( NULL, "Warning", "Non-tensor multi-component images not supported.");
 
             m_Controls->m_HistogramWidget->ClearItemModel();
             m_CurrentStatisticsValid = false;
             return;
         }
 
         m_CurrentStatisticsCalculator = NULL;
         if(!m_IsTensorImage)
         {
           // Retrieve HistogramStatisticsCalculator from has map (or create a new one
           // for this image if non-existant)
           PartialVolumeAnalysisMapType::iterator it =
               m_PartialVolumeAnalysisMap.find( m_SelectedImage );
 
           if ( it != m_PartialVolumeAnalysisMap.end() )
           {
             m_CurrentStatisticsCalculator = it->second;
           }
         }
         if(m_CurrentStatisticsCalculator.IsNull())
         {
             m_CurrentStatisticsCalculator = mitk::PartialVolumeAnalysisHistogramCalculator::New();
             m_CurrentStatisticsCalculator->SetPlanarFigureThickness(m_Controls->m_PlanarFiguresThickness->value());
             if(m_IsTensorImage)
             {
                 m_CurrentStatisticsCalculator->SetImage( m_CAImage );
                 m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_FAImage );
                 m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_DirectionComp1Image );
                 m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_DirectionComp2Image );
                 m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_RDImage );
                 m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_ADImage );
                 m_CurrentStatisticsCalculator->AddAdditionalResamplingImage( m_MDImage );
             }
             else
             {
                 m_CurrentStatisticsCalculator->SetImage( m_SelectedImage );
             }
             m_PartialVolumeAnalysisMap[m_SelectedImage] = m_CurrentStatisticsCalculator;
             MITK_DEBUG << "Creating StatisticsCalculator";
         }
 
         std::string maskName;
         std::string maskType;
         unsigned int maskDimension;
 
         if ( m_SelectedImageMask.IsNotNull() )
         {
 
             mitk::PixelType pixelType = m_SelectedImageMask->GetPixelType();
             MITK_DEBUG << pixelType.GetPixelTypeAsString();
 
 
             if(pixelType.GetComponentTypeAsString() == "char")
             {
                 MITK_DEBUG << "Pixel type is char instead of uchar";
                 return;
             }
 
 
             if(pixelType.GetBitsPerComponent() == 16)
             {
               //convert from ushort to uchar
               typedef itk::Image<unsigned char, 3> UCharImageType;
               UCharImageType::Pointer charImage;
 
 
               if(pixelType.GetComponentTypeAsString() == "short" )
               {
                 typedef itk::Image<short, 3> ShortImageType;
 
                 ShortImageType::Pointer shortImage;
                 mitk::CastToItkImage( m_SelectedImageMask, shortImage );
 
                 typedef itk::ImageDuplicator< ShortImageType > DuplicatorType;
                 DuplicatorType::Pointer duplicator = DuplicatorType::New();
                 duplicator->SetInputImage( shortImage );
                 duplicator->Update();
 
                 typedef itk::CastImageFilter<ShortImageType, UCharImageType> ImageCasterType;
 
                 ImageCasterType::Pointer caster = ImageCasterType::New();
                 caster->SetInput( duplicator->GetOutput() );
                 caster->Update();
                 charImage = caster->GetOutput();
 
               }
               else
               {
                 typedef itk::Image<unsigned short, 3> UShortImageType;
 
                 UShortImageType::Pointer shortImage;
                 mitk::CastToItkImage( m_SelectedImageMask, shortImage );
 
                 typedef itk::ImageDuplicator< UShortImageType > DuplicatorType;
                 DuplicatorType::Pointer duplicator = DuplicatorType::New();
                 duplicator->SetInputImage( shortImage );
                 duplicator->Update();
 
                 typedef itk::CastImageFilter<UShortImageType, UCharImageType> ImageCasterType;
 
                 ImageCasterType::Pointer caster = ImageCasterType::New();
                 caster->SetInput( duplicator->GetOutput() );
                 caster->Update();
                 charImage = caster->GetOutput();
               }
 
               m_SelectedImageMask = nullptr;
               m_SelectedImageMask = mitk::Image::New();
               m_SelectedImageMask->InitializeByItk( charImage.GetPointer() );
               m_SelectedImageMask->SetVolume( charImage->GetBufferPointer() );
 
               mitk::CastToMitkImage(charImage, m_SelectedImageMask);
             }
 
 
             m_CurrentStatisticsCalculator->SetImageMask( m_SelectedImageMask );
 
 
             m_CurrentStatisticsCalculator->SetMaskingModeToImage();
 
             maskName = m_SelectedMaskNode->GetName();
             maskType = m_SelectedImageMask->GetNameOfClass();
             maskDimension = 3;
 
             std::stringstream maskLabel;
             maskLabel << maskName;
             if ( maskDimension > 0 )
             {
                 maskLabel << "  [" << maskDimension << "D " << maskType << "]";
             }
             m_Controls->m_SelectedMaskLabel->setText( maskLabel.str().c_str() );
         }
         else if ( m_SelectedPlanarFigure.IsNotNull() && m_SelectedPlanarFigureNodes->GetNode().IsNotNull())
         {
             m_CurrentStatisticsCalculator->SetPlanarFigure( m_SelectedPlanarFigure );
             m_CurrentStatisticsCalculator->SetMaskingModeToPlanarFigure();
 
             maskName = m_SelectedPlanarFigureNodes->GetNode()->GetName();
             maskType = m_SelectedPlanarFigure->GetNameOfClass();
             maskDimension = 2;
         }
         else
         {
             m_CurrentStatisticsCalculator->SetMaskingModeToNone();
 
             maskName = "-";
             maskType = "";
             maskDimension = 0;
         }
 
         bool statisticsChanged = false;
         bool statisticsCalculationSuccessful = false;
 
         // Initialize progress bar
         mitk::ProgressBar::GetInstance()->AddStepsToDo( 100 );
 
         // Install listener for progress events and initialize progress bar
         typedef itk::SimpleMemberCommand< QmitkPartialVolumeAnalysisView > ITKCommandType;
         ITKCommandType::Pointer progressListener;
         progressListener = ITKCommandType::New();
         progressListener->SetCallbackFunction( this, &QmitkPartialVolumeAnalysisView::UpdateProgressBar );
         unsigned long progressObserverTag = m_CurrentStatisticsCalculator
                 ->AddObserver( itk::ProgressEvent(), progressListener );
 
         ClusteringType::ParamsType *cparams = 0;
         ClusteringType::ClusterResultType *cresult = 0;
         ClusteringType::HistType *chist = 0;
 
         try
         {
             m_CurrentStatisticsCalculator->SetNumberOfBins(m_Controls->m_NumberBins->text().toInt());
             m_CurrentStatisticsCalculator->SetUpsamplingFactor(m_Controls->m_Upsampling->text().toDouble());
             m_CurrentStatisticsCalculator->SetGaussianSigma(m_Controls->m_GaussianSigma->text().toDouble());
 
             // Compute statistics
             statisticsChanged =
                     m_CurrentStatisticsCalculator->ComputeStatistics( );
 
             mitk::Image* tmpImg = m_CurrentStatisticsCalculator->GetInternalImage();
             mitk::Image::ConstPointer imgToCluster = tmpImg;
             if(imgToCluster.IsNotNull())
             {
 
                 // perform clustering
                 const HistogramType *histogram = m_CurrentStatisticsCalculator->GetHistogram( );
 
                 if(histogram != NULL)
                 {
                     ClusteringType::Pointer clusterer = ClusteringType::New();
                     clusterer->SetStepsNumIntegration(200);
                     clusterer->SetMaxIt(1000);
 
                     mitk::Image::Pointer pFiberImg;
                     if(m_QuantifyClass==3)
                     {
                         if(m_Controls->m_Quantiles->isChecked())
                         {
                             m_CurrentRGBClusteringResults = clusterer->PerformRGBQuantiles(imgToCluster, histogram, m_Controls->m_q1->value(),m_Controls->m_q2->value());
                         }
                         else
                         {
                             m_CurrentRGBClusteringResults = clusterer->PerformRGBClustering(imgToCluster, histogram);
                         }
 
                         pFiberImg = m_CurrentRGBClusteringResults->rgbChannels->r;
                         cparams = m_CurrentRGBClusteringResults->params;
                         cresult = m_CurrentRGBClusteringResults->result;
                         chist = m_CurrentRGBClusteringResults->hist;
                     }
                     else
                     {
                         if(m_Controls->m_Quantiles->isChecked())
                         {
                             m_CurrentPerformClusteringResults =
                                     clusterer->PerformQuantiles(imgToCluster, histogram, m_Controls->m_q1->value(),m_Controls->m_q2->value());
                         }
                         else
                         {
                             m_CurrentPerformClusteringResults =
                                     clusterer->PerformClustering(imgToCluster, histogram, m_QuantifyClass);
                         }
 
                         pFiberImg = m_CurrentPerformClusteringResults->clusteredImage;
                         cparams = m_CurrentPerformClusteringResults->params;
                         cresult = m_CurrentPerformClusteringResults->result;
                         chist = m_CurrentPerformClusteringResults->hist;
                     }
 
                     if(m_IsTensorImage)
                     {
                         m_AngularErrorImage = clusterer->CaculateAngularErrorImage(
                                     m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(1),
                                     m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(2),
                                     pFiberImg);
 
-                        //          GetDefaultDataStorage()->Remove(m_newnode2);
+                        //          GetDataStorage()->Remove(m_newnode2);
                         //          m_newnode2 = mitk::DataNode::New();
                         //          m_newnode2->SetData(m_AngularErrorImage);
                         //          m_newnode2->SetName(("AngularError"));
                         //          m_newnode2->SetIntProperty( "layer", 1003 );
-                        //          GetDefaultDataStorage()->Add(m_newnode2, m_SelectedImageNodes->GetNode());
+                        //          GetDataStorage()->Add(m_newnode2, m_SelectedImageNodes->GetNode());
 
                         //          newnode = mitk::DataNode::New();
                         //          newnode->SetData(m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(1));
                         //          newnode->SetName(("Comp1"));
-                        //          GetDefaultDataStorage()->Add(newnode, m_SelectedImageNodes->GetNode());
+                        //          GetDataStorage()->Add(newnode, m_SelectedImageNodes->GetNode());
 
                         //          newnode = mitk::DataNode::New();
                         //          newnode->SetData(m_CurrentStatisticsCalculator->GetInternalAdditionalResampledImage(2));
                         //          newnode->SetName(("Comp2"));
-                        //          GetDefaultDataStorage()->Add(newnode, m_SelectedImageNodes->GetNode());
+                        //          GetDataStorage()->Add(newnode, m_SelectedImageNodes->GetNode());
                     }
                     ShowClusteringResults();
                 }
 
             }
 
             statisticsCalculationSuccessful = true;
         }
         catch ( const std::runtime_error &e )
         {
             QMessageBox::information( NULL, "Warning", e.what());
         }
         catch ( const std::exception &e )
         {
             MITK_ERROR << "Caught exception: " << e.what();
 
             QMessageBox::information( NULL, "Warning", e.what());
         }
 
         m_CurrentStatisticsCalculator->RemoveObserver( progressObserverTag );
 
         // Make sure that progress bar closes
         mitk::ProgressBar::GetInstance()->Progress( 100 );
 
         if ( statisticsCalculationSuccessful )
         {
             if ( statisticsChanged )
             {
                 // Do not show any error messages
                 m_CurrentStatisticsValid = true;
             }
 
             //      m_Controls->m_HistogramWidget->SetHistogramModeToDirectHistogram();
             m_Controls->m_HistogramWidget->SetParameters(
                         cparams, cresult, chist );
             //      m_Controls->m_HistogramWidget->UpdateItemModelFromHistogram();
 
         }
         else
         {
             m_Controls->m_SelectedMaskLabel->setText("<font color='red'>mandatory</font>");
 
             // Clear statistics and histogram
             m_Controls->m_HistogramWidget->ClearItemModel();
             m_CurrentStatisticsValid = false;
 
 
             // If a (non-closed) PlanarFigure is selected, display a line profile widget
             if ( m_SelectedPlanarFigure.IsNotNull() )
             {
                 // TODO: enable line profile widget
                 //m_Controls->m_StatisticsWidgetStack->setCurrentIndex( 1 );
                 //m_Controls->m_LineProfileWidget->SetImage( m_SelectedImage );
                 //m_Controls->m_LineProfileWidget->SetPlanarFigure( m_SelectedPlanarFigure );
                 //m_Controls->m_LineProfileWidget->UpdateItemModelFromPath();
             }
         }
     }
 
 }
 
 void QmitkPartialVolumeAnalysisView::SetMeasurementInfoToRenderWindow(const QString& text)
 {
 
     FindRenderWindow(m_SelectedPlanarFigureNodes->GetNode());
 
     if(m_LastRenderWindow != m_SelectedRenderWindow)
     {
 
         if(m_LastRenderWindow)
         {
             QObject::disconnect( m_LastRenderWindow, SIGNAL( destroyed(QObject*) )
                                  , this, SLOT( OnRenderWindowDelete(QObject*) ) );
         }
         m_LastRenderWindow = m_SelectedRenderWindow;
         if(m_LastRenderWindow)
         {
             QObject::connect( m_LastRenderWindow, SIGNAL( destroyed(QObject*) )
                               , this, SLOT( OnRenderWindowDelete(QObject*) ) );
         }
     }
 
     if(m_LastRenderWindow && m_SelectedPlanarFigureNodes->GetNode().IsNotNull())
     {
         if (!text.isEmpty())
         {
             m_MeasurementInfoAnnotation->SetText(1, text.toLatin1().data());
             mitk::VtkLayerController::GetInstance(m_LastRenderWindow->GetRenderWindow())->InsertForegroundRenderer(
                         m_MeasurementInfoRenderer, true);
         }
         else
         {
             if (mitk::VtkLayerController::GetInstance(
                         m_LastRenderWindow->GetRenderWindow()) ->IsRendererInserted(
                         m_MeasurementInfoRenderer))
                 mitk::VtkLayerController::GetInstance(m_LastRenderWindow->GetRenderWindow())->RemoveRenderer(
                             m_MeasurementInfoRenderer);
         }
     }
     else
     {
-        QmitkStdMultiWidget *multiWidget = 0;
-        QmitkStdMultiWidgetEditor * multiWidgetEdit = 0;
+        mitk::IRenderWindowPart* renderWindowPart = this->GetRenderWindowPart();
 
-        multiWidgetEdit = dynamic_cast<QmitkStdMultiWidgetEditor *>(this->GetRenderWindowPart());
-        if(multiWidgetEdit){
-            multiWidget = multiWidgetEdit->GetStdMultiWidget();
-        }
-
-        if ( multiWidget == NULL )
+        if ( renderWindowPart == nullptr )
         {
             return;
         }
 
         if (!text.isEmpty())
         {
             m_MeasurementInfoAnnotation->SetText(1, text.toLatin1().data());
-            mitk::VtkLayerController::GetInstance(multiWidget->GetRenderWindow1()->GetRenderWindow())->InsertForegroundRenderer(
+            mitk::VtkLayerController::GetInstance(renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderWindow())->InsertForegroundRenderer(
                         m_MeasurementInfoRenderer, true);
         }
         else
         {
             if (mitk::VtkLayerController::GetInstance(
-                        multiWidget->GetRenderWindow1()->GetRenderWindow()) ->IsRendererInserted(
+                        renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderWindow()) ->IsRendererInserted(
                         m_MeasurementInfoRenderer))
-                mitk::VtkLayerController::GetInstance(multiWidget->GetRenderWindow1()->GetRenderWindow())->RemoveRenderer(
+                mitk::VtkLayerController::GetInstance(renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderWindow())->RemoveRenderer(
                             m_MeasurementInfoRenderer);
         }
     }
 }
 
 void QmitkPartialVolumeAnalysisView::UpdateProgressBar()
 {
     mitk::ProgressBar::GetInstance()->Progress();
 }
 
 void QmitkPartialVolumeAnalysisView::RequestStatisticsUpdate()
 {
     if ( !m_StatisticsUpdatePending )
     {
         QApplication::postEvent( this, new QmitkRequestStatisticsUpdateEvent );
         m_StatisticsUpdatePending = true;
     }
 }
 
 
 void QmitkPartialVolumeAnalysisView::RemoveOrphanImages()
 {
     PartialVolumeAnalysisMapType::iterator it = m_PartialVolumeAnalysisMap.begin();
 
     while ( it != m_PartialVolumeAnalysisMap.end() )
     {
         mitk::Image *image = it->first;
         mitk::PartialVolumeAnalysisHistogramCalculator *calculator = it->second;
         ++it;
 
         mitk::NodePredicateData::Pointer hasImage = mitk::NodePredicateData::New( image );
         if ( this->GetDataStorage()->GetNode( hasImage ) == NULL )
         {
             if ( m_SelectedImage == image )
             {
                 m_SelectedImage = NULL;
                 m_SelectedImageNodes->RemoveAllNodes();
             }
             if ( m_CurrentStatisticsCalculator == calculator )
             {
                 m_CurrentStatisticsCalculator = NULL;
             }
             m_PartialVolumeAnalysisMap.erase( image );
             it = m_PartialVolumeAnalysisMap.begin();
         }
     }
 }
 
 void QmitkPartialVolumeAnalysisView::ExtractTensorImages(
         mitk::Image::Pointer tensorimage)
 {
     typedef itk::Image< itk::DiffusionTensor3D<float>, 3> TensorImageType;
 
     typedef mitk::ImageToItk<TensorImageType> CastType;
     CastType::Pointer caster = CastType::New();
     caster->SetInput(tensorimage);
     caster->Update();
     TensorImageType::Pointer image = caster->GetOutput();
 
     typedef itk::TensorDerivedMeasurementsFilter<float> MeasurementsType;
     MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
     measurementsCalculator->SetInput(image );
     measurementsCalculator->SetMeasure(MeasurementsType::FA);
     measurementsCalculator->Update();
     MeasurementsType::OutputImageType::Pointer fa = measurementsCalculator->GetOutput();
 
     m_FAImage = mitk::Image::New();
     m_FAImage->InitializeByItk(fa.GetPointer());
     m_FAImage->SetVolume(fa->GetBufferPointer());
 
     //  mitk::DataNode::Pointer node = mitk::DataNode::New();
     //  node->SetData(m_FAImage);
-    //  GetDefaultDataStorage()->Add(node);
+    //  GetDataStorage()->Add(node);
 
     measurementsCalculator = MeasurementsType::New();
     measurementsCalculator->SetInput(image );
     measurementsCalculator->SetMeasure(MeasurementsType::CA);
     measurementsCalculator->Update();
     MeasurementsType::OutputImageType::Pointer ca = measurementsCalculator->GetOutput();
 
     m_CAImage = mitk::Image::New();
     m_CAImage->InitializeByItk(ca.GetPointer());
     m_CAImage->SetVolume(ca->GetBufferPointer());
 
     //  node = mitk::DataNode::New();
     //  node->SetData(m_CAImage);
-    //  GetDefaultDataStorage()->Add(node);
+    //  GetDataStorage()->Add(node);
 
     measurementsCalculator = MeasurementsType::New();
     measurementsCalculator->SetInput(image );
     measurementsCalculator->SetMeasure(MeasurementsType::RD);
     measurementsCalculator->Update();
     MeasurementsType::OutputImageType::Pointer rd = measurementsCalculator->GetOutput();
 
     m_RDImage = mitk::Image::New();
     m_RDImage->InitializeByItk(rd.GetPointer());
     m_RDImage->SetVolume(rd->GetBufferPointer());
 
     //  node = mitk::DataNode::New();
     //  node->SetData(m_CAImage);
-    //  GetDefaultDataStorage()->Add(node);
+    //  GetDataStorage()->Add(node);
 
     measurementsCalculator = MeasurementsType::New();
     measurementsCalculator->SetInput(image );
     measurementsCalculator->SetMeasure(MeasurementsType::AD);
     measurementsCalculator->Update();
     MeasurementsType::OutputImageType::Pointer ad = measurementsCalculator->GetOutput();
 
     m_ADImage = mitk::Image::New();
     m_ADImage->InitializeByItk(ad.GetPointer());
     m_ADImage->SetVolume(ad->GetBufferPointer());
 
     //  node = mitk::DataNode::New();
     //  node->SetData(m_CAImage);
-    //  GetDefaultDataStorage()->Add(node);
+    //  GetDataStorage()->Add(node);
 
     measurementsCalculator = MeasurementsType::New();
     measurementsCalculator->SetInput(image );
     measurementsCalculator->SetMeasure(MeasurementsType::RA);
     measurementsCalculator->Update();
     MeasurementsType::OutputImageType::Pointer md = measurementsCalculator->GetOutput();
 
     m_MDImage = mitk::Image::New();
     m_MDImage->InitializeByItk(md.GetPointer());
     m_MDImage->SetVolume(md->GetBufferPointer());
 
     //  node = mitk::DataNode::New();
     //  node->SetData(m_CAImage);
-    //  GetDefaultDataStorage()->Add(node);
+    //  GetDataStorage()->Add(node);
 
     typedef DirectionsFilterType::OutputImageType DirImageType;
     DirectionsFilterType::Pointer dirFilter = DirectionsFilterType::New();
     dirFilter->SetInput(image );
     dirFilter->Update();
 
     itk::ImageRegionIterator<DirImageType>
             itd(dirFilter->GetOutput(), dirFilter->GetOutput()->GetLargestPossibleRegion());
     itd = itd.Begin();
     while( !itd.IsAtEnd() )
     {
         DirImageType::PixelType direction = itd.Get();
         direction[0] = fabs(direction[0]);
         direction[1] = fabs(direction[1]);
         direction[2] = fabs(direction[2]);
         itd.Set(direction);
         ++itd;
     }
 
     typedef itk::CartesianToPolarVectorImageFilter<
             DirImageType, DirImageType, true> C2PFilterType;
     C2PFilterType::Pointer cpFilter = C2PFilterType::New();
     cpFilter->SetInput(dirFilter->GetOutput());
     cpFilter->Update();
     DirImageType::Pointer dir = cpFilter->GetOutput();
 
     typedef itk::Image<float, 3> CompImageType;
     CompImageType::Pointer comp1 = CompImageType::New();
     comp1->SetSpacing( dir->GetSpacing() );   // Set the image spacing
     comp1->SetOrigin( dir->GetOrigin() );     // Set the image origin
     comp1->SetDirection( dir->GetDirection() );  // Set the image direction
     comp1->SetRegions( dir->GetLargestPossibleRegion() );
     comp1->Allocate();
 
     CompImageType::Pointer comp2 = CompImageType::New();
     comp2->SetSpacing( dir->GetSpacing() );   // Set the image spacing
     comp2->SetOrigin( dir->GetOrigin() );     // Set the image origin
     comp2->SetDirection( dir->GetDirection() );  // Set the image direction
     comp2->SetRegions( dir->GetLargestPossibleRegion() );
     comp2->Allocate();
 
     itk::ImageRegionConstIterator<DirImageType>
             it(dir, dir->GetLargestPossibleRegion());
 
     itk::ImageRegionIterator<CompImageType>
             it1(comp1, comp1->GetLargestPossibleRegion());
 
     itk::ImageRegionIterator<CompImageType>
             it2(comp2, comp2->GetLargestPossibleRegion());
 
     it = it.Begin();
     it1 = it1.Begin();
     it2 = it2.Begin();
 
     while( !it.IsAtEnd() )
     {
         it1.Set(it.Get()[1]);
         it2.Set(it.Get()[2]);
         ++it;
         ++it1;
         ++it2;
     }
 
     m_DirectionComp1Image = mitk::Image::New();
     m_DirectionComp1Image->InitializeByItk(comp1.GetPointer());
     m_DirectionComp1Image->SetVolume(comp1->GetBufferPointer());
 
     m_DirectionComp2Image = mitk::Image::New();
     m_DirectionComp2Image->InitializeByItk(comp2.GetPointer());
     m_DirectionComp2Image->SetVolume(comp2->GetBufferPointer());
 
 }
 
 void QmitkPartialVolumeAnalysisView::OnRenderWindowDelete(QObject * obj)
 {
     if(obj == m_LastRenderWindow)
         m_LastRenderWindow = 0;
     if(obj == m_SelectedRenderWindow)
         m_SelectedRenderWindow = 0;
 }
 
 bool QmitkPartialVolumeAnalysisView::event( QEvent *event )
 {
     if ( event->type() == (QEvent::Type) QmitkRequestStatisticsUpdateEvent::StatisticsUpdateRequest )
     {
         // Update statistics
 
         m_StatisticsUpdatePending = false;
 
         this->UpdateStatistics();
         return true;
     }
 
     return false;
 }
 
 
-bool QmitkPartialVolumeAnalysisView::IsExclusiveFunctionality() const
-{
-    return true;
-}
-
 void QmitkPartialVolumeAnalysisView::Activated()
 {
     mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDataStorage()->GetAll();
     mitk::DataNode* node = 0;
     mitk::PlanarFigure* figure = 0;
     mitk::PlanarFigureInteractor::Pointer figureInteractor = 0;
 
     // finally add all nodes to the model
     for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
         ; it++)
     {
         node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
         figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
 
         if(figure)
         {
           figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
 
           if(figureInteractor.IsNull())
           {
             figureInteractor = mitk::PlanarFigureInteractor::New();
             us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
             figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
             figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
             figureInteractor->SetDataNode( node );
           }
         }
     }
 }
 
 void QmitkPartialVolumeAnalysisView::Deactivated()
 {
 
 }
 
 void QmitkPartialVolumeAnalysisView::ActivatedZombieView(berry::IWorkbenchPartReference::Pointer reference)
 {
     this->SetMeasurementInfoToRenderWindow("");
 
     mitk::DataStorage::SetOfObjects::ConstPointer _NodeSet = this->GetDataStorage()->GetAll();
     mitk::DataNode* node = 0;
     mitk::PlanarFigure* figure = 0;
     mitk::PlanarFigureInteractor::Pointer figureInteractor = 0;
 
     // finally add all nodes to the model
     for(mitk::DataStorage::SetOfObjects::ConstIterator it=_NodeSet->Begin(); it!=_NodeSet->End()
         ; it++)
     {
         node = const_cast<mitk::DataNode*>(it->Value().GetPointer());
         figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
 
         if(figure)
         {
             figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
 
             if(figureInteractor)
               figureInteractor->SetDataNode( NULL );
         }
     }
 }
 
 void QmitkPartialVolumeAnalysisView::Hidden()
 {
     if (m_ClusteringResult.IsNotNull())
     {
         this->GetDataStorage()->Remove(m_ClusteringResult);
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
     Select(NULL, true, true);
     m_Visible = false;
 }
 
 void QmitkPartialVolumeAnalysisView::Visible()
 {
     m_Visible = true;
     berry::IWorkbenchPart::Pointer bla;
     if (!this->GetCurrentSelection().empty())
     {
         this->OnSelectionChanged(bla, this->GetCurrentSelection());
     }
     else
     {
         this->OnSelectionChanged(bla, this->GetDataManagerSelection());
     }
 }
 
-void QmitkPartialVolumeAnalysisView::SetFocus()
-{
-
-}
-
-
 void QmitkPartialVolumeAnalysisView::GreenRadio(bool checked)
 {
     if(checked)
     {
         m_Controls->m_PartialVolumeRadio->setChecked(false);
         m_Controls->m_BlueRadio->setChecked(false);
         m_Controls->m_AllRadio->setChecked(false);
         m_Controls->m_ExportClusteringResultsButton->setEnabled(true);
     }
 
     m_QuantifyClass = 0;
 
     RequestStatisticsUpdate();
 }
 
 
 void QmitkPartialVolumeAnalysisView::PartialVolumeRadio(bool checked)
 {
     if(checked)
     {
         m_Controls->m_GreenRadio->setChecked(false);
         m_Controls->m_BlueRadio->setChecked(false);
         m_Controls->m_AllRadio->setChecked(false);
         m_Controls->m_ExportClusteringResultsButton->setEnabled(true);
     }
 
     m_QuantifyClass = 1;
 
     RequestStatisticsUpdate();
 }
 
 void QmitkPartialVolumeAnalysisView::BlueRadio(bool checked)
 {
     if(checked)
     {
         m_Controls->m_PartialVolumeRadio->setChecked(false);
         m_Controls->m_GreenRadio->setChecked(false);
         m_Controls->m_AllRadio->setChecked(false);
         m_Controls->m_ExportClusteringResultsButton->setEnabled(true);
     }
 
     m_QuantifyClass = 2;
 
     RequestStatisticsUpdate();
 }
 
 void QmitkPartialVolumeAnalysisView::AllRadio(bool checked)
 {
     if(checked)
     {
         m_Controls->m_BlueRadio->setChecked(false);
         m_Controls->m_PartialVolumeRadio->setChecked(false);
         m_Controls->m_GreenRadio->setChecked(false);
         m_Controls->m_ExportClusteringResultsButton->setEnabled(false);
     }
 
     m_QuantifyClass = 3;
 
     RequestStatisticsUpdate();
 }
 
 void QmitkPartialVolumeAnalysisView::NumberBinsChangedSlider(int v )
 {
     m_Controls->m_NumberBins->setText(QString("%1").arg(m_Controls->m_NumberBinsSlider->value()*5.0));
 }
 
 void QmitkPartialVolumeAnalysisView::UpsamplingChangedSlider( int v)
 {
     m_Controls->m_Upsampling->setText(QString("%1").arg(m_Controls->m_UpsamplingSlider->value()/10.0));
 }
 
 void QmitkPartialVolumeAnalysisView::GaussianSigmaChangedSlider(int v )
 {
     m_Controls->m_GaussianSigma->setText(QString("%1").arg(m_Controls->m_GaussianSigmaSlider->value()/100.0));
 }
 
 void QmitkPartialVolumeAnalysisView::SimilarAnglesChangedSlider(int v )
 {
     m_Controls->m_SimilarAngles->setText(QString("%1°").arg(90-m_Controls->m_SimilarAnglesSlider->value()));
     ShowClusteringResults();
 }
 
 void QmitkPartialVolumeAnalysisView::OpacityChangedSlider(int v )
 {
 
     if(m_SelectedImageNodes->GetNode().IsNotNull())
     {
         float opacImag = 1.0f-(v-5)/5.0f;
         opacImag = opacImag < 0 ? 0 : opacImag;
         m_SelectedImageNodes->GetNode()->SetFloatProperty("opacity", opacImag);
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 
     if(m_ClusteringResult.IsNotNull())
     {
         float opacClust = v/5.0f;
         opacClust = opacClust > 1 ? 1 : opacClust;
         m_ClusteringResult->SetFloatProperty("opacity", opacClust);
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 }
 
 void QmitkPartialVolumeAnalysisView::NumberBinsReleasedSlider( )
 {
     RequestStatisticsUpdate();
 }
 
 void QmitkPartialVolumeAnalysisView::UpsamplingReleasedSlider( )
 {
     RequestStatisticsUpdate();
 }
 
 void QmitkPartialVolumeAnalysisView::GaussianSigmaReleasedSlider( )
 {
     RequestStatisticsUpdate();
 }
 
 void QmitkPartialVolumeAnalysisView::SimilarAnglesReleasedSlider( )
 {
 
 }
 
 void QmitkPartialVolumeAnalysisView::ToClipBoard()
 {
 
     std::vector<std::vector<double>* > vals  = m_Controls->m_HistogramWidget->m_Vals;
     QString clipboardText;
     for (std::vector<std::vector<double>* >::iterator it = vals.begin(); it
          != vals.end(); ++it)
     {
         for (std::vector<double>::iterator it2 = (**it).begin(); it2 != (**it).end(); ++it2)
         {
             clipboardText.append(QString("%1 \t").arg(*it2));
         }
         clipboardText.append(QString("\n"));
     }
 
     QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
 }
 
 void QmitkPartialVolumeAnalysisView::PropertyChanged(const mitk::DataNode* /*node*/, const mitk::BaseProperty* /*prop*/)
 {
 }
 
 void QmitkPartialVolumeAnalysisView::NodeChanged(const mitk::DataNode* /*node*/)
 {
 }
 
 void QmitkPartialVolumeAnalysisView::NodeRemoved(const mitk::DataNode* node)
 {
     if (dynamic_cast<mitk::PlanarFigure*>(node->GetData()))
         this->GetDataStorage()->Remove(m_ClusteringResult);
 
     if(  node == m_SelectedPlanarFigureNodes->GetNode().GetPointer()
          || node == m_SelectedMaskNode.GetPointer() )
     {
         this->Select(NULL,true,false);
         SetMeasurementInfoToRenderWindow("");
     }
 
     if(  node == m_SelectedImageNodes->GetNode().GetPointer() )
     {
         this->Select(NULL,false,true);
         SetMeasurementInfoToRenderWindow("");
     }
 }
 
 void QmitkPartialVolumeAnalysisView::NodeAddedInDataStorage(const mitk::DataNode* node)
 {
     if(!m_Visible)
         return;
 
     mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
     mitk::PlanarFigure* figure = dynamic_cast<mitk::PlanarFigure*>(nonConstNode->GetData());
 
     if(figure)
     {
 
         // set interactor for new node (if not already set)
         mitk::PlanarFigureInteractor::Pointer figureInteractor
                 = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
 
         if(figureInteractor.IsNull())
         {
           figureInteractor = mitk::PlanarFigureInteractor::New();
           us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
           figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
           figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
           figureInteractor->SetDataNode( nonConstNode );
         }
 
         // remove uninitialized old planars
         if( m_SelectedPlanarFigureNodes->GetNode().IsNotNull() && m_CurrentFigureNodeInitialized == false )
         {
             this->GetDataStorage()->Remove(m_SelectedPlanarFigureNodes->GetNode());
         }
 
     }
 }
 
 void QmitkPartialVolumeAnalysisView::TextIntON()
 {
     if(m_ClusteringResult.IsNotNull())
     {
         if(m_TexIsOn)
         {
             m_Controls->m_TextureIntON->setIcon(*m_IconTexOFF);
         }
         else
         {
             m_Controls->m_TextureIntON->setIcon(*m_IconTexON);
         }
 
         m_ClusteringResult->SetBoolProperty("texture interpolation", !m_TexIsOn);
         m_TexIsOn = !m_TexIsOn;
         this->RequestRenderWindowUpdate();
     }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.h
index 77cd111de9..75b9d2443b 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPartialVolumeAnalysisView.h
@@ -1,282 +1,272 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #if !defined(QmitkPartialVolumeAnalysisView_H__INCLUDED)
 #define QmitkPartialVolumeAnalysisView_H__INCLUDED
 
-//#include "QmitkFunctionality.h"
 #include "ui_QmitkPartialVolumeAnalysisViewControls.h"
 
 #include <QmitkAbstractView.h>
 #include <berryIWorkbenchPartReference.h>
 #include <mitkIZombieViewPart.h>
 
 // berry
 #include <berryISelectionListener.h>
 #include <berryIStructuredSelection.h>
 
 // itk
 #include <itkTimeStamp.h>
 #include <itkDiffusionTensorPrincipalDirectionImageFilter.h>
 #include <itkExtractChannelFromRgbaImageFilter.h>
 
 // qmitk
 #include "QmitkStepperAdapter.h"
 #include "QmitkRenderWindow.h"
 
 // mitk
 #include "mitkPartialVolumeAnalysisHistogramCalculator.h"
 #include "mitkPlanarLine.h"
 #include <mitkWeakPointer.h>
 #include "mitkDataStorageSelection.h"
 #include <mitkVtkLayerController.h>
 
 // vtk
 #include <vtkTextProperty.h>
 #include <vtkRenderer.h>
 #include <vtkCornerAnnotation.h>
 //#include "itkProcessObject.h"
 
 /*!
 \brief QmitkPartialVolumeAnalysis
-
-\sa QmitkFunctionality
-\ingroup Functionalities
 */
 class QmitkPartialVolumeAnalysisView : public QmitkAbstractView, public mitk::IZombieViewPart//, public itk::ProcessObject
 {
   Q_OBJECT
 
 public:
 
   /*!
   \  Convenient typedefs
   */
   typedef mitk::DataStorage::SetOfObjects                ConstVector;
   typedef ConstVector::ConstPointer                      ConstVectorPointer;
   typedef ConstVector::ConstIterator                     ConstVectorIterator;
   typedef mitk::PartialVolumeAnalysisHistogramCalculator HistogramCalculatorType;
   typedef HistogramCalculatorType::HistogramType         HistogramType;
   typedef mitk::PartialVolumeAnalysisClusteringCalculator ClusteringType;
   typedef itk::DiffusionTensorPrincipalDirectionImageFilter<float,float> DirectionsFilterType;
 
   /*!
   \brief default constructor
   */
   QmitkPartialVolumeAnalysisView(QObject *parent=0, const char *name=0);
 
   /*!
   \brief default destructor
   */
   virtual ~QmitkPartialVolumeAnalysisView();
 
   /*!
   \brief method for creating the widget containing the application   controls, like sliders, buttons etc.
   */
   virtual void CreateQtPartControl(QWidget *parent) override;
 
   /*!
   \brief method for creating the connections of main and control widget
   */
   virtual void CreateConnections();
 
-  bool IsExclusiveFunctionality() const;
-
   virtual bool event( QEvent *event ) override;
 
-  virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer> &nodes) override;
+  virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
   virtual void Activated() override;
 
   virtual void Deactivated() override;
 
   virtual void ActivatedZombieView(berry::IWorkbenchPartReference::Pointer reference) override;
 
   virtual void Hidden() override;
 
   virtual void Visible() override;
 
   virtual void SetFocus() override;
 
   bool AssertDrawingIsPossible(bool checked);
 
   virtual void NodeChanged(const mitk::DataNode* node) override;
   virtual void PropertyChanged(const mitk::DataNode* node, const mitk::BaseProperty* prop);
   virtual void NodeRemoved(const mitk::DataNode* node) override;
   virtual void NodeAddedInDataStorage(const mitk::DataNode* node);
 
   virtual void AddFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name,
     const char *propertyKey = NULL, mitk::BaseProperty *property = NULL );
 
   void PlanarFigureInitialized();
 
   void PlanarFigureFocus(mitk::DataNode* node);
 
   void ShowClusteringResults();
 
   static const std::string VIEW_ID;
 
 protected slots:
 
   void EstimateCircle();
   void SetHistogramVisibility();
   void SetAdvancedVisibility();
 
   void NumberBinsChangedSlider(int v );
   void UpsamplingChangedSlider( int v );
   void GaussianSigmaChangedSlider( int v );
   void SimilarAnglesChangedSlider(int v );
 
   void OpacityChangedSlider(int v );
 
   void NumberBinsReleasedSlider( );
   void UpsamplingReleasedSlider(  );
   void GaussianSigmaReleasedSlider(  );
   void SimilarAnglesReleasedSlider( );
 
   void ActionDrawEllipseTriggered();
   void ActionDrawRectangleTriggered();
   void ActionDrawPolygonTriggered();
 
   void ToClipBoard();
 
   void GreenRadio(bool checked);
   void PartialVolumeRadio(bool checked);
   void BlueRadio(bool checked);
   void AllRadio(bool checked);
 
   void OnRenderWindowDelete(QObject * obj);
 
   void TextIntON();
   void ExportClusteringResults();
 
 protected:
 
-  //void StdMultiWidgetAvailable( QmitkStdMultiWidget& stdMultiWidget );
-
   /** \brief Issues a request to update statistics by sending an event to the
   * Qt event processing queue.
   *
   * Statistics update should only be executed after program execution returns
   * to the Qt main loop. This mechanism also prevents multiple execution of
   * updates where only one is required.*/
   void RequestStatisticsUpdate();
 
   /** \brief Recalculate statistics for currently selected image and mask and
    * update the GUI. */
   void UpdateStatistics();
 
   /** \brief Listener for progress events to update progress bar. */
   void UpdateProgressBar();
 
   /** \brief Removes any cached images which are no longer referenced elsewhere. */
   void RemoveOrphanImages();
 
   void Select( mitk::DataNode::Pointer node, bool clearMaskOnFirstArgNULL=false, bool clearImageOnFirstArgNULL=false );
 
   void SetMeasurementInfoToRenderWindow(const QString& text);
 
   void FindRenderWindow(mitk::DataNode* node);
 
   void ExtractTensorImages(
       mitk::Image::Pointer tensorimage);
 
   typedef std::map< mitk::Image *, mitk::PartialVolumeAnalysisHistogramCalculator::Pointer >
     PartialVolumeAnalysisMapType;
 
-//  void OnSelectionChanged(const QList<mitk::DataNode::Pointer> &nodes);
-
   /*!
   * controls containing sliders for scrolling through the slices
   */
   Ui::QmitkPartialVolumeAnalysisViewControls *m_Controls;
 
   QmitkStepperAdapter*      m_TimeStepperAdapter;
   unsigned int              m_CurrentTime;
 
   QString                     m_Clipboard;
 
   // result text rendering
   vtkRenderer * m_MeasurementInfoRenderer;
   vtkCornerAnnotation *m_MeasurementInfoAnnotation;
 
   // Image and mask data
   mitk::DataStorageSelection::Pointer m_SelectedImageNodes;
   mitk::Image::Pointer m_SelectedImage;
 
   mitk::DataNode::Pointer m_SelectedMaskNode;
   mitk::Image::Pointer m_SelectedImageMask;
 
   mitk::DataStorageSelection::Pointer m_SelectedPlanarFigureNodes;
   mitk::PlanarFigure::Pointer m_SelectedPlanarFigure;
 
   bool m_IsTensorImage;
   mitk::Image::Pointer m_FAImage;
   mitk::Image::Pointer m_CAImage;
   mitk::Image::Pointer m_RDImage;
   mitk::Image::Pointer m_ADImage;
   mitk::Image::Pointer m_MDImage;
 //  mitk::Image::Pointer m_DirectionImage;
   mitk::Image::Pointer m_DirectionComp1Image;
   mitk::Image::Pointer m_DirectionComp2Image;
   mitk::Image::Pointer m_AngularErrorImage;
 
   QmitkRenderWindow* m_SelectedRenderWindow;
   QmitkRenderWindow* m_LastRenderWindow;
 
   long m_ImageObserverTag;
   long m_ImageMaskObserverTag;
   long m_PlanarFigureObserverTag;
 
   // Hash map for associating one image statistics calculator with each iamge
   // (so that previously calculated histograms / statistics can be recovered
   // if a recalculation is not required)
   PartialVolumeAnalysisMapType m_PartialVolumeAnalysisMap;
 
   HistogramCalculatorType::Pointer m_CurrentStatisticsCalculator;
 
   bool m_CurrentStatisticsValid;
 
   bool m_StatisticsUpdatePending;
 
   bool m_GaussianSigmaChangedSliding;
   bool m_NumberBinsSliding;
   bool m_UpsamplingChangedSliding;
 
   bool m_Visible;
 
   mitk::DataNode::Pointer m_ClusteringResult;
 
   int m_EllipseCounter;
   int m_RectangleCounter;
   int m_PolygonCounter;
   unsigned int m_InitializedObserverTag;
   bool m_CurrentFigureNodeInitialized;
 
   int m_QuantifyClass;
 
   ClusteringType::HelperStructPerformRGBClusteringRetval* m_CurrentRGBClusteringResults;
   ClusteringType::HelperStructPerformClusteringRetval *m_CurrentPerformClusteringResults;
 
 //  mitk::DataNode::Pointer m_newnode;
 //  mitk::DataNode::Pointer m_newnode2;
   QIcon* m_IconTexOFF;
   QIcon* m_IconTexON;
   bool m_TexIsOn;
 };
 
 
 #endif // !defined(QmitkPartialVolumeAnalysis_H__INCLUDED)
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.cpp
index 6a199e95d4..eae015374a 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.cpp
@@ -1,2384 +1,2379 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //#define MBILOG_ENABLE_DEBUG
 
 #include "QmitkPreprocessingView.h"
 #include "mitkDiffusionImagingConfigure.h"
 
 // qt includes
 #include <QMessageBox>
 
 // itk includes
 #include "itkTimeProbe.h"
 #include "itkB0ImageExtractionImageFilter.h"
 #include "itkB0ImageExtractionToSeparateImageFilter.h"
 #include "itkBrainMaskExtractionImageFilter.h"
 #include "itkCastImageFilter.h"
 #include "itkVectorContainer.h"
 #include <itkElectrostaticRepulsionDiffusionGradientReductionFilter.h>
 #include <itkMergeDiffusionImagesFilter.h>
 #include <itkDwiGradientLengthCorrectionFilter.h>
 #include <itkDwiNormilzationFilter.h>
 
 // Multishell includes
 #include <itkRadialMultishellToSingleshellImageFilter.h>
 
 // Multishell Functors
 #include <itkADCAverageFunctor.h>
 #include <itkKurtosisFitFunctor.h>
 #include <itkBiExpFitFunctor.h>
 #include <itkADCFitFunctor.h>
 
 // mitk includes
 #include "QmitkDataStorageComboBox.h"
-#include "QmitkStdMultiWidget.h"
 #include "mitkProgressBar.h"
 #include "mitkStatusBar.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkProperties.h"
 #include "mitkVtkResliceInterpolationProperty.h"
 #include "mitkLookupTable.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkTransferFunction.h"
 #include "mitkTransferFunctionProperty.h"
 #include "mitkDataNodeObject.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
 #include <mitkPointSet.h>
 #include <itkAdcImageFilter.h>
 #include <itkBrainMaskExtractionImageFilter.h>
 #include <mitkImageCast.h>
 #include <mitkRotationOperation.h>
 #include <QTableWidgetItem>
 #include <QTableWidget>
 #include <mitkInteractionConst.h>
 #include <mitkImageAccessByItk.h>
 #include <itkResampleDwiImageFilter.h>
 #include <itkResampleImageFilter.h>
 #include <itkImageDuplicator.h>
 #include <itkMaskImageFilter.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateOr.h>
 #include <itkCropImageFilter.h>
 #include <itkDiffusionTensor3DReconstructionImageFilter.h>
 #include <itkRemoveDwiChannelFilter.h>
 #include <itkExtractDwiChannelFilter.h>
 #include <mitkITKImageImport.h>
 #include <mitkBValueMapProperty.h>
 #include <mitkGradientDirectionsProperty.h>
 #include <mitkMeasurementFrameProperty.h>
 #include <itkImageDuplicator.h>
 #include <itkFlipImageFilter.h>
 #include <mitkITKImageImport.h>
 
 const std::string QmitkPreprocessingView::VIEW_ID =
     "org.mitk.views.preprocessing";
 
 #define DI_INFO MITK_INFO("DiffusionImaging")
 
 
 typedef float TTensorPixelType;
 
 
 QmitkPreprocessingView::QmitkPreprocessingView()
-  : QmitkFunctionality(),
-    m_Controls(NULL),
-    m_MultiWidget(NULL)
+  : QmitkAbstractView(),
+    m_Controls(NULL)
 {
 }
 
 QmitkPreprocessingView::~QmitkPreprocessingView()
 {
 
 }
 
 void QmitkPreprocessingView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkPreprocessingViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     m_Controls->m_MeasurementFrameTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
     m_Controls->m_MeasurementFrameTable->verticalHeader()->setSectionResizeMode(QHeaderView::Stretch);
     m_Controls->m_DirectionMatrixTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
     m_Controls->m_DirectionMatrixTable->verticalHeader()->setSectionResizeMode(QHeaderView::Stretch);
   }
 }
 
-void QmitkPreprocessingView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
+void QmitkPreprocessingView::SetFocus()
 {
-  m_MultiWidget = &stdMultiWidget;
-}
-
-void QmitkPreprocessingView::StdMultiWidgetNotAvailable()
-{
-  m_MultiWidget = NULL;
+  m_Controls->m_MirrorGradientToHalfSphereButton->setFocus();
 }
 
 void QmitkPreprocessingView::CreateConnections()
 {
   if ( m_Controls )
   {
     m_Controls->m_NormalizationMaskBox->SetDataStorage(this->GetDataStorage());
 
     m_Controls->m_SelctedImageComboBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_MergeDwiBox->SetDataStorage(this->GetDataStorage());
 
     mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage
         = mitk::TNodePredicateDataType<mitk::Image>::New();
 
     mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
     mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
     mitk::NodePredicateDataType::Pointer isQbi = mitk::NodePredicateDataType::New("QBallImage");
     mitk::NodePredicateOr::Pointer isDiffusionImage = mitk::NodePredicateOr::New(isDwi, isDti);
     isDiffusionImage = mitk::NodePredicateOr::New(isDiffusionImage, isQbi);
 
     mitk::NodePredicateNot::Pointer noDiffusionImage = mitk::NodePredicateNot::New(isDiffusionImage);
     mitk::NodePredicateAnd::Pointer finalPredicate = mitk::NodePredicateAnd::New(isMitkImage, noDiffusionImage);
     mitk::NodePredicateProperty::Pointer isBinaryPredicate
         = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
 
     finalPredicate = mitk::NodePredicateAnd::New(finalPredicate, isBinaryPredicate);
     m_Controls->m_NormalizationMaskBox->SetPredicate(finalPredicate);
     m_Controls->m_SelctedImageComboBox->SetPredicate(isMitkImage);
     m_Controls->m_MergeDwiBox->SetPredicate(isMitkImage);
 
     m_Controls->m_ExtractBrainMask->setVisible(false);
     m_Controls->m_BrainMaskIterationsBox->setVisible(false);
     m_Controls->m_ResampleIntFrame->setVisible(false);
     connect( (QObject*)(m_Controls->m_ButtonAverageGradients), SIGNAL(clicked()), this, SLOT(AverageGradients()) );
     connect( (QObject*)(m_Controls->m_ButtonExtractB0), SIGNAL(clicked()), this, SLOT(ExtractB0()) );
     connect( (QObject*)(m_Controls->m_ModifyMeasurementFrame), SIGNAL(clicked()), this, SLOT(DoApplyMesurementFrame()) );
     connect( (QObject*)(m_Controls->m_ReduceGradientsButton), SIGNAL(clicked()), this, SLOT(DoReduceGradientDirections()) );
     connect( (QObject*)(m_Controls->m_ShowGradientsButton), SIGNAL(clicked()), this, SLOT(DoShowGradientDirections()) );
     connect( (QObject*)(m_Controls->m_MirrorGradientToHalfSphereButton), SIGNAL(clicked()), this, SLOT(DoHalfSphereGradientDirections()) );
     connect( (QObject*)(m_Controls->m_MergeDwisButton), SIGNAL(clicked()), this, SLOT(MergeDwis()) );
     connect( (QObject*)(m_Controls->m_ProjectSignalButton), SIGNAL(clicked()), this, SLOT(DoProjectSignal()) );
     connect( (QObject*)(m_Controls->m_B_ValueMap_Rounder_SpinBox), SIGNAL(valueChanged(int)), this, SLOT(UpdateDwiBValueMapRounder(int)));
     connect( (QObject*)(m_Controls->m_CreateLengthCorrectedDwi), SIGNAL(clicked()), this, SLOT(DoLengthCorrection()) );
     connect( (QObject*)(m_Controls->m_CalcAdcButton), SIGNAL(clicked()), this, SLOT(DoAdcCalculation()) );
     connect( (QObject*)(m_Controls->m_NormalizeImageValuesButton), SIGNAL(clicked()), this, SLOT(DoDwiNormalization()) );
     connect( (QObject*)(m_Controls->m_ModifyDirection), SIGNAL(clicked()), this, SLOT(DoApplyDirectionMatrix()) );
     connect( (QObject*)(m_Controls->m_ModifySpacingButton), SIGNAL(clicked()), this, SLOT(DoApplySpacing()) );
     connect( (QObject*)(m_Controls->m_ModifyOriginButton), SIGNAL(clicked()), this, SLOT(DoApplyOrigin()) );
     connect( (QObject*)(m_Controls->m_ResampleImageButton), SIGNAL(clicked()), this, SLOT(DoResampleImage()) );
     connect( (QObject*)(m_Controls->m_ResampleTypeBox), SIGNAL(currentIndexChanged(int)), this, SLOT(DoUpdateInterpolationGui(int)) );
     connect( (QObject*)(m_Controls->m_CropImageButton), SIGNAL(clicked()), this, SLOT(DoCropImage()) );
     connect( (QObject*)(m_Controls->m_RemoveGradientButton), SIGNAL(clicked()), this, SLOT(DoRemoveGradient()) );
     connect( (QObject*)(m_Controls->m_ExtractGradientButton), SIGNAL(clicked()), this, SLOT(DoExtractGradient()) );
     connect( (QObject*)(m_Controls->m_FlipAxis), SIGNAL(clicked()), this, SLOT(DoFlipAxis()) );
     connect( (QObject*)(m_Controls->m_SelctedImageComboBox), SIGNAL(OnSelectionChanged(const mitk::DataNode*)),
              this, SLOT(OnImageSelectionChanged()) );
 
     m_Controls->m_NormalizationMaskBox->SetZeroEntryText("--");
 
   }
 }
 
 void QmitkPreprocessingView::DoFlipAxis()
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(node) );
 
   if (isDiffusionImage)
   {
     ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
     mitk::CastToItkImage(image, itkVectorImagePointer);
 
     itk::FixedArray<bool, 3> flipAxes;
     flipAxes[0] = m_Controls->m_FlipX->isChecked();
     flipAxes[1] = m_Controls->m_FlipY->isChecked();
     flipAxes[2] = m_Controls->m_FlipZ->isChecked();
 
     itk::FlipImageFilter< ItkDwiType >::Pointer flipper = itk::FlipImageFilter< ItkDwiType >::New();
     flipper->SetInput(itkVectorImagePointer);
     flipper->SetFlipAxes(flipAxes);
     flipper->Update();
 
     mitk::GradientDirectionsProperty::GradientDirectionsContainerType::Pointer oldGradients
         = static_cast<mitk::GradientDirectionsProperty*>
           ( image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
             ->GetGradientDirectionsContainer();
 
     mitk::GradientDirectionsProperty::GradientDirectionsContainerType::Pointer newGradients
         = mitk::GradientDirectionsProperty::GradientDirectionsContainerType::New();
 
     for (unsigned int i=0; i<oldGradients->Size(); i++)
     {
       mitk::GradientDirectionsProperty::GradientDirectionType g = oldGradients->GetElement(i);
       mitk::GradientDirectionsProperty::GradientDirectionType newG = g;
       if (flipAxes[0]) { newG[0] *= -1; }
 
       if (flipAxes[1]) { newG[1] *= -1; }
 
       if (flipAxes[2]) { newG[2] *= -1; }
 
       newGradients->InsertElement(i, newG);
     }
 
     mitk::Image::Pointer newImage = mitk::GrabItkImageMemory( flipper->GetOutput() );
 
     newImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(),
                            mitk::GradientDirectionsProperty::New( newGradients ) );
 
     newImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(),
                            mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>
                              (image->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
                                ->GetValue() ) );
 
     newImage->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(),
                            mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>
                              (image->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )
                                ->GetMeasurementFrame() ) );
 
     mitk::DiffusionPropertyHelper propertyHelper( newImage );
     propertyHelper.InitializeImage();
     newImage->GetGeometry()->SetOrigin(image->GetGeometry()->GetOrigin());
 
     mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
     imageNode->SetData( newImage );
     QString name = node->GetName().c_str();
 
     imageNode->SetName((name+"_flipped").toStdString().c_str());
-    GetDefaultDataStorage()->Add(imageNode, node);
+    GetDataStorage()->Add(imageNode, node);
 
     mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
   else if( image->GetPixelType().GetNumberOfComponents() == 1 )
   {
     AccessFixedDimensionByItk(image, TemplatedFlipAxis,3);
   }
   else
   {
     QMessageBox::warning(NULL,"Warning", QString("Operation not supported in multi-component images") );
   }
 }
 
 
 template < typename TPixel, unsigned int VImageDimension >
 void QmitkPreprocessingView::TemplatedFlipAxis(itk::Image<TPixel, VImageDimension>* itkImage)
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   itk::FixedArray<bool, 3> flipAxes;
   flipAxes[0] = m_Controls->m_FlipX->isChecked();
   flipAxes[1] = m_Controls->m_FlipY->isChecked();
   flipAxes[2] = m_Controls->m_FlipZ->isChecked();
 
   typename itk::FlipImageFilter< itk::Image<TPixel, VImageDimension> >::Pointer flipper
       = itk::FlipImageFilter< itk::Image<TPixel, VImageDimension> >::New();
   flipper->SetInput(itkImage);
   flipper->SetFlipAxes(flipAxes);
   flipper->Update();
 
   mitk::Image::Pointer newImage = mitk::GrabItkImageMemory( flipper->GetOutput() );
   newImage->GetGeometry()->SetOrigin(image->GetGeometry()->GetOrigin());
 
   mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
   imageNode->SetData( newImage );
   QString name = node->GetName().c_str();
 
   imageNode->SetName((name+"_flipped").toStdString().c_str());
-  GetDefaultDataStorage()->Add(imageNode, node);
+  GetDataStorage()->Add(imageNode, node);
 
   mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(),
                                                           mitk::RenderingManager::REQUEST_UPDATE_ALL,
                                                           true );
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkPreprocessingView::DoRemoveGradient()
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image) );
   if ( !isDiffusionImage )
   {
     return;
   }
 
   std::vector< unsigned int > channelsToRemove;
   channelsToRemove.push_back(m_Controls->m_RemoveGradientBox->value());
 
   ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
   mitk::CastToItkImage(image, itkVectorImagePointer);
 
   itk::RemoveDwiChannelFilter< short >::Pointer filter = itk::RemoveDwiChannelFilter< short >::New();
   filter->SetInput(itkVectorImagePointer);
   filter->SetChannelIndices(channelsToRemove);
 
   filter->SetDirections( static_cast<mitk::GradientDirectionsProperty*>
                          ( image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
                            ->GetGradientDirectionsContainer() );
   filter->Update();
 
   mitk::Image::Pointer newImage = mitk::GrabItkImageMemory( filter->GetOutput() );
 
   newImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(),
                          mitk::GradientDirectionsProperty::New( filter->GetNewDirections() ) );
 
   newImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(),
                          mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>
                            (image->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
                              ->GetValue() ) );
 
   newImage->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(),
                          mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>
                            (image->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )
                              ->GetMeasurementFrame() ) );
 
   mitk::DiffusionPropertyHelper propertyHelper( newImage );
   propertyHelper.InitializeImage();
 
   mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
   imageNode->SetData( newImage );
   QString name = node->GetName().c_str();
 
   imageNode->SetName((name+"_removedgradients").toStdString().c_str());
-  GetDefaultDataStorage()->Add(imageNode, node);
+  GetDataStorage()->Add(imageNode, node);
 
   mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(),
                                                           mitk::RenderingManager::REQUEST_UPDATE_ALL,
                                                           true );
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkPreprocessingView::DoExtractGradient()
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image) );
   if ( !isDiffusionImage ) { return; }
 
   ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
   mitk::CastToItkImage(image, itkVectorImagePointer);
 
   unsigned int channel = m_Controls->m_ExtractGradientBox->value();
   itk::ExtractDwiChannelFilter< short >::Pointer filter = itk::ExtractDwiChannelFilter< short >::New();
   filter->SetInput( itkVectorImagePointer);
   filter->SetChannelIndex(channel);
   filter->Update();
 
   mitk::Image::Pointer newImage = mitk::Image::New();
   newImage->InitializeByItk( filter->GetOutput() );
   newImage->SetImportChannel( filter->GetOutput()->GetBufferPointer() );
 
   mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
   imageNode->SetData( newImage );
 
   QString name = node->GetName().c_str();
   imageNode->SetName( (name+"_direction-"+QString::number(channel)).toStdString().c_str() );
-  GetDefaultDataStorage()->Add(imageNode, node);
+  GetDataStorage()->Add(imageNode, node);
 
   mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(),
                                                           mitk::RenderingManager::REQUEST_UPDATE_ALL,
                                                           true);
 }
 
 void QmitkPreprocessingView::DoCropImage()
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image) );
   if ( isDiffusionImage )
   {
     ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
     mitk::CastToItkImage(image, itkVectorImagePointer);
 
     ItkDwiType::SizeType lower;
     ItkDwiType::SizeType upper;
     lower[0] = m_Controls->m_XstartBox->value();
     lower[1] = m_Controls->m_YstartBox->value();
     lower[2] = m_Controls->m_ZstartBox->value();
     upper[0] = m_Controls->m_XendBox->value();
     upper[1] = m_Controls->m_YendBox->value();
     upper[2] = m_Controls->m_ZendBox->value();
 
     itk::CropImageFilter< ItkDwiType, ItkDwiType >::Pointer cropper = itk::CropImageFilter< ItkDwiType, ItkDwiType >::New();
     cropper->SetLowerBoundaryCropSize(lower);
     cropper->SetUpperBoundaryCropSize(upper);
     cropper->SetInput( itkVectorImagePointer );
     cropper->Update();
 
     ItkDwiType::Pointer itkOutImage = cropper->GetOutput();
     itk::Point<double,3> origin = itkOutImage->GetOrigin();
     origin[0] += lower[0]*itkOutImage->GetSpacing()[0];
     origin[1] += lower[1]*itkOutImage->GetSpacing()[1];
     origin[2] += lower[2]*itkOutImage->GetSpacing()[2];
     itkOutImage->SetOrigin(origin);
 
     mitk::Image::Pointer newimage = mitk::GrabItkImageMemory( itkOutImage );
 
     newimage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(),
                            mitk::GradientDirectionsProperty::New( static_cast<mitk::GradientDirectionsProperty*>
                              ( image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
                                ->GetGradientDirectionsContainer() ) );
 
     newimage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(),
                            mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>
                              (image->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
                                ->GetValue() ) );
 
     newimage->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(),
                            mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>
                                (image->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )
                                  ->GetMeasurementFrame() ) );
 
     mitk::DiffusionPropertyHelper propertyHelper( newimage );
     propertyHelper.InitializeImage();
 
     mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
     imageNode->SetData( newimage );
     QString name = node->GetName().c_str();
     imageNode->SetName((name+"_cropped").toStdString().c_str());
-    GetDefaultDataStorage()->Add(imageNode, node);
+    GetDataStorage()->Add(imageNode, node);
     mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(),
                                                             mitk::RenderingManager::REQUEST_UPDATE_ALL,
                                                             true );
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
     mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(),
                                                             mitk::RenderingManager::REQUEST_UPDATE_ALL,
                                                             true );
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
   else if( image->GetPixelType().GetNumberOfComponents() )
   {
     AccessFixedDimensionByItk(image, TemplatedCropImage,3);
   }
   else
   {
     QMessageBox::warning(NULL,"Warning", QString("Operation not supported in multi-component images") );
   }
 }
 
 template < typename TPixel, unsigned int VImageDimension >
 void QmitkPreprocessingView::TemplatedCropImage( itk::Image<TPixel, VImageDimension>* itkImage)
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   ItkDwiType::SizeType lower;
   ItkDwiType::SizeType upper;
   lower[0] = m_Controls->m_XstartBox->value();
   lower[1] = m_Controls->m_YstartBox->value();
   lower[2] = m_Controls->m_ZstartBox->value();
   upper[0] = m_Controls->m_XendBox->value();
   upper[1] = m_Controls->m_YendBox->value();
   upper[2] = m_Controls->m_ZendBox->value();
 
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typename itk::CropImageFilter< ImageType, ImageType >::Pointer cropper
       = itk::CropImageFilter< ImageType, ImageType >::New();
   cropper->SetLowerBoundaryCropSize(lower);
   cropper->SetUpperBoundaryCropSize(upper);
   cropper->SetInput(itkImage);
   cropper->Update();
 
   typename ImageType::Pointer itkOutImage = cropper->GetOutput();
   itk::Point<double,3> origin = itkOutImage->GetOrigin();
   origin[0] += lower[0]*itkOutImage->GetSpacing()[0];
   origin[1] += lower[1]*itkOutImage->GetSpacing()[1];
   origin[2] += lower[2]*itkOutImage->GetSpacing()[2];
   itkOutImage->SetOrigin(origin);
   mitk::Image::Pointer image = mitk::Image::New();
   image->InitializeByItk( itkOutImage.GetPointer() );
   image->SetVolume( itkOutImage->GetBufferPointer() );
   mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
   imageNode->SetData( image );
   QString name = node->GetName().c_str();
 
   imageNode->SetName((name+"_cropped").toStdString().c_str());
-  GetDefaultDataStorage()->Add(imageNode, node);
+  GetDataStorage()->Add(imageNode, node);
 
   mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(),
                                                           mitk::RenderingManager::REQUEST_UPDATE_ALL,
                                                           true );
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkPreprocessingView::DoApplySpacing()
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image) );
   if ( isDiffusionImage )
   {
     mitk::Vector3D spacing;
     spacing[0] = m_Controls->m_HeaderSpacingX->value();
     spacing[1] = m_Controls->m_HeaderSpacingY->value();
     spacing[2] = m_Controls->m_HeaderSpacingZ->value();
 
     mitk::Image::Pointer newImage = image->Clone();
     newImage->GetGeometry()->SetSpacing( spacing );
     mitk::DiffusionPropertyHelper propertyHelper( newImage );
     propertyHelper.InitializeImage();
 
     mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
     imageNode->SetData( newImage );
     QString name = node->GetName().c_str();
     imageNode->SetName((name+"_newspacing").toStdString().c_str());
-    GetDefaultDataStorage()->Add(imageNode, node);
+    GetDataStorage()->Add(imageNode, node);
     mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(),
                                                             mitk::RenderingManager::REQUEST_UPDATE_ALL,
                                                             true );
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
   else if( image->GetPixelType().GetNumberOfComponents() )
   {
     AccessFixedDimensionByItk(image, TemplatedSetImageSpacing,3);
   }
   else
   {
     QMessageBox::warning(NULL,"Warning", QString("Operation not supported in multi-component images") );
   }
 }
 
 template < typename TPixel, unsigned int VImageDimension >
 void QmitkPreprocessingView::TemplatedSetImageSpacing( itk::Image<TPixel, VImageDimension>* itkImage)
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull())
     return;
 
   mitk::Vector3D spacing;
   spacing[0] = m_Controls->m_HeaderSpacingX->value();
   spacing[1] = m_Controls->m_HeaderSpacingY->value();
   spacing[2] = m_Controls->m_HeaderSpacingZ->value();
 
   typedef itk::ImageDuplicator< itk::Image<TPixel, VImageDimension> > DuplicateFilterType;
   typename DuplicateFilterType::Pointer duplicator = DuplicateFilterType::New();
   duplicator->SetInputImage( itkImage );
   duplicator->Update();
   typename itk::Image<TPixel, VImageDimension>::Pointer newImage = duplicator->GetOutput();
   newImage->SetSpacing(spacing);
 
   mitk::Image::Pointer image = mitk::Image::New();
   image->InitializeByItk( newImage.GetPointer() );
   image->SetVolume( newImage->GetBufferPointer() );
   mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
   imageNode->SetData( image );
   QString name = node->GetName().c_str();
 
   imageNode->SetName((name+"_newspacing").toStdString().c_str());
-  GetDefaultDataStorage()->Add(imageNode, node);
+  GetDataStorage()->Add(imageNode, node);
   mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(),
                                                           mitk::RenderingManager::REQUEST_UPDATE_ALL,
                                                           true );
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkPreprocessingView::DoApplyOrigin()
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image));
   if ( isDiffusionImage )
   {
     mitk::Vector3D origin;
     origin[0] = m_Controls->m_HeaderOriginX->value();
     origin[1] = m_Controls->m_HeaderOriginY->value();
     origin[2] = m_Controls->m_HeaderOriginZ->value();
 
     mitk::Image::Pointer newImage = image->Clone();
 
     newImage->GetGeometry()->SetOrigin( origin );
     mitk::DiffusionPropertyHelper propertyHelper( newImage );
     propertyHelper.InitializeImage();
 
     mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
     imageNode->SetData( newImage );
     QString name = node->GetName().c_str();
     imageNode->SetName((name+"_neworigin").toStdString().c_str());
-    GetDefaultDataStorage()->Add(imageNode, node);
+    GetDataStorage()->Add(imageNode, node);
 
     mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(),
                                                             mitk::RenderingManager::REQUEST_UPDATE_ALL,
                                                             true );
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
   else if( image->GetPixelType().GetNumberOfComponents() )
   {
     AccessFixedDimensionByItk(image, TemplatedSetImageOrigin,3);
   }
   else
   {
     QMessageBox::warning(NULL,"Warning", QString("Operation not supported in multi-component images") );
   }
 }
 
 template < typename TPixel, unsigned int VImageDimension >
 void QmitkPreprocessingView::TemplatedSetImageOrigin( itk::Image<TPixel, VImageDimension>* itkImage)
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   mitk::Vector3D origin;
   origin[0] = m_Controls->m_HeaderOriginX->value();
   origin[1] = m_Controls->m_HeaderOriginY->value();
   origin[2] = m_Controls->m_HeaderOriginZ->value();
 
   typedef itk::ImageDuplicator< itk::Image<TPixel, VImageDimension> > DuplicateFilterType;
   typename DuplicateFilterType::Pointer duplicator = DuplicateFilterType::New();
   duplicator->SetInputImage( itkImage );
   duplicator->Update();
   typename itk::Image<TPixel, VImageDimension>::Pointer newImage = duplicator->GetOutput();
   newImage->SetOrigin(origin);
 
   mitk::Image::Pointer image = mitk::Image::New();
   image->InitializeByItk( newImage.GetPointer() );
   image->SetVolume( newImage->GetBufferPointer() );
   mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
   imageNode->SetData( image );
   QString name = node->GetName().c_str();
 
   imageNode->SetName((name+"_neworigin").toStdString().c_str());
-  GetDefaultDataStorage()->Add(imageNode, node);
+  GetDataStorage()->Add(imageNode, node);
   mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(),
                                                           mitk::RenderingManager::REQUEST_UPDATE_ALL,
                                                           true );
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkPreprocessingView::DoUpdateInterpolationGui(int i)
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   switch (i)
   {
     case 0:
     {
       m_Controls->m_ResampleIntFrame->setVisible(false);
       m_Controls->m_ResampleDoubleFrame->setVisible(true);
       break;
     }
     case 1:
     {
       m_Controls->m_ResampleIntFrame->setVisible(false);
       m_Controls->m_ResampleDoubleFrame->setVisible(true);
 
       mitk::BaseGeometry* geom = image->GetGeometry();
       m_Controls->m_ResampleDoubleX->setValue(geom->GetSpacing()[0]);
       m_Controls->m_ResampleDoubleY->setValue(geom->GetSpacing()[1]);
       m_Controls->m_ResampleDoubleZ->setValue(geom->GetSpacing()[2]);
       break;
     }
     case 2:
     {
       m_Controls->m_ResampleIntFrame->setVisible(true);
       m_Controls->m_ResampleDoubleFrame->setVisible(false);
 
       mitk::BaseGeometry* geom = image->GetGeometry();
       m_Controls->m_ResampleIntX->setValue(geom->GetExtent(0));
       m_Controls->m_ResampleIntY->setValue(geom->GetExtent(1));
       m_Controls->m_ResampleIntZ->setValue(geom->GetExtent(2));
       break;
     }
     default:
     {
       m_Controls->m_ResampleIntFrame->setVisible(false);
       m_Controls->m_ResampleDoubleFrame->setVisible(true);
     }
   }
 }
 
 void QmitkPreprocessingView::DoExtractBrainMask()
 {
 }
 
 void QmitkPreprocessingView::DoResampleImage()
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image) );
   if ( isDiffusionImage )
   {
     ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
     mitk::CastToItkImage(image, itkVectorImagePointer);
 
     typedef itk::ResampleDwiImageFilter< short > ResampleFilter;
     ResampleFilter::Pointer resampler = ResampleFilter::New();
     resampler->SetInput( itkVectorImagePointer );
 
     switch (m_Controls->m_ResampleTypeBox->currentIndex())
     {
       case 0:
       {
         itk::Vector< double, 3 > samplingFactor;
         samplingFactor[0] = m_Controls->m_ResampleDoubleX->value();
         samplingFactor[1] = m_Controls->m_ResampleDoubleY->value();
         samplingFactor[2] = m_Controls->m_ResampleDoubleZ->value();
         resampler->SetSamplingFactor(samplingFactor);
         break;
       }
       case 1:
       {
         itk::Vector< double, 3 > newSpacing;
         newSpacing[0] = m_Controls->m_ResampleDoubleX->value();
         newSpacing[1] = m_Controls->m_ResampleDoubleY->value();
         newSpacing[2] = m_Controls->m_ResampleDoubleZ->value();
         resampler->SetNewSpacing(newSpacing);
         break;
       }
       case 2:
       {
         itk::ImageRegion<3> newRegion;
         newRegion.SetSize(0, m_Controls->m_ResampleIntX->value());
         newRegion.SetSize(1, m_Controls->m_ResampleIntY->value());
         newRegion.SetSize(2, m_Controls->m_ResampleIntZ->value());
         resampler->SetNewImageSize(newRegion);
         break;
       }
       default:
       {
         MITK_WARN << "Unknown resampling parameters!";
         return;
       }
     }
 
     QString outAdd;
     switch (m_Controls->m_InterpolatorBox->currentIndex())
     {
       case 0:
       {
         resampler->SetInterpolation(ResampleFilter::Interpolate_NearestNeighbour);
         outAdd = "NearestNeighbour";
         break;
       }
       case 1:
       {
         resampler->SetInterpolation(ResampleFilter::Interpolate_Linear);
         outAdd = "Linear";
         break;
       }
       case 2:
       {
         resampler->SetInterpolation(ResampleFilter::Interpolate_BSpline);
         outAdd = "BSpline";
         break;
       }
       case 3:
       {
         resampler->SetInterpolation(ResampleFilter::Interpolate_WindowedSinc);
         outAdd = "WindowedSinc";
         break;
       }
       default:
       {
         resampler->SetInterpolation(ResampleFilter::Interpolate_NearestNeighbour);
         outAdd = "NearestNeighbour";
       }
     }
 
     resampler->Update();
 
     mitk::Image::Pointer newImage = mitk::GrabItkImageMemory( resampler->GetOutput() );
 
     newImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(),
                            mitk::GradientDirectionsProperty::New( static_cast<mitk::GradientDirectionsProperty*>
                              ( image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
                                ->GetGradientDirectionsContainer() ) );
 
     newImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(),
                            mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>
                              (image->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
                                ->GetValue() ) );
 
     newImage->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(),
                            mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>
                              (image->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )
                                ->GetMeasurementFrame() ) );
 
     mitk::DiffusionPropertyHelper propertyHelper( newImage );
     propertyHelper.InitializeImage();
 
     mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
     imageNode->SetData( newImage );
     QString name = node->GetName().c_str();
 
     imageNode->SetName((name+"_resampled_"+outAdd).toStdString().c_str());
     imageNode->SetVisibility(false);
-    GetDefaultDataStorage()->Add(imageNode, node);
+    GetDataStorage()->Add(imageNode, node);
   }
   else if( image->GetPixelType().GetNumberOfComponents() )
   {
     AccessFixedDimensionByItk(image, TemplatedResampleImage,3);
   }
   else
   {
     QMessageBox::warning(NULL,"Warning", QString("Operation not supported in multi-component images") );
   }
 }
 
 
 template < typename TPixel, unsigned int VImageDimension >
 void QmitkPreprocessingView::TemplatedResampleImage( itk::Image<TPixel, VImageDimension>* itkImage)
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   itk::Vector< double, 3 > newSpacing;
   itk::ImageRegion<3>   newRegion;
 
   switch (m_Controls->m_ResampleTypeBox->currentIndex())
   {
     case 0:
     {
       itk::Vector< double, 3 > sampling;
       sampling[0] = m_Controls->m_ResampleDoubleX->value();
       sampling[1] = m_Controls->m_ResampleDoubleY->value();
       sampling[2] = m_Controls->m_ResampleDoubleZ->value();
 
       newSpacing = itkImage->GetSpacing();
       newSpacing[0] /= sampling[0];
       newSpacing[1] /= sampling[1];
       newSpacing[2] /= sampling[2];
       newRegion = itkImage->GetLargestPossibleRegion();
       newRegion.SetSize(0, newRegion.GetSize(0)*sampling[0]);
       newRegion.SetSize(1, newRegion.GetSize(1)*sampling[1]);
       newRegion.SetSize(2, newRegion.GetSize(2)*sampling[2]);
 
       break;
     }
     case 1:
     {
       newSpacing[0] = m_Controls->m_ResampleDoubleX->value();
       newSpacing[1] = m_Controls->m_ResampleDoubleY->value();
       newSpacing[2] = m_Controls->m_ResampleDoubleZ->value();
 
       itk::Vector< double, 3 > oldSpacing = itkImage->GetSpacing();
       itk::Vector< double, 3 > sampling;
       sampling[0] = oldSpacing[0]/newSpacing[0];
       sampling[1] = oldSpacing[1]/newSpacing[1];
       sampling[2] = oldSpacing[2]/newSpacing[2];
       newRegion = itkImage->GetLargestPossibleRegion();
       newRegion.SetSize(0, newRegion.GetSize(0)*sampling[0]);
       newRegion.SetSize(1, newRegion.GetSize(1)*sampling[1]);
       newRegion.SetSize(2, newRegion.GetSize(2)*sampling[2]);
       break;
     }
     case 2:
     {
       newRegion.SetSize(0, m_Controls->m_ResampleIntX->value());
       newRegion.SetSize(1, m_Controls->m_ResampleIntY->value());
       newRegion.SetSize(2, m_Controls->m_ResampleIntZ->value());
 
       itk::ImageRegion<3> oldRegion = itkImage->GetLargestPossibleRegion();
       itk::Vector< double, 3 > sampling;
       sampling[0] = (double)newRegion.GetSize(0)/oldRegion.GetSize(0);
       sampling[1] = (double)newRegion.GetSize(1)/oldRegion.GetSize(1);
       sampling[2] = (double)newRegion.GetSize(2)/oldRegion.GetSize(2);
 
       newSpacing = itkImage->GetSpacing();
       newSpacing[0] /= sampling[0];
       newSpacing[1] /= sampling[1];
       newSpacing[2] /= sampling[2];
       break;
     }
     default:
     {
       MITK_WARN << "Unknown resampling parameters!";
       return;
     }
   }
 
   itk::Point<double,3> origin = itkImage->GetOrigin();
   origin[0] -= itkImage->GetSpacing()[0]/2;
   origin[1] -= itkImage->GetSpacing()[1]/2;
   origin[2] -= itkImage->GetSpacing()[2]/2;
   origin[0] += newSpacing[0]/2;
   origin[1] += newSpacing[1]/2;
   origin[2] += newSpacing[2]/2;
 
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typename ImageType::Pointer outImage = ImageType::New();
   outImage->SetSpacing( newSpacing );
   outImage->SetOrigin( origin );
   outImage->SetDirection( itkImage->GetDirection() );
   outImage->SetLargestPossibleRegion( newRegion );
   outImage->SetBufferedRegion( newRegion );
   outImage->SetRequestedRegion( newRegion );
   outImage->Allocate();
 
   typedef itk::ResampleImageFilter<ImageType, ImageType> ResampleFilter;
   typename ResampleFilter::Pointer resampler = ResampleFilter::New();
   resampler->SetInput(itkImage);
   resampler->SetOutputParametersFromImage(outImage);
 
   QString outAdd;
   switch (m_Controls->m_InterpolatorBox->currentIndex())
   {
     case 0:
     {
       typename itk::NearestNeighborInterpolateImageFunction<ImageType>::Pointer interp
           = itk::NearestNeighborInterpolateImageFunction<ImageType>::New();
       resampler->SetInterpolator(interp);
       outAdd = "NearestNeighbour";
       break;
     }
     case 1:
     {
       typename itk::LinearInterpolateImageFunction<ImageType>::Pointer interp
           = itk::LinearInterpolateImageFunction<ImageType>::New();
       resampler->SetInterpolator(interp);
       outAdd = "Linear";
       break;
     }
     case 2:
     {
       typename itk::BSplineInterpolateImageFunction<ImageType>::Pointer interp
           = itk::BSplineInterpolateImageFunction<ImageType>::New();
       resampler->SetInterpolator(interp);
       outAdd = "BSpline";
       break;
     }
     case 3:
     {
       typename itk::WindowedSincInterpolateImageFunction<ImageType, 3>::Pointer interp
           = itk::WindowedSincInterpolateImageFunction<ImageType, 3>::New();
       resampler->SetInterpolator(interp);
       outAdd = "WindowedSinc";
       break;
     }
     default:
     {
       typename itk::NearestNeighborInterpolateImageFunction<ImageType>::Pointer interp
           = itk::NearestNeighborInterpolateImageFunction<ImageType>::New();
       resampler->SetInterpolator(interp);
       outAdd = "NearestNeighbour";
     }
   }
 
   resampler->Update();
 
   mitk::Image::Pointer image = mitk::Image::New();
   image->InitializeByItk( resampler->GetOutput() );
   image->SetVolume( resampler->GetOutput()->GetBufferPointer() );
   mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
   imageNode->SetData( image );
   QString name = node->GetName().c_str();
 
   imageNode->SetName((name+"_resampled_"+outAdd).toStdString().c_str());
-  GetDefaultDataStorage()->Add(imageNode, node);
+  GetDataStorage()->Add(imageNode, node);
 }
 
 void QmitkPreprocessingView::DoApplyDirectionMatrix()
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image) );
   if ( isDiffusionImage )
   {
     ItkDwiType::DirectionType newDirection;
     for (int r=0; r<3; r++)
     {
       for (int c=0; c<3; c++)
       {
         QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item(r,c);
         if (!item)
           return;
         newDirection[r][c] = item->text().toDouble();
       }
     }
     ItkDwiType::Pointer itkDwi = ItkDwiType::New();
     mitk::CastToItkImage(image, itkDwi);
 
     itk::ImageDuplicator<ItkDwiType>::Pointer duplicator = itk::ImageDuplicator<ItkDwiType>::New();
     duplicator->SetInputImage(itkDwi);
     duplicator->Update();
     itkDwi = duplicator->GetOutput();
 
     vnl_matrix_fixed< double,3,3 > oldInverseDirection = itkDwi->GetDirection().GetInverse();
 
     mitk::GradientDirectionsProperty::GradientDirectionsContainerType::Pointer oldGradients
         = static_cast<mitk::GradientDirectionsProperty*>
           ( image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
             ->GetGradientDirectionsContainer();
 
     mitk::GradientDirectionsProperty::GradientDirectionsContainerType::Pointer newGradients
         = mitk::GradientDirectionsProperty::GradientDirectionsContainerType::New();
 
     for (unsigned int i=0; i<oldGradients->Size(); i++)
     {
       mitk::GradientDirectionsProperty::GradientDirectionType g = oldGradients->GetElement(i);
       double mag = g.magnitude();
       g.normalize();
       mitk::GradientDirectionsProperty::GradientDirectionType newG = oldInverseDirection*g;
       newG = newDirection.GetVnlMatrix()*newG;
       newG.normalize();
       newGradients->InsertElement(i, newG*mag);
     }
 
     itkDwi->SetDirection(newDirection);
     mitk::Image::Pointer newDwi2 = mitk::GrabItkImageMemory( itkDwi.GetPointer() );
 
     newDwi2->SetProperty( mitk::DiffusionPropertyHelper::ORIGINALGRADIENTCONTAINERPROPERTYNAME.c_str(),
                           mitk::GradientDirectionsProperty::New( newGradients ) );
 
     newDwi2->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(),
                           mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>
                               (image->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
                                 ->GetValue() ) );
 
     newDwi2->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(),
                           mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>
                               (image->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )
                                 ->GetMeasurementFrame() ) );
 
     mitk::DiffusionPropertyHelper propertyHelper( newDwi2 );
     propertyHelper.InitializeImage();
 
     mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
     imageNode->SetData( newDwi2 );
     QString name = node->GetName().c_str();
     imageNode->SetName((name+"_newdirection").toStdString().c_str());
-    GetDefaultDataStorage()->Add(imageNode, node);
+    GetDataStorage()->Add(imageNode, node);
 
     mitk::RenderingManager::GetInstance()
         ->InitializeViews( imageNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
   else if( image->GetPixelType().GetNumberOfComponents() )
   {
     AccessFixedDimensionByItk(image, TemplatedApplyRotation,3);
   }
   else
   {
     QMessageBox::warning(NULL,"Warning", QString("Operation not supported in multi-component images") );
   }
 }
 
 template < typename TPixel, unsigned int VImageDimension >
 void QmitkPreprocessingView::TemplatedApplyRotation( itk::Image<TPixel, VImageDimension>* itkImage)
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   ItkDwiType::DirectionType newDirection;
   for (int r=0; r<3; r++)
   {
     for (int c=0; c<3; c++)
     {
       QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item(r,c);
       if (!item)
         return;
       newDirection[r][c] = item->text().toDouble();
     }
   }
   typedef itk::Image<TPixel, VImageDimension> ImageType;
 
   typename ImageType::Pointer newImage = ImageType::New();
   newImage->SetSpacing( itkImage->GetSpacing() );
   newImage->SetOrigin( itkImage->GetOrigin() );
   newImage->SetDirection( newDirection );
   newImage->SetLargestPossibleRegion( itkImage->GetLargestPossibleRegion() );
   newImage->SetBufferedRegion( itkImage->GetLargestPossibleRegion() );
   newImage->SetRequestedRegion( itkImage->GetLargestPossibleRegion() );
   newImage->Allocate();
   newImage->FillBuffer(0);
 
   itk::ImageRegionIterator< itk::Image<TPixel, VImageDimension> > it(itkImage, itkImage->GetLargestPossibleRegion());
   while(!it.IsAtEnd())
   {
     newImage->SetPixel(it.GetIndex(), it.Get());
     ++it;
   }
 
   mitk::Image::Pointer newMitkImage = mitk::Image::New();
   newMitkImage->InitializeByItk(newImage.GetPointer());
   newMitkImage->SetVolume(newImage->GetBufferPointer());
 
   mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
   imageNode->SetData( newMitkImage );
   QString name = node->GetName().c_str();
   imageNode->SetName((name+"_newdirection").toStdString().c_str());
-  GetDefaultDataStorage()->Add(imageNode, node);
+  GetDataStorage()->Add(imageNode, node);
 
   mitk::RenderingManager::GetInstance()->InitializeViews( imageNode->GetData()->GetTimeGeometry(),
                                                           mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkPreprocessingView::DoProjectSignal()
 {
   switch(m_Controls->m_ProjectionMethodBox->currentIndex())
   {
     case 0:
       DoADCAverage();
     break;
     case 1:
       DoAKCFit();
     break;
     case 2:
       DoBiExpFit();
     break;
     default:
       DoADCAverage();
   }
 }
 
 void QmitkPreprocessingView::DoDwiNormalization()
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image) );
   if ( ! isDiffusionImage ) { return; }
 
   GradientDirectionContainerType::Pointer gradientContainer
       = static_cast<mitk::GradientDirectionsProperty*>
         ( image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
           ->GetGradientDirectionsContainer();
 
   int b0Index = -1;
   for (unsigned int i=0; i<gradientContainer->size(); i++)
   {
     GradientDirectionType g = gradientContainer->GetElement(i);
     if (g.magnitude()<0.001)
     {
       b0Index = i;
       break;
     }
   }
   if (b0Index==-1) { return; }
 
   typedef itk::DwiNormilzationFilter<short>  FilterType;
 
   ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
   mitk::CastToItkImage(image, itkVectorImagePointer);
 
   FilterType::Pointer filter = FilterType::New();
   filter->SetInput( itkVectorImagePointer );
   filter->SetGradientDirections( static_cast<mitk::GradientDirectionsProperty*>
                                  ( image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
                                    ->GetGradientDirectionsContainer() );
 
   UcharImageType::Pointer itkImage = NULL;
   if (m_Controls->m_NormalizationMaskBox->GetSelectedNode().IsNotNull())
   {
     itkImage = UcharImageType::New();
     if (  dynamic_cast<mitk::Image*>(m_Controls->m_NormalizationMaskBox->GetSelectedNode()->GetData()) != nullptr )
     {
       mitk::CastToItkImage( dynamic_cast<mitk::Image*>(m_Controls->m_NormalizationMaskBox->GetSelectedNode()->GetData()), itkImage );
     }
     filter->SetMaskImage(itkImage);
   }
 
   // determin normalization reference
   switch(m_Controls->m_NormalizationReferenceBox->currentIndex())
   {
     case 0: // normalize relative to mean white matter signal intensity
     {
       typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, double > TensorReconstructionImageFilterType;
       TensorReconstructionImageFilterType::Pointer dtFilter = TensorReconstructionImageFilterType::New();
       dtFilter->SetGradientImage( gradientContainer, itkVectorImagePointer );
       dtFilter->SetBValue( static_cast<mitk::FloatProperty*>
                            (image->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
                              ->GetValue() );
       dtFilter->Update();
       itk::Image< itk::DiffusionTensor3D< double >, 3 >::Pointer tensorImage = dtFilter->GetOutput();
       itk::ImageRegionIterator< itk::Image< itk::DiffusionTensor3D< double >, 3 > > inIt(tensorImage, tensorImage->GetLargestPossibleRegion());
       double ref = 0;
       unsigned int count = 0;
       while ( !inIt.IsAtEnd() )
       {
         if (itkImage.IsNotNull() && itkImage->GetPixel(inIt.GetIndex())<=0)
         {
           ++inIt;
           continue;
         }
 
         double FA = inIt.Get().GetFractionalAnisotropy();
         if (FA>0.4 && FA<0.99)
         {
           ref += itkVectorImagePointer->GetPixel(inIt.GetIndex())[b0Index];
           count++;
         }
         ++inIt;
       }
       if (count>0)
       {
         ref /= count;
         filter->SetUseGlobalReference(true);
         filter->SetReference(ref);
       }
       break;
     }
     case 1: // normalize relative to mean CSF signal intensity
     {
       itk::AdcImageFilter< short, double >::Pointer adcFilter = itk::AdcImageFilter< short, double >::New();
       adcFilter->SetInput( itkVectorImagePointer );
       adcFilter->SetGradientDirections( gradientContainer);
       adcFilter->SetB_value( static_cast<mitk::FloatProperty*>
                              (image->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
                                ->GetValue() );
       adcFilter->Update();
       ItkDoubleImageType::Pointer adcImage = adcFilter->GetOutput();
       itk::ImageRegionIterator<ItkDoubleImageType> inIt(adcImage, adcImage->GetLargestPossibleRegion());
       double max = 0.0030;
       double ref = 0;
       unsigned int count = 0;
       while ( !inIt.IsAtEnd() )
       {
         if (itkImage.IsNotNull() && itkImage->GetPixel(inIt.GetIndex())<=0)
         {
           ++inIt;
           continue;
         }
         if (inIt.Get()>max && inIt.Get()<0.004)
         {
           ref += itkVectorImagePointer->GetPixel(inIt.GetIndex())[b0Index];
           count++;
         }
         ++inIt;
       }
       if (count>0)
       {
         ref /= count;
         filter->SetUseGlobalReference(true);
         filter->SetReference(ref);
       }
       break;
     }
     case 2:
     {
       filter->SetUseGlobalReference(false);
     }
   }
   filter->Update();
 
   mitk::Image::Pointer newImage = mitk::GrabItkImageMemory( filter->GetOutput() );
 
   newImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(),
                          mitk::GradientDirectionsProperty::New( static_cast<mitk::GradientDirectionsProperty*>
                            ( image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
                              ->GetGradientDirectionsContainer() ) );
 
   newImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(),
                          mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>
                            (image->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
                              ->GetValue() ) );
 
   newImage->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(),
                          mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>
                            (image->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )
                              ->GetMeasurementFrame() ) );
 
   mitk::DiffusionPropertyHelper propertyHelper( newImage );
   propertyHelper.InitializeImage();
 
   mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
   imageNode->SetData( newImage );
   QString name = node->GetName().c_str();
 
   imageNode->SetName((name+"_normalized").toStdString().c_str());
-  GetDefaultDataStorage()->Add(imageNode, node);
+  GetDataStorage()->Add(imageNode, node);
 }
 
 void QmitkPreprocessingView::DoLengthCorrection()
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image) );
   if ( ! isDiffusionImage ) { return; }
 
   typedef itk::DwiGradientLengthCorrectionFilter  FilterType;
 
   ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
   mitk::CastToItkImage(image, itkVectorImagePointer);
 
   FilterType::Pointer filter = FilterType::New();
   filter->SetRoundingValue( m_Controls->m_B_ValueMap_Rounder_SpinBox->value());
   filter->SetReferenceBValue( static_cast<mitk::FloatProperty*>
       (image->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
         ->GetValue() );
 
   filter->SetReferenceGradientDirectionContainer( static_cast<mitk::GradientDirectionsProperty*>
       ( image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
         ->GetGradientDirectionsContainer() );
 
   filter->Update();
 
   mitk::Image::Pointer newImage = mitk::Image::New();//mitk::ImportItkImage( itkVectorImagePointer );
   newImage->InitializeByItk( itkVectorImagePointer.GetPointer() );
   newImage->SetImportVolume( itkVectorImagePointer->GetBufferPointer(), 0, 0, mitk::Image::CopyMemory);
   itkVectorImagePointer->GetPixelContainer()->ContainerManageMemoryOff();
 
   newImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetOutputGradientDirectionContainer() ) );
   newImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( filter->GetNewBValue() ) );
   newImage->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>(image->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame() ) );
   mitk::DiffusionPropertyHelper propertyHelper( newImage );
   propertyHelper.InitializeImage();
 
   mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
   imageNode->SetData( newImage );
   QString name = node->GetName().c_str();
 
   imageNode->SetName((name+"_rounded").toStdString().c_str());
-  GetDefaultDataStorage()->Add(imageNode, node);
+  GetDataStorage()->Add(imageNode, node);
 }
 
 void QmitkPreprocessingView::UpdateDwiBValueMapRounder(int i)
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(node) );
   if ( ! isDiffusionImage ) { return; }
 
   UpdateBValueTableWidget(i);
 }
 
 void QmitkPreprocessingView::
 CallMultishellToSingleShellFilter( itk::DWIVoxelFunctor * functor,
                                    mitk::Image::Pointer image,
                                    QString imageName,
                                    mitk::DataNode* parent )
 {
   typedef itk::RadialMultishellToSingleshellImageFilter<DiffusionPixelType, DiffusionPixelType> FilterType;
 
   // filter input parameter
   const mitk::BValueMapProperty::BValueMap& originalShellMap
       = static_cast<mitk::BValueMapProperty*>
         (image->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )
           ->GetBValueMap();
 
   ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
   mitk::CastToItkImage(image, itkVectorImagePointer);
   ItkDwiType* vectorImage = itkVectorImagePointer.GetPointer();
 
   const mitk::GradientDirectionsProperty::GradientDirectionsContainerType::Pointer gradientContainer
       = static_cast<mitk::GradientDirectionsProperty*>
         ( image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
           ->GetGradientDirectionsContainer();
 
   const unsigned int& bValue
       = static_cast<mitk::FloatProperty*>
         (image->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
           ->GetValue();
 
   mitk::DataNode::Pointer imageNode = 0;
 
   // filter call
   FilterType::Pointer filter = FilterType::New();
   filter->SetInput(vectorImage);
   filter->SetOriginalGradientDirections(gradientContainer);
   filter->SetOriginalBValueMap(originalShellMap);
   filter->SetOriginalBValue(bValue);
   filter->SetFunctor(functor);
   filter->Update();
 
   // create new DWI image
   mitk::Image::Pointer outImage = mitk::GrabItkImageMemory( filter->GetOutput() );
   outImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(),
                          mitk::GradientDirectionsProperty::New( filter->GetTargetGradientDirections() ) );
 
   outImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(),
                          mitk::FloatProperty::New( m_Controls->m_targetBValueSpinBox->value() ) );
 
   outImage->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(),
                          mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>
                          (image->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )
                          ->GetMeasurementFrame() ) );
 
   mitk::DiffusionPropertyHelper propertyHelper( outImage );
   propertyHelper.InitializeImage();
 
   imageNode = mitk::DataNode::New();
   imageNode->SetData( outImage );
   imageNode->SetName(imageName.toStdString().c_str());
-  GetDefaultDataStorage()->Add(imageNode, parent);
+  GetDataStorage()->Add(imageNode, parent);
 
   //  if(m_Controls->m_OutputRMSErrorImage->isChecked()){
   //    // create new Error image
   //    FilterType::ErrorImageType::Pointer errImage = filter->GetErrorImage();
   //    mitk::Image::Pointer mitkErrImage = mitk::Image::New();
   //    mitkErrImage->InitializeByItk<FilterType::ErrorImageType>(errImage);
   //    mitkErrImage->SetVolume(errImage->GetBufferPointer());
 
   //    imageNode = mitk::DataNode::New();
   //    imageNode->SetData( mitkErrImage );
   //    imageNode->SetName((imageName+"_Error").toStdString().c_str());
-  //    GetDefaultDataStorage()->Add(imageNode);
+  //    GetDataStorage()->Add(imageNode);
   //  }
 }
 
 void QmitkPreprocessingView::DoBiExpFit()
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image) );
   if ( ! isDiffusionImage ) { return; }
 
   itk::BiExpFitFunctor::Pointer functor = itk::BiExpFitFunctor::New();
 
   QString name(node->GetName().c_str());
 
   const mitk::BValueMapProperty::BValueMap& originalShellMap
       = static_cast<mitk::BValueMapProperty*>
         (image->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )
           ->GetBValueMap();
 
   mitk::BValueMapProperty::BValueMap::const_iterator it = originalShellMap.begin();
   ++it;/* skip b=0*/ unsigned int s = 0; /*shell index */
   vnl_vector<double> bValueList(originalShellMap.size()-1);
 
   while( it != originalShellMap.end() ) { bValueList.put(s++,(it++)->first); }
 
   const double targetBValue = m_Controls->m_targetBValueSpinBox->value();
   functor->setListOfBValues(bValueList);
   functor->setTargetBValue(targetBValue);
   CallMultishellToSingleShellFilter(functor,image,name + "_BiExp", node);
 }
 
 void QmitkPreprocessingView::DoAKCFit()
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image) );
   if ( ! isDiffusionImage ) { return; }
 
   itk::KurtosisFitFunctor::Pointer functor = itk::KurtosisFitFunctor::New();
 
   QString name(node->GetName().c_str());
 
   const mitk::BValueMapProperty::BValueMap& originalShellMap
       = static_cast<mitk::BValueMapProperty*>
         (image->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )
           ->GetBValueMap();
 
   mitk::BValueMapProperty::BValueMap::const_iterator it = originalShellMap.begin();
   ++it;/* skip b=0*/ unsigned int s = 0; /*shell index */
   vnl_vector<double> bValueList(originalShellMap.size()-1);
   while(it != originalShellMap.end())
     bValueList.put(s++,(it++)->first);
 
   const double targetBValue = m_Controls->m_targetBValueSpinBox->value();
   functor->setListOfBValues(bValueList);
   functor->setTargetBValue(targetBValue);
   CallMultishellToSingleShellFilter(functor,image,name + "_AKC", node);
 }
 
 void QmitkPreprocessingView::DoADCFit()
 {
   // later
 }
 
 void QmitkPreprocessingView::DoADCAverage()
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image) );
   if ( ! isDiffusionImage )
     return;
 
   itk::ADCAverageFunctor::Pointer functor = itk::ADCAverageFunctor::New();
 
   QString name(node->GetName().c_str());
 
   const mitk::BValueMapProperty::BValueMap
       &originalShellMap  = static_cast<mitk::BValueMapProperty*>(image->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
 
   mitk::BValueMapProperty::BValueMap::const_iterator it = originalShellMap.begin();
   ++it;/* skip b=0*/ unsigned int s = 0; /*shell index */
   vnl_vector<double> bValueList(originalShellMap.size()-1);
   while(it != originalShellMap.end())
     bValueList.put(s++,(it++)->first);
 
   const double targetBValue = m_Controls->m_targetBValueSpinBox->value();
   functor->setListOfBValues(bValueList);
   functor->setTargetBValue(targetBValue);
   CallMultishellToSingleShellFilter(functor,image,name + "_ADC", node);
 }
 
 void QmitkPreprocessingView::DoAdcCalculation()
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image) );
   if ( ! isDiffusionImage ) { return; }
 
   typedef itk::AdcImageFilter< DiffusionPixelType, double > FilterType;
 
   ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
   mitk::CastToItkImage(image, itkVectorImagePointer);
   FilterType::Pointer filter = FilterType::New();
   filter->SetInput( itkVectorImagePointer );
 
   filter->SetGradientDirections( static_cast<mitk::GradientDirectionsProperty*>
       ( image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
         ->GetGradientDirectionsContainer() );
 
   filter->SetB_value( static_cast<mitk::FloatProperty*>
       (image->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
         ->GetValue() );
 
   filter->Update();
 
   mitk::Image::Pointer newImage = mitk::Image::New();
   newImage->InitializeByItk( filter->GetOutput() );
   newImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
   mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
   imageNode->SetData( newImage );
   QString name = node->GetName().c_str();
 
   imageNode->SetName((name+"_ADC").toStdString().c_str());
-  GetDefaultDataStorage()->Add(imageNode, node);
+  GetDataStorage()->Add(imageNode, node);
 }
 
 void QmitkPreprocessingView::CleanBValueTableWidget()
 {
   m_Controls->m_B_ValueMap_TableWidget->clear();
   m_Controls->m_B_ValueMap_TableWidget->setRowCount(1);
   QStringList headerList;
   headerList << "b-Value" << "Number of gradients";
   m_Controls->m_B_ValueMap_TableWidget->setHorizontalHeaderLabels(headerList);
   m_Controls->m_B_ValueMap_TableWidget->setItem(0,0,new QTableWidgetItem("-"));
   m_Controls->m_B_ValueMap_TableWidget->setItem(0,1,new QTableWidgetItem("-"));
 }
 
 void QmitkPreprocessingView::UpdateBValueTableWidget(int)
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
 
   if (node.IsNull())
   {
     CleanBValueTableWidget();
     return;
   }
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   bool isDiffusionImage(false);
 
   isDiffusionImage = mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image);
 
   if ( ! isDiffusionImage )
   {
     CleanBValueTableWidget();
   }
   else
   {
     typedef mitk::BValueMapProperty::BValueMap BValueMap;
     typedef mitk::BValueMapProperty::BValueMap::iterator BValueMapIterator;
 
     BValueMapIterator it;
 
     BValueMap roundedBValueMap = static_cast<mitk::BValueMapProperty*>
         (image->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )
           ->GetBValueMap();
 
     m_Controls->m_B_ValueMap_TableWidget->clear();
     m_Controls->m_B_ValueMap_TableWidget->setRowCount(roundedBValueMap.size() );
     QStringList headerList;
     headerList << "b-Value" << "Number of gradients";
     m_Controls->m_B_ValueMap_TableWidget->setHorizontalHeaderLabels(headerList);
 
     int i = 0 ;
     for(it = roundedBValueMap.begin() ;it != roundedBValueMap.end(); it++)
     {
       m_Controls->m_B_ValueMap_TableWidget->setItem(i,0,new QTableWidgetItem(QString::number(it->first)));
       QTableWidgetItem* item = m_Controls->m_B_ValueMap_TableWidget->item(i,0);
       item->setFlags(item->flags() & ~Qt::ItemIsEditable);
       m_Controls->m_B_ValueMap_TableWidget->setItem(i,1,new QTableWidgetItem(QString::number(it->second.size())));
       i++;
     }
   }
 }
 
 
 template < typename TPixel, unsigned int VImageDimension >
 void QmitkPreprocessingView::TemplatedUpdateGui( itk::Image<TPixel, VImageDimension>* itkImage)
 {
   for (int r=0; r<3; r++)
   {
     for (int c=0; c<3; c++)
     {
       QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item(r,c);
       delete item;
       item = new QTableWidgetItem();
       item->setTextAlignment(Qt::AlignCenter | Qt::AlignVCenter);
       item->setText(QString::number(itkImage->GetDirection()[r][c]));
       m_Controls->m_DirectionMatrixTable->setItem(r,c,item);
     }
   }
 }
 
 template < typename TPixel, unsigned int VImageDimension >
 void QmitkPreprocessingView::TemplatedUpdateGui( itk::VectorImage<TPixel, VImageDimension>* itkImage)
 {
   for (int r=0; r<3; r++)
   {
     for (int c=0; c<3; c++)
     {
       QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item(r,c);
       delete item;
       item = new QTableWidgetItem();
       item->setTextAlignment(Qt::AlignCenter | Qt::AlignVCenter);
       item->setText(QString::number(itkImage->GetDirection()[r][c]));
       m_Controls->m_DirectionMatrixTable->setItem(r,c,item);
     }
   }
 }
 
 
 //todo/mdh
-void QmitkPreprocessingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
+void QmitkPreprocessingView::OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes)
 {
   (void) nodes;
   //maybe?
   this->OnImageSelectionChanged();
 }//todo/mdh/why not?
 
 
 void QmitkPreprocessingView::OnImageSelectionChanged()
 {
   bool foundImageVolume = true;
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   bool foundDwiVolume( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( node ) );
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   bool multiComponentVolume = (image->GetPixelType().GetNumberOfComponents() > 1);
   bool threeDplusTVolume = (image->GetTimeSteps() > 1);
 
   // we do not support multi-component and 3D+t images in the widget, check early to avoid access exception
   bool foundSingleImageVolume = foundDwiVolume || (foundImageVolume && (!multiComponentVolume) && (!threeDplusTVolume) );
 
   m_Controls->m_ButtonAverageGradients->setEnabled(foundDwiVolume);
   m_Controls->m_ButtonExtractB0->setEnabled(foundDwiVolume);
   m_Controls->m_CheckExtractAll->setEnabled(foundDwiVolume);
   m_Controls->m_ModifyMeasurementFrame->setEnabled(foundDwiVolume);
   m_Controls->m_MeasurementFrameTable->setEnabled(foundDwiVolume);
   m_Controls->m_ReduceGradientsButton->setEnabled(foundDwiVolume);
   m_Controls->m_ShowGradientsButton->setEnabled(foundDwiVolume);
   m_Controls->m_MirrorGradientToHalfSphereButton->setEnabled(foundDwiVolume);
   m_Controls->m_MergeDwisButton->setEnabled(foundDwiVolume);
   m_Controls->m_B_ValueMap_Rounder_SpinBox->setEnabled(foundDwiVolume);
   m_Controls->m_ProjectSignalButton->setEnabled(foundDwiVolume);
   m_Controls->m_CreateLengthCorrectedDwi->setEnabled(foundDwiVolume);
   m_Controls->m_CalcAdcButton->setEnabled(foundDwiVolume);
   m_Controls->m_targetBValueSpinBox->setEnabled(foundDwiVolume);
   m_Controls->m_NormalizeImageValuesButton->setEnabled(foundDwiVolume);
   m_Controls->m_DirectionMatrixTable->setEnabled(foundSingleImageVolume);
   m_Controls->m_ModifyDirection->setEnabled(foundSingleImageVolume);
   m_Controls->m_ExtractBrainMask->setEnabled(foundSingleImageVolume);
   m_Controls->m_ResampleImageButton->setEnabled(foundSingleImageVolume);
   m_Controls->m_ModifySpacingButton->setEnabled(foundSingleImageVolume);
   m_Controls->m_ModifyOriginButton->setEnabled(foundSingleImageVolume);
   m_Controls->m_CropImageButton->setEnabled(foundSingleImageVolume);
   m_Controls->m_RemoveGradientButton->setEnabled(foundDwiVolume);
   m_Controls->m_ExtractGradientButton->setEnabled(foundDwiVolume);
   m_Controls->m_FlipAxis->setEnabled(foundSingleImageVolume);
 
   // reset sampling frame to 1 and update all ealted components
   m_Controls->m_B_ValueMap_Rounder_SpinBox->setValue(1);
 
   UpdateBValueTableWidget(m_Controls->m_B_ValueMap_Rounder_SpinBox->value());
   DoUpdateInterpolationGui(m_Controls->m_ResampleTypeBox->currentIndex());
 
 
   if (foundDwiVolume)
   {
     m_Controls->m_InputData->setTitle("Input Data");
     vnl_matrix_fixed< double, 3, 3 >  mf
         = static_cast<mitk::MeasurementFrameProperty*>
           (image->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )
             ->GetMeasurementFrame();
 
     for (int r=0; r<3; r++)
     {
       for (int c=0; c<3; c++)
       {
         // Measurement frame
         {
           QTableWidgetItem* item = m_Controls->m_MeasurementFrameTable->item( r, c );
           delete item;
           item = new QTableWidgetItem();
           item->setTextAlignment(Qt::AlignCenter | Qt::AlignVCenter);
           item->setText(QString::number(mf.get(r,c)));
           m_Controls->m_MeasurementFrameTable->setItem( r, c, item );
         }
 
         // Direction matrix
         {
           ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
           mitk::CastToItkImage(image, itkVectorImagePointer);
 
           QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item( r, c );
           delete item;
           item = new QTableWidgetItem();
           item->setTextAlignment(Qt::AlignCenter | Qt::AlignVCenter);
           item->setText(QString::number(itkVectorImagePointer->GetDirection()[r][c]));
           m_Controls->m_DirectionMatrixTable->setItem( r, c, item );
         }
       }
     }
 
     //calculate target bValue for MultishellToSingleShellfilter
     const mitk::BValueMapProperty::BValueMap & bValMap
         = static_cast<mitk::BValueMapProperty*>
           (image->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )
             ->GetBValueMap();
 
     mitk::BValueMapProperty::BValueMap::const_iterator it = bValMap.begin();
     unsigned int targetBVal = 0;
     while(it != bValMap.end()) { targetBVal += (it++)->first; }
 
     targetBVal /= (float)bValMap.size()-1;
     m_Controls->m_targetBValueSpinBox->setValue(targetBVal);
 
     m_Controls->m_HeaderSpacingX->setValue(image->GetGeometry()->GetSpacing()[0]);
     m_Controls->m_HeaderSpacingY->setValue(image->GetGeometry()->GetSpacing()[1]);
     m_Controls->m_HeaderSpacingZ->setValue(image->GetGeometry()->GetSpacing()[2]);
     m_Controls->m_HeaderOriginX->setValue(image->GetGeometry()->GetOrigin()[0]);
     m_Controls->m_HeaderOriginY->setValue(image->GetGeometry()->GetOrigin()[1]);
     m_Controls->m_HeaderOriginZ->setValue(image->GetGeometry()->GetOrigin()[2]);
     m_Controls->m_XstartBox->setMaximum(image->GetGeometry()->GetExtent(0)-1);
     m_Controls->m_YstartBox->setMaximum(image->GetGeometry()->GetExtent(1)-1);
     m_Controls->m_ZstartBox->setMaximum(image->GetGeometry()->GetExtent(2)-1);
     m_Controls->m_XendBox->setMaximum(image->GetGeometry()->GetExtent(0)-1);
     m_Controls->m_YendBox->setMaximum(image->GetGeometry()->GetExtent(1)-1);
     m_Controls->m_ZendBox->setMaximum(image->GetGeometry()->GetExtent(2)-1);
 
     m_Controls->m_RemoveGradientBox->setMaximum(static_cast<mitk::GradientDirectionsProperty*>
       ( image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
         ->GetGradientDirectionsContainer()->Size()-1);
 
     m_Controls->m_ExtractGradientBox->setMaximum(static_cast<mitk::GradientDirectionsProperty*>
       ( image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
         ->GetGradientDirectionsContainer()->Size()-1);
   }
 
   else if (foundSingleImageVolume)
   {
     for (int r=0; r<3; r++)
     {
       for (int c=0; c<3; c++)
       {
         QTableWidgetItem* item = m_Controls->m_MeasurementFrameTable->item(r,c);
         delete item;
         item = new QTableWidgetItem();
         m_Controls->m_MeasurementFrameTable->setItem(r,c,item);
       }
     }
 
     m_Controls->m_HeaderSpacingX->setValue(image->GetGeometry()->GetSpacing()[0]);
     m_Controls->m_HeaderSpacingY->setValue(image->GetGeometry()->GetSpacing()[1]);
     m_Controls->m_HeaderSpacingZ->setValue(image->GetGeometry()->GetSpacing()[2]);
     m_Controls->m_HeaderOriginX->setValue(image->GetGeometry()->GetOrigin()[0]);
     m_Controls->m_HeaderOriginY->setValue(image->GetGeometry()->GetOrigin()[1]);
     m_Controls->m_HeaderOriginZ->setValue(image->GetGeometry()->GetOrigin()[2]);
     m_Controls->m_XstartBox->setMaximum(image->GetGeometry()->GetExtent(0)-1);
     m_Controls->m_YstartBox->setMaximum(image->GetGeometry()->GetExtent(1)-1);
     m_Controls->m_ZstartBox->setMaximum(image->GetGeometry()->GetExtent(2)-1);
     m_Controls->m_XendBox->setMaximum(image->GetGeometry()->GetExtent(0)-1);
     m_Controls->m_YendBox->setMaximum(image->GetGeometry()->GetExtent(1)-1);
     m_Controls->m_ZendBox->setMaximum(image->GetGeometry()->GetExtent(2)-1);
 
     AccessFixedDimensionByItk(image, TemplatedUpdateGui,3);
   }
 
   else
   {
     for (int r=0; r<3; r++)
     {
       for (int c=0; c<3; c++)
       {
         {
           QTableWidgetItem* item = m_Controls->m_MeasurementFrameTable->item( r, c );
           delete item;
           item = new QTableWidgetItem();
           m_Controls->m_MeasurementFrameTable->setItem( r, c, item );
         }
         {
           QTableWidgetItem* item = m_Controls->m_DirectionMatrixTable->item( r, c );
           delete item;
           item = new QTableWidgetItem();
           m_Controls->m_DirectionMatrixTable->setItem( r, c, item );
         }
       }
     }
   }
 }
 
 
-void QmitkPreprocessingView::Visible()
+void QmitkPreprocessingView::Activated()
+{
+}
+
+void QmitkPreprocessingView::Deactivated()
 {
-  QmitkFunctionality::Visible();
   OnImageSelectionChanged();
 }
 
-void QmitkPreprocessingView::Activated()
+void QmitkPreprocessingView::Visible()
 {
-  QmitkFunctionality::Activated();
+  OnImageSelectionChanged();
 }
 
-void QmitkPreprocessingView::Deactivated()
+void QmitkPreprocessingView::Hidden()
 {
-  QmitkFunctionality::Deactivated();
 }
 
 void QmitkPreprocessingView::DoHalfSphereGradientDirections()
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   mitk::Image::Pointer newDwi = image->Clone();
   GradientDirectionContainerType::Pointer gradientContainer =
     static_cast<mitk::GradientDirectionsProperty*>
       ( newDwi->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
         ->GetGradientDirectionsContainer();
 
   for (unsigned int j=0; j<gradientContainer->Size(); j++)
   {
     if (gradientContainer->at(j)[0]<0) { gradientContainer->at(j) = -gradientContainer->at(j); }
   }
 
   newDwi->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(),
                        mitk::GradientDirectionsProperty::New( gradientContainer ) );
 
   mitk::DiffusionPropertyHelper propertyHelper( newDwi );
   propertyHelper.InitializeImage();
 
   mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
   imageNode->SetData( newDwi );
 
   QString name = node->GetName().c_str();
   imageNode->SetName( (name+"_halfsphere").toStdString().c_str() );
-  GetDefaultDataStorage()->Add( imageNode, node );
+  GetDataStorage()->Add( imageNode, node );
 }
 
 void QmitkPreprocessingView::DoApplyMesurementFrame()
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image) );
   if ( !isDiffusionImage )
     return;
 
   vnl_matrix_fixed< double, 3, 3 > mf;
   for (int r=0; r<3; r++)
   {
     for (int c=0; c<3; c++)
     {
       QTableWidgetItem* item = m_Controls->m_MeasurementFrameTable->item(r,c);
       if (!item)
         return;
       mf[r][c] = item->text().toDouble();
     }
   }
 
   mitk::Image::Pointer newDwi = image->Clone();
   newDwi->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(),
                        mitk::MeasurementFrameProperty::New( mf ) );
 
   mitk::DiffusionPropertyHelper propertyHelper( newDwi );
   propertyHelper.InitializeImage();
 
   mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
   imageNode->SetData( newDwi );
 
   QString name = node->GetName().c_str();
   imageNode->SetName((name+"_new-MF").toStdString().c_str());
-  GetDefaultDataStorage()->Add( imageNode, node );
+  GetDataStorage()->Add( imageNode, node );
 }
 
 void QmitkPreprocessingView::DoShowGradientDirections()
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image) );
   if ( !isDiffusionImage ) { return; }
 
   int maxIndex = 0;
   unsigned int maxSize = image->GetDimension(0);
   if (maxSize<image->GetDimension(1))
   {
     maxSize = image->GetDimension(1);
     maxIndex = 1;
   }
   if (maxSize<image->GetDimension(2))
   {
     maxSize = image->GetDimension(2);
     maxIndex = 2;
   }
 
   mitk::Point3D origin = image->GetGeometry()->GetOrigin();
   mitk::PointSet::Pointer originSet = mitk::PointSet::New();
 
   typedef mitk::BValueMapProperty::BValueMap BValueMap;
   typedef mitk::BValueMapProperty::BValueMap::iterator BValueMapIterator;
   BValueMap bValMap =  static_cast<mitk::BValueMapProperty*>
     (image->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )
       ->GetBValueMap();
 
   GradientDirectionContainerType::Pointer gradientContainer = static_cast<mitk::GradientDirectionsProperty*>
     ( image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
       ->GetGradientDirectionsContainer();
 
   mitk::BaseGeometry::Pointer geometry = image->GetGeometry();
   int shellCount = 1;
 
   for(BValueMapIterator it = bValMap.begin(); it!=bValMap.end(); ++it)
   {
     mitk::PointSet::Pointer pointset = mitk::PointSet::New();
     for (unsigned int j=0; j<it->second.size(); j++)
     {
       mitk::Point3D ip;
       vnl_vector_fixed< double, 3 > v = gradientContainer->at(it->second[j]);
       if (v.magnitude()>mitk::eps)
       {
         ip[0] = v[0]*maxSize*geometry->GetSpacing()[maxIndex]/2
                 + origin[0]-0.5*geometry->GetSpacing()[0]
                 + geometry->GetSpacing()[0]*image->GetDimension(0)/2;
 
         ip[1] = v[1]*maxSize*geometry->GetSpacing()[maxIndex]/2
                 + origin[1]-0.5*geometry->GetSpacing()[1]
                 + geometry->GetSpacing()[1]*image->GetDimension(1)/2;
 
         ip[2] = v[2]*maxSize*geometry->GetSpacing()[maxIndex]/2
                 + origin[2]-0.5*geometry->GetSpacing()[2]
                 + geometry->GetSpacing()[2]*image->GetDimension(2)/2;
 
         pointset->InsertPoint(j, ip);
       }
       else if (originSet->IsEmpty())
       {
         ip[0] = v[0]*maxSize*geometry->GetSpacing()[maxIndex]/2
                 + origin[0]-0.5*geometry->GetSpacing()[0]
                 + geometry->GetSpacing()[0]*image->GetDimension(0)/2;
 
         ip[1] = v[1]*maxSize*geometry->GetSpacing()[maxIndex]/2
                 + origin[1]-0.5*geometry->GetSpacing()[1]
                 + geometry->GetSpacing()[1]*image->GetDimension(1)/2;
 
         ip[2] = v[2]*maxSize*geometry->GetSpacing()[maxIndex]/2
                 + origin[2]-0.5*geometry->GetSpacing()[2]
                 + geometry->GetSpacing()[2]*image->GetDimension(2)/2;
 
         originSet->InsertPoint(j, ip);
       }
     }
     if ( it->first < mitk::eps ) { continue; }
 
     // add shell to datastorage
     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
     newNode->SetData(pointset);
 
     QString name = node->GetName().c_str();
     name += "_Shell_";
     name += QString::number( it->first );
     newNode->SetName( name.toStdString().c_str() );
     newNode->SetProperty( "pointsize", mitk::FloatProperty::New((float)maxSize / 50) );
 
     int b0 = shellCount % 2;
     int b1 = 0;
     int b2 = 0;
     if (shellCount>4) { b2 = 1; }
 
     if (shellCount%4 >= 2) { b1 = 1; }
 
     newNode->SetProperty("color", mitk::ColorProperty::New( b2, b1, b0 ));
-    GetDefaultDataStorage()->Add( newNode, node );
+    GetDataStorage()->Add( newNode, node );
     shellCount++;
   }
 
   // add origin to datastorage
   mitk::DataNode::Pointer newNode = mitk::DataNode::New();
   newNode->SetData(originSet);
 
   QString name = node->GetName().c_str();
   name += "_Origin";
   newNode->SetName(name.toStdString().c_str());
   newNode->SetProperty("pointsize", mitk::FloatProperty::New((float)maxSize/50));
   newNode->SetProperty("color", mitk::ColorProperty::New(1,1,1));
-  GetDefaultDataStorage()->Add(newNode, node);
+  GetDataStorage()->Add(newNode, node);
 }
 
 void QmitkPreprocessingView::DoReduceGradientDirections()
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image) );
   if ( !isDiffusionImage ) { return; }
 
   typedef itk::ElectrostaticRepulsionDiffusionGradientReductionFilter<DiffusionPixelType, DiffusionPixelType> FilterType;
   typedef mitk::BValueMapProperty::BValueMap BValueMap;
 
   // GetShellSelection from GUI
   BValueMap shellSlectionMap;
   BValueMap originalShellMap = static_cast<mitk::BValueMapProperty*>
     (image->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )
       ->GetBValueMap();
 
   std::vector<unsigned int> newNumGradientDirections;
   int shellCounter = 0;
 
   QString name = node->GetName().c_str();
   for (int i=0; i<m_Controls->m_B_ValueMap_TableWidget->rowCount(); i++)
   {
     double BValue = m_Controls->m_B_ValueMap_TableWidget->item(i,0)->text().toDouble();
     shellSlectionMap[BValue] = originalShellMap[BValue];
     unsigned int num = m_Controls->m_B_ValueMap_TableWidget->item(i,1)->text().toUInt();
     newNumGradientDirections.push_back(num);
     name += "_";
     name += QString::number(num);
     shellCounter++;
   }
 
   if (newNumGradientDirections.empty()) { return; }
 
   GradientDirectionContainerType::Pointer gradientContainer
       = static_cast<mitk::GradientDirectionsProperty*>
         ( image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
           ->GetGradientDirectionsContainer();
 
   ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
   mitk::CastToItkImage(image, itkVectorImagePointer);
 
   FilterType::Pointer filter = FilterType::New();
   filter->SetInput( itkVectorImagePointer );
   filter->SetOriginalGradientDirections(gradientContainer);
   filter->SetNumGradientDirections(newNumGradientDirections);
   filter->SetOriginalBValueMap(originalShellMap);
   filter->SetShellSelectionBValueMap(shellSlectionMap);
   filter->Update();
 
   mitk::Image::Pointer newImage = mitk::GrabItkImageMemory( filter->GetOutput() );
   newImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(),
                          mitk::GradientDirectionsProperty::New( filter->GetGradientDirections() ) );
 
   newImage->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(),
                          mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>
                          (image->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )
                            ->GetMeasurementFrame() ) );
 
   newImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(),
                          mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>
                          (image->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
                            ->GetValue() ) );
 
   mitk::DiffusionPropertyHelper propertyHelper( newImage );
   propertyHelper.InitializeImage();
 
   mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
   imageNode->SetData( newImage );
 
   imageNode->SetName(name.toStdString().c_str());
-  GetDefaultDataStorage()->Add(imageNode, node);
+  GetDataStorage()->Add(imageNode, node);
 
   // update the b-value widget to remove the modified number of gradients used for extraction
   this->CleanBValueTableWidget();
   this->UpdateBValueTableWidget(0);
 }
 
 void QmitkPreprocessingView::MergeDwis()
 {
   typedef mitk::GradientDirectionsProperty::GradientDirectionsContainerType GradientContainerType;
 
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image) );
   if ( !isDiffusionImage ) { return; }
 
   mitk::DataNode::Pointer node2 = m_Controls->m_MergeDwiBox->GetSelectedNode();
   if (node2.IsNull()) { return; }
 
   mitk::Image::Pointer image2 = dynamic_cast<mitk::Image*>(node2->GetData());
   if ( image2 == nullptr ) { return; }
 
   typedef itk::VectorImage<DiffusionPixelType,3> DwiImageType;
   typedef DwiImageType::PixelType                DwiPixelType;
   typedef DwiImageType::RegionType               DwiRegionType;
   typedef std::vector< DwiImageType::Pointer >   DwiImageContainerType;
 
   typedef std::vector< GradientContainerType::Pointer >  GradientListContainerType;
 
   DwiImageContainerType       imageContainer;
   GradientListContainerType   gradientListContainer;
   std::vector< double >       bValueContainer;
 
   QString name = "";
   {
     ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
     mitk::CastToItkImage(image, itkVectorImagePointer);
 
     imageContainer.push_back( itkVectorImagePointer );
     gradientListContainer.push_back( static_cast<mitk::GradientDirectionsProperty*>
         ( image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
           ->GetGradientDirectionsContainer() );
 
     bValueContainer.push_back( static_cast<mitk::FloatProperty*>
         (image->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
           ->GetValue() );
 
     name += node->GetName().c_str();
   }
 
   {
     ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
     mitk::CastToItkImage(image2, itkVectorImagePointer);
 
     imageContainer.push_back( itkVectorImagePointer );
     gradientListContainer.push_back( static_cast<mitk::GradientDirectionsProperty*>
         ( image2->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
           ->GetGradientDirectionsContainer() );
 
     bValueContainer.push_back( static_cast<mitk::FloatProperty*>
         (image2->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
           ->GetValue() );
 
     name += "+";
     name += node2->GetName().c_str();
   }
 
   typedef itk::MergeDiffusionImagesFilter<short> FilterType;
   FilterType::Pointer filter = FilterType::New();
   filter->SetImageVolumes(imageContainer);
   filter->SetGradientLists(gradientListContainer);
   filter->SetBValues(bValueContainer);
   filter->Update();
 
   vnl_matrix_fixed< double, 3, 3 > mf; mf.set_identity();
   mitk::Image::Pointer newImage = mitk::GrabItkImageMemory( filter->GetOutput() );
 
   newImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(),
                          mitk::GradientDirectionsProperty::New( filter->GetOutputGradients() ) );
 
   newImage->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(),
                          mitk::MeasurementFrameProperty::New( mf ) );
 
   newImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(),
                          mitk::FloatProperty::New( filter->GetB_Value() ) );
 
   mitk::DiffusionPropertyHelper propertyHelper( newImage );
   propertyHelper.InitializeImage();
 
   mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
   imageNode->SetData( newImage );
   imageNode->SetName(name.toStdString().c_str());
-  GetDefaultDataStorage()->Add(imageNode);
+  GetDataStorage()->Add(imageNode);
 }
 
 void QmitkPreprocessingView::ExtractB0()
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image) );
   if ( !isDiffusionImage ) { return; }
 
   typedef mitk::GradientDirectionsProperty::GradientDirectionsContainerType GradientContainerType;
 
   // call the extraction withou averaging if the check-box is checked
   if( this->m_Controls->m_CheckExtractAll->isChecked() )
   {
     DoExtractBOWithoutAveraging();
     return;
   }
 
   ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
   mitk::CastToItkImage(image, itkVectorImagePointer);
 
   // Extract image using found index
   typedef itk::B0ImageExtractionImageFilter<short, short> FilterType;
   FilterType::Pointer filter = FilterType::New();
   filter->SetInput( itkVectorImagePointer );
   filter->SetDirections( static_cast<mitk::GradientDirectionsProperty*>
       ( image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
         ->GetGradientDirectionsContainer() );
 
   filter->Update();
 
   mitk::Image::Pointer mitkImage = mitk::Image::New();
   mitkImage->InitializeByItk( filter->GetOutput() );
   mitkImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
   mitk::DataNode::Pointer newNode=mitk::DataNode::New();
   newNode->SetData( mitkImage );
   newNode->SetProperty( "name", mitk::StringProperty::New(node->GetName() + "_B0"));
 
-  GetDefaultDataStorage()->Add(newNode, node);
+  GetDataStorage()->Add(newNode, node);
 }
 
 void QmitkPreprocessingView::DoExtractBOWithoutAveraging()
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image) );
   if ( !isDiffusionImage ) { return; }
 
   // typedefs
   typedef mitk::GradientDirectionsProperty::GradientDirectionsContainerType    GradientContainerType;
   typedef itk::B0ImageExtractionToSeparateImageFilter< short, short> FilterType;
 
   ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
   mitk::CastToItkImage(image, itkVectorImagePointer);
 
   // Extract image using found index
   FilterType::Pointer filter = FilterType::New();
   filter->SetInput( itkVectorImagePointer );
   filter->SetDirections( static_cast<mitk::GradientDirectionsProperty*>
       ( image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
         ->GetGradientDirectionsContainer() );
 
   filter->Update();
 
   mitk::Image::Pointer mitkImage = mitk::Image::New();
   mitkImage->InitializeByItk( filter->GetOutput() );
   mitkImage->SetImportChannel( filter->GetOutput()->GetBufferPointer() );
   mitk::DataNode::Pointer newNode=mitk::DataNode::New();
   newNode->SetData( mitkImage );
   newNode->SetProperty( "name", mitk::StringProperty::New(node->GetName() + "_B0_ALL"));
 
-  GetDefaultDataStorage()->Add(newNode, node);
+  GetDataStorage()->Add(newNode, node);
 
   /*A reinitialization is needed to access the time channels via the ImageNavigationController
     The Global-Geometry can not recognize the time channel without a re-init.
     (for a new selection in datamanger a automatically updated of the Global-Geometry should be done
     - if it contains the time channel)*/
   mitk::RenderingManager::GetInstance()->InitializeViews( newNode->GetData()->GetTimeGeometry(),
                                                           mitk::RenderingManager::REQUEST_UPDATE_ALL,
                                                           true);
 }
 
 void QmitkPreprocessingView::AverageGradients()
 {
   mitk::DataNode::Pointer node = m_Controls->m_SelctedImageComboBox->GetSelectedNode();
   if (node.IsNull()) { return; }
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if ( image == nullptr ) { return; }
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image) );
   if ( !isDiffusionImage )
     return;
 
   mitk::Image::Pointer newDwi = image->Clone();
   newDwi->SetPropertyList( image->GetPropertyList()->Clone() );
 
   mitk::DiffusionPropertyHelper propertyHelper(newDwi);
   propertyHelper.AverageRedundantGradients(m_Controls->m_Blur->value());
   propertyHelper.InitializeImage();
 
   mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
   imageNode->SetData( newDwi );
   QString name = node->GetName().c_str();
   imageNode->SetName((name+"_averaged").toStdString().c_str());
-  GetDefaultDataStorage()->Add(imageNode, node);
+  GetDataStorage()->Add(imageNode, node);
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.h
index a7444bafbf..9ea3ff3d9c 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkPreprocessingView.h
@@ -1,167 +1,168 @@
 /*===================================================================
 
 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 _QMITKPREPROCESSINGVIEW_H_INCLUDED
 #define _QMITKPREPROCESSINGVIEW_H_INCLUDED
 
-#include <QmitkFunctionality.h>
+#include <QmitkAbstractView.h>
+#include <mitkILifecycleAwarePart.h>
 
 #include "ui_QmitkPreprocessingViewControls.h"
 
 // st includes
 #include <string>
 
 // itk includes
 #include <itkImage.h>
 #include <itkVectorImage.h>
 
 // mitk includes
 #include <mitkImage.h>
 #include "itkDWIVoxelFunctor.h"
 #include <mitkDiffusionPropertyHelper.h>
 
 typedef short DiffusionPixelType;
 
 struct PrpSelListener;
 
 /*!
  * \ingroup org_mitk_gui_qt_preprocessing_internal
  *
  * \brief Viewing and modifying diffusion weighted images (gradient reduction, resampling, b-value projection, ...)
  *
- * \sa QmitkFunctionality
  */
-class QmitkPreprocessingView : public QmitkFunctionality
+class QmitkPreprocessingView : public QmitkAbstractView, public mitk::ILifecycleAwarePart
 {
 
   friend struct PrpSelListener;
 
   // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
   public:
 
   static const std::string VIEW_ID;
 
   typedef mitk::DiffusionPropertyHelper::GradientDirectionType            GradientDirectionType;
   typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType  GradientDirectionContainerType;
   typedef itk::VectorImage< short, 3 >                                    ItkDwiType;
   typedef itk::Image< unsigned char, 3 >                                  UcharImageType;
   typedef itk::Image< double, 3 >                                         ItkDoubleImageType;
 
   QmitkPreprocessingView();
   virtual ~QmitkPreprocessingView();
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
   /// \brief Creation of the connections of main and control widget
   virtual void CreateConnections();
 
-  /// \brief Called when the functionality is activated
   virtual void Activated() override;
 
   virtual void Deactivated() override;
 
   virtual void Visible() override;
 
-  virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget) override;
-  virtual void StdMultiWidgetNotAvailable() override;
+  virtual void Hidden() override;
+
+  ///
+  /// Sets the focus to an internal widget.
+  ///
+  virtual void SetFocus() override;
 
   static const int nrconvkernels;
 
 protected slots:
 
   void AverageGradients();
   void ExtractB0();
   void MergeDwis();
   void DoApplySpacing();
   void DoApplyOrigin();
   void DoApplyDirectionMatrix();
   void DoApplyMesurementFrame();
   void DoReduceGradientDirections();
   void DoShowGradientDirections();
   void DoHalfSphereGradientDirections();
   void UpdateDwiBValueMapRounder(int i);
   void DoLengthCorrection();
   void DoAdcCalculation();
   void DoDwiNormalization();
   void DoProjectSignal();
   void DoExtractBrainMask();
   void DoResampleImage();
   void DoCropImage();
   void DoUpdateInterpolationGui(int i);
   void DoRemoveGradient();
   void DoExtractGradient();
   void DoFlipAxis();
   void OnImageSelectionChanged();
 
 protected:
 
   void DoADCFit();
   void DoAKCFit();
   void DoBiExpFit();
   void DoADCAverage();
 
   template < typename TPixel, unsigned int VImageDimension >
   void TemplatedFlipAxis( itk::Image<TPixel, VImageDimension>* itkImage);
 
   template < typename TPixel, unsigned int VImageDimension >
   void TemplatedCropImage( itk::Image<TPixel, VImageDimension>* itkImage);
 
   template < typename TPixel, unsigned int VImageDimension >
   void TemplatedApplyRotation( itk::Image<TPixel, VImageDimension>* itkImage);
 
   template < typename TPixel, unsigned int VImageDimension >
   void TemplatedUpdateGui( itk::Image<TPixel, VImageDimension>* itkImage);
 
   template < typename TPixel, unsigned int VImageDimension >
   void TemplatedUpdateGui( itk::VectorImage<TPixel, VImageDimension>* itkImage);
 
   template < typename TPixel, unsigned int VImageDimension >
   void TemplatedResampleImage( itk::Image<TPixel, VImageDimension>* itkImage);
 
   template < typename TPixel, unsigned int VImageDimension >
   void TemplatedSetImageSpacing( itk::Image<TPixel, VImageDimension>* itkImage);
 
   template < typename TPixel, unsigned int VImageDimension >
   void TemplatedSetImageOrigin( itk::Image<TPixel, VImageDimension>* itkImage);
 
   /** Called by ExtractB0 if check-box activated, extracts all b0 images without averaging */
   void DoExtractBOWithoutAveraging();
 
   void UpdateBValueTableWidget(int);
 
-  /// \brief called by QmitkFunctionality when DataManager's selection has changed
-  virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes ) override; // why not?
+  /// \brief called by QmitkAbstractView when DataManager's selection has changed
+  virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
   Ui::QmitkPreprocessingViewControls* m_Controls;
 
-  QmitkStdMultiWidget* m_MultiWidget;
-
   void SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name);
   void CallMultishellToSingleShellFilter( itk::DWIVoxelFunctor * functor,
                                           mitk::Image::Pointer ImPtr, QString imageName,
                                           mitk::DataNode* parent );
 
   void CleanBValueTableWidget();
 
 };
 
 
 
 
 #endif // _QMITKPREPROCESSINGVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.cpp
index e04072db6c..65580571b8 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.cpp
@@ -1,1119 +1,1117 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //#define MBILOG_ENABLE_DEBUG
 
 #include "QmitkQBallReconstructionView.h"
 
 // qt includes
 #include <QMessageBox>
 
 // itk includes
 #include "itkTimeProbe.h"
 
 // mitk includes
 #include "mitkProgressBar.h"
 #include "mitkStatusBar.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "QmitkDataStorageComboBox.h"
-#include "QmitkStdMultiWidget.h"
 
 #include "itkDiffusionQballReconstructionImageFilter.h"
 #include "itkAnalyticalDiffusionQballReconstructionImageFilter.h"
 #include "itkDiffusionMultiShellQballReconstructionImageFilter.h"
 #include "itkVectorContainer.h"
 #include "itkB0ImageExtractionImageFilter.h"
 #include <itkBinaryThresholdImageFilter.h>
 
 #include "mitkQBallImage.h"
 #include "mitkProperties.h"
 #include "mitkVtkResliceInterpolationProperty.h"
 #include "mitkLookupTable.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkTransferFunction.h"
 #include "mitkTransferFunctionProperty.h"
 #include "mitkDataNodeObject.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
 #include <mitkImageCast.h>
 #include "mitkDiffusionImagingConfigure.h"
 
 #include "berryIStructuredSelection.h"
 #include "berryIWorkbenchWindow.h"
 #include "berryISelectionService.h"
 
 #include <boost/version.hpp>
 
 const std::string QmitkQBallReconstructionView::VIEW_ID = "org.mitk.views.qballreconstruction";
 
 
 typedef float TTensorPixelType;
 
 const int QmitkQBallReconstructionView::nrconvkernels = 252;
 
 
 struct QbrShellSelection
 {
   typedef mitk::DiffusionPropertyHelper::GradientDirectionType            GradientDirectionType;
   typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType  GradientDirectionContainerType;
   typedef mitk::DiffusionPropertyHelper::BValueMapType                    BValueMapType;
   typedef itk::VectorImage< DiffusionPixelType, 3 >                       ITKDiffusionImageType;
 
   QmitkQBallReconstructionView* m_View;
   mitk::DataNode * m_Node;
   std::string m_NodeName;
 
   std::vector<QCheckBox *> m_CheckBoxes;
   QLabel * m_Label;
 
   mitk::Image * m_Image;
 
   QbrShellSelection(QmitkQBallReconstructionView* view, mitk::DataNode * node)
     : m_View(view),
       m_Node(node),
       m_NodeName(node->GetName())
   {
     m_Image = dynamic_cast<mitk::Image * > (node->GetData());
 
     if(!m_Image)
     {
       MITK_ERROR << "QmitkQBallReconstructionView::QbrShellSelection : no image selected";
       return;
     }
     bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_Node->GetData())) );
 
     if( !isDiffusionImage )
     {
       MITK_ERROR <<
         "QmitkQBallReconstructionView::QbrShellSelection : selected image contains no diffusion information";
       return;
     }
 
     GenerateCheckboxes();
 
   }
 
   void GenerateCheckboxes()
   {
     BValueMapType origMap = static_cast<mitk::BValueMapProperty*>(m_Image->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
     BValueMapType::iterator itStart = origMap.begin();
     itStart++;
     BValueMapType::iterator itEnd = origMap.end();
 
     m_Label = new QLabel(m_NodeName.c_str());
     m_Label->setVisible(true);
     m_View->m_Controls->m_QBallSelectionBox->layout()->addWidget(m_Label);
 
     for(BValueMapType::iterator it = itStart ; it!= itEnd; it++)
     {
       QCheckBox * box  = new QCheckBox(QString::number(it->first));
       m_View->m_Controls->m_QBallSelectionBox->layout()->addWidget(box);
 
       box->setChecked(true);
       box->setCheckable(true);
       // box->setVisible(true);
       m_CheckBoxes.push_back(box);
     }
   }
 
   void SetVisible(bool vis)
   {
     foreach(QCheckBox * box, m_CheckBoxes)
     {
       box->setVisible(vis);
     }
   }
 
   BValueMapType GetBValueSelctionMap()
   {
     BValueMapType inputMap = static_cast<mitk::BValueMapProperty*>(m_Image->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();
     BValueMapType outputMap;
 
     unsigned int val = 0;
 
     if(inputMap.find(0) == inputMap.end()){
       MITK_INFO << "QbrShellSelection: return empty BValueMap from GUI Selection";
       return outputMap;
     }else{
       outputMap[val] = inputMap[val];
       MITK_INFO << val;
     }
 
     foreach(QCheckBox * box, m_CheckBoxes)
     {
       if(box->isChecked()){
         val = box->text().toDouble();
         outputMap[val] = inputMap[val];
         MITK_INFO << val;
       }
     }
 
     return outputMap;
   }
 
   ~QbrShellSelection()
   {
     m_View->m_Controls->m_QBallSelectionBox->layout()->removeWidget(m_Label);
     delete m_Label;
 
     for(std::vector<QCheckBox *>::iterator it = m_CheckBoxes.begin() ; it!= m_CheckBoxes.end(); it++)
     {
       m_View->m_Controls->m_QBallSelectionBox->layout()->removeWidget((*it));
       delete (*it);
     }
     m_CheckBoxes.clear();
   }
 };
 
 using namespace berry;
 
 struct QbrSelListener : ISelectionListener
 {
 
   QbrSelListener(QmitkQBallReconstructionView* view)
   {
     m_View = view;
   }
 
   void DoSelectionChanged(ISelection::ConstPointer selection)
   {
     // save current selection in member variable
     m_View->m_CurrentSelection = selection.Cast<const IStructuredSelection>();
 
     // do something with the selected items
     if(m_View->m_CurrentSelection)
     {
       bool foundDwiVolume = false;
 
       m_View->m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
       m_View->m_Controls->m_InputData->setTitle("Please Select Input Data");
 
       QString selected_images = "";
 
       mitk::DataStorage::SetOfObjects::Pointer set =
           mitk::DataStorage::SetOfObjects::New();
 
       int at = 0;
 
       // iterate selection
       for (IStructuredSelection::iterator i = m_View->m_CurrentSelection->Begin();
            i != m_View->m_CurrentSelection->End(); ++i)
       {
 
         // extract datatree node
         if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
         {
           mitk::DataNode::Pointer node = nodeObj->GetDataNode();
           bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
           mitk::Image* diffusionImage = dynamic_cast<mitk::Image * >(node->GetData());
           // only look at interesting types
           if(diffusionImage && isDiffusionImage)
           {
             foundDwiVolume = true;
             selected_images += QString(node->GetName().c_str());
             if(i + 1 != m_View->m_CurrentSelection->End())
               selected_images += "\n";
             set->InsertElement(at++, node);
           }
         }
       }
       m_View->GenerateShellSelectionUI(set);
       m_View->m_Controls->m_DiffusionImageLabel->setText(selected_images);
       m_View->m_Controls->m_ButtonStandard->setEnabled(foundDwiVolume);
       if (foundDwiVolume)
         m_View->m_Controls->m_InputData->setTitle("Input Data");
       else
         m_View->m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
     }
   }
 
   void SelectionChanged(const IWorkbenchPart::Pointer& part,
                         const ISelection::ConstPointer& selection) override
   {
     // check, if selection comes from datamanager
     if (part)
     {
       QString partname = part->GetPartName();
       if(partname == "Data Manager")
       {
 
         // apply selection
         DoSelectionChanged(selection);
 
       }
     }
   }
 
   QmitkQBallReconstructionView* m_View;
 };
 
 
 // --------------- QmitkQBallReconstructionView----------------- //
 
 
 QmitkQBallReconstructionView::QmitkQBallReconstructionView()
-  : QmitkFunctionality(),
-    m_Controls(NULL),
-    m_MultiWidget(NULL)
+  : QmitkAbstractView(),
+    m_Controls(NULL)
 {
 }
 
 QmitkQBallReconstructionView::~QmitkQBallReconstructionView()
 {
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->RemovePostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener.data());
 }
 
 void QmitkQBallReconstructionView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkQBallReconstructionViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
 
     QStringList items;
     items << "2" << "4" << "6" << "8" << "10" << "12";
     m_Controls->m_QBallReconstructionMaxLLevelComboBox->addItems(items);
     m_Controls->m_QBallReconstructionMaxLLevelComboBox->setCurrentIndex(1);
     MethodChoosen(m_Controls->m_QBallReconstructionMethodComboBox->currentIndex());
 
 
 #ifndef DIFFUSION_IMAGING_EXTENDED
     m_Controls->m_QBallReconstructionMethodComboBox->removeItem(3);
 #endif
 
     AdvancedCheckboxClicked();
   }
 
   m_SelListener.reset(new QbrSelListener(this));
   this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddPostSelectionListener(/*"org.mitk.views.datamanager",*/ m_SelListener.data());
   berry::ISelection::ConstPointer sel(
         this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
   static_cast<QbrSelListener*>(m_SelListener.data())->DoSelectionChanged(sel);
 }
 
-void QmitkQBallReconstructionView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
+void QmitkQBallReconstructionView::SetFocus()
 {
-  m_MultiWidget = &stdMultiWidget;
-}
-
-void QmitkQBallReconstructionView::StdMultiWidgetNotAvailable()
-{
-  m_MultiWidget = NULL;
+  m_Controls->m_AdvancedCheckbox->setFocus();
 }
 
 void QmitkQBallReconstructionView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_ButtonStandard), SIGNAL(clicked()), this, SLOT(ReconstructStandard()) );
     connect( (QObject*)(m_Controls->m_AdvancedCheckbox), SIGNAL(clicked()), this, SLOT(AdvancedCheckboxClicked()) );
     connect( (QObject*)(m_Controls->m_QBallReconstructionMethodComboBox), SIGNAL(currentIndexChanged(int)), this, SLOT(MethodChoosen(int)) );
     connect( (QObject*)(m_Controls->m_QBallReconstructionThreasholdEdit), SIGNAL(valueChanged(int)), this, SLOT(PreviewThreshold(int)) );
   }
 }
 
-void QmitkQBallReconstructionView::OnSelectionChanged( std::vector<mitk::DataNode*> )
+void QmitkQBallReconstructionView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& /*nodes*/)
 {
 
 }
 
 void QmitkQBallReconstructionView::Activated()
 {
-  QmitkFunctionality::Activated();
-
   berry::ISelection::ConstPointer sel(
         this->GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.datamanager"));
   m_CurrentSelection = sel.Cast<const IStructuredSelection>();
   static_cast<QbrSelListener*>(m_SelListener.data())->DoSelectionChanged(sel);
 }
 
 void QmitkQBallReconstructionView::Deactivated()
 {
 
-  mitk::DataStorage::SetOfObjects::ConstPointer objects =  this->GetDefaultDataStorage()->GetAll();
+  mitk::DataStorage::SetOfObjects::ConstPointer objects =  this->GetDataStorage()->GetAll();
   mitk::DataStorage::SetOfObjects::const_iterator itemiter( objects->begin() );
   mitk::DataStorage::SetOfObjects::const_iterator itemiterend( objects->end() );
   while ( itemiter != itemiterend ) // for all items
   {
       mitk::DataNode::Pointer node = *itemiter;
       if (node.IsNull())
           continue;
 
       // only look at interesting types
       bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
       if( isDiffusionImage )
       {
-          if (this->GetDefaultDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter))
+          if (this->GetDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter))
           {
-              node = this->GetDefaultDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter);
-              this->GetDefaultDataStorage()->Remove(node);
+              node = this->GetDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter);
+              this->GetDataStorage()->Remove(node);
           }
       }
       itemiter++;
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-  QmitkFunctionality::Deactivated();
+}
+
+void QmitkQBallReconstructionView::Visible()
+{
+}
+
+void QmitkQBallReconstructionView::Hidden()
+{
 }
 
 void QmitkQBallReconstructionView::ReconstructStandard()
 {
 
   int index = m_Controls->m_QBallReconstructionMethodComboBox->currentIndex();
 
 #ifndef DIFFUSION_IMAGING_EXTENDED
   if(index>=3)
   {
     index = index + 1;
   }
 #endif
 
   switch(index)
   {
   case 0:
   {
     // Numerical
     Reconstruct(0,0);
     break;
   }
   case 1:
   {
     // Standard
     Reconstruct(1,0);
     break;
   }
   case 2:
   {
     // Solid Angle
     Reconstruct(1,6);
     break;
   }
   case 3:
   {
     // Constrained Solid Angle
     Reconstruct(1,7);
     break;
   }
   case 4:
   {
     // ADC
     Reconstruct(1,4);
     break;
   }
   case 5:
   {
     // Raw Signal
     Reconstruct(1,5);
     break;
   }
   case 6:
   {
     // Q-Ball reconstruction
     Reconstruct(2,0);
     break;
   }
   }
 }
 
 void QmitkQBallReconstructionView::MethodChoosen(int method)
 {
 
 #ifndef DIFFUSION_IMAGING_EXTENDED
   if(method>=3)
   {
     method = method + 1;
   }
 #endif
 
   m_Controls->m_QBallSelectionBox->setHidden(true);
   m_Controls->m_OutputCoeffsImage->setHidden(true);
 
   if (method==0)
     m_Controls->m_ShFrame->setVisible(false);
   else
     m_Controls->m_ShFrame->setVisible(true);
 
   switch(method)
   {
   case 0:
     m_Controls->m_Description->setText("Numerical recon. (Tuch 2004)");
     break;
   case 1:
     m_Controls->m_Description->setText("Spherical harmonics recon. (Descoteaux 2007)");
     m_Controls->m_OutputCoeffsImage->setHidden(false);
     break;
   case 2:
     m_Controls->m_Description->setText("SH recon. with solid angle consideration (Aganj 2009)");
     m_Controls->m_OutputCoeffsImage->setHidden(false);
     break;
   case 3:
     m_Controls->m_Description->setText("SH solid angle with non-neg. constraint (Goh 2009)");
     break;
   case 4:
     m_Controls->m_Description->setText("SH recon. of the plain ADC-profiles");
     break;
   case 5:
     m_Controls->m_Description->setText("SH recon. of the raw diffusion signal");
     break;
   case 6:
     m_Controls->m_Description->setText("SH recon. of the multi shell diffusion signal (Aganj 2010)");
     m_Controls->m_QBallSelectionBox->setHidden(false);
     m_Controls->m_OutputCoeffsImage->setHidden(false);
     break;
   }
 }
 
 
 
 void QmitkQBallReconstructionView::AdvancedCheckboxClicked()
 {
   bool check = m_Controls->m_AdvancedCheckbox->isChecked();
 
   m_Controls->m_QBallReconstructionMaxLLevelTextLabel_2->setVisible(check);
   m_Controls->m_QBallReconstructionMaxLLevelComboBox->setVisible(check);
   m_Controls->m_QBallReconstructionLambdaTextLabel_2->setVisible(check);
   m_Controls->m_QBallReconstructionLambdaLineEdit->setVisible(check);
 
   m_Controls->m_QBallReconstructionThresholdLabel_2->setVisible(check);
   m_Controls->m_QBallReconstructionThreasholdEdit->setVisible(check);
   m_Controls->label_2->setVisible(check);
   m_Controls->frame_2->setVisible(check);
 }
 
 void QmitkQBallReconstructionView::Reconstruct(int method, int normalization)
 {
   if (m_CurrentSelection)
   {
     mitk::DataStorage::SetOfObjects::Pointer set =
         mitk::DataStorage::SetOfObjects::New();
 
     int at = 0;
     for (IStructuredSelection::iterator i = m_CurrentSelection->Begin();
          i != m_CurrentSelection->End();
          ++i)
     {
 
       if (mitk::DataNodeObject::Pointer nodeObj = i->Cast<mitk::DataNodeObject>())
       {
         mitk::DataNode::Pointer node = nodeObj->GetDataNode();
 
         bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
         if ( isDiffusionImage )
         {
           set->InsertElement(at++, node);
         }
       }
     }
 
     if(method == 0)
     {
       NumericalQBallReconstruction(set, normalization);
     }
     else
     {
 #if BOOST_VERSION / 100000 > 0
 #if BOOST_VERSION / 100 % 1000 > 34
       if(method == 1)
       {
         AnalyticalQBallReconstruction(set, normalization);
       }
       if(method == 2)
       {
         MultiQBallReconstruction(set);
       }
 #else
       std::cout << "ERROR: Boost 1.35 minimum required" << std::endl;
       QMessageBox::warning(NULL,"ERROR","Boost 1.35 minimum required");
 #endif
 #else
       std::cout << "ERROR: Boost 1.35 minimum required" << std::endl;
       QMessageBox::warning(NULL,"ERROR","Boost 1.35 minimum required");
 #endif
     }
   }
 }
 
 void QmitkQBallReconstructionView::NumericalQBallReconstruction
 (mitk::DataStorage::SetOfObjects::Pointer inImages, int normalization)
 {
   try
   {
     itk::TimeProbe clock;
 
     int nrFiles = inImages->size();
     if (!nrFiles) return;
 
     QString status;
     mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles);
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
 
     while ( itemiter != itemiterend ) // for all items
     {
 
       mitk::Image* vols =
           static_cast<mitk::Image*>(
             (*itemiter)->GetData());
 
       std::string nodename;
       (*itemiter)->GetStringProperty("name", nodename);
 
       // QBALL RECONSTRUCTION
       clock.Start();
       MITK_INFO << "QBall reconstruction ";
       mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
                                                     "QBall reconstruction for %s", nodename.c_str()).toLatin1());
 
       typedef itk::DiffusionQballReconstructionImageFilter
           <DiffusionPixelType, DiffusionPixelType, TTensorPixelType, QBALL_ODFSIZE>
           QballReconstructionImageFilterType;
 
       ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
       mitk::CastToItkImage(vols, itkVectorImagePointer);
 
       QballReconstructionImageFilterType::Pointer filter =
           QballReconstructionImageFilterType::New();
       filter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
       filter->SetBValue( static_cast<mitk::FloatProperty*>(vols->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
       filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->value() );
 
       std::string nodePostfix;
       switch(normalization)
       {
       case 0:
       {
         filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_STANDARD);
         nodePostfix = "_Numerical_Qball";
         break;
       }
       case 1:
       {
         filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_B_ZERO_B_VALUE);
         nodePostfix = "_Numerical_ZeroBvalueNormalization_Qball";
         break;
       }
       case 2:
       {
         filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_B_ZERO);
         nodePostfix = "_NumericalQball_ZeroNormalization_Qball";
         break;
       }
       case 3:
       {
         filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_NONE);
         nodePostfix = "_NumericalQball_NoNormalization_Qball";
         break;
       }
       default:
       {
         filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_STANDARD);
         nodePostfix = "_NumericalQball_Qball";
       }
       }
 
       filter->Update();
       clock.Stop();
       MITK_DEBUG << "took " << clock.GetMean() << "s." ;
 
       // ODFs TO DATATREE
       mitk::QBallImage::Pointer image = mitk::QBallImage::New();
       image->InitializeByItk( filter->GetOutput() );
       image->SetVolume( filter->GetOutput()->GetBufferPointer() );
       mitk::DataNode::Pointer node=mitk::DataNode::New();
       node->SetData( image );
       SetDefaultNodeProperties(node, nodename+nodePostfix);
       mitk::ProgressBar::GetInstance()->Progress();
 
-      GetDefaultDataStorage()->Add(node, *itemiter);
+      GetDataStorage()->Add(node, *itemiter);
       ++itemiter;
     }
 
     mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toLatin1());
-    m_MultiWidget->RequestUpdate();
+    this->GetRenderWindowPart()->RequestUpdate();
 
   }
   catch (itk::ExceptionObject &ex)
   {
     MITK_INFO << ex ;
     QMessageBox::information(0, "Reconstruction not possible:", ex.GetDescription());
     return ;
   }
 }
 
 void QmitkQBallReconstructionView::AnalyticalQBallReconstruction(
     mitk::DataStorage::SetOfObjects::Pointer inImages,
     int normalization)
 {
   try
   {
     itk::TimeProbe clock;
 
     int nrFiles = inImages->size();
     if (!nrFiles) return;
 
     std::vector<float> lambdas;
     float minLambda  = m_Controls->m_QBallReconstructionLambdaLineEdit->value();
     lambdas.push_back(minLambda);
     int nLambdas = lambdas.size();
 
 
     QString status;
     mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles*nLambdas);
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
 
     std::vector<mitk::DataNode::Pointer>* nodes
         = new std::vector<mitk::DataNode::Pointer>();
     while ( itemiter != itemiterend ) // for all items
     {
       // QBALL RECONSTRUCTION
       clock.Start();
       MITK_INFO << "QBall reconstruction ";
       mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("QBall reconstruction for %s", (*itemiter)->GetName().c_str()).toLatin1());
 
       for(int i=0; i<nLambdas; i++)
       {
         float currentLambda = lambdas[i];
         switch(m_Controls->m_QBallReconstructionMaxLLevelComboBox->currentIndex())
         {
         case 0:
         {
           TemplatedAnalyticalQBallReconstruction<2>(*itemiter, currentLambda, normalization);
           break;
         }
         case 1:
         {
           TemplatedAnalyticalQBallReconstruction<4>(*itemiter, currentLambda, normalization);
           break;
         }
         case 2:
         {
           TemplatedAnalyticalQBallReconstruction<6>(*itemiter, currentLambda, normalization);
           break;
         }
         case 3:
         {
           TemplatedAnalyticalQBallReconstruction<8>(*itemiter, currentLambda, normalization);
           break;
         }
         case 4:
         {
           TemplatedAnalyticalQBallReconstruction<10>(*itemiter, currentLambda, normalization);
           break;
         }
         case 5:
         {
           TemplatedAnalyticalQBallReconstruction<12>(*itemiter, currentLambda, normalization);
           break;
         }
         }
         clock.Stop();
         MITK_DEBUG << "took " << clock.GetMean() << "s." ;
         mitk::ProgressBar::GetInstance()->Progress();
         itemiter++;
       }
     }
 
     std::vector<mitk::DataNode::Pointer>::iterator nodeIt;
     for(nodeIt = nodes->begin(); nodeIt != nodes->end(); ++nodeIt)
-      GetDefaultDataStorage()->Add(*nodeIt);
+      GetDataStorage()->Add(*nodeIt);
 
-    m_MultiWidget->RequestUpdate();
+    this->GetRenderWindowPart()->RequestUpdate();
 
     mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toLatin1());
 
   }
   catch (itk::ExceptionObject &ex)
   {
     MITK_INFO << ex;
     QMessageBox::information(0, "Reconstruction not possible:", ex.GetDescription());
     return;
   }
 }
 
 template<int L>
 void QmitkQBallReconstructionView::TemplatedAnalyticalQBallReconstruction(mitk::DataNode* dataNodePointer, float lambda, int normalization)
 {
   typedef itk::AnalyticalDiffusionQballReconstructionImageFilter
       <DiffusionPixelType,DiffusionPixelType,TTensorPixelType,L,QBALL_ODFSIZE> FilterType;
   typename FilterType::Pointer filter = FilterType::New();
 
   mitk::Image* vols = dynamic_cast<mitk::Image*>(dataNodePointer->GetData());
 
     ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
   mitk::CastToItkImage(vols, itkVectorImagePointer);
 
   filter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
   filter->SetBValue( static_cast<mitk::FloatProperty*>(vols->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
   filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->value() );
   filter->SetLambda(lambda);
 
   std::string nodePostfix;
   switch(normalization)
   {
   case 0:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
     nodePostfix = "_SphericalHarmonics_Qball";
     break;
   }
   case 1:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_B_ZERO_B_VALUE);
     nodePostfix = "_SphericalHarmonics_1_Qball";
     break;
   }
   case 2:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_B_ZERO);
     nodePostfix = "_SphericalHarmonics_2_Qball";
     break;
   }
   case 3:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_NONE);
     nodePostfix = "_SphericalHarmonics_3_Qball";
     break;
   }
   case 4:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_ADC_ONLY);
     nodePostfix = "_AdcProfile";
     break;
   }
   case 5:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_RAW_SIGNAL);
     nodePostfix = "_RawSignal";
     break;
   }
   case 6:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
     nodePostfix = "_SphericalHarmonics_CSA_Qball";
     break;
   }
   case 7:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_NONNEG_SOLID_ANGLE);
     nodePostfix = "_SphericalHarmonics_NonNegCSA_Qball";
     break;
   }
   default:
   {
     filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
   }
   }
 
   filter->Update();
 
   // ODFs TO DATATREE
   mitk::QBallImage::Pointer image = mitk::QBallImage::New();
   image->InitializeByItk( filter->GetOutput() );
   image->SetVolume( filter->GetOutput()->GetBufferPointer() );
   mitk::DataNode::Pointer node=mitk::DataNode::New();
   node->SetData( image );
   SetDefaultNodeProperties(node, dataNodePointer->GetName()+nodePostfix);
 
-  GetDefaultDataStorage()->Add(node, dataNodePointer);
+  GetDataStorage()->Add(node, dataNodePointer);
 
   if(m_Controls->m_OutputCoeffsImage->isChecked())
   {
     mitk::Image::Pointer coeffsImage = mitk::Image::New();
     coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
     coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
     mitk::DataNode::Pointer coeffsNode=mitk::DataNode::New();
     coeffsNode->SetData( coeffsImage );
     coeffsNode->SetProperty( "name", mitk::StringProperty::New(dataNodePointer->GetName()+"_SH-Coeffs") );
     coeffsNode->SetVisibility(false);
-    GetDefaultDataStorage()->Add(coeffsNode, node);
+    GetDataStorage()->Add(coeffsNode, node);
   }
 }
 
 void QmitkQBallReconstructionView::MultiQBallReconstruction(mitk::DataStorage::SetOfObjects::Pointer inImages)
 {
   try
   {
     itk::TimeProbe clock;
 
     int nrFiles = inImages->size();
     if (!nrFiles) return;
 
     std::vector<float> lambdas;
     float minLambda  = m_Controls->m_QBallReconstructionLambdaLineEdit->value();
     lambdas.push_back(minLambda);
     int nLambdas = lambdas.size();
 
     QString status;
     mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles*nLambdas);
 
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
 
     while ( itemiter != itemiterend ) // for all items
     {
       mitk::DataNode* nodePointer = (*itemiter).GetPointer();
       std::string nodename;
       (*itemiter)->GetStringProperty("name",nodename);
 
       itemiter++;
 
       // QBALL RECONSTRUCTION
       clock.Start();
       MITK_INFO << "QBall reconstruction ";
       mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("QBall reconstruction for %s", nodename.c_str()).toLatin1());
 
       for(int i=0; i<nLambdas; i++)
       {
 
         float currentLambda = lambdas[i];
 
         switch(m_Controls->m_QBallReconstructionMaxLLevelComboBox->currentIndex())
         {
         case 0:
         {
           TemplatedMultiQBallReconstruction<2>(currentLambda, nodePointer);
           break;
         }
         case 1:
         {
           TemplatedMultiQBallReconstruction<4>(currentLambda, nodePointer);
           break;
         }
         case 2:
         {
           TemplatedMultiQBallReconstruction<6>(currentLambda, nodePointer);
           break;
         }
         case 3:
         {
           TemplatedMultiQBallReconstruction<8>(currentLambda, nodePointer);
           break;
         }
         case 4:
         {
           TemplatedMultiQBallReconstruction<10>(currentLambda, nodePointer);
           break;
         }
         case 5:
         {
           TemplatedMultiQBallReconstruction<12>(currentLambda, nodePointer);
           break;
         }
         }
 
         clock.Stop();
         MITK_DEBUG << "took " << clock.GetMean() << "s." ;
         mitk::ProgressBar::GetInstance()->Progress();
       }
     }
-    m_MultiWidget->RequestUpdate();
+    this->GetRenderWindowPart()->RequestUpdate();
     mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toLatin1());
   }
   catch (itk::ExceptionObject &ex)
   {
     MITK_INFO << ex ;
     QMessageBox::information(0, "Reconstruction not possible:", ex.GetDescription());
     return ;
   }
 }
 
 template<int L>
 void QmitkQBallReconstructionView::TemplatedMultiQBallReconstruction(float lambda, mitk::DataNode* dataNodePointer)
 {
   typedef itk::DiffusionMultiShellQballReconstructionImageFilter
       <DiffusionPixelType,DiffusionPixelType,TTensorPixelType,L,QBALL_ODFSIZE> FilterType;
   typename FilterType::Pointer filter = FilterType::New();
 
   std::string nodename;
   dataNodePointer->GetStringProperty("name",nodename);
 
   mitk::Image* dwi = dynamic_cast<mitk::Image*>(dataNodePointer->GetData());
   BValueMapType currSelectionMap = m_ShellSelectorMap[dataNodePointer]->GetBValueSelctionMap();
 
   if(currSelectionMap.size() != 4 && currSelectionMap.find(0) != currSelectionMap.end())
   {
     QMessageBox::information(0, "Reconstruction not possible:" ,QString("Only three shells in a equidistant configuration is supported. (ImageName: " + QString(nodename.c_str()) + ")"));
     return;
   }
 
   BValueMapType::reverse_iterator it1 = currSelectionMap.rbegin();
   BValueMapType::reverse_iterator it2 = currSelectionMap.rbegin();
   ++it2;
 
   // Get average distance
   int avdistance = 0;
   for(; it2 != currSelectionMap.rend(); ++it1,++it2)
     avdistance += (int)it1->first - (int)it2->first;
   avdistance /= currSelectionMap.size()-1;
 
   // Check if all shells are using the same averae distance
   it1 = currSelectionMap.rbegin();
   it2 = currSelectionMap.rbegin();
   ++it2;
   for(; it2 != currSelectionMap.rend(); ++it1,++it2)
     if(avdistance != (int)it1->first - (int)it2->first)
     {
       QMessageBox::information(0, "Reconstruction not possible:" ,QString("Selected Shells are not in a equidistant configuration. (ImageName: " + QString(nodename.c_str()) + ")"));
       return;
     }
 
     ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
     mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
     filter->SetBValueMap(m_ShellSelectorMap[dataNodePointer]->GetBValueSelctionMap());
     filter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( dwi->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer, static_cast<mitk::FloatProperty*>(dwi->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
     filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->value() );
     filter->SetLambda(lambda);
     filter->Update();
 
 
     // ODFs TO DATATREE
     mitk::QBallImage::Pointer image = mitk::QBallImage::New();
     image->InitializeByItk( filter->GetOutput() );
     image->SetVolume( filter->GetOutput()->GetBufferPointer() );
     mitk::DataNode::Pointer node=mitk::DataNode::New();
     node->SetData( image );
     SetDefaultNodeProperties(node, nodename+"_SphericalHarmonics_MultiShell_Qball");
 
-    GetDefaultDataStorage()->Add(node, dataNodePointer);
+    GetDataStorage()->Add(node, dataNodePointer);
 
     if(m_Controls->m_OutputCoeffsImage->isChecked())
     {
       mitk::Image::Pointer coeffsImage = mitk::Image::New();
       coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
       coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
       mitk::DataNode::Pointer coeffsNode=mitk::DataNode::New();
       coeffsNode->SetData( coeffsImage );
       coeffsNode->SetProperty( "name", mitk::StringProperty::New(
         QString(nodename.c_str()).append("_SH-Coefficients").toStdString()) );
       coeffsNode->SetVisibility(false);
-      GetDefaultDataStorage()->Add(coeffsNode, node);
+      GetDataStorage()->Add(coeffsNode, node);
     }
 
 }
 
 void QmitkQBallReconstructionView::SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name)
 {
   node->SetProperty( "ShowMaxNumber", mitk::IntProperty::New( 500 ) );
   node->SetProperty( "Scaling", mitk::FloatProperty::New( 1.0 ) );
   node->SetProperty( "Normalization", mitk::OdfNormalizationMethodProperty::New());
   node->SetProperty( "ScaleBy", mitk::OdfScaleByProperty::New());
   node->SetProperty( "IndexParam1", mitk::FloatProperty::New(2));
   node->SetProperty( "IndexParam2", mitk::FloatProperty::New(1));
   node->SetProperty( "visible", mitk::BoolProperty::New( true ) );
   node->SetProperty( "VisibleOdfs", mitk::BoolProperty::New( false ) );
   node->SetProperty ("layer", mitk::IntProperty::New(100));
   node->SetProperty( "DoRefresh", mitk::BoolProperty::New( true ) );
   node->SetProperty( "name", mitk::StringProperty::New(name) );
 }
 
 void QmitkQBallReconstructionView::GenerateShellSelectionUI(mitk::DataStorage::SetOfObjects::Pointer set)
 {
   m_DiffusionImages = set;
 
   std::map<const mitk::DataNode * , QbrShellSelection * > tempMap;
 
   const mitk::DataStorage::SetOfObjects::iterator setEnd( set->end() );
   mitk::DataStorage::SetOfObjects::iterator NodeIt( set->begin() );
   while(NodeIt != setEnd)
   {
 
 
     if(m_ShellSelectorMap.find(  (*NodeIt).GetPointer() ) != m_ShellSelectorMap.end())
     {
       tempMap[(*NodeIt).GetPointer()] = m_ShellSelectorMap[(*NodeIt).GetPointer()];
       m_ShellSelectorMap.erase((*NodeIt).GetPointer());
     }else
     {
       tempMap[(*NodeIt).GetPointer()] = new QbrShellSelection(this, (*NodeIt) );
       tempMap[(*NodeIt).GetPointer()]->SetVisible(true);
     }
 
     NodeIt++;
   }
 
   for(std::map<const mitk::DataNode * , QbrShellSelection * >::iterator it = m_ShellSelectorMap.begin(); it != m_ShellSelectorMap.end();it ++)
   {
     delete it->second;
   }
   m_ShellSelectorMap.clear();
   m_ShellSelectorMap = tempMap;
 }
 
 
 
 void QmitkQBallReconstructionView::PreviewThreshold(int threshold)
 {
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( m_DiffusionImages->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( m_DiffusionImages->end() );
     while ( itemiter != itemiterend ) // for all items
     {
         mitk::Image* vols =
                 static_cast<mitk::Image*>(
                     (*itemiter)->GetData());
 
         // Extract b0 image
         ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
         mitk::CastToItkImage(vols, itkVectorImagePointer);
 
         typedef itk::B0ImageExtractionImageFilter<short, short> FilterType;
         FilterType::Pointer filterB0 = FilterType::New();
         filterB0->SetInput( itkVectorImagePointer );
         filterB0->SetDirections( static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
         filterB0->Update();
 
         mitk::Image::Pointer mitkImage = mitk::Image::New();
 
         typedef itk::Image<short, 3> ImageType;
         typedef itk::Image<short, 3> SegmentationType;
         typedef itk::BinaryThresholdImageFilter<ImageType, SegmentationType> ThresholdFilterType;
         // apply threshold
         ThresholdFilterType::Pointer filterThreshold = ThresholdFilterType::New();
         filterThreshold->SetInput(filterB0->GetOutput());
         filterThreshold->SetLowerThreshold(threshold);
         filterThreshold->SetInsideValue(0);
         filterThreshold->SetOutsideValue(1); // mark cut off values red
         filterThreshold->Update();
 
         mitkImage->InitializeByItk( filterThreshold->GetOutput() );
         mitkImage->SetVolume( filterThreshold->GetOutput()->GetBufferPointer() );
         mitk::DataNode::Pointer node;
-        if (this->GetDefaultDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter))
+        if (this->GetDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter))
         {
-            node = this->GetDefaultDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter);
+            node = this->GetDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter);
         }
         else
         {
             // create a new node, to show thresholded values
             node = mitk::DataNode::New();
-            GetDefaultDataStorage()->Add( node, *itemiter );
+            GetDataStorage()->Add( node, *itemiter );
             node->SetProperty( "name", mitk::StringProperty::New("ThresholdOverlay"));
             node->SetBoolProperty("helper object", true);
         }
         node->SetData( mitkImage );
         itemiter++;
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.h
index 07800c0942..792fa3aa2d 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkQBallReconstructionView.h
@@ -1,138 +1,144 @@
 /*===================================================================
 
 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 _QMITKQBALLRECONSTRUCTIONVIEW_H_INCLUDED
 #define _QMITKQBALLRECONSTRUCTIONVIEW_H_INCLUDED
 
-#include <QmitkFunctionality.h>
+#include <QmitkAbstractView.h>
+#include <mitkILifecycleAwarePart.h>
 
 #include <string>
 
 #include "ui_QmitkQBallReconstructionViewControls.h"
 
 #include <berryIPartListener.h>
 #include <berryISelectionListener.h>
 #include <berryIStructuredSelection.h>
 
 #include <mitkImage.h>
 #include <mitkDiffusionPropertyHelper.h>
 #include <itkVectorImage.h>
 
 typedef short DiffusionPixelType;
 
 struct QbrSelListener;
 
 struct QbrShellSelection;
 
 /*!
  * \ingroup org_mitk_gui_qt_qballreconstruction_internal
  *
  * \brief QmitkQBallReconstructionView
  *
  * Document your class here.
- *
- * \sa QmitkFunctionality
  */
-class QmitkQBallReconstructionView : public QmitkFunctionality
+class QmitkQBallReconstructionView : public QmitkAbstractView, public mitk::ILifecycleAwarePart
 {
 
   friend struct QbrSelListener;
 
   friend struct QbrShellSelection;
 
   typedef mitk::DiffusionPropertyHelper::GradientDirectionType            GradientDirectionType;
   typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType  GradientDirectionContainerType;
   typedef mitk::DiffusionPropertyHelper::BValueMapType                    BValueMapType;
   typedef itk::VectorImage< DiffusionPixelType, 3 >                       ITKDiffusionImageType;
 
   // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
   public:
 
   static const std::string VIEW_ID;
 
   QmitkQBallReconstructionView();
   virtual ~QmitkQBallReconstructionView();
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
   /// \brief Creation of the connections of main and control widget
   virtual void CreateConnections();
 
-  /// \brief Called when the functionality is activated
+  ///
+  /// Sets the focus to an internal widget.
+  ///
+  virtual void SetFocus() override;
+
+  /// \brief Called when the view gets activated
   virtual void Activated() override;
 
+  /// \brief Called when the view gets deactivated
   virtual void Deactivated() override;
 
-  virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget) override;
-  virtual void StdMultiWidgetNotAvailable() override;
+  /// \brief Called when the view becomes visible
+  virtual void Visible() override;
+
+  /// \brief Called when the view becomes hidden
+  virtual void Hidden() override;
 
   static const int nrconvkernels;
 
 protected slots:
 
   void ReconstructStandard();
   void AdvancedCheckboxClicked();
   void MethodChoosen(int method);
   void Reconstruct(int method, int normalization);
 
   void NumericalQBallReconstruction(mitk::DataStorage::SetOfObjects::Pointer inImages, int normalization);
   void AnalyticalQBallReconstruction(mitk::DataStorage::SetOfObjects::Pointer inImages, int normalization);
   void MultiQBallReconstruction(mitk::DataStorage::SetOfObjects::Pointer inImages);
 
 
   /**
    * @brief PreviewThreshold Generates a preview of the values that are cut off by the thresholds
    * @param threshold
    */
   void PreviewThreshold(int threshold);
 
 protected:
 
-  /// \brief called by QmitkFunctionality when DataManager's selection has changed
-  virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes ) override;
+  /// \brief called by QmitkAbstractView when DataManager's selection has changed
+  virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
   Ui::QmitkQBallReconstructionViewControls* m_Controls;
 
-  QmitkStdMultiWidget* m_MultiWidget;
-
   template<int L>
   void TemplatedAnalyticalQBallReconstruction(mitk::DataNode* dataNodePointer, float lambda, int normalization);
 
   template<int L>
   void TemplatedMultiQBallReconstruction(float lambda, mitk::DataNode*);
 
   void SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name);
 
   //void Create
 
   QScopedPointer<berry::ISelectionListener> m_SelListener;
   berry::IStructuredSelection::ConstPointer m_CurrentSelection;
 
   mitk::DataStorage::SetOfObjects::Pointer m_DiffusionImages;
 
 private:
 
   std::map< const mitk::DataNode *, QbrShellSelection * > m_ShellSelectorMap;
   void GenerateShellSelectionUI(mitk::DataStorage::SetOfObjects::Pointer set);
 };
 
 
 
 
 #endif // _QMITKQBALLRECONSTRUCTIONVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp
index 8edbb0fa2a..58825fba4f 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.cpp
@@ -1,288 +1,278 @@
 /*===================================================================
 
 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 <berryIStructuredSelection.h>
 
 // Qmitk
 #include "QmitkStochasticFiberTrackingView.h"
-#include "QmitkStdMultiWidget.h"
 
 // Qt
 #include <QMessageBox>
 
 // MITK
 #include <mitkImageToItk.h>
 #include <mitkFiberBundle.h>
 #include <mitkImageCast.h>
 
 // VTK
 #include <vtkPolyData.h>
 #include <vtkPoints.h>
 #include <vtkCellArray.h>
 #include <vtkSmartPointer.h>
 #include <vtkPolyLine.h>
 #include <vtkCellData.h>
 
 
 const std::string QmitkStochasticFiberTrackingView::VIEW_ID = "org.mitk.views.stochasticfibertracking";
 const std::string id_DataManager = "org.mitk.views.datamanager";
 using namespace berry;
 
 QmitkStochasticFiberTrackingView::QmitkStochasticFiberTrackingView()
-    : QmitkFunctionality()
+    : QmitkAbstractView()
     , m_Controls( 0 )
-    , m_MultiWidget( NULL )
     , m_SeedRoi( NULL )
     , m_DiffusionImage( NULL )
 {
 }
 
 // Destructor
 QmitkStochasticFiberTrackingView::~QmitkStochasticFiberTrackingView()
 {
 
 }
 
 void QmitkStochasticFiberTrackingView::CreateQtPartControl( QWidget *parent )
 {
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkStochasticFiberTrackingViewControls;
         m_Controls->setupUi( parent );
 
         connect( m_Controls->commandLinkButton, SIGNAL(clicked()), this, SLOT(DoFiberTracking()) );
         connect( m_Controls->m_SeedsPerVoxelSlider, SIGNAL(valueChanged(int)), this, SLOT(OnSeedsPerVoxelChanged(int)) );
         connect( m_Controls->m_MaxCacheSizeSlider, SIGNAL(valueChanged(int)), this, SLOT(OnMaxCacheSizeChanged(int)) );
         connect( m_Controls->m_MaxTractLengthSlider, SIGNAL(valueChanged(int)), this, SLOT(OnMaxTractLengthChanged(int)) );
     }
 }
 
+void QmitkStochasticFiberTrackingView::SetFocus()
+{
+  m_Controls->commandLinkButton->setFocus();
+}
+
 void QmitkStochasticFiberTrackingView::OnSeedsPerVoxelChanged(int value)
 {
     m_Controls->m_SeedsPerVoxelLabel->setText(QString("Seeds per Voxel: ")+QString::number(value));
 }
 
 void QmitkStochasticFiberTrackingView::OnMaxTractLengthChanged(int value)
 {
     m_Controls->m_MaxTractLengthLabel->setText(QString("Max. Tract Length: ")+QString::number(value));
 }
 
 void QmitkStochasticFiberTrackingView::OnMaxCacheSizeChanged(int value)
 {
     m_Controls->m_MaxCacheSizeLabel->setText(QString("Max. Cache Size: ")+QString::number(value)+"GB");
 }
 
-void QmitkStochasticFiberTrackingView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
-{
-    m_MultiWidget = &stdMultiWidget;
-}
-
-
-void QmitkStochasticFiberTrackingView::StdMultiWidgetNotAvailable()
-{
-    m_MultiWidget = NULL;
-}
-
-void QmitkStochasticFiberTrackingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
+void QmitkStochasticFiberTrackingView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
     m_DiffusionImageNode = NULL;
     m_DiffusionImage = NULL;
     m_SeedRoi = NULL;
     m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_RoiImageLabel->setText("<font color='red'>mandatory</font>");
 
-    for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
+    for (mitk::DataNode::Pointer node: nodes)
     {
-        mitk::DataNode::Pointer node = *it;
-
         if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
           bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
           if ( isDiffusionImage )
             {
                 m_DiffusionImageNode = node;
                 m_DiffusionImage = dynamic_cast<mitk::Image*>(node->GetData());
                 m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
             }
             else
             {
                 bool isBinary = false;
                 node->GetPropertyValue<bool>("binary", isBinary);
                 if (isBinary)
                 {
                     m_SeedRoi = dynamic_cast<mitk::Image*>(node->GetData());
                     m_Controls->m_RoiImageLabel->setText(node->GetName().c_str());
                 }
             }
         }
     }
 
     if(m_DiffusionImage.IsNotNull() && m_SeedRoi.IsNotNull())
     {
         m_Controls->m_InputData->setTitle("Input Data");
         m_Controls->commandLinkButton->setEnabled(true);
     }
     else
     {
         m_Controls->m_InputData->setTitle("Please Select Input Data");
         m_Controls->commandLinkButton->setEnabled(false);
     }
 }
 
 
 
 void QmitkStochasticFiberTrackingView::DoFiberTracking()
 {
     typedef itk::VectorImage< short int, 3 >    DWIVectorImageType;
     typedef itk::Image< float, 3 >              FloatImageType;
     typedef itk::Image< unsigned int, 3 >       CImageType;
     typedef itk::StochasticTractographyFilter< DWIVectorImageType, FloatImageType, CImageType > TrackingFilterType;
     typedef itk::DTITubeSpatialObject<3>        DTITubeType;
     typedef itk::DTITubeSpatialObjectPoint<3>   DTITubePointType;
     typedef itk::SceneSpatialObject<3>          SceneSpatialObjectType;
 
     /* get Gradients/Direction of dwi */
     GradientDirectionContainerType::Pointer Pdir = static_cast<mitk::GradientDirectionsProperty*>( m_DiffusionImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
 
     /* bValueContainer, Container includes b-values according to corresponding gradient-direction*/
     TrackingFilterType::bValueContainerType::Pointer vecCont = TrackingFilterType::bValueContainerType::New();
 
     /* for each gradient set b-Value; for 0-gradient set b-value eq. 0 */
     for ( int i=0; i<(int)Pdir->size(); ++i)
     {
         vnl_vector_fixed<double,3> valsGrad = Pdir->at(i);
         if (valsGrad.get(0) == 0 && valsGrad.get(1) == 0 && valsGrad.get(2) == 0)
         {  //set 0-Gradient to bValue 0
             vecCont->InsertElement(i,0);
         }else{
             vecCont->InsertElement(i, static_cast<mitk::FloatProperty*>(m_DiffusionImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue());
         }
     }
 
     /* define measurement frame (identity-matrix 3x3) */
     TrackingFilterType::MeasurementFrameType measurement_frame =  static_cast<mitk::MeasurementFrameProperty*>(m_DiffusionImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame();
 
     /* generate white matterImage (dummy?)*/
     ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
   mitk::CastToItkImage(m_DiffusionImage, itkVectorImagePointer);
 
     FloatImageType::Pointer wmImage = FloatImageType::New();
     wmImage->SetSpacing( itkVectorImagePointer->GetSpacing() );
     wmImage->SetOrigin( itkVectorImagePointer->GetOrigin() );
     wmImage->SetDirection( itkVectorImagePointer->GetDirection() );
     wmImage->SetLargestPossibleRegion( itkVectorImagePointer->GetLargestPossibleRegion() );
     wmImage->SetBufferedRegion( wmImage->GetLargestPossibleRegion() );
     wmImage->SetRequestedRegion( wmImage->GetLargestPossibleRegion() );
     wmImage->Allocate();
     wmImage->FillBuffer(1);
 
     /* init TractographyFilter */
     TrackingFilterType::Pointer trackingFilter = TrackingFilterType::New();
     trackingFilter->SetPrimaryInput(itkVectorImagePointer.GetPointer());
     trackingFilter->SetbValues(vecCont);
     trackingFilter->SetGradients(Pdir);
     trackingFilter->SetMeasurementFrame(measurement_frame);
     trackingFilter->SetWhiteMatterProbabilityImage(wmImage);
     trackingFilter->SetTotalTracts(m_Controls->m_SeedsPerVoxelSlider->value());
     trackingFilter->SetMaxLikelihoodCacheSize(m_Controls->m_MaxCacheSizeSlider->value()*1000);
     trackingFilter->SetMaxTractLength(m_Controls->m_MaxTractLengthSlider->value());
 
 
     BinaryImageType::Pointer mask = BinaryImageType::New();
     mitk::CastToItkImage(m_SeedRoi, mask);
 
     vtkSmartPointer<vtkPoints> vPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vCellArray = vtkSmartPointer<vtkCellArray>::New();
 
     itk::ImageRegionConstIterator< BinaryImageType > it(mask, mask->GetRequestedRegion());
     it.GoToBegin();
     mitk::BaseGeometry* geom = m_DiffusionImage->GetGeometry();
 
     while(!it.IsAtEnd())
     {
         itk::ImageConstIterator<BinaryImageType>::PixelType tmpPxValue = it.Get();
 
         if(tmpPxValue != 0){
             mitk::Point3D point;
             itk::ImageRegionConstIterator< BinaryImageType >::IndexType seedIdx = it.GetIndex();
             trackingFilter->SetSeedIndex(seedIdx);
             trackingFilter->Update();
 
 
             /* get results from Filter */
             /* write each single tract into member container */
             TrackingFilterType::TractContainerType::Pointer container_tmp = trackingFilter->GetOutputTractContainer();
             TrackingFilterType::TractContainerType::Iterator elIt = container_tmp->Begin();
             TrackingFilterType::TractContainerType::Iterator end = container_tmp->End();
             bool addTract = true;
 
             while( elIt != end ){
                 TrackingFilterType::TractContainerType::Element tract = elIt.Value();
                 TrackingFilterType::TractContainerType::Element::ObjectType::VertexListType::ConstPointer vertexlist = tract->GetVertexList();
 
                 vtkSmartPointer<vtkPolyLine> vPolyLine = vtkSmartPointer<vtkPolyLine>::New();
                 for( int j=0; j<(int)vertexlist->Size(); j++)
                 {
                     TrackingFilterType::TractContainerType::Element::ObjectType::VertexListType::Element vertex = vertexlist->GetElement(j);
                     mitk::Point3D index;
                     index[0] = (float)vertex[0];
                     index[1] = (float)vertex[1];
                     index[2] = (float)vertex[2];
 
                     if (geom->IsIndexInside(index))
                     {
                         geom->IndexToWorld(index, point);
                         vtkIdType id = vPoints->InsertNextPoint(point.GetDataPointer());
                         vPolyLine->GetPointIds()->InsertNextId(id);
                     }
                     else
                     {
                         addTract = false;
                         break;
                     }
                 }
 
                 if (addTract)
                     vCellArray->InsertNextCell(vPolyLine);
 
                 ++elIt;
             }
         }
         ++it;
     }
 
     vtkSmartPointer<vtkPolyData> fiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     fiberPolyData->SetPoints(vPoints);
     fiberPolyData->SetLines(vCellArray);
 
     mitk::FiberBundle::Pointer fib = mitk::FiberBundle::New(fiberPolyData);
     fib->SetReferenceGeometry(dynamic_cast<mitk::Image*>(m_DiffusionImageNode->GetData())->GetGeometry());
     mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
     fbNode->SetData(fib);
     QString name("FiberBundle_");
     name += m_DiffusionImageNode->GetName().c_str();
     name += "_Probabilistic";
     fbNode->SetName(name.toStdString());
     fbNode->SetVisibility(true);
     GetDataStorage()->Add(fbNode, m_DiffusionImageNode);
 }
 
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.h
index b27fac2d7f..8b22ccdfa6 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStochasticFiberTrackingView.h
@@ -1,89 +1,90 @@
 /*===================================================================
 
 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 QmitkStochasticFiberTrackingView_h
 #define QmitkStochasticFiberTrackingView_h
 
-#include <QmitkFunctionality.h>
+#include <QmitkAbstractView.h>
 #include "ui_QmitkStochasticFiberTrackingViewControls.h"
 #include <mitkDataStorage.h>
 #include <itkVectorImage.h>
 #include <itkImage.h>
 #include <itkDTITubeSpatialObject.h>
 #include <itkDTITubeSpatialObjectPoint.h>
 #include <itkSceneSpatialObject.h>
 #include <itkStochasticTractographyFilter.h>
 #include <mitkDiffusionPropertyHelper.h>
 
 /*!
 \brief View for probabilistic streamline fiber tracking
-\sa QmitkFunctionality
-\ingroup Functionalities
 */
-class QmitkStochasticFiberTrackingView : public QmitkFunctionality
+class QmitkStochasticFiberTrackingView : public QmitkAbstractView
 {
     // 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:
 
   typedef short                                                           DiffusionPixelType;
   typedef mitk::DiffusionPropertyHelper::GradientDirectionType            GradientDirectionType;
   typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType  GradientDirectionContainerType;
   typedef mitk::DiffusionPropertyHelper::BValueMapType                    BValueMapType;
   typedef itk::VectorImage< DiffusionPixelType, 3 >                       ITKDiffusionImageType;
 
     typedef itk::Image< unsigned char, 3 >  BinaryImageType;
 
     static const std::string VIEW_ID;
 
     QmitkStochasticFiberTrackingView();
     virtual ~QmitkStochasticFiberTrackingView();
 
     virtual void CreateQtPartControl(QWidget *parent) override;
-    virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget) override;
-    virtual void StdMultiWidgetNotAvailable() override;
+
+    ///
+    /// Sets the focus to an internal widget.
+    ///
+    virtual void SetFocus() override;
 
 protected slots:
 
     void DoFiberTracking();   ///< start fiber tracking
 
 protected:
 
-    /// \brief called by QmitkFunctionality when DataManager's selection has changed
-    virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes ) override;
+    /// \brief called by QmitkAbstractView when DataManager's selection has changed
+    virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
+
     Ui::QmitkStochasticFiberTrackingViewControls* m_Controls;
-    QmitkStdMultiWidget* m_MultiWidget;
 
 protected slots:
 
     /** update labels if parameters have changed */
     void OnSeedsPerVoxelChanged(int value);
     void OnMaxTractLengthChanged(int value);
     void OnMaxCacheSizeChanged(int value);
 
 private:
 
     mitk::Image::Pointer                  m_SeedRoi;              ///< binary image defining seed voxels for tracking process
     mitk::Image::Pointer                  m_DiffusionImage;       ///< input image
     mitk::DataNode::Pointer               m_DiffusionImageNode;   ///< data node containing input image
 };
 
 
 
 #endif // _QMITKFIBERTRACKINGVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStreamlineTrackingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStreamlineTrackingView.cpp
index 340a80c5b8..f67532bd76 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStreamlineTrackingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStreamlineTrackingView.cpp
@@ -1,286 +1,276 @@
 /*===================================================================
 
 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 <berryIStructuredSelection.h>
 
 // Qmitk
 #include "QmitkStreamlineTrackingView.h"
-#include "QmitkStdMultiWidget.h"
 
 // Qt
 #include <QMessageBox>
 
 // MITK
 #include <mitkImageToItk.h>
 #include <mitkFiberBundle.h>
 #include <mitkImageCast.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateDimension.h>
 
 // VTK
 #include <vtkPolyData.h>
 #include <vtkPoints.h>
 #include <vtkCellArray.h>
 #include <vtkSmartPointer.h>
 #include <vtkPolyLine.h>
 #include <vtkCellData.h>
 
 
 const std::string QmitkStreamlineTrackingView::VIEW_ID = "org.mitk.views.streamlinetracking";
 const std::string id_DataManager = "org.mitk.views.datamanager";
 using namespace berry;
 
 QmitkStreamlineTrackingView::QmitkStreamlineTrackingView()
-    : QmitkFunctionality()
+    : QmitkAbstractView()
     , m_Controls( 0 )
-    , m_MultiWidget( NULL )
     , m_MaskImage( NULL )
     , m_SeedRoi( NULL )
 {
 }
 
 // Destructor
 QmitkStreamlineTrackingView::~QmitkStreamlineTrackingView()
 {
 
 }
 
 void QmitkStreamlineTrackingView::CreateQtPartControl( QWidget *parent )
 {
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkStreamlineTrackingViewControls;
         m_Controls->setupUi( parent );
         m_Controls->m_FaImageBox->SetDataStorage(this->GetDataStorage());
 
         mitk::TNodePredicateDataType<mitk::Image>::Pointer isImagePredicate = mitk::TNodePredicateDataType<mitk::Image>::New();
 
         mitk::NodePredicateProperty::Pointer isBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
         mitk::NodePredicateNot::Pointer isNotBinaryPredicate = mitk::NodePredicateNot::New( isBinaryPredicate );
         mitk::NodePredicateAnd::Pointer isNotABinaryImagePredicate = mitk::NodePredicateAnd::New( isImagePredicate, isNotBinaryPredicate );
         mitk::NodePredicateDimension::Pointer dimensionPredicate = mitk::NodePredicateDimension::New(3);
 
         m_Controls->m_FaImageBox->SetPredicate( mitk::NodePredicateAnd::New(isNotABinaryImagePredicate, dimensionPredicate) );
 
         connect( m_Controls->commandLinkButton, SIGNAL(clicked()), this, SLOT(DoFiberTracking()) );
         connect( m_Controls->m_SeedsPerVoxelSlider, SIGNAL(valueChanged(int)), this, SLOT(OnSeedsPerVoxelChanged(int)) );
         connect( m_Controls->m_MinTractLengthSlider, SIGNAL(valueChanged(int)), this, SLOT(OnMinTractLengthChanged(int)) );
         connect( m_Controls->m_ScalarThresholdBox, SIGNAL(valueChanged(double)), this, SLOT(OnFaThresholdChanged(double)) );
         connect( m_Controls->m_AngularThresholdSlider, SIGNAL(valueChanged(int)), this, SLOT(OnAngularThresholdChanged(int)) );
         connect( m_Controls->m_StepsizeSlider, SIGNAL(valueChanged(int)), this, SLOT(OnStepsizeChanged(int)) );
         connect( m_Controls->m_fSlider, SIGNAL(valueChanged(int)), this, SLOT(OnfChanged(int)) );
         connect( m_Controls->m_gSlider, SIGNAL(valueChanged(int)), this, SLOT(OngChanged(int)) );
     }
 }
 
+void QmitkStreamlineTrackingView::SetFocus()
+{
+  m_Controls->commandLinkButton->setFocus();
+}
+
 void QmitkStreamlineTrackingView::OnfChanged(int value)
 {
     m_Controls->m_fLabel->setText(QString("f: ")+QString::number((float)value/100));
 }
 
 void QmitkStreamlineTrackingView::OngChanged(int value)
 {
     m_Controls->m_gLabel->setText(QString("g: ")+QString::number((float)value/100));
 }
 
 void QmitkStreamlineTrackingView::OnAngularThresholdChanged(int value)
 {
     if (value<0)
         m_Controls->m_AngularThresholdLabel->setText(QString("Min. Curvature Radius: auto"));
     else
         m_Controls->m_AngularThresholdLabel->setText(QString("Min. Curvature Radius: ")+QString::number((float)value/10)+QString("mm"));
 }
 
 void QmitkStreamlineTrackingView::OnSeedsPerVoxelChanged(int value)
 {
     m_Controls->m_SeedsPerVoxelLabel->setText(QString("Seeds per Voxel: ")+QString::number(value));
 }
 
 void QmitkStreamlineTrackingView::OnMinTractLengthChanged(int value)
 {
     m_Controls->m_MinTractLengthLabel->setText(QString("Min. Tract Length: ")+QString::number(value)+QString("mm"));
 }
 
 void QmitkStreamlineTrackingView::OnFaThresholdChanged(double value)
 {
     m_Controls->m_FaThresholdLabel->setText(QString("FA Threshold: ")+QString::number(value));
 }
 
 void QmitkStreamlineTrackingView::OnStepsizeChanged(int value)
 {
     if (value==0)
         m_Controls->m_StepsizeLabel->setText(QString("Stepsize: auto"));
     else
         m_Controls->m_StepsizeLabel->setText(QString("Stepsize: ")+QString::number((float)value/10)+QString("mm"));
 }
 
-void QmitkStreamlineTrackingView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
-{
-    m_MultiWidget = &stdMultiWidget;
-}
-
-
-void QmitkStreamlineTrackingView::StdMultiWidgetNotAvailable()
-{
-    m_MultiWidget = NULL;
-}
-
-void QmitkStreamlineTrackingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
+void QmitkStreamlineTrackingView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
     m_TensorImageNodes.clear();
     m_TensorImages.clear();
     m_SeedRoi = NULL;
     m_MaskImage = NULL;
     m_Controls->m_TensorImageLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_RoiImageLabel->setText("<font color='grey'>optional</font>");
     m_Controls->m_MaskImageLabel->setText("<font color='grey'>optional</font>");
 
-    for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
+    for (mitk::DataNode::Pointer node: nodes)
     {
-        mitk::DataNode::Pointer node = *it;
-
         if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
             if( dynamic_cast<mitk::TensorImage*>(node->GetData()) )
             {
                 m_TensorImageNodes.push_back(node);
                 m_TensorImages.push_back(dynamic_cast<mitk::TensorImage*>(node->GetData()));
             }
             else
             {
                 bool isBinary = false;
                 node->GetPropertyValue<bool>("binary", isBinary);
                 if (isBinary && m_SeedRoi.IsNull())
                 {
                     m_SeedRoi = dynamic_cast<mitk::Image*>(node->GetData());
                     m_Controls->m_RoiImageLabel->setText(node->GetName().c_str());
                 }
                 else if (isBinary)
                 {
                     m_MaskImage = dynamic_cast<mitk::Image*>(node->GetData());
                     m_Controls->m_MaskImageLabel->setText(node->GetName().c_str());
                 }
             }
         }
     }
 
     if(!m_TensorImageNodes.empty())
     {
         if (m_TensorImageNodes.size()>1)
             m_Controls->m_TensorImageLabel->setText(m_TensorImageNodes.size()+" tensor images selected");
         else
             m_Controls->m_TensorImageLabel->setText(m_TensorImageNodes.at(0)->GetName().c_str());
         m_Controls->m_InputData->setTitle("Input Data");
         m_Controls->commandLinkButton->setEnabled(true);
     }
     else
     {
         m_Controls->m_InputData->setTitle("Please Select Input Data");
         m_Controls->commandLinkButton->setEnabled(false);
     }
 }
 
 
 
 void QmitkStreamlineTrackingView::DoFiberTracking()
 {
     if (m_TensorImages.empty())
         return;
 
     typedef itk::Image< itk::DiffusionTensor3D<float>, 3> TensorImageType;
     typedef mitk::ImageToItk<TensorImageType> CastType;
     typedef mitk::ImageToItk<ItkUCharImageType> CastType2;
 
     typedef itk::StreamlineTrackingFilter< float > FilterType;
     FilterType::Pointer filter = FilterType::New();
 
     for (int i=0; i<(int)m_TensorImages.size(); i++)
     {
         CastType::Pointer caster = CastType::New();
         caster->SetInput(m_TensorImages.at(i));
         caster->Update();
         filter->SetInput(i, caster->GetOutput());
     }
 
     if (m_Controls->m_UseFaImage->isChecked())
     {
         mitk::ImageToItk<ItkFloatImageType>::Pointer floatCast = mitk::ImageToItk<ItkFloatImageType>::New();
         floatCast->SetInput(dynamic_cast<mitk::Image*>(m_Controls->m_FaImageBox->GetSelectedNode()->GetData()));
         floatCast->Update();
         filter->SetFaImage(floatCast->GetOutput());
     }
 
     //filter->SetNumberOfThreads(1);
     filter->SetSeedsPerVoxel(m_Controls->m_SeedsPerVoxelSlider->value());
     filter->SetFaThreshold(m_Controls->m_ScalarThresholdBox->value());
     filter->SetMinCurvatureRadius((float)m_Controls->m_AngularThresholdSlider->value()/10);
     filter->SetStepSize((float)m_Controls->m_StepsizeSlider->value()/10);
     filter->SetF((float)m_Controls->m_fSlider->value()/100);
     filter->SetG((float)m_Controls->m_gSlider->value()/100);
     filter->SetInterpolate(m_Controls->m_InterpolationBox->isChecked());
     filter->SetMinTractLength(m_Controls->m_MinTractLengthSlider->value());
 
     if (m_SeedRoi.IsNotNull())
     {
         ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
         mitk::CastToItkImage(m_SeedRoi, mask);
         filter->SetSeedImage(mask);
     }
 
     if (m_MaskImage.IsNotNull())
     {
         ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
         mitk::CastToItkImage(m_MaskImage, mask);
         filter->SetMaskImage(mask);
     }
 
     filter->Update();
 
     vtkSmartPointer<vtkPolyData> fiberBundle = filter->GetFiberPolyData();
     if ( fiberBundle->GetNumberOfLines()==0 )
     {
         QMessageBox warnBox;
         warnBox.setWindowTitle("Warning");
         warnBox.setText("No fiberbundle was generated!");
         warnBox.setDetailedText("No fibers were generated using the parameters: \n\n" + m_Controls->m_FaThresholdLabel->text() + "\n" + m_Controls->m_AngularThresholdLabel->text() + "\n" + m_Controls->m_fLabel->text() + "\n" + m_Controls->m_gLabel->text() + "\n" + m_Controls->m_StepsizeLabel->text() + "\n" + m_Controls->m_MinTractLengthLabel->text() + "\n" + m_Controls->m_SeedsPerVoxelLabel->text() + "\n\nPlease check your parametersettings.");
         warnBox.setIcon(QMessageBox::Warning);
         warnBox.exec();
         return;
     }
     mitk::FiberBundle::Pointer fib = mitk::FiberBundle::New(fiberBundle);
     fib->SetReferenceGeometry(dynamic_cast<mitk::Image*>(m_TensorImageNodes.at(0)->GetData())->GetGeometry());
     if (m_Controls->m_ResampleFibersBox->isChecked())
         fib->Compress(m_Controls->m_FiberErrorBox->value());
 
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(fib);
     QString name("FiberBundle_");
     name += m_TensorImageNodes.at(0)->GetName().c_str();
     name += "_Streamline";
     node->SetName(name.toStdString());
     node->SetVisibility(true);
     GetDataStorage()->Add(node, m_TensorImageNodes.at(0));
 }
 
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStreamlineTrackingView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStreamlineTrackingView.h
index c94119b123..156e1c0932 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStreamlineTrackingView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkStreamlineTrackingView.h
@@ -1,90 +1,90 @@
 /*===================================================================
 
 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 QmitkStreamlineTrackingView_h
 #define QmitkStreamlineTrackingView_h
 
-#include <QmitkFunctionality.h>
+#include <QmitkAbstractView.h>
 
 #include "ui_QmitkStreamlineTrackingViewControls.h"
 
 #include <mitkTensorImage.h>
 #include <mitkDataStorage.h>
 #include <mitkImage.h>
 #include <itkImage.h>
 #include <itkStreamlineTrackingFilter.h>
 
 
 /*!
 \brief View for tensor based deterministic streamline fiber tracking.
-\sa QmitkFunctionality
-\ingroup Functionalities
 */
-class QmitkStreamlineTrackingView : public QmitkFunctionality
+class QmitkStreamlineTrackingView : public QmitkAbstractView
 {
     // 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:
 
     static const std::string VIEW_ID;
 
     typedef itk::Image< unsigned char, 3 > ItkUCharImageType;
     typedef itk::Image< float, 3 > ItkFloatImageType;
 
     QmitkStreamlineTrackingView();
     virtual ~QmitkStreamlineTrackingView();
 
     virtual void CreateQtPartControl(QWidget *parent) override;
 
-    virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget) override;
-    virtual void StdMultiWidgetNotAvailable() override;
+    ///
+    /// Sets the focus to an internal widget.
+    ///
+    virtual void SetFocus() override;
 
 protected slots:
 
     void DoFiberTracking();   ///< start fiber tracking
 
 protected:
 
-    /// \brief called by QmitkFunctionality when DataManager's selection has changed
-    virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes ) override;
+    /// \brief called by QmitkAbstractView when DataManager's selection has changed
+    virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
+
     Ui::QmitkStreamlineTrackingViewControls* m_Controls;
-    QmitkStdMultiWidget* m_MultiWidget;
 
 protected slots:
 
     /** update labels if parameters have changed */
     void OnSeedsPerVoxelChanged(int value);
     void OnMinTractLengthChanged(int value);
     void OnFaThresholdChanged(double value);
     void OnAngularThresholdChanged(int value);
     void OnfChanged(int value);
     void OngChanged(int value);
     void OnStepsizeChanged(int value);
 
 private:
 
     mitk::Image::Pointer          m_MaskImage;        ///< abort tracking if leaving mask
     mitk::Image::Pointer          m_SeedRoi;          ///< binary image defining seed voxels for tracking process
     std::vector< mitk::DataNode::Pointer > m_TensorImageNodes; ///< input images
     std::vector< mitk::TensorImage::Pointer > m_TensorImages; ///< input image datanode
 };
 
 
 
 #endif // _QMITKFIBERTRACKINGVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.cpp
index 9ef3407493..3154134487 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.cpp
@@ -1,498 +1,502 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // Qmitk
 #include "QmitkTbssSkeletonizationView.h"
 
 
 #include <itkSkeletonizationFilter.h>
 #include <itkProjectionFilter.h>
 #include <itkDistanceMapFilter.h>
 #include <itkBinaryThresholdImageFilter.h>
 
 #include <itkImageFileReader.h>
 
 // mitk
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkImagePixelWriteAccessor.h>
 #include <mitkPixelTypeMultiplex.h>
 #include <mitkImage.h>
 
 // Qt
 #include <QInputDialog>
 #include <QMessageBox>
 
 //vtk
 #include <vtkLinearTransform.h>
 #include <vtkMatrix4x4.h>
 
 // Boost
 #include <boost/lexical_cast.hpp>
 
 
 
 const std::string QmitkTbssSkeletonizationView::VIEW_ID = "org.mitk.views.tbssskeletonization";
 
 using namespace berry;
 
 
 QmitkTbssSkeletonizationView::QmitkTbssSkeletonizationView()
-  : QmitkFunctionality()
+  : QmitkAbstractView()
   , m_Controls( 0 )
-  , m_MultiWidget( NULL )
+  , m_Activated(false)
 {
 
 }
 
 QmitkTbssSkeletonizationView::~QmitkTbssSkeletonizationView()
 {
 }
 
-void QmitkTbssSkeletonizationView::OnSelectionChanged(std::vector<mitk::DataNode*> nodes)
+void QmitkTbssSkeletonizationView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
 
 
   //datamanager selection changed
   if (!this->IsActivated())
     return;
 
   bool found3dImage = false;
   bool found4dImage = false;
 
   this->m_Controls->m_TubularName->setText(QString("Tubular Structure Mask: "));
   this->m_Controls->m_TubularName->setEnabled(false);
   this->m_Controls->m_MeanLabel->setText(QString("Mean: "));
   this->m_Controls->m_MeanLabel->setEnabled(false);
   this->m_Controls->m_PatientDataLabel->setText(QString("Patient Data: "));
   this->m_Controls->m_PatientDataLabel->setEnabled(false);
 
 
   // iterate selection
-  for ( int i=0; i<nodes.size(); i++ )
+  for (mitk::DataNode::Pointer node: nodes)
   {
-
-
     // only look at interesting types from valid nodes
-    mitk::BaseData* nodeData = nodes[i]->GetData();
+    mitk::BaseData* nodeData = node->GetData();
     std::string name = "";
-    nodes[i]->GetStringProperty("name", name);
+    node->GetStringProperty("name", name);
 
 
     if(nodeData)
     {
       if(QString("Image").compare(nodeData->GetNameOfClass())==0)
       {
         mitk::Image* img = static_cast<mitk::Image*>(nodeData);
 
         if(img->GetDimension() == 3)
         {
           bool isBinary(false);
-          nodes[i]->GetBoolProperty("binary", isBinary);
+          node->GetBoolProperty("binary", isBinary);
 
 
           if(isBinary)
           {
             QString label("Tubular Structure Mask: ");
             label.append(QString(name.c_str()));
             this->m_Controls->m_TubularName->setText(label);
             this->m_Controls->m_TubularName->setEnabled(true);
           }
           else
           {
             found3dImage = true;
             QString label("Mean: ");
             label.append(QString(name.c_str()));
             this->m_Controls->m_MeanLabel->setText(label);
             this->m_Controls->m_MeanLabel->setEnabled(true);
           }
         }
         else if(img->GetDimension() == 4)
         {
           found4dImage = true;
           QString label("Patient Data: ");
           label.append(QString(name.c_str()));
           this->m_Controls->m_PatientDataLabel->setText(label);
           this->m_Controls->m_PatientDataLabel->setEnabled(true);
         }
       }
     }
 
   }
 
   this->m_Controls->m_Skeletonize->setEnabled(found3dImage);
   this->m_Controls->m_Project->setEnabled(found3dImage && found4dImage);
   this->m_Controls->m_OutputMask->setEnabled(found3dImage && found4dImage);
   this->m_Controls->m_OutputDistanceMap->setEnabled(found3dImage && found4dImage);
 
 }
 
 
 
 void QmitkTbssSkeletonizationView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkTbssSkeletonizationViewControls;
     m_Controls->setupUi( parent );
     this->CreateConnections();
   }
 
 }
 
+void QmitkTbssSkeletonizationView::SetFocus()
+{
+  m_Controls->m_Skeletonize->setFocus();
+}
+
 void QmitkTbssSkeletonizationView::Activated()
 {
-  QmitkFunctionality::Activated();
+  m_Activated = true;
 }
 
 void QmitkTbssSkeletonizationView::Deactivated()
 {
-  QmitkFunctionality::Deactivated();
+  m_Activated = false;
 }
 
-void QmitkTbssSkeletonizationView::CreateConnections()
+bool QmitkTbssSkeletonizationView::IsActivated() const
 {
-  if ( m_Controls )
-  {
-    connect( (QObject*)(m_Controls->m_Skeletonize), SIGNAL(clicked()), this, SLOT(Skeletonize() ));
-    connect( (QObject*)(m_Controls->m_Project), SIGNAL(clicked()), this, SLOT(Project() ));
-  }
+  return m_Activated;
 }
 
-
-
-void QmitkTbssSkeletonizationView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
+void QmitkTbssSkeletonizationView::Visible()
 {
-  m_MultiWidget = &stdMultiWidget;
 }
 
+void QmitkTbssSkeletonizationView::Hidden()
+{
+}
 
-void QmitkTbssSkeletonizationView::StdMultiWidgetNotAvailable()
+void QmitkTbssSkeletonizationView::CreateConnections()
 {
-  m_MultiWidget = NULL;
+  if ( m_Controls )
+  {
+    connect( (QObject*)(m_Controls->m_Skeletonize), SIGNAL(clicked()), this, SLOT(Skeletonize() ));
+    connect( (QObject*)(m_Controls->m_Project), SIGNAL(clicked()), this, SLOT(Project() ));
+  }
 }
 
 
+
 void QmitkTbssSkeletonizationView::Skeletonize()
 {
 
 
 
 
   typedef itk::SkeletonizationFilter<FloatImageType, FloatImageType> SkeletonisationFilterType;
   SkeletonisationFilterType::Pointer skeletonizer = SkeletonisationFilterType::New();
 
 
-  std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
+  QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
 
 
   mitk::Image::Pointer meanImage = mitk::Image::New();
   std::string name = "";
 
-  for ( int i=0; i<nodes.size(); i++ )
+  for (auto node: nodes)
   {
     // process only on valid nodes
-    mitk::BaseData* nodeData = nodes[i]->GetData();
+    mitk::BaseData* nodeData = node->GetData();
 
     if(nodeData)
     {
       if(QString("Image").compare(nodeData->GetNameOfClass())==0)
       {
 
         bool isBinary(false);
-        nodes[i]->GetBoolProperty("binary", isBinary);
+        node->GetBoolProperty("binary", isBinary);
 
         mitk::Image* img = static_cast<mitk::Image*>(nodeData);
         if(img->GetDimension() == 3 && !isBinary)
         {
           meanImage = img;
-          name = nodes[i]->GetName();
+          name = node->GetName();
         }
       }
     }
   }
 
 
   // Calculate skeleton
   FloatImageType::Pointer itkImg = FloatImageType::New();
   mitk::CastToItkImage(meanImage, itkImg);
   skeletonizer->SetInput(itkImg);
   skeletonizer->Update();
 
 
   FloatImageType::Pointer output = skeletonizer->GetOutput();
   mitk::Image::Pointer mitkOutput = mitk::Image::New();
   mitk::CastToMitkImage(output, mitkOutput);
   name += "_skeleton";
   AddToDataStorage(mitkOutput, name);
 
 
 
 }
 
 void QmitkTbssSkeletonizationView::Project()
 {
 
   typedef itk::SkeletonizationFilter<FloatImageType, FloatImageType> SkeletonisationFilterType;
   typedef itk::ProjectionFilter ProjectionFilterType;
   typedef itk::DistanceMapFilter<FloatImageType, FloatImageType> DistanceMapFilterType;
 
   SkeletonisationFilterType::Pointer skeletonizer = SkeletonisationFilterType::New();
 
 
 
-  std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
+  QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
 
 
   mitk::Image::Pointer meanImage = mitk::Image::New();
   mitk::Image::Pointer subjects = mitk::Image::New();
   mitk::Image::Pointer tubular = mitk::Image::New();
 
-  for ( int i=0; i<nodes.size(); i++ )
+  for (auto node: nodes)
   {
     // process only on valid nodes
-    mitk::BaseData* nodeData = nodes[i]->GetData();
+    mitk::BaseData* nodeData = node->GetData();
 
     if(nodeData)
     {
       if(QString("Image").compare(nodeData->GetNameOfClass())==0)
       {
         mitk::Image* img = static_cast<mitk::Image*>(nodeData);
         if(img->GetDimension() == 3)
         {
 
           bool isBinary(false);
-          nodes[i]->GetBoolProperty("binary", isBinary);
+          node->GetBoolProperty("binary", isBinary);
 
 
           if(isBinary)
           {
             tubular = img;
           }
           else
           {
             meanImage = img;
           }
         }
 
         else if(img->GetDimension() == 4)
         {
           subjects = img;
         }
       }
     }
 
   }
 
   Float4DImageType::Pointer allFA;
   mitkPixelTypeMultiplex2(ConvertToItk,subjects->GetChannelDescriptor().GetPixelType(),subjects, allFA);
 
     // Calculate skeleton
   FloatImageType::Pointer itkImg = FloatImageType::New();
   mitk::CastToItkImage(meanImage, itkImg);
   skeletonizer->SetInput(itkImg);
   skeletonizer->Update();
 
 
   FloatImageType::Pointer output = skeletonizer->GetOutput();
   mitk::Image::Pointer mitkOutput = mitk::Image::New();
   mitk::CastToMitkImage(output, mitkOutput);
   AddToDataStorage(mitkOutput, "mean_FA_skeletonised");
 
 
 
   // Retrieve direction image needed later by the projection filter
   DirectionImageType::Pointer directionImg = skeletonizer->GetVectorImage();
 
 
   // Calculate distance image
   DistanceMapFilterType::Pointer distanceMapFilter = DistanceMapFilterType::New();
   distanceMapFilter->SetInput(output);
   distanceMapFilter->Update();
   FloatImageType::Pointer distanceMap = distanceMapFilter->GetOutput();
 
   if(m_Controls->m_OutputDistanceMap->isChecked())
   {
     mitk::Image::Pointer mitkDistance = mitk::Image::New();
     mitk::CastToMitkImage(distanceMap, mitkDistance);
     AddToDataStorage(mitkDistance, "distance map");
   }
 
   // Do projection
 
   // Ask a threshold to create a skeleton mask
   double threshold = -1.0;
   while(threshold == -1.0)
   {
     threshold = QInputDialog::getDouble(m_Controls->m_Skeletonize, tr("Specify the FA threshold"),
                                         tr("Threshold:"), QLineEdit::Normal,
                                         0.2);
 
     if(threshold < 0.0 || threshold > 1.0)
     {
       QMessageBox msgBox;
       msgBox.setText("Please choose a value between 0 and 1");
       msgBox.exec();
       threshold = -1.0;
     }
   }
 
   typedef itk::BinaryThresholdImageFilter<FloatImageType, CharImageType> ThresholdFilterType;
   ThresholdFilterType::Pointer thresholder = ThresholdFilterType::New();
   thresholder->SetInput(output);
   thresholder->SetLowerThreshold(threshold);
   thresholder->SetUpperThreshold(std::numeric_limits<float>::max());
   thresholder->SetOutsideValue(0);
   thresholder->SetInsideValue(1);
   thresholder->Update();
 
 
   CharImageType::Pointer thresholdedImg = thresholder->GetOutput();
 
 
   if(m_Controls->m_OutputMask->isChecked())
   {
     mitk::Image::Pointer mitkThresholded = mitk::Image::New();
     mitk::CastToMitkImage(thresholdedImg, mitkThresholded);
     std::string maskName = "skeleton_mask_at_" + boost::lexical_cast<std::string>(threshold);
     AddToDataStorage(mitkThresholded, maskName);
   }
 
 
 
 
   CharImageType::Pointer itkTubular = CharImageType::New();
   mitk::CastToItkImage(tubular, itkTubular);
 
 
   ProjectionFilterType::Pointer projectionFilter = ProjectionFilterType::New();
   projectionFilter->SetDistanceMap(distanceMap);
   projectionFilter->SetDirections(directionImg);
   projectionFilter->SetAllFA(allFA);
   projectionFilter->SetTube(itkTubular);
   projectionFilter->SetSkeleton(thresholdedImg);
   projectionFilter->Project();
 
   Float4DImageType::Pointer projected = projectionFilter->GetProjections();
 
   mitk::Image::Pointer mitkProjections = mitk::Image::New();
   mitk::CastToMitkImage(projected, mitkProjections);
 
   AddToDataStorage(mitkProjections, "all_FA_projected");
 
 
 
 }
 
 void QmitkTbssSkeletonizationView::AddToDataStorage(mitk::Image* img, std::string name)
 {
   mitk::DataNode::Pointer result = mitk::DataNode::New();
   result->SetProperty( "name", mitk::StringProperty::New(name) );
   result->SetData( img );
 
   // add new image to data storage and set as active to ease further processing
-  GetDefaultDataStorage()->Add( result );
+  GetDataStorage()->Add( result );
 }
 
 
 
 template <class TPixel>
 void QmitkTbssSkeletonizationView::ConvertToItk(mitk::PixelType ptype, mitk::Image* image, Float4DImageType::Pointer output)
 {
   output = Float4DImageType::New();
 
   mitk::BaseGeometry* geo = image->GetGeometry();
   mitk::Vector3D mitkSpacing = geo->GetSpacing();
   mitk::Point3D mitkOrigin = geo->GetOrigin();
 
   Float4DImageType::SpacingType spacing;
   spacing[0] = mitkSpacing[0];
   spacing[1] = mitkSpacing[1];
   spacing[2] = mitkSpacing[2];
   spacing[3] = 1.0; // todo: check if spacing has length 4
 
   Float4DImageType::PointType origin;
   origin[0] = mitkOrigin[0];
   origin[1] = mitkOrigin[1];
   origin[2] = mitkOrigin[2];
   origin[3] = 0;
 
   Float4DImageType::SizeType size;
   size[0] = image->GetDimension(0);
   size[1] = image->GetDimension(1);
   size[2] = image->GetDimension(2);
   size[3] = image->GetDimension(3);
 
   Float4DImageType::DirectionType dir;
   vtkLinearTransform* lin = geo->GetVtkTransform();
   vtkMatrix4x4 *m = lin->GetMatrix();
 
   dir.Fill(0.0);
   for(int x=0; x<3; x++)
   {
     for(int y=0; y<3; y++)
     {
       dir[x][y] = m->GetElement(x,y);
     }
   }
   dir[3][3] = 1;
 
 
 
   output->SetSpacing(spacing);
   output->SetOrigin(origin);
   output->SetRegions(size);
   output->SetDirection(dir);
   output->Allocate();
 
 
   if(image->GetDimension() == 4)
   {
     int timesteps = image->GetDimension(3);
 
     try{
       // REPLACE THIS METHODE()ConvertToItk) WITH mitk::CastToItk
 
       // iterate through the subjects and copy data to output
       for(int t=0; t<timesteps; t++)
       {
         mitk::ImagePixelReadAccessor <TPixel,3> inAcc(image,image->GetVolumeData(t));
 
         for(int x=0; x<image->GetDimension(0); x++)
         {
           for(int y=0; y<image->GetDimension(1); y++)
           {
             for(int z=0; z<image->GetDimension(2); z++)
             {
               itk::Index<3> ix = {x, y, z};
               itk::Index<4> ix4 = {x, y, z, t};
 
               output->SetPixel(ix4, inAcc.GetPixelByIndex(ix));
 
             }
           }
         }
       }
     }
     catch(std::exception & e)
     {
       MITK_INFO << e.what();
     }
 
   }
 
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.h
index 9726be3290..a0b2c88cc6 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.h
@@ -1,100 +1,114 @@
 /*===================================================================
 
 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 QmitkTbssSkeletonizationView_h
 #define QmitkTbssSkeletonizationView_h
 
 
-#include <QmitkFunctionality.h>
+#include <QmitkAbstractView.h>
+#include <mitkILifecycleAwarePart.h>
+
 #include "ui_QmitkTbssSkeletonizationViewControls.h"
 #include "itkImage.h"
 #include "mitkPixelType.h"
 
 namespace mitk {
   class Image;
 }
 
 typedef itk::Image<float, 3> FloatImageType;
 typedef itk::Image<char, 3> CharImageType;
 typedef itk::Image<float, 4> Float4DImageType;
 
 typedef itk::CovariantVector<int,3> VectorType;
 typedef itk::Image<VectorType, 3> DirectionImageType;
 
 
 /*!
   * \brief Implementation of the core functionality of TBSS.
   * This plugin provides the core functionality of TBSS (see Smith et al., 2009. http://dx.doi.org/10.1016/j.neuroimage.2006.02.024)
   * It can skeletonize a mean FA image and calculate the projection of all individual subjects to this skeleton.
 */
 
-class QmitkTbssSkeletonizationView : public QmitkFunctionality
+class QmitkTbssSkeletonizationView : public QmitkAbstractView, public mitk::ILifecycleAwarePart
 {
 
   Q_OBJECT
 
   public:
 
     static const std::string VIEW_ID;
 
     QmitkTbssSkeletonizationView();
     virtual ~QmitkTbssSkeletonizationView();
 
     virtual void CreateQtPartControl(QWidget *parent) override;
 
     //Creation of the connections of main and control widget
     virtual void CreateConnections();
 
-    virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget) override;
-    virtual void StdMultiWidgetNotAvailable() override;
+    ///
+    /// Sets the focus to an internal widget.
+    ///
+    virtual void SetFocus() override;
 
-    /// \brief Called when the functionality is activated
+    /// \brief Called when the view gets activated
     virtual void Activated() override;
 
+    /// \brief Called when the view gets deactivated
     virtual void Deactivated() override;
 
+    bool IsActivated() const;
+
+    /// \brief Called when the view gets visible
+    virtual void Visible() override;
+
+    /// \brief Called when the view gets hidden
+    virtual void Hidden() override;
 
   protected slots:
 
 
     /* \brief Perform skeletonization only */
     void Skeletonize();
 
     // Perform skeletonization and Projection of subject data to the skeleton
     void Project();
 
 
 
   protected:
 
-    //brief called by QmitkFunctionality when DataManager's selection has changed
-    virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes ) override;
+    //brief called by QmitkAbstractView when DataManager's selection has changed
+    virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
     Ui::QmitkTbssSkeletonizationViewControls* m_Controls;
 
-    QmitkStdMultiWidget* m_MultiWidget;
-
     void AddToDataStorage(mitk::Image* img, std::string name);
 
     template <class TPixel>
     void ConvertToItk(mitk::PixelType, mitk::Image* image, Float4DImageType::Pointer);
 
+  private:
+
+    bool m_Activated;
+
 };
 
 
 
 #endif // _QMITKTbssSkeletonizationVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.cpp
index fc890225ad..7f0afd2094 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.cpp
@@ -1,1068 +1,1064 @@
 /*===================================================================
 
 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 "QmitkTensorReconstructionView.h"
 #include "mitkDiffusionImagingConfigure.h"
 
 // qt includes
 #include <QMessageBox>
 #include <QImage>
 #include <QGraphicsScene>
 #include <QGraphicsPixmapItem>
 #include <QGraphicsLinearLayout>
 
 
 // itk includes
 #include "itkTimeProbe.h"
 //#include "itkTensor.h"
 
 // mitk includes
 #include "mitkProgressBar.h"
 #include "mitkStatusBar.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "QmitkDataStorageComboBox.h"
-#include "QmitkStdMultiWidget.h"
 
 #include "mitkTeemDiffusionTensor3DReconstructionImageFilter.h"
 #include "itkDiffusionTensor3DReconstructionImageFilter.h"
 #include "itkTensorImageToDiffusionImageFilter.h"
 #include "itkPointShell.h"
 #include "itkVector.h"
 #include "itkB0ImageExtractionImageFilter.h"
 #include "itkTensorReconstructionWithEigenvalueCorrectionFilter.h"
 
 #include "mitkImageCast.h"
 #include "mitkImageAccessByItk.h"
 #include <itkBinaryThresholdImageFilter.h>
 #include <mitkImageVtkMapper2D.h>
 
 #include "mitkProperties.h"
 #include "mitkDataNodeObject.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkLookupTable.h"
 #include "mitkImageStatisticsHolder.h"
 #include <mitkITKImageImport.h>
 
 #include <itkTensorImageToQBallImageFilter.h>
 #include <itkResidualImageFilter.h>
 
 #include <berryIWorkbenchWindow.h>
 #include <berryISelectionService.h>
 #include <mitkImageVtkMapper2D.h>
 
 const std::string QmitkTensorReconstructionView::VIEW_ID = "org.mitk.views.tensorreconstruction";
 
 typedef float                                       TTensorPixelType;
 typedef itk::DiffusionTensor3D< TTensorPixelType >  TensorPixelType;
 typedef itk::Image< TensorPixelType, 3 >            TensorImageType;
 
 using namespace berry;
 
 QmitkTensorReconstructionView::QmitkTensorReconstructionView()
-    : QmitkFunctionality(),
-      m_Controls(NULL),
-      m_MultiWidget(NULL)
+    : QmitkAbstractView(),
+      m_Controls(NULL)
 {
     m_DiffusionImages = mitk::DataStorage::SetOfObjects::New();
     m_TensorImages = mitk::DataStorage::SetOfObjects::New();
 }
 
 QmitkTensorReconstructionView::~QmitkTensorReconstructionView()
 {
 
 }
 
 void QmitkTensorReconstructionView::CreateQtPartControl(QWidget *parent)
 {
     if (!m_Controls)
     {
         // create GUI widgets
         m_Controls = new Ui::QmitkTensorReconstructionViewControls;
         m_Controls->setupUi(parent);
         this->CreateConnections();
 
         Advanced1CheckboxClicked();
     }
 }
 
-void QmitkTensorReconstructionView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
+void QmitkTensorReconstructionView::SetFocus()
 {
-    m_MultiWidget = &stdMultiWidget;
-}
-
-void QmitkTensorReconstructionView::StdMultiWidgetNotAvailable()
-{
-    m_MultiWidget = NULL;
+  m_Controls->m_Advanced1->setFocus();
 }
 
 void QmitkTensorReconstructionView::CreateConnections()
 {
     if ( m_Controls )
     {
         connect( (QObject*)(m_Controls->m_StartReconstruction), SIGNAL(clicked()), this, SLOT(Reconstruct()) );
         connect( (QObject*)(m_Controls->m_Advanced1), SIGNAL(clicked()), this, SLOT(Advanced1CheckboxClicked()) );
         connect( (QObject*)(m_Controls->m_TensorsToDWIButton), SIGNAL(clicked()), this, SLOT(TensorsToDWI()) );
         connect( (QObject*)(m_Controls->m_TensorsToQbiButton), SIGNAL(clicked()), this, SLOT(TensorsToQbi()) );
         connect( (QObject*)(m_Controls->m_ResidualButton), SIGNAL(clicked()), this, SLOT(ResidualCalculation()) );
         connect( (QObject*)(m_Controls->m_PerSliceView), SIGNAL(pointSelected(int, int)), this, SLOT(ResidualClicked(int, int)) );
         connect( (QObject*)(m_Controls->m_TensorReconstructionThreshold), SIGNAL(valueChanged(int)), this, SLOT(PreviewThreshold(int)) );
     }
 }
 
 void QmitkTensorReconstructionView::ResidualClicked(int slice, int volume)
 {
     // Use image coord to reset crosshair
 
     // Find currently selected diffusion image
 
     // Update Label
 
 
     // to do: This position should be modified in order to skip B0 volumes that are not taken into account
     // when calculating residuals
 
     // Find the diffusion image
     mitk::Image* diffImage;
     mitk::DataNode::Pointer correctNode;
     mitk::BaseGeometry* geometry;
 
     bool isDiffusionImage(false);
 
     if (m_DiffusionImage.IsNotNull())
     {
       isDiffusionImage = mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_DiffusionImage->GetData())) ;
       diffImage = static_cast<mitk::Image*>(m_DiffusionImage->GetData());
 
         geometry = m_DiffusionImage->GetData()->GetGeometry();
 
         // Remember the node whose display index must be updated
         correctNode = mitk::DataNode::New();
         correctNode = m_DiffusionImage;
     }
 
     if( isDiffusionImage )
     {
 
         GradientDirectionContainerType::Pointer dirs = static_cast<mitk::GradientDirectionsProperty*>( diffImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
 
         for(unsigned int i=0; i<dirs->Size() && i<=volume; i++)
         {
             GradientDirectionType grad = dirs->ElementAt(i);
 
             // check if image is b0 weighted
             if(fabs(grad[0]) < 0.001 && fabs(grad[1]) < 0.001 && fabs(grad[2]) < 0.001)
             {
                 volume++;
             }
         }
 
         QString pos = "Volume: ";
         pos.append(QString::number(volume));
         pos.append(", Slice: ");
         pos.append(QString::number(slice));
         m_Controls->m_PositionLabel->setText(pos);
 
         if(correctNode)
         {
             int oldDisplayVal;
             correctNode->GetIntProperty("DisplayChannel", oldDisplayVal);
             QString oldVal = QString::number(oldDisplayVal);
             QString newVal = QString::number(volume);
             correctNode->SetIntProperty("DisplayChannel",volume);
             correctNode->SetSelected(true);
             this->FirePropertyChanged("DisplayChannel", oldVal, newVal);
             correctNode->UpdateOutputInformation();
 
 
-            mitk::Point3D p3 = m_MultiWidget->GetCrossPosition();
+            mitk::Point3D p3 = this->GetRenderWindowPart()->GetSelectedPosition();
             itk::Index<3> ix;
             geometry->WorldToIndex(p3, ix);
             // ix[2] = slice;
 
             mitk::Vector3D vec;
             vec[0] = ix[0];
             vec[1] = ix[1];
             vec[2] = slice;
 
             mitk::Vector3D v3New;
             geometry->IndexToWorld(vec, v3New);
             mitk::Point3D origin = geometry->GetOrigin();
             mitk::Point3D p3New;
             p3New[0] = v3New[0] + origin[0];
             p3New[1] = v3New[1] + origin[1];
             p3New[2] = v3New[2] + origin[2];
 
-            m_MultiWidget->MoveCrossToPosition(p3New);
-            m_MultiWidget->RequestUpdate();
+            this->GetRenderWindowPart()->SetSelectedPosition(p3New);
+            this->GetRenderWindowPart()->RequestUpdate();
         }
     }
 }
 
 void QmitkTensorReconstructionView::Advanced1CheckboxClicked()
 {
     bool check = m_Controls->
             m_Advanced1->isChecked();
 
     m_Controls->frame->setVisible(check);
 }
 
 void QmitkTensorReconstructionView::Activated()
 {
-    QmitkFunctionality::Activated();
-
 }
 
 void QmitkTensorReconstructionView::Deactivated()
 {
 
     // Get all current nodes
 
-    mitk::DataStorage::SetOfObjects::ConstPointer objects =  this->GetDefaultDataStorage()->GetAll();
+    mitk::DataStorage::SetOfObjects::ConstPointer objects =  this->GetDataStorage()->GetAll();
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( objects->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( objects->end() );
     while ( itemiter != itemiterend ) // for all items
     {
         mitk::DataNode::Pointer node = *itemiter;
         if (node.IsNull())
             continue;
 
         // only look at interesting types
         if( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(dynamic_cast<mitk::Image*>(node->GetData())))
         {
-            if (this->GetDefaultDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter))
+            if (this->GetDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter))
             {
-                node = this->GetDefaultDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter);
-                this->GetDefaultDataStorage()->Remove(node);
+                node = this->GetDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter);
+                this->GetDataStorage()->Remove(node);
             }
         }
         itemiter++;
     }
 
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
+}
 
-    QmitkFunctionality::Deactivated();
+void QmitkTensorReconstructionView::Visible()
+{
+}
+
+void QmitkTensorReconstructionView::Hidden()
+{
 }
 
 void QmitkTensorReconstructionView::ResidualCalculation()
 {
     // Extract dwi and dti from current selection
     // In case of multiple selections, take the first one, since taking all combinations is not meaningful
 
     mitk::DataStorage::SetOfObjects::Pointer set =
             mitk::DataStorage::SetOfObjects::New();
 
     mitk::Image::Pointer diffImage
             = mitk::Image::New();
 
     TensorImageType::Pointer tensorImage;
 
     std::string nodename;
 
     if(m_DiffusionImage.IsNotNull())
     {
         diffImage = static_cast<mitk::Image*>(m_DiffusionImage->GetData());
     }
     else
         return;
     if(m_TensorImage.IsNotNull())
     {
         mitk::TensorImage* mitkVol;
         mitkVol = static_cast<mitk::TensorImage*>(m_TensorImage->GetData());
         mitk::CastToItkImage(mitkVol, tensorImage);
         m_TensorImage->GetStringProperty("name", nodename);
     }
     else
         return;
 
     typedef itk::TensorImageToDiffusionImageFilter<
             TTensorPixelType, DiffusionPixelType > FilterType;
 
     GradientDirectionContainerType* gradients
             =  static_cast<mitk::GradientDirectionsProperty*>( diffImage->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer();
 
     // Find the min and the max values from a baseline image
     mitk::ImageStatisticsHolder *stats = diffImage->GetStatistics();
 
     //Initialize filter that calculates the modeled diffusion weighted signals
     FilterType::Pointer filter = FilterType::New();
     filter->SetInput( tensorImage );
     filter->SetBValue( static_cast<mitk::FloatProperty*>(diffImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue());
     filter->SetGradientList(gradients);
     filter->SetMin(stats->GetScalarValueMin());
     filter->SetMax(stats->GetScalarValueMax());
     filter->Update();
 
 
     // TENSORS TO DATATREE
     mitk::Image::Pointer image = mitk::GrabItkImageMemory( filter->GetOutput() );
     image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( gradients ) );
     image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>(diffImage->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
     image->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( static_cast<mitk::MeasurementFrameProperty*>(diffImage->GetProperty(mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str()).GetPointer() )->GetMeasurementFrame() ) );
     mitk::DiffusionPropertyHelper propertyHelper( image );
     propertyHelper.InitializeImage();
 
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData( image );
     mitk::ImageVtkMapper2D::SetDefaultProperties(node);
 
     QString newname;
     newname = newname.append(nodename.c_str());
     newname = newname.append("_Estimated DWI");
     node->SetName(newname.toLatin1());
 
-    GetDefaultDataStorage()->Add(node, m_TensorImage);
+    GetDataStorage()->Add(node, m_TensorImage);
 
     BValueMapType map = static_cast<mitk::BValueMapProperty*>(image->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )->GetBValueMap();;
     std::vector< unsigned int > b0Indices = map[0];
 
 
     typedef itk::ResidualImageFilter<DiffusionPixelType, float> ResidualImageFilterType;
 
     ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
     mitk::CastToItkImage(diffImage, itkVectorImagePointer);
     ITKDiffusionImageType::Pointer itkSecondVectorImagePointer = ITKDiffusionImageType::New();
     mitk::CastToItkImage(image, itkSecondVectorImagePointer);
 
     ResidualImageFilterType::Pointer residualFilter = ResidualImageFilterType::New();
     residualFilter->SetInput( itkVectorImagePointer );
     residualFilter->SetSecondDiffusionImage( itkSecondVectorImagePointer );
     residualFilter->SetGradients(gradients);
     residualFilter->SetB0Index(b0Indices[0]);
     residualFilter->SetB0Threshold(30);
     residualFilter->Update();
 
     itk::Image<float, 3>::Pointer residualImage = itk::Image<float, 3>::New();
     residualImage = residualFilter->GetOutput();
 
     mitk::Image::Pointer mitkResImg = mitk::Image::New();
 
     mitk::CastToMitkImage(residualImage, mitkResImg);
 
     stats = mitkResImg->GetStatistics();
     float min = stats->GetScalarValueMin();
     float max = stats->GetScalarValueMax();
 
     mitk::LookupTableProperty::Pointer lutProp = mitk::LookupTableProperty::New();
     mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
 
 
     vtkSmartPointer<vtkLookupTable> lookupTable =
             vtkSmartPointer<vtkLookupTable>::New();
 
     lookupTable->SetTableRange(min, max);
 
 
     // If you don't want to use the whole color range, you can use
     // SetValueRange, SetHueRange, and SetSaturationRange
     lookupTable->Build();
 
     vtkSmartPointer<vtkLookupTable> reversedlookupTable =
             vtkSmartPointer<vtkLookupTable>::New();
     reversedlookupTable->SetTableRange(min+1, max);
     reversedlookupTable->Build();
 
     for(int i=0; i<256; i++)
     {
         double* rgba = reversedlookupTable->GetTableValue(255-i);
 
         lookupTable->SetTableValue(i, rgba[0], rgba[1], rgba[2], rgba[3]);
     }
 
     lut->SetVtkLookupTable(lookupTable);
     lutProp->SetLookupTable(lut);
 
     // Create lookuptable
 
     mitk::DataNode::Pointer resNode=mitk::DataNode::New();
     resNode->SetData( mitkResImg );
     resNode->SetName("Residuals");
 
     resNode->SetProperty("LookupTable", lutProp);
 
     bool b;
     resNode->GetBoolProperty("use color", b);
     resNode->SetBoolProperty("use color", false);
 
-    GetDefaultDataStorage()->Add(resNode, m_TensorImage);
+    GetDataStorage()->Add(resNode, m_TensorImage);
 
-    m_MultiWidget->RequestUpdate();
+    this->GetRenderWindowPart()->RequestUpdate();
 
 
 
     // Draw Graph
     std::vector<double> means = residualFilter->GetMeans();
     std::vector<double> q1s = residualFilter->GetQ1();
     std::vector<double> q3s = residualFilter->GetQ3();
     std::vector<double> percentagesOfOUtliers = residualFilter->GetPercentagesOfOutliers();
 
     m_Controls->m_ResidualAnalysis->SetMeans(means);
     m_Controls->m_ResidualAnalysis->SetQ1(q1s);
     m_Controls->m_ResidualAnalysis->SetQ3(q3s);
     m_Controls->m_ResidualAnalysis->SetPercentagesOfOutliers(percentagesOfOUtliers);
 
     if(m_Controls->m_PercentagesOfOutliers->isChecked())
     {
         m_Controls->m_ResidualAnalysis->DrawPercentagesOfOutliers();
     }
     else
     {
         m_Controls->m_ResidualAnalysis->DrawMeans();
     }
 
 
 
     // Draw Graph for volumes per slice in the QGraphicsView
     std::vector< std::vector<double> > outliersPerSlice = residualFilter->GetOutliersPerSlice();
     int xSize = outliersPerSlice.size();
     if(xSize == 0)
     {
         return;
     }
     int ySize = outliersPerSlice[0].size();
 
 
     // Find maximum in outliersPerSlice
     double maxOutlier= 0.0;
     for(int i=0; i<xSize; i++)
     {
         for(int j=0; j<ySize; j++)
         {
             if(outliersPerSlice[i][j]>maxOutlier)
             {
                 maxOutlier = outliersPerSlice[i][j];
             }
         }
     }
 
 
     // Create some QImage
     QImage qImage(xSize, ySize, QImage::Format_RGB32);
     QImage legend(1, 256, QImage::Format_RGB32);
     QRgb value;
 
     vtkSmartPointer<vtkLookupTable> lookup =
             vtkSmartPointer<vtkLookupTable>::New();
 
     lookup->SetTableRange(0.0, maxOutlier);
     lookup->Build();
 
     reversedlookupTable->SetTableRange(0, maxOutlier);
     reversedlookupTable->Build();
 
     for(int i=0; i<256; i++)
     {
         double* rgba = reversedlookupTable->GetTableValue(255-i);
         lookup->SetTableValue(i, rgba[0], rgba[1], rgba[2], rgba[3]);
     }
 
 
     // Fill qImage
     for(int i=0; i<xSize; i++)
     {
         for(int j=0; j<ySize; j++)
         {
             double out = outliersPerSlice[i][j];
 
             unsigned char *_rgba = lookup->MapValue(out);
             int r, g, b;
             r = _rgba[0];
             g = _rgba[1];
             b = _rgba[2];
 
             value = qRgb(r, g, b);
 
             qImage.setPixel(i,j,value);
 
         }
     }
 
     for(int i=0; i<256; i++)
     {
         double* rgba = lookup->GetTableValue(i);
         int r, g, b;
         r = rgba[0]*255;
         g = rgba[1]*255;
         b = rgba[2]*255;
         value = qRgb(r, g, b);
         legend.setPixel(0,255-i,value);
     }
 
     QString upper = QString::number(maxOutlier, 'g', 3);
     upper.append(" %");
     QString lower = QString::number(0.0);
     lower.append(" %");
     m_Controls->m_UpperLabel->setText(upper);
     m_Controls->m_LowerLabel->setText(lower);
 
     QPixmap pixmap(QPixmap::fromImage(qImage));
     QGraphicsPixmapItem *item = new QGraphicsPixmapItem(pixmap);
     item->setTransform(QTransform::fromScale(10.0, 3.0), true);
 
     QPixmap pixmap2(QPixmap::fromImage(legend));
     QGraphicsPixmapItem *item2 = new QGraphicsPixmapItem(pixmap2);
     item2->setTransform(QTransform::fromScale(20.0, 1.0), true);
 
     m_Controls->m_PerSliceView->SetResidualPixmapItem(item);
 
     QGraphicsScene* scene = new QGraphicsScene;
     QGraphicsScene* scene2 = new QGraphicsScene;
 
     scene->addItem(item);
     scene2->addItem(item2);
 
     m_Controls->m_PerSliceView->setScene(scene);
     m_Controls->m_LegendView->setScene(scene2);
     m_Controls->m_PerSliceView->show();
     m_Controls->m_PerSliceView->repaint();
 
     m_Controls->m_LegendView->setHorizontalScrollBarPolicy ( Qt::ScrollBarAlwaysOff );
     m_Controls->m_LegendView->setVerticalScrollBarPolicy ( Qt::ScrollBarAlwaysOff );
     m_Controls->m_LegendView->show();
     m_Controls->m_LegendView->repaint();
 }
 
 void QmitkTensorReconstructionView::Reconstruct()
 {
     int method = m_Controls->m_ReconctructionMethodBox->currentIndex();
 
     switch (method)
     {
     case 0:
         ItkTensorReconstruction(m_DiffusionImages);
         break;
     case 1:
         TensorReconstructionWithCorr(m_DiffusionImages);
         break;
     default:
         ItkTensorReconstruction(m_DiffusionImages);
     }
 }
 
 void QmitkTensorReconstructionView::TensorReconstructionWithCorr
 (mitk::DataStorage::SetOfObjects::Pointer inImages)
 {
     try
     {
         int nrFiles = inImages->size();
         if (!nrFiles) return;
 
         QString status;
         mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles);
 
         mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
         mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
 
         while ( itemiter != itemiterend ) // for all items
         {
 
             mitk::Image* vols = static_cast<mitk::Image*>((*itemiter)->GetData());
 
             std::string nodename;
             (*itemiter)->GetStringProperty("name", nodename);
 
             // TENSOR RECONSTRUCTION
             MITK_INFO << "Tensor reconstruction with correction for negative eigenvalues";
             mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Tensor reconstruction for %s", nodename.c_str()).toLatin1());
 
             typedef itk::TensorReconstructionWithEigenvalueCorrectionFilter< DiffusionPixelType, TTensorPixelType > ReconstructionFilter;
 
             float b0Threshold = m_Controls->m_TensorReconstructionThreshold->value();
 
             GradientDirectionContainerType::Pointer gradientContainerCopy = GradientDirectionContainerType::New();
             for(GradientDirectionContainerType::ConstIterator it = static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer()->Begin();
               it != static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer()->End(); it++)
             {
               gradientContainerCopy->push_back(it.Value());
             }
 
             ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
             mitk::CastToItkImage(vols, itkVectorImagePointer);
 
             ReconstructionFilter::Pointer reconFilter = ReconstructionFilter::New();
             reconFilter->SetGradientImage( gradientContainerCopy, itkVectorImagePointer);
             reconFilter->SetBValue( static_cast<mitk::FloatProperty*>(vols->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
             reconFilter->SetB0Threshold(b0Threshold);
             reconFilter->Update();
 
             typedef itk::Image<itk::DiffusionTensor3D<TTensorPixelType>, 3> TensorImageType;
             TensorImageType::Pointer outputTensorImg = reconFilter->GetOutput();
 
             typedef itk::ImageRegionIterator<TensorImageType> TensorImageIteratorType;
             TensorImageIteratorType tensorIt(outputTensorImg, outputTensorImg->GetRequestedRegion());
             tensorIt.GoToBegin();
 
             int negatives = 0;
             while(!tensorIt.IsAtEnd())
             {
                 typedef itk::DiffusionTensor3D<TTensorPixelType> TensorType;
                 TensorType tensor = tensorIt.Get();
 
                 TensorType::EigenValuesArrayType ev;
                 tensor.ComputeEigenValues(ev);
 
                 for(unsigned int i=0; i<ev.Size(); i++)
                 {
                     if(ev[i] < 0.0)
                     {
                         tensor.Fill(0.0);
                         tensorIt.Set(tensor);
                         negatives++;
                         break;
                     }
                 }
                 ++tensorIt;
             }
             MITK_INFO << negatives << " tensors with negative eigenvalues" << std::endl;
 
             mitk::TensorImage::Pointer image = mitk::TensorImage::New();
             image->InitializeByItk( outputTensorImg.GetPointer() );
             image->SetVolume( outputTensorImg->GetBufferPointer() );
             mitk::DataNode::Pointer node=mitk::DataNode::New();
             node->SetData( image );
             SetDefaultNodeProperties(node, nodename+"_EigenvalueCorrected_DT");
-            GetDefaultDataStorage()->Add(node, *itemiter);
+            GetDataStorage()->Add(node, *itemiter);
 
             mitk::ProgressBar::GetInstance()->Progress();
             ++itemiter;
         }
 
         mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toLatin1());
-        m_MultiWidget->RequestUpdate();
+        this->GetRenderWindowPart()->RequestUpdate();
     }
     catch (itk::ExceptionObject &ex)
     {
         MITK_INFO << ex ;
         QMessageBox::information(0, "Reconstruction not possible:", ex.GetDescription());
     }
 }
 
 void QmitkTensorReconstructionView::ItkTensorReconstruction(mitk::DataStorage::SetOfObjects::Pointer inImages)
 {
     try
     {
         itk::TimeProbe clock;
 
         int nrFiles = inImages->size();
         if (!nrFiles) return;
 
         QString status;
         mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles);
 
         mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
         mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
 
         while ( itemiter != itemiterend ) // for all items
         {
 
             mitk::Image* vols =
                     static_cast<mitk::Image*>(
                         (*itemiter)->GetData());
 
             std::string nodename;
             (*itemiter)->GetStringProperty("name", nodename);
 
             // TENSOR RECONSTRUCTION
             clock.Start();
             MITK_DEBUG << "Tensor reconstruction ";
             mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Tensor reconstruction for %s", nodename.c_str()).toLatin1());
             typedef itk::DiffusionTensor3DReconstructionImageFilter<
                     DiffusionPixelType, DiffusionPixelType, TTensorPixelType > TensorReconstructionImageFilterType;
             TensorReconstructionImageFilterType::Pointer tensorReconstructionFilter =
                     TensorReconstructionImageFilterType::New();
 
             GradientDirectionContainerType::Pointer gradientContainerCopy = GradientDirectionContainerType::New();
             for(GradientDirectionContainerType::ConstIterator it = static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer()->Begin();
               it != static_cast<mitk::GradientDirectionsProperty*>( vols->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer()->End(); it++)
             {
               gradientContainerCopy->push_back(it.Value());
             }
 
             ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
             mitk::CastToItkImage(vols, itkVectorImagePointer);
 
             tensorReconstructionFilter->SetGradientImage( gradientContainerCopy, itkVectorImagePointer );
             tensorReconstructionFilter->SetBValue(  static_cast<mitk::FloatProperty*>(vols->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
             tensorReconstructionFilter->SetThreshold( m_Controls->m_TensorReconstructionThreshold->value() );
             tensorReconstructionFilter->Update();
             clock.Stop();
             MITK_DEBUG << "took " << clock.GetMean() << "s.";
 
             // TENSORS TO DATATREE
             mitk::TensorImage::Pointer image = mitk::TensorImage::New();
 
             typedef itk::Image<itk::DiffusionTensor3D<TTensorPixelType>, 3> TensorImageType;
             TensorImageType::Pointer tensorImage;
             tensorImage = tensorReconstructionFilter->GetOutput();
 
             // Check the tensor for negative eigenvalues
             if(m_Controls->m_CheckNegativeEigenvalues->isChecked())
             {
                 typedef itk::ImageRegionIterator<TensorImageType> TensorImageIteratorType;
                 TensorImageIteratorType tensorIt(tensorImage, tensorImage->GetRequestedRegion());
                 tensorIt.GoToBegin();
 
                 while(!tensorIt.IsAtEnd())
                 {
 
                     typedef itk::DiffusionTensor3D<TTensorPixelType> TensorType;
                     //typedef itk::Tensor<TTensorPixelType, 3> TensorType2;
 
                     TensorType tensor = tensorIt.Get();
 
                     TensorType::EigenValuesArrayType ev;
                     tensor.ComputeEigenValues(ev);
                     for(unsigned int i=0; i<ev.Size(); i++)
                     {
                         if(ev[i] < 0.0)
                         {
                             tensor.Fill(0.0);
                             tensorIt.Set(tensor);
                             break;
                         }
                     }
                     ++tensorIt;
                 }
             }
 
             tensorImage->SetDirection( itkVectorImagePointer->GetDirection() );
             image->InitializeByItk( tensorImage.GetPointer() );
             image->SetVolume( tensorReconstructionFilter->GetOutput()->GetBufferPointer() );
             mitk::DataNode::Pointer node=mitk::DataNode::New();
             node->SetData( image );
             SetDefaultNodeProperties(node, nodename+"_LinearLeastSquares_DT");
-            GetDefaultDataStorage()->Add(node, *itemiter);
+            GetDataStorage()->Add(node, *itemiter);
             mitk::ProgressBar::GetInstance()->Progress();
             ++itemiter;
         }
 
         mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toLatin1());
-        m_MultiWidget->RequestUpdate();
+        this->GetRenderWindowPart()->RequestUpdate();
     }
     catch (itk::ExceptionObject &ex)
     {
         MITK_INFO << ex ;
         QMessageBox::information(0, "Reconstruction not possible:", ex.GetDescription());
         return;
     }
 }
 
 void QmitkTensorReconstructionView::SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name)
 {
     node->SetProperty( "ShowMaxNumber", mitk::IntProperty::New( 500 ) );
     node->SetProperty( "Scaling", mitk::FloatProperty::New( 1.0 ) );
     node->SetProperty( "Normalization", mitk::OdfNormalizationMethodProperty::New());
     node->SetProperty( "ScaleBy", mitk::OdfScaleByProperty::New());
     node->SetProperty( "IndexParam1", mitk::FloatProperty::New(2));
     node->SetProperty( "IndexParam2", mitk::FloatProperty::New(1));
     node->SetProperty( "visible", mitk::BoolProperty::New( true ) );
     node->SetProperty( "VisibleOdfs", mitk::BoolProperty::New( false ) );
     node->SetProperty ("layer", mitk::IntProperty::New(100));
     node->SetProperty( "DoRefresh", mitk::BoolProperty::New( true ) );
 
     node->SetProperty( "name", mitk::StringProperty::New(name) );
 }
 
 void QmitkTensorReconstructionView::TensorsToDWI()
 {
     DoTensorsToDWI(m_TensorImages);
 }
 
 void QmitkTensorReconstructionView::TensorsToQbi()
 {
     for (unsigned int i=0; i<m_TensorImages->size(); i++)
     {
         mitk::DataNode::Pointer tensorImageNode = m_TensorImages->at(i);
         MITK_INFO << "starting Q-Ball estimation";
 
         typedef float                                       TTensorPixelType;
         typedef itk::DiffusionTensor3D< TTensorPixelType >  TensorPixelType;
         typedef itk::Image< TensorPixelType, 3 >            TensorImageType;
 
         TensorImageType::Pointer itkvol = TensorImageType::New();
         mitk::CastToItkImage(dynamic_cast<mitk::TensorImage*>(tensorImageNode->GetData()), itkvol);
 
         typedef itk::TensorImageToQBallImageFilter< TTensorPixelType, TTensorPixelType > FilterType;
         FilterType::Pointer filter = FilterType::New();
         filter->SetInput( itkvol );
         filter->Update();
 
         typedef itk::Vector<TTensorPixelType,QBALL_ODFSIZE>  OutputPixelType;
         typedef itk::Image<OutputPixelType,3>                OutputImageType;
 
         mitk::QBallImage::Pointer image = mitk::QBallImage::New();
         OutputImageType::Pointer outimg = filter->GetOutput();
         image->InitializeByItk( outimg.GetPointer() );
         image->SetVolume( outimg->GetBufferPointer() );
         mitk::DataNode::Pointer node = mitk::DataNode::New();
         node->SetData( image );
         node->SetName(tensorImageNode->GetName()+"_Qball");
-        GetDefaultDataStorage()->Add(node, tensorImageNode);
+        GetDataStorage()->Add(node, tensorImageNode);
     }
 }
 
-void QmitkTensorReconstructionView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
+void QmitkTensorReconstructionView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
     m_DiffusionImages = mitk::DataStorage::SetOfObjects::New();
     m_TensorImages = mitk::DataStorage::SetOfObjects::New();
     bool foundDwiVolume = false;
     bool foundTensorVolume = false;
     m_Controls->m_DiffusionImageLabel->setText("<font color='red'>mandatory</font>");
     m_DiffusionImage = NULL;
     m_TensorImage = NULL;
 
     m_Controls->m_InputData->setTitle("Please Select Input Data");
 
     // iterate selection
-    for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
+    for (mitk::DataNode::Pointer node: nodes)
     {
-        mitk::DataNode::Pointer node = *it;
         if (node.IsNull())
             continue;
 
         // only look at interesting types
         bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) );
         if ( isDiffusionImage )
         {
           foundDwiVolume = true;
           m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
           m_DiffusionImages->push_back(node);
           m_DiffusionImage = node;
         }
         else if(dynamic_cast<mitk::TensorImage*>(node->GetData()))
         {
             foundTensorVolume = true;
             m_Controls->m_DiffusionImageLabel->setText(node->GetName().c_str());
             m_TensorImages->push_back(node);
             m_TensorImage = node;
         }
     }
 
     m_Controls->m_StartReconstruction->setEnabled(foundDwiVolume);
 
     m_Controls->m_TensorsToDWIButton->setEnabled(foundTensorVolume);
     m_Controls->m_TensorsToQbiButton->setEnabled(foundTensorVolume);
 
     if (foundDwiVolume || foundTensorVolume)
         m_Controls->m_InputData->setTitle("Input Data");
 
     m_Controls->m_ResidualButton->setEnabled(foundDwiVolume && foundTensorVolume);
     m_Controls->m_PercentagesOfOutliers->setEnabled(foundDwiVolume && foundTensorVolume);
     m_Controls->m_PerSliceView->setEnabled(foundDwiVolume && foundTensorVolume);
 }
 
 template<int ndirs>
 itk::VectorContainer<unsigned int, vnl_vector_fixed<double, 3> >::Pointer
 QmitkTensorReconstructionView::MakeGradientList()
 {
     itk::VectorContainer<unsigned int, vnl_vector_fixed<double,3> >::Pointer retval =
         itk::VectorContainer<unsigned int, vnl_vector_fixed<double,3> >::New();
     vnl_matrix_fixed<double, 3, ndirs>* U =
             itk::PointShell<ndirs, vnl_matrix_fixed<double, 3, ndirs> >::DistributePointShell();
 
     for(int i=0; i<ndirs;i++)
     {
         vnl_vector_fixed<double,3> v;
         v[0] = U->get(0,i); v[1] = U->get(1,i); v[2] = U->get(2,i);
         retval->push_back(v);
     }
     // Add 0 vector for B0
     vnl_vector_fixed<double,3> v;
     v.fill(0.0);
     retval->push_back(v);
 
     return retval;
 }
 
 void QmitkTensorReconstructionView::DoTensorsToDWI(mitk::DataStorage::SetOfObjects::Pointer inImages)
 {
     try
     {
         itk::TimeProbe clock;
 
         int nrFiles = inImages->size();
         if (!nrFiles) return;
 
         QString status;
         mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles);
 
         mitk::DataStorage::SetOfObjects::const_iterator itemiter( inImages->begin() );
         mitk::DataStorage::SetOfObjects::const_iterator itemiterend( inImages->end() );
 
         while ( itemiter != itemiterend ) // for all items
         {
 
             std::string nodename;
             (*itemiter)->GetStringProperty("name", nodename);
 
             mitk::TensorImage* vol =
                     static_cast<mitk::TensorImage*>((*itemiter)->GetData());
 
             typedef float                                       TTensorPixelType;
             typedef itk::DiffusionTensor3D< TTensorPixelType >  TensorPixelType;
             typedef itk::Image< TensorPixelType, 3 >            TensorImageType;
 
 
             TensorImageType::Pointer itkvol = TensorImageType::New();
             mitk::CastToItkImage(vol, itkvol);
 
             typedef itk::TensorImageToDiffusionImageFilter<
                     TTensorPixelType, DiffusionPixelType > FilterType;
 
             FilterType::GradientListPointerType gradientList = FilterType::GradientListType::New();
 
             switch(m_Controls->m_TensorsToDWINumDirsSelect->currentIndex())
             {
             case 0:
                 gradientList = MakeGradientList<12>();
                 break;
             case 1:
                 gradientList = MakeGradientList<42>();
                 break;
             case 2:
                 gradientList = MakeGradientList<92>();
                 break;
             case 3:
                 gradientList = MakeGradientList<162>();
                 break;
             case 4:
                 gradientList = MakeGradientList<252>();
                 break;
             case 5:
                 gradientList = MakeGradientList<362>();
                 break;
             case 6:
                 gradientList = MakeGradientList<492>();
                 break;
             case 7:
                 gradientList = MakeGradientList<642>();
                 break;
             case 8:
                 gradientList = MakeGradientList<812>();
                 break;
             case 9:
                 gradientList = MakeGradientList<1002>();
                 break;
             default:
                 gradientList = MakeGradientList<92>();
 
             }
 
             double bVal = m_Controls->m_TensorsToDWIBValueEdit->text().toDouble();
 
             // DWI ESTIMATION
             clock.Start();
             MBI_INFO << "DWI Estimation ";
             mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
                                                             "DWI Estimation for %s", nodename.c_str()).toLatin1());
             FilterType::Pointer filter = FilterType::New();
             filter->SetInput( itkvol );
             filter->SetBValue(bVal);
             filter->SetGradientList(gradientList);
             //filter->SetNumberOfThreads(1);
             filter->Update();
             clock.Stop();
             MBI_DEBUG << "took " << clock.GetMean() << "s.";
 
             // TENSORS TO DATATREE
             mitk::Image::Pointer image = mitk::GrabItkImageMemory( filter->GetOutput() );
 
             image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( gradientList ) );
             image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( bVal ) );
             image->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New() );
             mitk::DiffusionPropertyHelper propertyHelper( image );
             propertyHelper.InitializeImage();
 
             mitk::DataNode::Pointer node=mitk::DataNode::New();
             node->SetData( image );
             mitk::ImageVtkMapper2D::SetDefaultProperties(node);
             node->SetName(nodename+"_DWI");
-            GetDefaultDataStorage()->Add(node, *itemiter);
+            GetDataStorage()->Add(node, *itemiter);
 
             mitk::ProgressBar::GetInstance()->Progress();
             ++itemiter;
         }
 
 
         mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles).toLatin1());
-        m_MultiWidget->RequestUpdate();
+        this->GetRenderWindowPart()->RequestUpdate();
 
     }
     catch (itk::ExceptionObject &ex)
     {
         MITK_INFO << ex ;
         QMessageBox::information(0, "DWI estimation failed:", ex.GetDescription());
         return ;
     }
 }
 
 
 void QmitkTensorReconstructionView::PreviewThreshold(int threshold)
 {
     mitk::DataStorage::SetOfObjects::const_iterator itemiter( m_DiffusionImages->begin() );
     mitk::DataStorage::SetOfObjects::const_iterator itemiterend( m_DiffusionImages->end() );
     while ( itemiter != itemiterend ) // for all items
     {
         mitk::Image* vols =
                 static_cast<mitk::Image*>(
              (*itemiter)->GetData());
 
         ITKDiffusionImageType::Pointer itkVectorImagePointer = ITKDiffusionImageType::New();
         mitk::CastToItkImage(vols, itkVectorImagePointer);
 
         // Extract b0 image
         typedef itk::B0ImageExtractionImageFilter<short, short> FilterType;
         FilterType::Pointer filterB0 = FilterType::New();
         filterB0->SetInput(itkVectorImagePointer);
         filterB0->SetDirections(mitk::DiffusionPropertyHelper::GetGradientContainer(vols));
         filterB0->Update();
 
         mitk::Image::Pointer mitkImage = mitk::Image::New();
 
         typedef itk::Image<short, 3> ImageType;
         typedef itk::Image<short, 3> SegmentationType;
         typedef itk::BinaryThresholdImageFilter<ImageType, SegmentationType> ThresholdFilterType;
         // apply threshold
         ThresholdFilterType::Pointer filterThreshold = ThresholdFilterType::New();
         filterThreshold->SetInput(filterB0->GetOutput());
         filterThreshold->SetLowerThreshold(threshold);
         filterThreshold->SetInsideValue(0);
         filterThreshold->SetOutsideValue(1); // mark cut off values red
         filterThreshold->Update();
 
         mitkImage->InitializeByItk( filterThreshold->GetOutput() );
         mitkImage->SetVolume( filterThreshold->GetOutput()->GetBufferPointer() );
         mitk::DataNode::Pointer node;
-        if (this->GetDefaultDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter))
+        if (this->GetDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter))
         {
-            node = this->GetDefaultDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter);
+            node = this->GetDataStorage()->GetNamedDerivedNode("ThresholdOverlay", *itemiter);
         }
         else
         {
             // create a new node, to show thresholded values
             node = mitk::DataNode::New();
-            GetDefaultDataStorage()->Add( node, *itemiter );
+            GetDataStorage()->Add( node, *itemiter );
             node->SetProperty( "name", mitk::StringProperty::New("ThresholdOverlay"));
             node->SetBoolProperty("helper object", true);
         }
         node->SetData( mitkImage );
         itemiter++;
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.h
index fbd243ad27..eb83870ab5 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTensorReconstructionView.h
@@ -1,124 +1,130 @@
 /*===================================================================
 
 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 _QMITKTENSORRECONSTRUCTIONVIEW_H_INCLUDED
 #define _QMITKTENSORRECONSTRUCTIONVIEW_H_INCLUDED
 
-#include <QmitkFunctionality.h>
+#include <QmitkAbstractView.h>
+#include <mitkILifecycleAwarePart.h>
 
 #include <string>
 
 #include "ui_QmitkTensorReconstructionViewControls.h"
 
 #include <mitkTensorImage.h>
 #include <mitkImage.h>
 #include <mitkDiffusionPropertyHelper.h>
 #include <itkVectorImage.h>
 
 typedef short DiffusionPixelType;
 
 struct TrSelListener;
 
 /*!
  * \ingroup org_mitk_gui_qt_tensorreconstruction_internal
  *
  * \brief QmitkTensorReconstructionView
  *
  * Document your class here.
- *
- * \sa QmitkFunctionality
  */
-class QmitkTensorReconstructionView : public QmitkFunctionality
+class QmitkTensorReconstructionView : public QmitkAbstractView, public mitk::ILifecycleAwarePart
 {
 
   friend struct TrSelListener;
 
   // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
   public:
 
     typedef mitk::DiffusionPropertyHelper::GradientDirectionType            GradientDirectionType;
     typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType  GradientDirectionContainerType;
     typedef mitk::DiffusionPropertyHelper::BValueMapType                    BValueMapType;
     typedef itk::VectorImage< DiffusionPixelType, 3 >                       ITKDiffusionImageType;
 
   static const std::string VIEW_ID;
 
   QmitkTensorReconstructionView();
   virtual ~QmitkTensorReconstructionView();
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
   /// \brief Creation of the connections of main and control widget
   virtual void CreateConnections();
 
-  /// \brief Called when the functionality is activated
+  ///
+  /// Sets the focus to an internal widget.
+  ///
+  virtual void SetFocus() override;
+
+  /// \brief Called when the view gets activated
   virtual void Activated() override;
 
+  /// \brief Called when the view gets deactivated
   virtual void Deactivated() override;
 
-  virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget) override;
-  virtual void StdMultiWidgetNotAvailable() override;
+  /// \brief Called when the view becomes visible
+  virtual void Visible() override;
+
+  /// \brief Called when the view becomes hidden
+  virtual void Hidden() override;
 
   static const int nrconvkernels;
 
 protected slots:
 
   void TensorsToQbi();
   void TensorsToDWI();
   void DoTensorsToDWI(mitk::DataStorage::SetOfObjects::Pointer inImages);
   void Advanced1CheckboxClicked();
   void Reconstruct();
   void ResidualCalculation();
   void ResidualClicked(int slice, int volume);
   /**
    * @brief PreviewThreshold Generates a preview of the values that are cut off by the thresholds
    * @param threshold
    */
   void PreviewThreshold(int threshold);
 
 protected:
 
   void ItkTensorReconstruction(mitk::DataStorage::SetOfObjects::Pointer inImages);
   void TeemTensorReconstruction(mitk::DataStorage::SetOfObjects::Pointer inImages);
   void TensorReconstructionWithCorr(mitk::DataStorage::SetOfObjects::Pointer inImages);
 
-  void OnSelectionChanged( std::vector<mitk::DataNode*> nodes ) override;
+  virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
   Ui::QmitkTensorReconstructionViewControls* m_Controls;
 
-  QmitkStdMultiWidget* m_MultiWidget;
-
   template<int ndirs> itk::VectorContainer<unsigned int, vnl_vector_fixed<double,3> >::Pointer MakeGradientList();
 
   template<int L>
   void TemplatedAnalyticalTensorReconstruction(mitk::Image* vols,
     float lambda, std::string nodename, std::vector<mitk::DataNode::Pointer>* nodes, int normalization);
 
   void SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name);
 
   mitk::DataNode::Pointer m_DiffusionImage;
   mitk::DataNode::Pointer m_TensorImage;
   mitk::DataStorage::SetOfObjects::Pointer m_DiffusionImages;
   mitk::DataStorage::SetOfObjects::Pointer m_TensorImages;
 };
 
 
 
 
 #endif // _QMITKTENSORRECONSTRUCTIONVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.cpp
index 2b74d81443..3e6961b76b 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.cpp
@@ -1,1132 +1,1141 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // Qmitk
 #include "QmitkTractbasedSpatialStatisticsView.h"
-#include "QmitkStdMultiWidget.h"
 
 #include "mitkDataNodeObject.h"
 #include <itkCastImageFilter.h>
 
 // Qt
 #include <QMessageBox>
 #include <QInputDialog>
 #include <QClipboard>
 
 #include <qwt_plot_picker.h>
 
 #include <mitkTractAnalyzer.h>
 #include <mitkTbssImporter.h>
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarFigureInteractor.h>
 
 
 #include "vtkPoints.h"
 #include <vtkCellArray.h>
 #include <vtkPolyLine.h>
 
 
 const std::string QmitkTractbasedSpatialStatisticsView::VIEW_ID = "org.mitk.views.tractbasedspatialstatistics";
 
 using namespace berry;
 
 
 QmitkTractbasedSpatialStatisticsView::QmitkTractbasedSpatialStatisticsView()
-: QmitkFunctionality()
+: QmitkAbstractView()
 , m_Controls( 0 )
-, m_MultiWidget( NULL )
+, m_Activated(false)
 {
 
 }
 
 QmitkTractbasedSpatialStatisticsView::~QmitkTractbasedSpatialStatisticsView()
 {
 }
 
 
 void QmitkTractbasedSpatialStatisticsView::PerformChange()
 {
   m_Controls->m_RoiPlotWidget->ModifyPlot(m_Controls->m_Segments->value(), m_Controls->m_Average->isChecked());
 }
 
-void QmitkTractbasedSpatialStatisticsView::OnSelectionChanged(std::vector<mitk::DataNode*> nodes)
+void QmitkTractbasedSpatialStatisticsView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
   //datamanager selection changed
   if (!this->IsActivated())
     return;
 
 
   // Check which datatypes are selected in the datamanager and enable/disable widgets accordingly
 
   bool foundTbssRoi = false;
   bool foundTbss = false;
   bool found3dImage = false;
   bool found4dImage = false;
   bool foundFiberBundle = false;
   bool foundStartRoi = false;
   bool foundEndRoi = false;
 
   mitk::TbssRoiImage* roiImage;
   mitk::TbssImage* image;
   mitk::Image* img;
   mitk::FiberBundle* fib;
   mitk::DataNode* start;
   mitk::DataNode* end;
 
   m_CurrentStartRoi = NULL;
   m_CurrentEndRoi = NULL;
 
 
 
-  for ( int i=0; i<nodes.size(); i++ )
+  for (mitk::DataNode::Pointer node: nodes)
   {
-
     // only look at interesting types
     // check for valid data
-    mitk::BaseData* nodeData = nodes[i]->GetData();
+    mitk::BaseData* nodeData = node->GetData();
     if( nodeData )
     {
       if(QString("TbssRoiImage").compare(nodeData->GetNameOfClass())==0)
       {
         foundTbssRoi = true;
         roiImage = static_cast<mitk::TbssRoiImage*>(nodeData);
       }
       else if (QString("TbssImage").compare(nodeData->GetNameOfClass())==0)
       {
         foundTbss = true;
         image = static_cast<mitk::TbssImage*>(nodeData);
       }
       else if(QString("Image").compare(nodeData->GetNameOfClass())==0)
       {
         img = static_cast<mitk::Image*>(nodeData);
         if(img->GetDimension() == 3)
         {
           found3dImage = true;
         }
         else if(img->GetDimension() == 4)
         {
           found4dImage = true;
         }
       }
 
       else if (QString("FiberBundle").compare(nodeData->GetNameOfClass())==0)
       {
         foundFiberBundle = true;
         fib = static_cast<mitk::FiberBundle*>(nodeData);
-        this->m_CurrentFiberNode = nodes[i];
+        this->m_CurrentFiberNode = node;
       }
 
 
       if(QString("PlanarCircle").compare(nodeData->GetNameOfClass())==0)
       {
         if(!foundStartRoi)
         {
-          start = nodes[i];
-          this->m_CurrentStartRoi = nodes[i];
+          start = node;
+          this->m_CurrentStartRoi = node;
           foundStartRoi =  true;
         }
         else
         {
-          end = nodes[i];
-          this->m_CurrentEndRoi = nodes[i];
+          end = node;
+          this->m_CurrentEndRoi = node;
           foundEndRoi = true;
         }
       }
     }
   }
 
 
   this->m_Controls->m_CreateRoi->setEnabled(found3dImage);
   this->m_Controls->m_ImportFsl->setEnabled(found4dImage);
 
 
 
   if(foundTbss && foundTbssRoi)
   {
     this->Plot(image, roiImage);
   }
 
   else if(found3dImage && foundFiberBundle && foundStartRoi && foundEndRoi)
   {
     this->PlotFiberBundle(fib, img, start, end);
   }
 
   else if(found3dImage && foundFiberBundle)
   {
     this->PlotFiberBundle(fib, img);
   }
 
   else if(foundTbss && foundStartRoi && foundEndRoi && foundFiberBundle)
   {
     this->PlotFiber4D(image, fib, start, end);
   }
 
   if(found3dImage)
   {
     this->InitPointsets();
   }
 
   this->m_Controls->m_Cut->setEnabled(foundFiberBundle && foundStartRoi && foundEndRoi);
   this->m_Controls->m_SegmentLabel->setEnabled(foundFiberBundle && foundStartRoi && foundEndRoi && (found3dImage || foundTbss));
   this->m_Controls->m_Segments->setEnabled(foundFiberBundle && foundStartRoi && foundEndRoi && (found3dImage || foundTbss));
   this->m_Controls->m_Average->setEnabled(foundFiberBundle && foundStartRoi && foundEndRoi && found3dImage);
 
 }
 
 void QmitkTractbasedSpatialStatisticsView::InitPointsets()
 {
   // Check if PointSetStart exsits, if not create it.
-  m_P1 = this->GetDefaultDataStorage()->GetNamedNode("PointSetNode");
+  m_P1 = this->GetDataStorage()->GetNamedNode("PointSetNode");
 
   if (m_PointSetNode)
   {
     //m_PointSetNode = dynamic_cast<mitk::PointSet*>(m_P1->GetData());
     return;
   }
 
   if ((!m_P1) || (!m_PointSetNode))
   {
     // create new ones
     m_PointSetNode = mitk::PointSet::New();
     m_P1 = mitk::DataNode::New();
     m_P1->SetData( m_PointSetNode );
     m_P1->SetProperty( "name", mitk::StringProperty::New( "PointSet" ) );
     m_P1->SetProperty( "opacity", mitk::FloatProperty::New( 1 ) );
     m_P1->SetProperty( "helper object", mitk::BoolProperty::New(true) ); // CHANGE if wanted
     m_P1->SetProperty( "pointsize", mitk::FloatProperty::New( 0.1 ) );
     m_P1->SetColor( 1.0, 0.0, 0.0 );
-    this->GetDefaultDataStorage()->Add(m_P1);
+    this->GetDataStorage()->Add(m_P1);
     m_Controls->m_PointWidget->SetPointSetNode(m_P1);
-    m_Controls->m_PointWidget->SetMultiWidget(GetActiveStdMultiWidget());
+    auto renderWindowPart = this->GetRenderWindowPart(OPEN);
+    auto axialSnc = renderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController();
+    auto sagittalSnc = renderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController();
+    auto coronalSnc = renderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController();
+    m_Controls->m_PointWidget->AddSliceNavigationController(axialSnc);
+    m_Controls->m_PointWidget->AddSliceNavigationController(sagittalSnc);
+    m_Controls->m_PointWidget->AddSliceNavigationController(coronalSnc);
   }
 }
 
 void QmitkTractbasedSpatialStatisticsView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkTractbasedSpatialStatisticsViewControls;
     m_Controls->setupUi( parent );
     this->CreateConnections();
   }
 
 
   // Table for the FSL TBSS import
   m_GroupModel = new QmitkTbssTableModel();
   m_Controls->m_GroupInfo->setModel(m_GroupModel);
 
 
 }
 
-void QmitkTractbasedSpatialStatisticsView::Activated()
+void QmitkTractbasedSpatialStatisticsView::SetFocus()
 {
-  QmitkFunctionality::Activated();
+  m_Controls->m_AddGroup->setFocus();
+}
 
+void QmitkTractbasedSpatialStatisticsView::Activated()
+{
+  m_Activated = true;
 }
 
 void QmitkTractbasedSpatialStatisticsView::Deactivated()
 {
-  QmitkFunctionality::Deactivated();
+  m_Activated = false;
+}
+
+bool QmitkTractbasedSpatialStatisticsView::IsActivated() const
+{
+  return m_Activated;
+}
+
+void QmitkTractbasedSpatialStatisticsView::Visible()
+{
+}
+
+void QmitkTractbasedSpatialStatisticsView::Hidden()
+{
 }
 
 void QmitkTractbasedSpatialStatisticsView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_CreateRoi), SIGNAL(clicked()), this, SLOT(CreateRoi()) );
     connect( (QObject*)(m_Controls->m_ImportFsl), SIGNAL(clicked()), this, SLOT(TbssImport()) );
     connect( (QObject*)(m_Controls->m_AddGroup), SIGNAL(clicked()), this, SLOT(AddGroup()) );
     connect( (QObject*)(m_Controls->m_RemoveGroup), SIGNAL(clicked()), this, SLOT(RemoveGroup()) );
     connect( (QObject*)(m_Controls->m_Clipboard), SIGNAL(clicked()), this, SLOT(CopyToClipboard()) );
     connect( m_Controls->m_RoiPlotWidget->m_PlotPicker, SIGNAL(selected(const QPointF&)), SLOT(Clicked(const QPointF&) ) );
     connect( m_Controls->m_RoiPlotWidget->m_PlotPicker, SIGNAL(moved(const QPointF&)), SLOT(Clicked(const QPointF&) ) );
     connect( (QObject*)(m_Controls->m_Cut), SIGNAL(clicked()), this, SLOT(Cut()) );
     connect( (QObject*)(m_Controls->m_Average), SIGNAL(stateChanged(int)), this, SLOT(PerformChange()) );
     connect( (QObject*)(m_Controls->m_Segments), SIGNAL(valueChanged(int)), this, SLOT(PerformChange()) );
 
   }
 }
 
 
 void QmitkTractbasedSpatialStatisticsView::CopyToClipboard()
 {
 
 
 
   if(m_Controls->m_RoiPlotWidget->IsPlottingFiber())
   {
     // Working with fiber bundles
     std::vector <std::vector<double> > profiles = m_Controls->m_RoiPlotWidget->GetIndividualProfiles();
 
     QString clipboardText;
     for (std::vector<std::vector<double> >::iterator it = profiles.begin(); it
                                                            != profiles.end(); ++it)
     {
       for (std::vector<double>::iterator it2 = (*it).begin(); it2 !=
             (*it).end(); ++it2)
       {
         clipboardText.append(QString("%1 \t").arg(*it2));
       }
       clipboardText.append(QString("\n"));
     }
 
 
 
     if(m_Controls->m_Average->isChecked())
     {
       std::vector<double> averages = m_Controls->m_RoiPlotWidget->GetAverageProfile();
       clipboardText.append(QString("\nAverage\n"));
 
       for (std::vector<double>::iterator it2 = averages.begin(); it2 !=
             averages.end(); ++it2)
       {
         clipboardText.append(QString("%1 \t").arg(*it2));
 
       }
     }
 
     QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
 
   }
 
   else{
 
     // Working with TBSS Data
     if(m_Controls->m_Average->isChecked())
     {
       std::vector<std::vector<double> > vals = m_Controls->m_RoiPlotWidget->GetVals();
       QString clipboardText;
       for (std::vector<std::vector<double> >::iterator it = vals.begin(); it
                                                              != vals.end(); ++it)
       {
         for (std::vector<double>::iterator it2 = (*it).begin(); it2 !=
               (*it).end(); ++it2)
         {
           clipboardText.append(QString("%1 \t").arg(*it2));
 
           double d = *it2;
           std::cout << d <<std::endl;
         }
         clipboardText.append(QString("\n"));
       }
 
       QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
     }
     else
     {
       std::vector<std::vector<double> > vals = m_Controls->m_RoiPlotWidget->GetIndividualProfiles();
       QString clipboardText;
       for (std::vector<std::vector<double> >::iterator it = vals.begin(); it
                                                              != vals.end(); ++it)
       {
         for (std::vector<double>::iterator it2 = (*it).begin(); it2 !=
               (*it).end(); ++it2)
         {
           clipboardText.append(QString("%1 \t").arg(*it2));
 
           double d = *it2;
           std::cout << d <<std::endl;
         }
         clipboardText.append(QString("\n"));
       }
       QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
     }
 
   }
 
 
 }
 
 void QmitkTractbasedSpatialStatisticsView::RemoveGroup()
 {
 
   QTableView *temp = static_cast<QTableView*>(m_Controls->m_GroupInfo);
 
   QItemSelectionModel *selectionModel = temp->selectionModel();
 
   QModelIndexList indices = selectionModel->selectedRows();
 
   QModelIndex index;
 
   foreach(index, indices)
   {
     int row = index.row();
     m_GroupModel->removeRows(row, 1, QModelIndex());
   }
 
 }
 
 
 
 void QmitkTractbasedSpatialStatisticsView::AddGroup()
 {
   QString group("Group");
   int number = 0;
   QPair<QString, int> pair(group, number);
   QList< QPair<QString, int> >list = m_GroupModel->getList();
 
 
   if(!list.contains(pair))
   {
     m_GroupModel->insertRows(0, 1, QModelIndex());
 
     QModelIndex index = m_GroupModel->index(0, 0, QModelIndex());
     m_GroupModel->setData(index, group, Qt::EditRole);
     index = m_GroupModel->index(0, 1, QModelIndex());
     m_GroupModel->setData(index, number, Qt::EditRole);
 
   }
 }
 
 
 void QmitkTractbasedSpatialStatisticsView::TbssImport()
 {
 
   // Read groups from the interface
   mitk::TbssImporter::Pointer importer = mitk::TbssImporter::New();
 
   QList< QPair<QString, int> >list = m_GroupModel->getList();
 
 
   if(list.size() == 0)
   {
     QMessageBox msgBox;
     msgBox.setText("No study group information has been set yet.");
     msgBox.exec();
     return;
   }
 
 
   std::vector < std::pair<std::string, int> > groups;
   for(int i=0; i<list.size(); i++)
   {
     QPair<QString, int> pair = list.at(i);
     std::string s = pair.first.toStdString();
     int n = pair.second;
 
     std::pair<std::string, int> p;
     p.first = s;
     p.second = n;
     groups.push_back(p);
   }
 
   importer->SetGroupInfo(groups);
 
   std::string minfo = m_Controls->m_MeasurementInfo->text().toStdString();
   importer->SetMeasurementInfo(minfo);
 
 
   std::string name = "";
 
-  std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
+  QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
 
-  for ( int i=0; i<nodes.size(); i++ )
+  for (auto node: nodes)
   {
-    if(QString("Image").compare(nodes[i]->GetData()->GetNameOfClass())==0)
+    if(QString("Image").compare(node->GetData()->GetNameOfClass())==0)
     {
-      mitk::Image* img = static_cast<mitk::Image*>(nodes[i]->GetData());
+      mitk::Image* img = static_cast<mitk::Image*>(node->GetData());
       if(img->GetDimension() == 4)
       {
         importer->SetImportVolume(img);
-        name = nodes[i]->GetName();
+        name = node->GetName();
       }
     }
   }
 
 
   mitk::TbssImage::Pointer tbssImage;
 
   tbssImage = importer->Import();
   name += "_tbss";
   AddTbssToDataStorage(tbssImage, name);
 
 
 }
 
 
 void QmitkTractbasedSpatialStatisticsView::AddTbssToDataStorage(mitk::Image* image, std::string name)
 {
   mitk::LevelWindow levelwindow;
   levelwindow.SetAuto( image );
   mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
   levWinProp->SetLevelWindow( levelwindow );
 
   mitk::DataNode::Pointer result = mitk::DataNode::New();
   result->SetProperty( "name", mitk::StringProperty::New(name) );
   result->SetData( image );
   result->SetProperty( "levelwindow", levWinProp );
 
 
   // add new image to data storage and set as active to ease further processing
-  GetDefaultDataStorage()->Add( result );
+  GetDataStorage()->Add( result );
 
   // show the results
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 
 void QmitkTractbasedSpatialStatisticsView::Clicked(const QPointF& pos)
 {
   int index = (int)pos.x();
 
   if(m_Roi.size() > 0 && m_CurrentGeometry != NULL && !m_Controls->m_RoiPlotWidget->IsPlottingFiber() )
   {
 
     index = std::min( (int)m_Roi.size()-1, std::max(0, index) );
     itk::Index<3> ix = m_Roi.at(index);
 
     mitk::Vector3D i;
     i[0] = ix[0];
     i[1] = ix[1];
     i[2] = ix[2];
 
     mitk::Vector3D w;
 
     m_CurrentGeometry->IndexToWorld(i, w);
 
     mitk::Point3D origin = m_CurrentGeometry->GetOrigin();
 
     mitk::Point3D p;
     p[0] = w[0] + origin[0];
     p[1] = w[1] + origin[1];
     p[2] = w[2] + origin[2];
 
-    m_MultiWidget->MoveCrossToPosition(p);
+    this->GetRenderWindowPart()->SetSelectedPosition(p);
     m_Controls->m_RoiPlotWidget->drawBar(index);
   }
 
   else if(m_Controls->m_RoiPlotWidget->IsPlottingFiber() )
   {
 
     mitk::Point3D point = m_Controls->m_RoiPlotWidget->GetPositionInWorld(index);
-    m_MultiWidget->MoveCrossToPosition(point);
+    this->GetRenderWindowPart()->SetSelectedPosition(point);
 
 
   }
 
 
 }
 
 void QmitkTractbasedSpatialStatisticsView::Cut()
 {
   mitk::BaseData* fibData = m_CurrentFiberNode->GetData();
   mitk::FiberBundle* fib = static_cast<mitk::FiberBundle*>(fibData);
 
   mitk::PlaneGeometry* startGeometry2D = const_cast<mitk::PlaneGeometry*>(dynamic_cast<mitk::PlanarFigure*>(m_CurrentStartRoi->GetData())->GetPlaneGeometry());
   mitk::PlaneGeometry* endGeometry2D = const_cast<mitk::PlaneGeometry*>(dynamic_cast<mitk::PlanarFigure*>(m_CurrentEndRoi->GetData())->GetPlaneGeometry());
 
   mitk::Point3D startCenter = dynamic_cast<mitk::PlanarFigure*>(m_CurrentStartRoi->GetData())->GetWorldControlPoint(0); //center Point of start roi
   mitk::Point3D endCenter = dynamic_cast<mitk::PlanarFigure*>(m_CurrentEndRoi->GetData())->GetWorldControlPoint(0); //center Point of end roi
 
   mitk::FiberBundle::Pointer inStart = fib->ExtractFiberSubset(m_CurrentStartRoi, NULL);
   mitk::FiberBundle::Pointer inBoth = inStart->ExtractFiberSubset(m_CurrentEndRoi, NULL);
 
   int num = inBoth->GetNumFibers();
 
   vtkSmartPointer<vtkPolyData> fiberPolyData = inBoth->GetFiberPolyData();
   vtkCellArray* lines = fiberPolyData->GetLines();
   lines->InitTraversal();
 
 
   // initialize new vtk polydata
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
 
   int pointIndex=0;
 
 
   // find start and endpoint
   for( int fiberID( 0 ); fiberID < num; fiberID++ )
   {
     vtkIdType   numPointsInCell(0);
     vtkIdType*  pointsInCell(NULL);
     lines->GetNextCell ( numPointsInCell, pointsInCell );
 
     int startId = 0;
     int endId = 0;
 
     float minDistStart = std::numeric_limits<float>::max();
     float minDistEnd = std::numeric_limits<float>::max();
 
 
     vtkSmartPointer<vtkPolyLine> polyLine = vtkSmartPointer<vtkPolyLine>::New();
     int lineIndex=0;
 
 
     for( int pointInCellID( 0 ); pointInCellID < numPointsInCell ; pointInCellID++)
     {
       double *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
 
       mitk::Point3D point;
       point[0] = p[0];
       point[1] = p[1];
       point[2] = p[2];
 
       float distanceToStart = point.EuclideanDistanceTo(startCenter);
       float distanceToEnd = point.EuclideanDistanceTo(endCenter);
 
       if(distanceToStart < minDistStart)
       {
         minDistStart = distanceToStart;
         startId = pointInCellID;
       }
 
       if(distanceToEnd < minDistEnd)
       {
         minDistEnd = distanceToEnd;
         endId = pointInCellID;
       }
 
 
 
     }
 
 
 
     /* We found the start and end points of of the part that should be plottet for
        the current fiber. now we need to plot them. If the endId is smaller than the startId the plot order
        must be reversed*/
 
     if(startId < endId)
     {
 
       double *p = fiberPolyData->GetPoint( pointsInCell[ startId ] );
 
       mitk::Vector3D p0;
       p0[0] = p[0];
       p0[1] = p[1];
       p0[2] = p[2];
 
       p = fiberPolyData->GetPoint( pointsInCell[ startId+1 ] );
 
       mitk::Vector3D p1;
       p1[0] = p[0];
       p1[1] = p[1];
       p1[2] = p[2];
 
 
       // Check if p and p2 are both on the same side of the plane
       mitk::Vector3D normal = startGeometry2D->GetNormal();
 
       mitk::Point3D pStart;
       pStart[0] = p0[0];
       pStart[1] = p0[1];
       pStart[2] = p0[2];
 
       bool startOnPositive = startGeometry2D->IsAbove(pStart);
 
       mitk::Point3D pSecond;
       pSecond[0] = p1[0];
       pSecond[1] = p1[1];
       pSecond[2] = p1[2];
 
       bool secondOnPositive = startGeometry2D->IsAbove(pSecond);
 
 
       // Calculate intersection with the plane
 
       mitk::Vector3D onPlane;
       onPlane[0] = startCenter[0];
       onPlane[1] = startCenter[1];
       onPlane[2] = startCenter[2];
 
 
       if(! (secondOnPositive ^ startOnPositive) )
       {
         /* startId and startId+1 lie on the same side of the plane, so we need
            need startId-1 to calculate the intersection with the planar figure*/
         p = fiberPolyData->GetPoint( pointsInCell[ startId-1 ] );
         p1[0] = p[0];
         p1[1] = p[1];
         p1[2] = p[2];
       }
 
 
       double d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
 
       mitk::Vector3D newPoint = (p0-p1);
 
       newPoint[0] = d*newPoint[0] + p0[0];
       newPoint[1] = d*newPoint[1] + p0[1];
       newPoint[2] = d*newPoint[2] + p0[2];
 
 
       double insertPoint[3];
       insertPoint[0] = newPoint[0];
       insertPoint[1] = newPoint[1];
       insertPoint[2] = newPoint[2];
 
 
       // First insert the intersection with the start roi
       points->InsertNextPoint(insertPoint);
       polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
       lineIndex++;
       pointIndex++;
 
       if(! (secondOnPositive ^ startOnPositive) )
       {
         /* StartId and startId+1 lie on the same side of the plane
            so startId is also part of the ROI*/
 
         double *start = fiberPolyData->GetPoint( pointsInCell[startId] );
         points->InsertNextPoint(start);
         polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
         lineIndex++;
         pointIndex++;
 
 
       }
 
       // Insert the rest up and to including endId-1
       for( int pointInCellID( startId+1 ); pointInCellID < endId ; pointInCellID++)
       {
         // create new polyline for new polydata
         double *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
         points->InsertNextPoint(p);
 
 
         // add point to line
         polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
         lineIndex++;
         pointIndex++;
 
       }
 
 
 
       /* endId must be included if endId and endId-1 lie on the same side of the
          plane defined by endRoi*/
 
 
       p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
       p0[0] = p[0];      p0[1] = p[1];      p0[2] = p[2];
 
 
       p = fiberPolyData->GetPoint( pointsInCell[ endId-1 ] );
       p1[0] = p[0];      p1[1] = p[1];      p1[2] = p[2];
 
 
       mitk::Point3D pLast;
       pLast[0] = p0[0];      pLast[1] = p0[1];      pLast[2] = p0[2];
 
       mitk::Point3D pBeforeLast;
       pBeforeLast[0] = p1[0];      pBeforeLast[1] = p1[1];      pBeforeLast[2] = p1[2];
 
       bool lastOnPositive = endGeometry2D->IsAbove(pLast);
       bool secondLastOnPositive = endGeometry2D->IsAbove(pBeforeLast);
       normal = endGeometry2D->GetNormal();
 
 
       onPlane[0] = endCenter[0];
       onPlane[1] = endCenter[1];
       onPlane[2] = endCenter[2];
 
 
 
       if(! (lastOnPositive ^ secondLastOnPositive) )
       {
         /* endId and endId-1 lie on the same side of the plane, so we need
            need endId+1 to calculate the intersection with the planar figure.
            this should exist since we know that the fiber crosses the planar figure
            endId is part of the roi so can also be included here*/
         p = fiberPolyData->GetPoint( pointsInCell[ endId+1 ] );
         p1[0] = p[0];
         p1[1] = p[1];
         p1[2] = p[2];
 
 
         double *end = fiberPolyData->GetPoint( pointsInCell[endId] );
         points->InsertNextPoint(end);
         polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
         lineIndex++;
         pointIndex++;
       }
 
       d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
 
       newPoint = (p0-p1);
 
       newPoint[0] = d*newPoint[0] + p0[0];
       newPoint[1] = d*newPoint[1] + p0[1];
       newPoint[2] = d*newPoint[2] + p0[2];
 
       insertPoint[0] = newPoint[0];
       insertPoint[1] = newPoint[1];
       insertPoint[2] = newPoint[2];
 
       //Insert the Last Point (intersection with the end roi)
 
       points->InsertNextPoint(insertPoint);
       polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
       lineIndex++;
       pointIndex++;
 
 
     }
 
     // Need to reverse walking order
     else{
       double *p = fiberPolyData->GetPoint( pointsInCell[ startId ] );
 
       mitk::Vector3D p0;
       p0[0] = p[0];
       p0[1] = p[1];
       p0[2] = p[2];
 
       p = fiberPolyData->GetPoint( pointsInCell[ startId-1 ] );
 
       mitk::Vector3D p1;
       p1[0] = p[0];
       p1[1] = p[1];
       p1[2] = p[2];
 
 
       // Check if p and p2 are both on the same side of the plane
       mitk::Vector3D normal = startGeometry2D->GetNormal();
 
       mitk::Point3D pStart;
       pStart[0] = p0[0];
       pStart[1] = p0[1];
       pStart[2] = p0[2];
 
       bool startOnPositive = startGeometry2D->IsAbove(pStart);
 
       mitk::Point3D pSecond;
       pSecond[0] = p1[0];
       pSecond[1] = p1[1];
       pSecond[2] = p1[2];
 
       bool secondOnPositive = startGeometry2D->IsAbove(pSecond);
 
 
       // Calculate intersection with the plane
 
       mitk::Vector3D onPlane;
       onPlane[0] = startCenter[0];
       onPlane[1] = startCenter[1];
       onPlane[2] = startCenter[2];
 
 
       if(! (secondOnPositive ^ startOnPositive) )
       {
         /* startId and startId-1 lie on the same side of the plane, so we need
            need startId+1 to calculate the intersection with the planar figure*/
         p = fiberPolyData->GetPoint( pointsInCell[ startId+1 ] );
         p1[0] = p[0];
         p1[1] = p[1];
         p1[2] = p[2];
       }
 
 
       double d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
 
       mitk::Vector3D newPoint = (p0-p1);
 
       newPoint[0] = d*newPoint[0] + p0[0];
       newPoint[1] = d*newPoint[1] + p0[1];
       newPoint[2] = d*newPoint[2] + p0[2];
 
 
       double insertPoint[3];
       insertPoint[0] = newPoint[0];
       insertPoint[1] = newPoint[1];
       insertPoint[2] = newPoint[2];
 
 
       // First insert the intersection with the start roi
       points->InsertNextPoint(insertPoint);
       polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
       lineIndex++;
       pointIndex++;
 
       if(! (secondOnPositive ^ startOnPositive) )
       {
         /* startId and startId-1 lie on the same side of the plane
            so endId is also part of the ROI*/
 
         double *start = fiberPolyData->GetPoint( pointsInCell[startId] );
         points->InsertNextPoint(start);
         polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
         lineIndex++;
         pointIndex++;
 
 
       }
 
       // Insert the rest up and to including endId-1
       for( int pointInCellID( startId-1 ); pointInCellID > endId ; pointInCellID--)
       {
         // create new polyline for new polydata
         double *p = fiberPolyData->GetPoint( pointsInCell[ pointInCellID ] );
         points->InsertNextPoint(p);
 
 
         // add point to line
         polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
         lineIndex++;
         pointIndex++;
 
       }
 
 
 
       /* startId must be included if startId and startId+ lie on the same side of the
          plane defined by endRoi*/
 
 
       p = fiberPolyData->GetPoint( pointsInCell[ endId ] );
       p0[0] = p[0];
       p0[1] = p[1];
       p0[2] = p[2];
 
 
       p = fiberPolyData->GetPoint( pointsInCell[ endId+1 ] );
       p1[0] = p[0];
       p1[1] = p[1];
       p1[2] = p[2];
 
 
       mitk::Point3D pLast;
       pLast[0] = p0[0];
       pLast[1] = p0[1];
       pLast[2] = p0[2];
 
       bool lastOnPositive = endGeometry2D->IsAbove(pLast);
 
       mitk::Point3D pBeforeLast;
       pBeforeLast[0] = p1[0];
       pBeforeLast[1] = p1[1];
       pBeforeLast[2] = p1[2];
 
       bool secondLastOnPositive = endGeometry2D->IsAbove(pBeforeLast);
 
       onPlane[0] = endCenter[0];
       onPlane[1] = endCenter[1];
       onPlane[2] = endCenter[2];
 
 
 
       if(! (lastOnPositive ^ secondLastOnPositive) )
       {
         /* endId and endId+1 lie on the same side of the plane, so we need
            need endId-1 to calculate the intersection with the planar figure.
            this should exist since we know that the fiber crosses the planar figure*/
         p = fiberPolyData->GetPoint( pointsInCell[ endId-1 ] );
         p1[0] = p[0];
         p1[1] = p[1];
         p1[2] = p[2];
 
 
         /* endId and endId+1 lie on the same side of the plane
            so startId is also part of the ROI*/
 
         double *end = fiberPolyData->GetPoint( pointsInCell[endId] );
         points->InsertNextPoint(end);
         polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
         lineIndex++;
         pointIndex++;
       }
 
       d = ( (onPlane-p0)*normal) / ( (p0-p1) * normal );
 
       newPoint = (p0-p1);
 
       newPoint[0] = d*newPoint[0] + p0[0];
       newPoint[1] = d*newPoint[1] + p0[1];
       newPoint[2] = d*newPoint[2] + p0[2];
 
 
       insertPoint[0] = newPoint[0];
       insertPoint[1] = newPoint[1];
       insertPoint[2] = newPoint[2];
 
 
 
       //Insert the Last Point (intersection with the end roi)
       points->InsertNextPoint(insertPoint);
       polyLine->GetPointIds()->InsertId(lineIndex,pointIndex);
       lineIndex++;
       pointIndex++;
 
 
 
     }
 
 
     // add polyline to vtk cell array
      cells->InsertNextCell(polyLine);
 
   }
 
 
   // Add the points to the dataset
   polyData->SetPoints(points);
 
   // Add the lines to the dataset
   polyData->SetLines(cells);
 
   mitk::FiberBundle::Pointer cutBundle = mitk::FiberBundle::New(polyData);
 
 
   mitk::DataNode::Pointer cutNode = mitk::DataNode::New();
   cutNode->SetData(cutBundle);
   std::string name = "fiberCut";
   cutNode->SetName(name);
   GetDataStorage()->Add(cutNode);
 
 
 
 }
 
 
-void QmitkTractbasedSpatialStatisticsView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
-{
-  m_MultiWidget = &stdMultiWidget;
-}
-
-
-void QmitkTractbasedSpatialStatisticsView::StdMultiWidgetNotAvailable()
-{
-  m_MultiWidget = NULL;
-}
-
-
 void QmitkTractbasedSpatialStatisticsView::CreateRoi()
 {
   bool ok;
   double threshold = QInputDialog::getDouble(m_Controls->m_CreateRoi, tr("Set an FA threshold"),
                                                       tr("Threshold:"), 0.2, 0.0, 1.0, 2, &ok);
 
   if(!ok)
     return;
 
   mitk::Image::Pointer image;
 
-  std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
+  QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
 
-  for ( int i=0; i<nodes.size(); i++ )
+  for (auto node: nodes)
   {
-    if(QString("Image").compare(nodes[i]->GetData()->GetNameOfClass())==0)
+    if(QString("Image").compare(node->GetData()->GetNameOfClass())==0)
     {
-        mitk::Image* img = static_cast<mitk::Image*>(nodes[i]->GetData());
+        mitk::Image* img = static_cast<mitk::Image*>(node->GetData());
         if(img->GetDimension() == 3)
         {
           image = img;
         }
     }
   }
 
   if(image.IsNull())
   {
     return;
   }
 
   mitk::TractAnalyzer analyzer;
   analyzer.SetInputImage(image);
   analyzer.SetThreshold(threshold);
 
   m_PointSetNode = this->m_Controls->m_PointWidget->GetPointSet();
 
   // Set Pointset to analyzer
   analyzer.SetPointSet(m_PointSetNode);
 
   // Run Analyzer
   try
   {
     analyzer.MakeRoi();
   }
   catch (const mitk::Exception& e)
   {
     QMessageBox msgBox;
     msgBox.setText(QString::fromStdString(e.what()));
     msgBox.exec();
   }
 
   // Obtain tbss roi image from analyzer
   mitk::TbssRoiImage::Pointer tbssRoi = analyzer.GetRoiImage();
 
   tbssRoi->SetStructure(m_Controls->m_Structure->text().toStdString());
 
   // get path description and set to interface
   std::string pathDescription = analyzer.GetPathDescription();
   m_Controls->m_PathTextEdit->setPlainText(QString(pathDescription.c_str()));
 
 
   // Add roi image to datastorage
   AddTbssToDataStorage(tbssRoi, m_Controls->m_RoiName->text().toStdString());
 
 
 
 
 }
 
 void QmitkTractbasedSpatialStatisticsView::PlotFiber4D(mitk::TbssImage* image,
                                                             mitk::FiberBundle* fib,
                                                             mitk::DataNode* startRoi,
                                                             mitk::DataNode* endRoi)
 {
 
 
   if(m_Controls->m_TabWidget->currentWidget() == m_Controls->m_MeasureTAB)
   {
     m_CurrentGeometry = image->GetGeometry();
 
     m_Controls->m_RoiPlotWidget->SetGroups(image->GetGroupInfo());
     m_Controls->m_RoiPlotWidget->SetProjections(image->GetImage());
     m_Controls->m_RoiPlotWidget->SetMeasure( image->GetMeasurementInfo() );
     m_Controls->m_RoiPlotWidget->PlotFiber4D(image, fib, startRoi, endRoi, m_Controls->m_Segments->value());
   }
 
 
 }
 
 void QmitkTractbasedSpatialStatisticsView:: PlotFiberBundle(mitk::FiberBundle *fib, mitk::Image* img,
                                                            mitk::DataNode* startRoi, mitk::DataNode* endRoi)
 {
   bool avg = m_Controls->m_Average->isChecked();
   int segments = m_Controls->m_Segments->value();
   m_Controls->m_RoiPlotWidget->PlotFiberBetweenRois(fib, img, startRoi ,endRoi, avg, segments);
   m_Controls->m_RoiPlotWidget->SetPlottingFiber(true);
   mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
 }
 
 
 void QmitkTractbasedSpatialStatisticsView::Plot(mitk::TbssImage* image, mitk::TbssRoiImage* roiImage)
 {
   if(m_Controls->m_TabWidget->currentWidget() == m_Controls->m_MeasureTAB)
   {
 
     std::vector< itk::Index<3> > roi = roiImage->GetRoi();
     m_Roi = roi;
     m_CurrentGeometry = image->GetGeometry();
 
 
     std::string structure = roiImage->GetStructure();
 
     m_Controls->m_RoiPlotWidget->SetGroups(image->GetGroupInfo());
     m_Controls->m_RoiPlotWidget->SetProjections(image->GetImage());
     m_Controls->m_RoiPlotWidget->SetRoi(roi);
     m_Controls->m_RoiPlotWidget->SetStructure(structure);
     m_Controls->m_RoiPlotWidget->SetMeasure( image->GetMeasurementInfo() );
     m_Controls->m_RoiPlotWidget->DrawProfiles();
   }
 
   m_Controls->m_RoiPlotWidget->SetPlottingFiber(false);
 
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.h
index 32bf17a724..51c987a2bc 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTractbasedSpatialStatisticsView.h
@@ -1,177 +1,184 @@
 /*===================================================================
 
 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 QmitkTractbasedSpatialStatisticsView_h
 #define QmitkTractbasedSpatialStatisticsView_h
 
 
-#include <QmitkFunctionality.h>
+#include <QmitkAbstractView.h>
+#include <mitkILifecycleAwarePart.h>
 
 #include "ui_QmitkTractbasedSpatialStatisticsViewControls.h"
 #include <QListWidgetItem>
 
 #include <itkImageFileReader.h>
 #include <itkImageFileWriter.h>
 
 #include <itkDiffusionTensor3D.h>
 
 #include <mitkTbssImage.h>
 #include <mitkTbssRoiImage.h>
 
 #include "QmitkTbssTableModel.h"
 #include "QmitkTbssMetaTableModel.h"
 
 #include <mitkFiberBundle.h>
 
 
 // Image types
 typedef short DiffusionPixelType;
 typedef itk::Image<char, 3> CharImageType;
 typedef itk::Image<unsigned char, 3> UCharImageType;
 typedef itk::Image<float, 4> Float4DImageType;
 typedef itk::Image<float, 3> FloatImageType;
 typedef itk::VectorImage<float, 3> VectorImageType;
 
 // Readers/Writers
 typedef itk::ImageFileReader< CharImageType > CharReaderType;
 typedef itk::ImageFileReader< UCharImageType > UCharReaderType;
 typedef itk::ImageFileWriter< CharImageType > CharWriterType;
 typedef itk::ImageFileReader< FloatImageType > FloatReaderType;
 typedef itk::ImageFileWriter< FloatImageType > FloatWriterType;
 typedef itk::ImageFileReader< Float4DImageType > Float4DReaderType;
 typedef itk::ImageFileWriter< Float4DImageType > Float4DWriterType;
 
 
 
 /*!
   * \brief This plugin provides an extension for Tract-based spatial statistics (see Smith et al., 2009. http://dx.doi.org/10.1016/j.neuroimage.2006.02.024)
   * TBSS enables analyzing the brain by a pipeline of registration, skeletonization, and projection that results in a white matter skeleton
   * for all subjects that are analyzed statistically in a whole-brain manner.
   * This plugin provides functionality to select single tracts and analyze them separately.
   *
   * Prerequisites: the mean_FA_skeleton and all_FA_skeletonised datasets produced by the FSL TBSS pipeline: http://fsl.fmrib.ox.ac.uk/fsl/fsl4.0/tbss/index
 */
 
-class QmitkTractbasedSpatialStatisticsView : public QmitkFunctionality
+class QmitkTractbasedSpatialStatisticsView : public QmitkAbstractView, public mitk::ILifecycleAwarePart
 {
 
   Q_OBJECT
 
   public:
 
     static const std::string VIEW_ID;
 
     QmitkTractbasedSpatialStatisticsView();
     virtual ~QmitkTractbasedSpatialStatisticsView();
 
     virtual void CreateQtPartControl(QWidget *parent) override;
 
     /// \brief Creation of the connections of main and control widget
     virtual void CreateConnections();
 
-    virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget) override;
-    virtual void StdMultiWidgetNotAvailable() override;
+    ///
+    /// Sets the focus to an internal widget.
+    ///
+    virtual void SetFocus() override;
 
-    /// \brief Called when the functionality is activated
+    /// \brief Called when the view gets activated
     virtual void Activated() override;
 
+    /// \brief Called when the view gets deactivated
     virtual void Deactivated() override;
 
+    bool IsActivated() const;
+
+    /// \brief Called when the view gets visible
+    virtual void Visible() override;
+
+    /// \brief Called when the view gets hidden
+    virtual void Hidden() override;
 
   protected slots:
 
     // Creates Roi
     void CreateRoi();
 
     void Clicked(const QPointF& pos);
 
     // Import of FSL TBSS data
     void TbssImport();
 
     // Add a group as metadata. This metadata is required by the plotting functionality
     void AddGroup();
 
     // Remove a group
     void RemoveGroup();
 
     // Copies the values displayed in the plot widget to clipboard, i.e. exports the data
     void CopyToClipboard();
 
     // Method to cut away parts of fiber bundles that should not be plotted.
     void Cut();
 
     // Adjust plot widget
     void PerformChange();
 
 
   protected:
 
 
-    /// \brief called by QmitkFunctionality when DataManager's selection has changed
-    virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes ) override;
+    /// \brief called by QmitkAbstractView when DataManager's selection has changed
+    virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
     // Creates a plot using a 4D image containing the projections of all subjects and a region of interest
     void Plot(mitk::TbssImage*, mitk::TbssRoiImage*);
 
 
     void PlotFiberBundle(mitk::FiberBundle* fib, mitk::Image* img, mitk::DataNode* startRoi=NULL, mitk::DataNode* endRoi=NULL);
 
 
     void PlotFiber4D(mitk::TbssImage*, mitk::FiberBundle* fib, mitk::DataNode *startRoi=NULL, mitk::DataNode *endRoi=NULL);
 
     // Create a point set. This point set defines the points through which a region of interest should go
     void InitPointsets();
 
     // Pointset and DataNode to contain the PointSet used in ROI creation
     mitk::PointSet::Pointer m_PointSetNode;
     mitk::DataNode::Pointer m_P1;
 
     // GUI widgets
     Ui::QmitkTractbasedSpatialStatisticsViewControls* m_Controls;
 
-    /* A pointer to the QmitkStdMultiWidget. Used for interaction with the plot widget
-    (clicking in the plot widget makes the image cross jump to the corresponding location
-    on the skeleton).*/
-    QmitkStdMultiWidget* m_MultiWidget;
-
     // Used to save the region of interest in a vector of itk::index.
     std::vector< itk::Index<3> > m_Roi;
 
     mitk::FiberBundle* m_Fib;
 
     mitk::BaseGeometry* m_CurrentGeometry;
 
     // A table model for saving group information in a name,number pair.
     QmitkTbssTableModel* m_GroupModel;
 
     // Convenience function for adding a new image to the datastorage and giving it a name.
     void AddTbssToDataStorage(mitk::Image* image, std::string name);
 
     mitk::DataNode::Pointer m_CurrentFiberNode; // needed for the index property when interacting with the plot widget
 
     // needed when a plot should only show values between a start end end roi
     mitk::DataNode::Pointer m_CurrentStartRoi;
     mitk::DataNode::Pointer m_CurrentEndRoi;
 
+private:
 
-
+  bool m_Activated;
 
 };
 
 
 
 #endif // _QMITKTRACTBASEDSPATIALSTATISTICSVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/deprecated/QmitkDiffusionTensorEstimation.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/deprecated/QmitkDiffusionTensorEstimation.cpp
index e4cffca1d7..cabac3a25d 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/deprecated/QmitkDiffusionTensorEstimation.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/deprecated/QmitkDiffusionTensorEstimation.cpp
@@ -1,2499 +1,2499 @@
 /*===================================================================
 
 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 "itkTimeProbe.h"
 
 #include "QmitkDiffusionTensorEstimation.h"
 #include "QmitkDiffusionTensorEstimationControls.h"
 #include <qaction.h>
 #include "QmitkDataTreeComboBox.h"
 #include "QmitkDataTreeListView.h"
-#include "QmitkStdMultiWidget.h"
 #include "QmitkDiffusionTensorIcon.h"
 #include <qfiledialog.h>
 #include "QmitkPropertyViewFactory.h"
 #include <qobjectlist.h>
 #include <qlistbox.h>
 #include <qpushbutton.h>
 #include <qprogressbar.h>
 #include <qspinbox.h>
 #include <qlineedit.h>
 #include <qcheckbox.h>
 
 // properties
 #include "mitkStringProperty.h"
 #include "mitkProperties.h"
 #include "mitkMaterialProperty.h"
 #include "mitkLevelWindowProperty.h"
 #include "mitkVtkRepresentationProperty.h"
 #include "mitkVtkInterpolationProperty.h"
 #include "mitkVtkScalarModeProperty.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkLookupTable.h"
 #include "mitkTransferFunctionProperty.h"
 #include "mitkGridRepresentationProperty.h"
 #include "mitkGridVolumeMapperProperty.h"
 #include "mitkVtkResliceInterpolationProperty.h"
 #include "mitkVectorImageMapper2D.h"
 #include "mitkOdfVtkMapper2D.h"
 
 #include "itkOrientedImage.h"
 #include "itkVectorImage.h"
 #include "itkImageSeriesReader.h"
 #include "itkImageFileWriter.h"
 #include "itkExceptionObject.h"
 #include "itkDiffusionTensor3DReconstructionImageFilter.h"
 #include "itkDiffusionTensor3D.h"
 #include "itkTensorFractionalAnisotropyImageFilter.h"
 #include "itkTensorRelativeAnisotropyImageFilter.h"
 #include "itkGDCMSeriesFileNames.h"
 #include "itkImageRegionConstIterator.h"
 #include "itkRescaleIntensityImageFilter.h"
 #include "itkDiffusionQballReconstructionImageFilter.h"
 #include "itkAnalyticalDiffusionQballReconstructionImageFilter.h"
 #include "itkPointShell.h"
 #include "itkRGBPixel.h"
 #include "itkOrientationDistributionFunction.h"
 #include "itkDiffusionQballPrincipleDirectionsImageFilter.h"
 #include "itkDiffusionQballGeneralizedFaImageFilter.h"
 #include "itkShiftScaleImageFilter.h"
 #include "itkDiffusionQballPrepareVisualizationImageFilter.h"
 #include "itkDiffusionTensorPrincipleDirectionImageFilter.h"
 #include "itkDiffusionQballSphericalDeconvolutionImageFilter.h"
 #include "itkVectorImagesAngularErrorImageFilter.h"
 
 #include "mitkDicomDiffusionVolumeHeaderReader.h"
 #include "mitkGroupDiffusionHeadersFilter.h"
 #include "mitkDicomDiffusionVolumesReader.h"
 #include "mitkNrrdDiffusionVolumesWriter.h"
 #include "mitkNrrdDiffusionVolumesReader.h"
 #include "mitkDiffusionVolumes.h"
 #include "mitkDataTreeFilterFunctions.h"
 #include "mitkProgressBar.h"
 #include "mitkStatusBar.h"
 #include "mitkTeemDiffusionTensor3DReconstructionImageFilter.h"
 #include "mitkSurface.h"
 #include "mitkDataNodeFactory.h"
 
 #include "vtkPolyData.h"
 #include "vtkPoints.h"
 #include "vtkCellArray.h"
 #include "vtkDelaunay2D.h"
 #include "vtkCleanPolyData.h"
 #include "vtkAppendPolyData.h"
 
 #include "mitkImageCast.h"
 
 #include <time.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 #define DIFF_EST_PI   M_PI
 
 typedef float TTensorPixelType;
 typedef itk::DiffusionTensor3D< TTensorPixelType >    TensorPixelType;
 typedef itk::Image< TensorPixelType, 3 >              TensorImageType;
 
 typedef itk::VectorImage< DiffusionPixelType, 3 >   DiffusionImageType;
 
 //CAST_N_VEC(3)
 //CAST_N_VEC(42)
 //CAST_N_VEC(92)
 //CAST_N_VEC(162)
 //CAST_N_VEC(252)
 //CAST_N_VEC(362)
 //CAST_N_VEC(492)
 //CAST_N_VEC(642)
 //CAST_N_VEC(812)
 //CAST_N_VEC(1002)
 
 const int QmitkDiffusionTensorEstimation::odfsize = 252;
 const int QmitkDiffusionTensorEstimation::nrconvkernels = 252;
 
 // Compile-time Square Root Computation: ceil(sqrt(N))
 template <int Size, int Low = 1, int High = Size>
 struct Root;
 template <int Size, int Mid>
 struct Root<Size,Mid,Mid> {
   static const int root = Mid;
 };
 template <int Size, int Low, int High>
 struct Root {
   static const int mean = (Low + High)/2;
   static const bool down = (mean * mean >= Size);
   static const int root = Root<Size,
     (down ? Low : mean+1),
     (down ? mean : High) >::root;
 };
 
-QmitkDiffusionTensorEstimation::QmitkDiffusionTensorEstimation(QObject *parent, const char *name, QmitkStdMultiWidget *mitkStdMultiWidget, mitk::DataTreeIteratorBase* it)
-: QmitkFunctionality(parent, name, it), m_MultiWidget(mitkStdMultiWidget), m_Controls(NULL)
+QmitkDiffusionTensorEstimation::QmitkDiffusionTensorEstimation(QObject *parent, const char *name,  mitk::DataTreeIteratorBase* it)
+: QmitkAbstractView(parent, name, it), m_Controls(NULL)
 {
   SetAvailability(true);
   m_FilterInitialized = false;
 }
 
 QmitkDiffusionTensorEstimation::~QmitkDiffusionTensorEstimation()
 {}
 
-QWidget * QmitkDiffusionTensorEstimation::CreateMainWidget(QWidget *parent)
-{
-  if ( m_MultiWidget == NULL )
-  {
-    m_MultiWidget = new QmitkStdMultiWidget( parent );
-  }
-  return m_MultiWidget;
-}
-
 QWidget * QmitkDiffusionTensorEstimation::CreateControlWidget(QWidget *parent)
 {
   if (m_Controls == NULL)
   {
     m_Controls = new QmitkDiffusionTensorEstimationControls(parent);
   }
 
   m_Controls->m_TensorEstimationTeemErrorImage->setChecked(false);
   m_Controls->m_TensorEstimationTeemSigmaEdit->setText("NaN");
   m_Controls->m_TensorEstimationTeemEstimationMethodCombo->insertItem("LLS (Linear Least Squares)");
   m_Controls->m_TensorEstimationTeemEstimationMethodCombo->insertItem("MLE (Maximum Likelihood)");
   m_Controls->m_TensorEstimationTeemEstimationMethodCombo->insertItem("NLS (Nonlinear Least Squares)");
   m_Controls->m_TensorEstimationTeemEstimationMethodCombo->insertItem("WLS (Weighted Least Squares)");
   m_Controls->m_TensorEstimationTeemNumItsSpin->setValue(1);
   m_Controls->m_TensorEstimationTeemConfThresholdEdit->setText("NaN");
   m_Controls->m_TensorEstimationTeemFuzzyEdit->setText("0.0");
   m_Controls->m_TensorEstimationTeemMinValEdit->setText("1.0");
 
   m_Controls->m_QBallReconstructionThreasholdEdit->setText("0.0");
   m_Controls->m_QBallStandardAlgorithmsOrderSpinbox->setValue(0);
   m_Controls->m_QBallStandardAlgorithmsProbThreshEdit->setText(QString::number(1.0/double(odfsize)));
   m_Controls->m_QBallReconstructionNumberThreadsSpinbox->setValue(4);
 
   m_Controls->m_QBallReconstructionMaxLLevelComboBox->insertItem( QString("2") );
   m_Controls->m_QBallReconstructionMaxLLevelComboBox->insertItem( QString("4") );
   m_Controls->m_QBallReconstructionMaxLLevelComboBox->insertItem( QString("6") );
   m_Controls->m_QBallReconstructionMaxLLevelComboBox->insertItem( QString("8") );
   m_Controls->m_QBallReconstructionMaxLLevelComboBox->setCurrentItem( 3 );
 
   m_Controls->m_QBallReconstructionNumberThreadsAnalyticalSpinbox->setValue(4);
   m_Controls->m_QBallReconstructionThreasholdAnalyticalEdit->setText("0.0");
   m_Controls->m_QBallReconstructionLambdaLineEdit->setText("0.006");
 
   m_Controls->m_QBallStandardAlgorithmsNumberThreadsSpinbox->setValue(4);
   m_Controls->m_QBallStandardAlgorithmsDeconvNumberThreadsSpinbox->setValue(4);
   m_Controls->m_QBallStandardAlgorithmsDeconvolutionThreshEdit->setText("0.1");
   m_Controls->m_QBallStandardAlgorithmsDeconvolutionAngResThresholdEdit->setText("15");
 
   m_Controls->m_QBallStandardAlgorithmsGFAParam1->setText("2");
   m_Controls->m_QBallStandardAlgorithmsGFAParam2->setText("1");
 
   return m_Controls;
 }
 
 void QmitkDiffusionTensorEstimation::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_TensorEstimationButton), SIGNAL(clicked()),(QObject*) this, SLOT(TensorEstimationButton()));
     connect( (QObject*)(m_Controls->m_QBallReconstructionButton), SIGNAL(clicked()),(QObject*) this, SLOT(QBallReconstructionButton()));
     connect( (QObject*)(m_Controls->m_QBallReconstructionAnalyticalButton), SIGNAL(clicked()),(QObject*) this, SLOT(QBallReconstructionAnalyticalButton()));
     connect( (QObject*)(m_Controls->m_TensorEstimationTeemEstimateButton), SIGNAL(clicked()),(QObject*) this, SLOT(TensorEstimationTeemEstimateButton()));
 
     connect( (QObject*)(m_Controls->m_TensorVolumesSaveButton), SIGNAL(clicked()),(QObject*) this, SLOT(TensorVolumesSaveButton()));
     connect( (QObject*)(m_Controls->m_TensorVolumesLoadButton), SIGNAL(clicked()),(QObject*) this, SLOT(TensorVolumesLoadButton()));
     connect( (QObject*)(m_Controls->m_TensorVolumesRemoveButton), SIGNAL(clicked()),(QObject*) this, SLOT(TensorVolumesRemoveButton()));
     connect( (QObject*)(m_Controls->m_StandardAlgorithmsFAButton), SIGNAL(clicked()),(QObject*) this, SLOT(StandardAlgorithmsFAButton()));
     connect( (QObject*)(m_Controls->m_StandardAlgorithmsRAButton), SIGNAL(clicked()),(QObject*) this, SLOT(StandardAlgorithmsRAButton()));
     connect( (QObject*)(m_Controls->m_StandardAlgorithmsDirectionButton), SIGNAL(clicked()),(QObject*) this, SLOT(StandardAlgorithmsDirectionButton()));
 
     connect( (QObject*)(m_Controls->m_QBallVolumesSaveButton), SIGNAL(clicked()),(QObject*) this, SLOT(QBallVolumesSaveButton()));
     connect( (QObject*)(m_Controls->m_QBallVolumesLoadButton), SIGNAL(clicked()),(QObject*) this, SLOT(QBallVolumesLoadButton()));
     connect( (QObject*)(m_Controls->m_QBallVolumesRemoveButton), SIGNAL(clicked()),(QObject*) this, SLOT(QBallVolumesRemoveButton()));
     connect( (QObject*)(m_Controls->m_QBallStandardAlgorithmsDirectionButton), SIGNAL(clicked()),(QObject*) this, SLOT(QBallStandardAlgorithmsDirectionButton()));
     connect( (QObject*)(m_Controls->m_QBallStandardAlgorithmsDeconvolutionButton), SIGNAL(clicked()),(QObject*) this, SLOT(QBallStandardAlgorithmsDeconvolutionButton()));
     connect( (QObject*)(m_Controls->m_QBallStandardAlgorithmsGFAButton), SIGNAL(clicked()),(QObject*) this, SLOT(QBallStandardAlgorithmsGFAButton()));
     connect( (QObject*)(m_Controls->m_QBallVolumesVisualizeSelectedButton), SIGNAL(clicked()),(QObject*) this, SLOT(QBallVolumesVisualizeSelectedButton()));
 
     connect( (QObject*)(m_Controls->m_DirectionVolumesSaveButton), SIGNAL(clicked()),(QObject*) this, SLOT(DirectionVolumesSaveButton()));
     connect( (QObject*)(m_Controls->m_DirectionVolumesLoadButton), SIGNAL(clicked()),(QObject*) this, SLOT(DirectionVolumesLoadButton()));
     connect( (QObject*)(m_Controls->m_DirectionVolumesRemoveButton), SIGNAL(clicked()),(QObject*) this, SLOT(DirectionVolumesRemoveButton()));
     connect( (QObject*)(m_Controls->m_DirectionVolumesAngularErrorButton), SIGNAL(clicked()),(QObject*) this, SLOT(DirectionVolumesAngularErrorButton()));
 
     connect( (QObject*)(m_Controls->m_DiffusionVolumesLoadButton), SIGNAL(clicked()),(QObject*) this, SLOT(DiffusionVolumesLoadButton()));
     connect( (QObject*)(m_Controls->m_DiffusionVolumeSaveButton), SIGNAL(clicked()),(QObject*) this, SLOT(DiffusionVolumeSaveButton()));
     connect( (QObject*)(m_Controls->m_DiffusionVolumesRemoveButton), SIGNAL(clicked()),(QObject*) this, SLOT(DiffusionVolumesRemoveButton()));
     connect( (QObject*)(m_Controls->m_TensorEstimationDiffusionVolumesSelectAllButton), SIGNAL(clicked()),(QObject*) this, SLOT(DiffusionVolumesSelectAll()));
 }
 }
 
 QAction * QmitkDiffusionTensorEstimation::CreateAction(QActionGroup *parent)
 {
 
   //action = new QAction( tr( "Brain Atrophy" ), pixmap, tr( "BrainAtrophy" ), 0, parent, "BrainAtrophy" );
 
   QImage icon = qembed_findImage("QmitkDiffusionTensorEstimation");
   QPixmap pixmap(icon);
   QAction* action;
   action = new QAction( tr( "Diffusion Tensor Estimation" ), pixmap, tr( "QmitkDiffusionTensorEstimation menu" ), 0, parent, "QmitkDiffusionTensorEstimation" );
   return action;
 }
 
 void QmitkDiffusionTensorEstimation::TreeChanged()
 {
   m_Controls->m_TensorEstimationDiffusionVolumesSelector->Update();
   m_Controls->m_TensorVolumesSelector->Update();
   m_Controls->m_QBallVolumesSelector->Update();
   m_Controls->m_DirectionVolumesSelector->Update();
 
   if(m_DiffusionVolumesDataTreeFilter
     &&m_DiffusionVolumesDataTreeFilter->GetItems()->Size() > 0)
   {
     m_Controls->m_TensorEstimationButton->setEnabled(true);
     m_Controls->m_QBallReconstructionButton->setEnabled(true);
     m_Controls->m_QBallReconstructionAnalyticalButton->setEnabled(true);
   }
   else
   {
     m_Controls->m_QBallReconstructionButton->setEnabled(false);
     m_Controls->m_QBallReconstructionAnalyticalButton->setEnabled(false);
     m_Controls->m_TensorEstimationButton->setEnabled(false);
   }
 
   if(m_TensorVolumesDataTreeFilter
     && m_TensorVolumesDataTreeFilter->GetItems()->Size() > 0)
   {
     m_Controls->m_TensorVolumesSaveButton->setEnabled(true);
     m_Controls->m_TensorVolumesRemoveButton->setEnabled(true);
   }
   else
   {
     m_Controls->m_TensorVolumesSaveButton->setEnabled(false);
     m_Controls->m_TensorVolumesRemoveButton->setEnabled(false);
   }
 
   if(m_QballVolumesDataTreeFilter
     && m_QballVolumesDataTreeFilter->GetItems()->Size() > 0)
   {
     m_Controls->m_QBallVolumesSaveButton->setEnabled(true);
     m_Controls->m_QBallVolumesRemoveButton->setEnabled(true);
     m_Controls->m_QBallVolumesVisualizeSelectedButton->setEnabled(true);
   }
   else
   {
     m_Controls->m_QBallVolumesSaveButton->setEnabled(false);
     m_Controls->m_QBallVolumesRemoveButton->setEnabled(false);
     m_Controls->m_QBallVolumesVisualizeSelectedButton->setEnabled(false);
   }
 
   if(m_DirectionVolumesDataTreeFilter
     && m_DirectionVolumesDataTreeFilter->GetItems()->Size() > 0)
   {
     m_Controls->m_DirectionVolumesSaveButton->setEnabled(true);
     m_Controls->m_DirectionVolumesRemoveButton->setEnabled(true);
   }
   else
   {
     m_Controls->m_DirectionVolumesSaveButton->setEnabled(false);
     m_Controls->m_DirectionVolumesRemoveButton->setEnabled(false);
   }
 
   if(m_DirectionVolumesDataTreeFilter
     && m_DirectionVolumesDataTreeFilter->GetItems()->Size() > 1)
   {
     m_Controls->m_DirectionVolumesAngularErrorButton->setEnabled(true);
   }
   else
   {
     m_Controls->m_DirectionVolumesAngularErrorButton->setEnabled(false);
   }
 }
 
 void QmitkDiffusionTensorEstimation::Activated()
 {
-  QmitkFunctionality::Activated();
-
   if (m_FilterInitialized)
     return;
 
   // diffusion volumes filter
   m_DiffusionVolumesDataTreeFilter = mitk::DataTreeFilter::New( GetDataTreeIterator()->GetTree() );
   m_DiffusionVolumesDataTreeFilter->SetSelectionMode(mitk::DataTreeFilter::MULTI_SELECT);
   m_DiffusionVolumesDataTreeFilter->SetHierarchyHandling(mitk::DataTreeFilter::FLATTEN_HIERARCHY);
   m_DiffusionVolumesDataTreeFilter->SetFilter( mitk::IsBaseDataType<mitk::DiffusionVolumes<short> >() ); // show diffusion volumes
 
   mitk::DataTreeFilter::PropertyList visible_props;
   visible_props.push_back("name");
   m_DiffusionVolumesDataTreeFilter->SetVisibleProperties(visible_props);
 
   mitk::DataTreeFilter::PropertyList property_labels;
   property_labels.push_back("Diffusion Volumes");
   m_DiffusionVolumesDataTreeFilter->SetPropertiesLabels(property_labels);
 
   m_Controls->m_TensorEstimationDiffusionVolumesSelector->SetDataTree( GetDataTreeIterator()->GetTree() );
   m_Controls->m_TensorEstimationDiffusionVolumesSelector->SetFilter( m_DiffusionVolumesDataTreeFilter );
   m_Controls->m_TensorEstimationDiffusionVolumesSelector->SetAutoUpdate( false );
   m_Controls->m_TensorEstimationDiffusionVolumesSelector->setStretchedColumn(1);
 
   // tensor volumes filter
   m_TensorVolumesDataTreeFilter = mitk::DataTreeFilter::New( GetDataTreeIterator()->GetTree() );
   m_TensorVolumesDataTreeFilter->SetSelectionMode(mitk::DataTreeFilter::SINGLE_SELECT);
   m_TensorVolumesDataTreeFilter->SetHierarchyHandling(mitk::DataTreeFilter::FLATTEN_HIERARCHY);
   m_TensorVolumesDataTreeFilter->SetFilter( mitk::IsBaseDataTypeWithBoolProperty<mitk::Image>("IsTensorVolume") ); // show tensor volumes
 
   m_TensorVolumesDataTreeFilter->SetVisibleProperties(visible_props);
 
   mitk::DataTreeFilter::PropertyList tensor_property_labels;
   tensor_property_labels.push_back("Tensor Volumes");
   m_TensorVolumesDataTreeFilter->SetPropertiesLabels(tensor_property_labels);
 
   m_Controls->m_TensorVolumesSelector->SetDataTree( GetDataTreeIterator()->GetTree() );
   m_Controls->m_TensorVolumesSelector->SetFilter( m_TensorVolumesDataTreeFilter );
   m_Controls->m_TensorVolumesSelector->SetAutoUpdate( false );
   m_Controls->m_TensorVolumesSelector->setStretchedColumn(1);
 
   // qBall volumes filter
   m_QballVolumesDataTreeFilter = mitk::DataTreeFilter::New( GetDataTreeIterator()->GetTree() );
   m_QballVolumesDataTreeFilter->SetSelectionMode(mitk::DataTreeFilter::MULTI_SELECT);
   m_QballVolumesDataTreeFilter->SetHierarchyHandling(mitk::DataTreeFilter::FLATTEN_HIERARCHY);
   m_QballVolumesDataTreeFilter->SetFilter( mitk::IsBaseDataTypeWithBoolProperty<mitk::Image>("IsQBallVolume") );
 
   m_QballVolumesDataTreeFilter->SetVisibleProperties(visible_props);
 
   mitk::DataTreeFilter::PropertyList qball_property_labels;
   qball_property_labels.push_back("Q-Ball Volumes");
   m_QballVolumesDataTreeFilter->SetPropertiesLabels(qball_property_labels);
 
   m_Controls->m_QBallVolumesSelector->SetDataTree( GetDataTreeIterator()->GetTree() );
   m_Controls->m_QBallVolumesSelector->SetFilter( m_QballVolumesDataTreeFilter );
   m_Controls->m_QBallVolumesSelector->SetAutoUpdate( false );
   m_Controls->m_QBallVolumesSelector->setStretchedColumn(1);
 
   // direction volumes filter
   m_DirectionVolumesDataTreeFilter = mitk::DataTreeFilter::New( GetDataTreeIterator()->GetTree() );
   m_DirectionVolumesDataTreeFilter->SetSelectionMode(mitk::DataTreeFilter::MULTI_SELECT);
   m_DirectionVolumesDataTreeFilter->SetHierarchyHandling(mitk::DataTreeFilter::FLATTEN_HIERARCHY);
   m_DirectionVolumesDataTreeFilter->SetFilter( mitk::IsBaseDataTypeWithBoolProperty<mitk::Image>("IsDirectionVolume") );
 
   m_DirectionVolumesDataTreeFilter->SetVisibleProperties(visible_props);
 
   mitk::DataTreeFilter::PropertyList direction_property_labels;
   direction_property_labels.push_back("Direction Volumes");
   m_DirectionVolumesDataTreeFilter->SetPropertiesLabels(direction_property_labels);
 
   m_Controls->m_DirectionVolumesSelector->SetDataTree( GetDataTreeIterator()->GetTree() );
   m_Controls->m_DirectionVolumesSelector->SetFilter( m_DirectionVolumesDataTreeFilter );
   m_Controls->m_DirectionVolumesSelector->SetAutoUpdate( false );
   m_Controls->m_DirectionVolumesSelector->setStretchedColumn(1);
 
   m_FilterInitialized = true;
 
   TreeChanged();
 
 }
 
+void QmitkDiffusionTensorEstimation::Deactivated()
+{
+}
+
+void QmitkDiffusionTensorEstimation::Visible()
+{
+}
+
+void QmitkDiffusionTensorEstimation::Hidden()
+{
+}
+
 
 void QmitkDiffusionTensorEstimation::TensorVolumesSaveButton()
 {
   // GET SELECTED ITEM
   const mitk::DataTreeFilter::Item* selectedItem
     = m_TensorVolumesDataTreeFilter->GetSelectedItem();
   if( !selectedItem )
     return;
   mitk::Image::Pointer tensorVol =
     static_cast<mitk::Image*>(selectedItem->GetNode()->GetData());
   TensorImageType::Pointer itkTensorVol =
     TensorImageType::New();
   mitk::CastToItkImage<TensorImageType>(tensorVol, itkTensorVol);
 
   // SELECT FILE DIALOG
   std::string sName = selectedItem->GetNode()->GetName();
   QString qName;
   qName.sprintf("%s.nhdr",sName.c_str());
   QString filename = QFileDialog::getSaveFileName(
     qName,
     "Nrrd Images (*.nrrd *.nhdr)",
     this->m_Controls,
     "save file dialog",
     "Select Nrrd Outputfile" );
   if ( !filename )
     return;
 
   // WRITING TENSORS TO FILE
   MBI_INFO << "Writing tensors ";
   typedef itk::ImageFileWriter<TensorImageType> TensorWriterType;
   TensorWriterType::Pointer tensorWriter = TensorWriterType::New();
   tensorWriter->SetFileName(filename.ascii());
   tensorWriter->SetInput(itkTensorVol);
   tensorWriter->Update();
 }
 
 void QmitkDiffusionTensorEstimation::TensorVolumesLoadButton()
 {
   // SELECT FOLDER DIALOG
   QFileDialog* w = new QFileDialog( this->m_Controls, "Select DWI data file", TRUE );
   w->setMode( QFileDialog::ExistingFiles );
   w->setFilter( "Nrrd Images (*.nrrd *.nhdr)" );
 
   // RETRIEVE SELECTION
   if ( w->exec() != QDialog::Accepted )
     return;
 
   QStringList filenames = w->selectedFiles();
   QStringList::Iterator it = filenames.begin();
   while( it != filenames.end() ) {
     std::string filename = ( *it ).ascii();
     ++it;
 
     // READING TENSOR VOLUME
     typedef itk::ImageFileReader<TensorImageType> ReaderType;
     ReaderType::Pointer tensorReader = ReaderType::New();
     tensorReader->SetFileName(filename);
     try
     {
       tensorReader->Update();
     }
     catch (itk::ExceptionObject e)
     {
       std::cout << e << std::endl;
     }
 
     // Tensorvolume
     mitk::Image::Pointer image = mitk::Image::New();
     image->InitializeByItk( tensorReader->GetOutput() );
     image->SetVolume( tensorReader->GetOutput()->GetBufferPointer() );
     mitk::DataNode::Pointer node=mitk::DataNode::New();
     node->SetData( image );
     mitk::DataStorage::GetInstance()->Add(node);
     SetDefaultNodeProperties(node, itksys::SystemTools::GetFilenameName(filename));
     node->SetProperty( "IsTensorVolume", mitk::BoolProperty::New( true ) );
 
     TreeChanged();
   }
 }
 
 void QmitkDiffusionTensorEstimation::TensorVolumesRemoveButton()
 {
   m_TensorVolumesDataTreeFilter->DeleteSelectedItems();
 }
 
 void QmitkDiffusionTensorEstimation::QBallVolumesSaveButton()
 {
   // GET SELECTED ITEM
   const mitk::DataTreeFilter::Item* selectedItem
     = m_QballVolumesDataTreeFilter->GetSelectedItem();
   if( !selectedItem ) return;
 
   mitk::Image::Pointer qBallVol =
     static_cast<mitk::Image*>(selectedItem->GetNode()->GetData());
   if( !qBallVol)return;
 
   typedef itk::Image<itk::Vector<TTensorPixelType,odfsize>,3 > IType;
   IType::Pointer itkQBallVol = IType::New();
   mitk::CastToItkImage<IType>(qBallVol, itkQBallVol);
 
   typedef itk::VectorImage<TTensorPixelType, 3> VarVecImgType;
   VarVecImgType::Pointer vecImg = VarVecImgType::New();
   vecImg->SetSpacing( itkQBallVol->GetSpacing() );   // Set the image spacing
   vecImg->SetOrigin( itkQBallVol->GetOrigin() );     // Set the image origin
   vecImg->SetDirection( itkQBallVol->GetDirection() );  // Set the image direction
   vecImg->SetLargestPossibleRegion( itkQBallVol->GetLargestPossibleRegion());
   vecImg->SetBufferedRegion( itkQBallVol->GetLargestPossibleRegion() );
   vecImg->SetVectorLength(odfsize);
   vecImg->Allocate();
   itk::ImageRegionIterator<VarVecImgType> ot (vecImg, vecImg->GetLargestPossibleRegion() );
   ot = ot.Begin();
 
   itk::ImageRegionIterator<IType> it (itkQBallVol, itkQBallVol->GetLargestPossibleRegion() );
   it = it.Begin();
   MBI_DEBUG << it.Get();
   for (it = it.Begin(); !it.IsAtEnd(); ++it)
   {
     itk::Vector<TTensorPixelType,odfsize> vec = it.Get();
     VarVecImgType::PixelType varvec(vec.GetDataPointer(), odfsize);
     ot.Set(varvec);
     ++ot;
   }
 
   // SELECT FILE DIALOG
   std::string sName = selectedItem->GetNode()->GetName();
   QString qName;
   qName.sprintf("%s.nhdr",sName.c_str());
   QString filename = QFileDialog::getSaveFileName(
     qName,
     "Nrrd Images (*.nrrd *.nhdr)",
     this->m_Controls,
     "save file dialog",
     "Select Nrrd Outputfile" );
   if ( !filename )
     return;
 
   // WRITING TENSORS TO FILE
   MBI_INFO << "Writing data ";
   typedef itk::ImageFileWriter<VarVecImgType> QBallWriterType;
   QBallWriterType::Pointer qballWriter = QBallWriterType::New();
   qballWriter->SetFileName(filename.ascii());
   qballWriter->SetInput(vecImg);
   qballWriter->Update();
 }
 
 void QmitkDiffusionTensorEstimation::QBallVolumesLoadButton()
 {
   // SELECT FOLDER DIALOG
   QFileDialog* w = new QFileDialog( this->m_Controls, "Select DWI data file", TRUE );
   w->setMode( QFileDialog::ExistingFiles );
   w->setFilter( "Nrrd Images (*.nrrd *.nhdr)" );
 
   // RETRIEVE SELECTION
   if ( w->exec() != QDialog::Accepted )
     return;
 
   QStringList filenames = w->selectedFiles();
   QStringList::Iterator it = filenames.begin();
   while( it != filenames.end() ) {
     std::string filename = ( *it ).ascii();
     ++it;
 
     // READING TENSOR VOLUME
     typedef itk::Image<itk::Vector<TTensorPixelType,odfsize>,3 > IVType;
     typedef itk::ImageFileReader<IVType> ReaderType;
     ReaderType::Pointer qballReader = ReaderType::New();
     qballReader->SetFileName(filename);
     try
     {
       qballReader->Update();
     }
     catch (itk::ExceptionObject e)
     {
       MBI_LOG << e;
     }
 
     //itk::ImageRegionConstIterator<IVType> it (qballReader->GetOutput(), qballReader->GetOutput()->GetLargestPossibleRegion() );
     //it = it.Begin();
     //std::cout << it.Get() << std::endl;
 
     // Tensorvolume
     mitk::Image::Pointer image = mitk::Image::New();
     image->InitializeByItk( qballReader->GetOutput() );
     image->SetVolume( qballReader->GetOutput()->GetBufferPointer() );
     mitk::DataNode::Pointer node=mitk::DataNode::New();
     node->SetData( image );
     mitk::DataStorage::GetInstance()->Add(node);
     SetDefaultNodeProperties(node, itksys::SystemTools::GetFilenameName(filename));
     node->SetProperty( "IsQBallVolume", mitk::BoolProperty::New( true ) );
     node->SetProperty( "visible", mitk::BoolProperty::New( false ) );
 
     TreeChanged();
   }
 }
 
 void QmitkDiffusionTensorEstimation::QBallVolumesRemoveButton()
 {
   m_QballVolumesDataTreeFilter->DeleteSelectedItems();
 }
 
 void QmitkDiffusionTensorEstimation::QBallVolumesVisualizeSelectedButton()
 {
   itk::TimeProbe clock;
   QString status;
   const mitk::DataTreeFilter::Item* item
     = m_QballVolumesDataTreeFilter->GetSelectedItem();
   if(!item)return;
 
   typedef itk::Vector<TTensorPixelType,odfsize> OdfVectorType;
   typedef itk::Image<OdfVectorType,3> OdfVectorImgType;
   mitk::Image* vol =
     static_cast<mitk::Image*>(item->GetNode()->GetData());
   OdfVectorImgType::Pointer itkvol = OdfVectorImgType::New();
   mitk::CastToItkImage<OdfVectorImgType>(vol, itkvol);
   std::string nodename = item->GetProperty("name");
 
   // PREPARE FOR VISUALIZATION
   clock.Start();
   MBI_INFO << "Preparing for Visualization ";
   mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
     "Preparing for Visualization of %s", nodename.c_str()));
   typedef itk::DiffusionQballPrepareVisualizationImageFilter<TTensorPixelType,odfsize>
     FilterType;
   FilterType::Pointer filter = FilterType::New();
   filter->SetInput(itkvol);
   filter->SetNumberOfThreads(4);
 
   switch(m_Controls->m_QBallVolumesVisualizeNormalizationMethod->currentItem())
   {
   case 0:
     {
       filter->SetNormalizationMethod(FilterType::PV_MIN_MAX);
       break;
     }
   case 1:
     {
       filter->SetNormalizationMethod(FilterType::PV_NONE);
       break;
     }
   case 2:
     {
       filter->SetNormalizationMethod(FilterType::PV_MAX);
       break;
     }
   case 3:
     {
       filter->SetNormalizationMethod(FilterType::PV_GLOBAL_MAX);
       break;
     }
   case 4:
     {
       filter->SetNormalizationMethod(FilterType::PV_MIN_MAX_INVERT);
       break;
     }
   default:
     {
       filter->SetNormalizationMethod(FilterType::PV_MIN_MAX);
       break;
     }
   }
 
   if(m_Controls->m_QBallVolumesVisualizeScaleGfaCheckbox->isChecked() )
   {
     typedef itk::DiffusionQballGeneralizedFaImageFilter<TTensorPixelType,TTensorPixelType,odfsize>
       GfaFilterType;
     filter->SetDoScaleGfa(true);
     float p1 = m_Controls->m_QBallStandardAlgorithmsGFAParam1->text().toFloat();
     float p2 = m_Controls->m_QBallStandardAlgorithmsGFAParam2->text().toFloat();
     switch(m_Controls->m_QBallStandardAlgorithmsGFAMethod->currentItem())
     {
     case 0:
       filter->SetScaleByGfaType(GfaFilterType::GFA_STANDARD);
       break;
     case 1:
       filter->SetScaleByGfaType(GfaFilterType::GFA_QUANTILES_HIGH_LOW);
       break;
     case 2:
       filter->SetScaleByGfaType(GfaFilterType::GFA_QUANTILE_HIGH);
       break;
     case 3:
       filter->SetScaleByGfaType(GfaFilterType::GFA_MAX_ODF_VALUE);
       break;
     case 4:
       filter->SetScaleByGfaType(GfaFilterType::GFA_DECONVOLUTION_COEFFS);
       break;
     case 5:
       filter->SetScaleByGfaType(GfaFilterType::GFA_MIN_MAX_NORMALIZED_STANDARD);
       break;
     case 6:
       filter->SetScaleByGfaType(GfaFilterType::GFA_NORMALIZED_ENTROPY);
       break;
     case 7:
       filter->SetScaleByGfaType(GfaFilterType::GFA_NEMATIC_ORDER_PARAMETER);
       break;
     case 8:
       filter->SetScaleByGfaType(GfaFilterType::GFA_QUANTILES_LOW_HIGH);
       break;
     case 9:
       filter->SetScaleByGfaType(GfaFilterType::GFA_QUANTILE_LOW);
       break;
     case 10:
       filter->SetScaleByGfaType(GfaFilterType::GFA_MIN_ODF_VALUE);
       break;
     case 11:
       filter->SetScaleByGfaType(GfaFilterType::GFA_STD_BY_MAX);
       break;
     case 12:
       filter->SetScaleByGfaType(GfaFilterType::GFA_PRINCIPLE_CURVATURE);
       filter->SetGfaParam1(p1);
       break;
     case 13:
       filter->SetScaleByGfaType(GfaFilterType::GFA_GENERALIZED_GFA);
       filter->SetGfaParam1(p1);
       filter->SetGfaParam2(p2);
       break;
     default:
       filter->SetScaleByGfaType(GfaFilterType::GFA_STANDARD);
     }
   }
   filter->Update();
   clock.Stop();
   MBI_DEBUG << "took " << clock.GetMeanTime() << "s.";
 
   // VIZ TO DATATREE
   mitk::Image::Pointer image = mitk::Image::New();
   image->InitializeByItk( filter->GetOutput() );
   image->SetVolume( filter->GetOutput()->GetBufferPointer() );
   mitk::DataNode::Pointer node=mitk::DataNode::New();
   node->SetData( image );
   mitk::DataStorage::GetInstance()->Add(node);
   SetDefaultNodeProperties(node, nodename.append(" Viz"));
   node->SetProperty( "IsQBallVolume", mitk::BoolProperty::New( true ) );
   node->SetProperty( "ShowMaxNumber", mitk::IntProperty::New( 1500 ) );
   node->SetProperty( "DoRefresh", mitk::BoolProperty::New( true ) );
   node->SetProperty( "layer", mitk::IntProperty::New( 1 ) );
   node->SetProperty( "global_scaling", mitk::FloatProperty::New( 1.0 ) );
   mitk::OdfVtkMapper2D<TTensorPixelType,odfsize>::Pointer odfMapper =
     mitk::OdfVtkMapper2D<TTensorPixelType,odfsize>::New();
   node->SetMapper(1,odfMapper);
 
   mitk::StatusBar::GetInstance()->DisplayText("Computation complete.");
 
   m_DataTreeIterator->GetTree()->Modified();
-  m_MultiWidget->RequestUpdate();
+  this->GetRenderWindowPart()->RequestUpdate();
   TreeChanged();
   m_Controls->update();
 
 }
 
 void QmitkDiffusionTensorEstimation::DirectionVolumesSaveButton()
 {
   // GET SELECTED ITEM
   const mitk::DataTreeFilter::Item* selectedItem
     = m_DirectionVolumesDataTreeFilter->GetSelectedItem();
   if( !selectedItem ) return;
 
   mitk::Image::Pointer vol =
     static_cast<mitk::Image*>(selectedItem->GetNode()->GetData());
   if( !vol)return;
 
   typedef itk::Image<itk::Vector<TTensorPixelType,3>,3 > IType;
   IType::Pointer itkVol = IType::New();
   mitk::CastToItkImage<IType>(vol, itkVol);
 
   typedef itk::VectorImage<TTensorPixelType, 3> VarVecImgType;
   VarVecImgType::Pointer vecImg = VarVecImgType::New();
   vecImg->SetSpacing( itkVol->GetSpacing() );   // Set the image spacing
   vecImg->SetOrigin( itkVol->GetOrigin() );     // Set the image origin
   vecImg->SetDirection( itkVol->GetDirection() );  // Set the image direction
   vecImg->SetLargestPossibleRegion( itkVol->GetLargestPossibleRegion());
   vecImg->SetBufferedRegion( itkVol->GetLargestPossibleRegion() );
   vecImg->SetVectorLength(3);
   vecImg->Allocate();
   itk::ImageRegionIterator<VarVecImgType> ot (vecImg, vecImg->GetLargestPossibleRegion() );
   ot = ot.Begin();
 
   itk::ImageRegionIterator<IType> it (itkVol, itkVol->GetLargestPossibleRegion() );
   it = it.Begin();
   for (it = it.Begin(); !it.IsAtEnd(); ++it)
   {
     itk::Vector<TTensorPixelType,3> vec = it.Get();
     VarVecImgType::PixelType varvec(vec.GetDataPointer(), 3);
     ot.Set(varvec);
     ++ot;
   }
 
   // SELECT FILE DIALOG
   std::string sName = selectedItem->GetNode()->GetName();
   QString qName;
   qName.sprintf("%s.nhdr",sName.c_str());
   QString filename = QFileDialog::getSaveFileName(
     qName,
     "Nrrd Images (*.nrrd *.nhdr)",
     this->m_Controls,
     "save file dialog",
     "Select Nrrd Outputfile" );
   if ( !filename )
     return;
 
   // WRITING TENSORS TO FILE
   MBI_INFO << "Writing data ";
   typedef itk::ImageFileWriter<VarVecImgType> WriterType;
   WriterType::Pointer writer = WriterType::New();
   writer->SetFileName(filename.ascii());
   writer->SetInput(vecImg);
   writer->Update();
 }
 
 void QmitkDiffusionTensorEstimation::DirectionVolumesLoadButton()
 {
   // SELECT FOLDER DIALOG
   QFileDialog* w = new QFileDialog( this->m_Controls, "Select DWI data file", TRUE );
   w->setMode( QFileDialog::ExistingFiles );
   w->setFilter( "Nrrd Images (*.nrrd *.nhdr)" );
 
   // RETRIEVE SELECTION
   if ( w->exec() != QDialog::Accepted )
     return;
 
   QStringList filenames = w->selectedFiles();
   QStringList::Iterator it = filenames.begin();
   while( it != filenames.end() ) {
     std::string filename = ( *it ).ascii();
     ++it;
 
     // READING VOLUME
     typedef itk::Image<itk::Vector<TTensorPixelType,3>,3 > IType;
     typedef itk::ImageFileReader<IType> ReaderType;
     ReaderType::Pointer reader = ReaderType::New();
     reader->SetFileName(filename);
     try
     {
       reader->Update();
     }
     catch (itk::ExceptionObject e)
     {
       MBI_INFO << e << std::endl;
     }
 
     // Tensorvolume
     mitk::Image::Pointer image = mitk::Image::New();
     image->InitializeByItk( reader->GetOutput() );
     image->SetVolume( reader->GetOutput()->GetBufferPointer() );
     mitk::DataNode::Pointer node=mitk::DataNode::New();
     node->SetData( image );
     mitk::DataStorage::GetInstance()->Add(node);
     SetDefaultNodeProperties(node, itksys::SystemTools::GetFilenameName(filename));
     node->SetProperty( "IsDirectionVolume", mitk::BoolProperty::New( true ) );
 
     mitk::VectorImageMapper2D::Pointer mapper =
       mitk::VectorImageMapper2D::New();
     node->SetMapper(1,mapper);
 
     TreeChanged();
   }
 }
 
 void QmitkDiffusionTensorEstimation::DirectionVolumesRemoveButton()
 {
   m_DirectionVolumesDataTreeFilter->DeleteSelectedItems();
 }
 
 void QmitkDiffusionTensorEstimation::TensorEstimationTeemEstimateButton()
 {
   try
   {
     itk::TimeProbe clock;
 
     const mitk::DataTreeFilter::ItemSet* selectedItems
       = m_DiffusionVolumesDataTreeFilter->GetSelectedItems();
 
 
     int nrFiles = selectedItems->size();
     if (!nrFiles) return;
 
     QString status;
     mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles);
 
     mitk::DataTreeFilter::ItemSet::const_iterator itemiter( selectedItems->begin() );
     mitk::DataTreeFilter::ItemSet::const_iterator itemiterend( selectedItems->end() );
 
     std::vector<mitk::DataNode::Pointer> nodes;
     while ( itemiter != itemiterend ) // for all items
     {
 
       mitk::DiffusionVolumes<DiffusionPixelType>* vols =
         static_cast<mitk::DiffusionVolumes<DiffusionPixelType>*>(
         (*itemiter)->GetNode()->GetData());
 
       std::string nodename = (*itemiter)->GetProperty("name");
       itemiter++;
 
       // TENSOR RECONSTRUCTION
       clock.Start();
       MBI_INFO << "Teem Tensor reconstruction ";
       mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
         "Teem Tensor reconstruction for %s", nodename.c_str()));
       typedef mitk::TeemDiffusionTensor3DReconstructionImageFilter<
         DiffusionPixelType, TTensorPixelType > TensorReconstructionImageFilterType;
       TensorReconstructionImageFilterType::Pointer tensorReconstructionFilter =
         TensorReconstructionImageFilterType::New();
       tensorReconstructionFilter->SetInput( vols );
       tensorReconstructionFilter->SetEstimateErrorImage( m_Controls->m_TensorEstimationTeemErrorImage->isChecked() );
       if(!m_Controls->m_TensorEstimationTeemSigmaEdit->text().contains(QString("NaN")))
         tensorReconstructionFilter->SetSigma( m_Controls->m_TensorEstimationTeemSigmaEdit->text().toFloat() );
       switch(m_Controls->m_TensorEstimationTeemEstimationMethodCombo->currentItem())
       {
       case 0:
         tensorReconstructionFilter->SetEstimationMethod(mitk::TeemTensorEstimationMethodsLLS);
         break;
       case 1:
         tensorReconstructionFilter->SetEstimationMethod(mitk::TeemTensorEstimationMethodsNLS);
         break;
       case 2:
         tensorReconstructionFilter->SetEstimationMethod(mitk::TeemTensorEstimationMethodsWLS);
         break;
       case 3:
         tensorReconstructionFilter->SetEstimationMethod(mitk::TeemTensorEstimationMethodsMLE);
         break;
       default:
         tensorReconstructionFilter->SetEstimationMethod(mitk::TeemTensorEstimationMethodsLLS);
       }
       tensorReconstructionFilter->SetNumIterations( m_Controls->m_TensorEstimationTeemNumItsSpin->value() );
       if(!m_Controls->m_TensorEstimationTeemConfThresholdEdit->text().contains(QString("NaN")))
         tensorReconstructionFilter->SetConfidenceThreshold( m_Controls->m_TensorEstimationTeemConfThresholdEdit->text().toDouble() );
       tensorReconstructionFilter->SetConfidenceFuzzyness( m_Controls->m_TensorEstimationTeemFuzzyEdit->text().toFloat() );
       tensorReconstructionFilter->SetMinPlausibleValue( m_Controls->m_TensorEstimationTeemMinValEdit->text().toDouble() );
       tensorReconstructionFilter->Update();
       clock.Stop();
       MBI_DEBUG << "took " << clock.GetMeanTime() << "s.";
 
       // TENSORS TO DATATREE
       //mitk::DataNode::Pointer node=mitk::DataNode::New();
       //node->SetData( tensorReconstructionFilter->GetOutput() );
       //mitk::DataStorage::GetInstance()->Add(node);
       //SetDefaultNodeProperties(node, nodename.append(" tensors"));
       //node->SetProperty( "IsConfidenceTensorVolume", mitk::BoolProperty::New( true ) );
 
       mitk::DataNode::Pointer node2=mitk::DataNode::New();
       node2->SetData( tensorReconstructionFilter->GetOutputItk() );
       SetDefaultNodeProperties(node2, nodename.append(" (itk)"));
       node2->SetProperty( "IsTensorVolume", mitk::BoolProperty::New( true ) );
       nodes.push_back(node2);
 
       mitk::ProgressBar::GetInstance()->Progress();
 
     }
 
     std::vector<mitk::DataNode::Pointer>::iterator nodeIt;
     for(nodeIt = nodes.begin(); nodeIt != nodes.end(); ++nodeIt)
       mitk::DataStorage::GetInstance()->Add(*nodeIt);
 
     mitk::ProgressBar::GetInstance()->Progress();
     TreeChanged();
     m_Controls->update();
 
     mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles));
 
   }
   catch (itk::ExceptionObject &ex)
   {
     MBI_INFO << ex;
     return ;
   }
 }
 
 void QmitkDiffusionTensorEstimation::TensorEstimationButton()
 {
   try
   {
     itk::TimeProbe clock;
 
     const mitk::DataTreeFilter::ItemSet* selectedItems
       = m_DiffusionVolumesDataTreeFilter->GetSelectedItems();
 
     int nrFiles = selectedItems->size();
     if (!nrFiles) return;
 
     QString status;
     mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles);
 
     mitk::DataTreeFilter::ItemSet::const_iterator itemiter( selectedItems->begin() );
     mitk::DataTreeFilter::ItemSet::const_iterator itemiterend( selectedItems->end() );
 
     std::vector<mitk::DataNode::Pointer> nodes;
     while ( itemiter != itemiterend ) // for all items
     {
 
       mitk::DiffusionVolumes<DiffusionPixelType>* vols =
         static_cast<mitk::DiffusionVolumes<DiffusionPixelType>*>(
         (*itemiter)->GetNode()->GetData());
 
       std::string nodename = (*itemiter)->GetProperty("name");
       itemiter++;
 
       // TENSOR RECONSTRUCTION
       clock.Start();
       MBI_INFO << "Tensor reconstruction ";
       mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
         "Tensor reconstruction for %s", nodename.c_str()));
       typedef itk::DiffusionTensor3DReconstructionImageFilter<
         DiffusionPixelType, DiffusionPixelType, TTensorPixelType > TensorReconstructionImageFilterType;
       TensorReconstructionImageFilterType::Pointer tensorReconstructionFilter =
         TensorReconstructionImageFilterType::New();
       tensorReconstructionFilter->SetGradientImage( vols->GetDirections(), vols->GetImage() );
       tensorReconstructionFilter->SetNumberOfThreads( m_Controls->m_TensorEstimationNumberThreadsSpinbox->value() );
       tensorReconstructionFilter->SetBValue(vols->GetB_Value());
       tensorReconstructionFilter->SetThreshold( m_Controls->m_TensorEstimationThreasholdEdit->text().toFloat() );
       tensorReconstructionFilter->Update();
       clock.Stop();
       MBI_DEBUG << "took " << clock.GetMeanTime() << "s.";
 
       // TENSORS TO DATATREE
       mitk::Image::Pointer image = mitk::Image::New();
       image->InitializeByItk( tensorReconstructionFilter->GetOutput() );
       image->SetVolume( tensorReconstructionFilter->GetOutput()->GetBufferPointer() );
       mitk::DataNode::Pointer node=mitk::DataNode::New();
       node->SetData( image );
       SetDefaultNodeProperties(node, nodename.append(" tensors"));
       node->SetProperty( "IsTensorVolume", mitk::BoolProperty::New( true ) );
       nodes.push_back(node);
 
       mitk::ProgressBar::GetInstance()->Progress();
 
     }
 
     std::vector<mitk::DataNode::Pointer>::iterator nodeIt;
     for(nodeIt = nodes.begin(); nodeIt != nodes.end(); ++nodeIt)
       mitk::DataStorage::GetInstance()->Add(*nodeIt);
 
     mitk::ProgressBar::GetInstance()->Progress();
     TreeChanged();
     m_Controls->update();
 
     mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles));
 
   }
   catch (itk::ExceptionObject &ex)
   {
     MBI_INFO << ex;
     return ;
   }
 }
 
 void QmitkDiffusionTensorEstimation::QBallReconstructionButton()
 {
   try
   {
     itk::TimeProbe clock;
 
     const mitk::DataTreeFilter::ItemSet* selectedItems
       = m_DiffusionVolumesDataTreeFilter->GetSelectedItems();
 
     int nrFiles = selectedItems->size();
     if (!nrFiles) return;
 
     QString status;
     mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles);
 
     mitk::DataTreeFilter::ItemSet::const_iterator itemiter( selectedItems->begin() );
     mitk::DataTreeFilter::ItemSet::const_iterator itemiterend( selectedItems->end() );
 
     std::vector<mitk::DataNode::Pointer> nodes;
     while ( itemiter != itemiterend ) // for all items
     {
 
       mitk::DiffusionVolumes<DiffusionPixelType>* vols =
         static_cast<mitk::DiffusionVolumes<DiffusionPixelType>*>(
         (*itemiter)->GetNode()->GetData());
 
       std::string nodename = (*itemiter)->GetProperty("name");
       ++itemiter;
 
       // QBALL RECONSTRUCTION
       clock.Start();
       MBI_INFO << "QBall reconstruction ";
       mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
         "QBall reconstruction for %s", nodename.c_str()));
 
       typedef itk::DiffusionQballReconstructionImageFilter<
         DiffusionPixelType, DiffusionPixelType, TTensorPixelType, odfsize>
         //int NOdfDirections = 162,
         QballReconstructionImageFilterType;
       QballReconstructionImageFilterType::Pointer filter =
         QballReconstructionImageFilterType::New();
       filter->SetGradientImage( vols->GetDirections(), vols->GetImage() );
       filter->SetNumberOfThreads( m_Controls->m_QBallReconstructionNumberThreadsSpinbox->value() );
       filter->SetBValue(vols->GetB_Value());
       filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdEdit->text().toFloat() );
 
       int normalization = m_Controls->m_QBallReconstructionPostprocessingMethod->currentItem();
       switch(normalization)
       {
       case 0:
         {
           filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_STANDARD);
           break;
         }
       case 1:
         {
           filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_B_ZERO_B_VALUE);
           break;
         }
       case 2:
         {
           filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_B_ZERO);
           break;
         }
       case 3:
         {
           filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_NONE);
           break;
         }
       default:
         {
           filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_STANDARD);
         }
       }
 
       filter->Update();
       clock.Stop();
       MBI_DEBUG << "took " << clock.GetMeanTime() << "s." << std::endl;
 
       // ODFs TO DATATREE
       mitk::Image::Pointer image = mitk::Image::New();
       image->InitializeByItk( filter->GetOutput() );
       //image->SetImportVolume( filter->GetOutput()->GetBufferPointer(), 0, 0, mitk::Image::ImportMemoryManagementType::ManageMemory );
       image->SetVolume( filter->GetOutput()->GetBufferPointer() );
       mitk::DataNode::Pointer node=mitk::DataNode::New();
       node->SetData( image );
       QString newname;
       newname = newname.append(nodename.c_str());
       newname = newname.append("_QN%1").arg(normalization);
       SetDefaultNodeProperties(node, newname.ascii());
       node->SetProperty( "IsQBallVolume", mitk::BoolProperty::New( true ) );
       nodes.push_back(node);
 
       // B-Zero TO DATATREE
       mitk::Image::Pointer image4 = mitk::Image::New();
       image4->InitializeByItk( filter->GetBZeroImage().GetPointer() );
       image4->SetVolume( filter->GetBZeroImage()->GetBufferPointer() );
       mitk::DataNode::Pointer node4=mitk::DataNode::New();
       node4->SetData( image4 );
       SetDefaultNodeProperties(node4, nodename.append("B0"));
       nodes.push_back(node4);
 
       mitk::ProgressBar::GetInstance()->Progress();
 
     }
 
     std::vector<mitk::DataNode::Pointer>::iterator nodeIt;
     for(nodeIt = nodes.begin(); nodeIt != nodes.end(); ++nodeIt)
       mitk::DataStorage::GetInstance()->Add(*nodeIt);
 
     mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles));
     m_DataTreeIterator->GetTree()->Modified();
-    m_MultiWidget->RequestUpdate();
+    this->GetRenderWindowPart()->RequestUpdate();
     TreeChanged();
     m_Controls->update();
 
   }
   catch (itk::ExceptionObject &ex)
   {
     MBI_INFO << ex;
     return ;
   }
 }
 
 template<int L>
 void QmitkDiffusionTensorEstimation::ReconstructAnalytically(
   mitk::DiffusionVolumes<DiffusionPixelType>* vols, float lambda,
   std::string nodename, std::vector<mitk::DataNode::Pointer>* nodes)
 {
   typedef itk::AnalyticalDiffusionQballReconstructionImageFilter
     <DiffusionPixelType,DiffusionPixelType,TTensorPixelType,L,odfsize> FilterType;
   typename FilterType::Pointer filter = FilterType::New();
   filter->SetGradientImage( vols->GetDirections(), vols->GetImage() );
   filter->SetNumberOfThreads( m_Controls->m_QBallReconstructionNumberThreadsAnalyticalSpinbox->value() );
   filter->SetBValue(vols->GetB_Value());
   filter->SetThreshold( m_Controls->m_QBallReconstructionThreasholdAnalyticalEdit->text().toFloat() );
   filter->SetLambda(lambda);
   filter->SetAdcProfileOnly(m_Controls->m_QBallReconstructionAdcOnlyCheckbox->isChecked());
   int normalization = m_Controls->m_QBallReconstructionPostprocessingMethodAnalytical->currentItem();
   switch(normalization)
   {
   case 0:
     {
       filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
       break;
     }
   case 1:
     {
       filter->SetNormalizationMethod(FilterType::QBAR_B_ZERO_B_VALUE);
       break;
     }
   case 2:
     {
       filter->SetNormalizationMethod(FilterType::QBAR_B_ZERO);
       break;
     }
   case 3:
     {
       filter->SetNormalizationMethod(FilterType::QBAR_NONE);
       break;
     }
   default:
     {
       filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
     }
   }
 
   filter->Update();
 
   // ODFs TO DATATREE
   mitk::Image::Pointer image = mitk::Image::New();
   image->InitializeByItk( filter->GetOutput() );
   image->SetVolume( filter->GetOutput()->GetBufferPointer() );
   mitk::DataNode::Pointer node=mitk::DataNode::New();
   node->SetData( image );
   nodes->push_back(node);
   QString newname;
   newname = newname.append(nodename.c_str());
   newname = newname.append("_QA%1").arg(normalization);
   SetDefaultNodeProperties(node, newname.ascii());
   node->SetProperty( "IsQBallVolume", mitk::BoolProperty::New( true ) );
 
   // B-Zero TO DATATREE
   mitk::Image::Pointer image4 = mitk::Image::New();
   image4->InitializeByItk( filter->GetBZeroImage().GetPointer() );
   image4->SetVolume( filter->GetBZeroImage()->GetBufferPointer() );
   mitk::DataNode::Pointer node4=mitk::DataNode::New();
   node4->SetData( image4 );
   nodes->push_back(node4);
   SetDefaultNodeProperties(node4, nodename.append("B0"));
 
 }
 
 void QmitkDiffusionTensorEstimation::QBallReconstructionAnalyticalButton()
 {
   try
   {
     itk::TimeProbe clock;
 
     const mitk::DataTreeFilter::ItemSet* selectedItems
       = m_DiffusionVolumesDataTreeFilter->GetSelectedItems();
 
     int nrFiles = selectedItems->size();
     if (!nrFiles) return;
 
     std::vector<float> lambdas;
     float minLambda  = m_Controls->m_QBallReconstructionLambdaLineEdit->text().toFloat();
     if(m_Controls->m_QBallReconstructionLambdaMultiCheckbox->isChecked())
     {
       float stepLambda = m_Controls->m_QBallReconstructionLambdaStepLineEdit->text().toFloat();
       float maxLambda  = m_Controls->m_QBallReconstructionLambdaMaxLineEdit->text().toFloat();
       for(float l=minLambda; l<maxLambda; l+=stepLambda)
       {
         lambdas.push_back(l);
       }
     }
     int nLambdas = lambdas.size();
     if(nLambdas == 0)
     {
       lambdas.push_back(minLambda);
       nLambdas = 1;
     }
 
     QString status;
     mitk::ProgressBar::GetInstance()->AddStepsToDo(nrFiles*nLambdas);
 
     mitk::DataTreeFilter::ItemSet::const_iterator itemiter( selectedItems->begin() );
     mitk::DataTreeFilter::ItemSet::const_iterator itemiterend( selectedItems->end() );
 
     std::vector<mitk::DataNode::Pointer>* nodes
       = new std::vector<mitk::DataNode::Pointer>();
     while ( itemiter != itemiterend ) // for all items
     {
 
       mitk::DiffusionVolumes<DiffusionPixelType>* vols =
         static_cast<mitk::DiffusionVolumes<DiffusionPixelType>*>(
         (*itemiter)->GetNode()->GetData());
 
       std::string nodename = (*itemiter)->GetProperty("name");
       itemiter++;
 
       // QBALL RECONSTRUCTION
       clock.Start();
       MBI_INFO << "QBall reconstruction ";
       mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
         "QBall reconstruction for %s", nodename.c_str()));
 
       for(int i=0; i<nLambdas; i++)
       {
 
         float currentLambda = lambdas[i];
 
         switch(m_Controls->m_QBallReconstructionMaxLLevelComboBox->currentItem())
         {
         case 0:
           {
             ReconstructAnalytically<2>(vols, currentLambda, nodename, nodes);
             break;
           }
         case 1:
           {
             ReconstructAnalytically<4>(vols, currentLambda, nodename, nodes);
             break;
           }
         case 2:
           {
             ReconstructAnalytically<6>(vols, currentLambda, nodename, nodes);
             break;
           }
         case 3:
           {
             ReconstructAnalytically<8>(vols, currentLambda, nodename, nodes);
             break;
           }
         }
 
         clock.Stop();
         MBI_DEBUG << "took " << clock.GetMeanTime() << "s.";
         mitk::ProgressBar::GetInstance()->Progress();
 
       }
     }
 
     std::vector<mitk::DataNode::Pointer>::iterator nodeIt;
     for(nodeIt = nodes->begin(); nodeIt != nodes->end(); ++nodeIt)
       mitk::DataStorage::GetInstance()->Add(*nodeIt);
 
     m_DataTreeIterator->GetTree()->Modified();
-    m_MultiWidget->RequestUpdate();
+    this->GetRenderWindowPart()->RequestUpdate();
     TreeChanged();
     m_Controls->update();
 
     mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished Processing %d Files", nrFiles));
 
   }
   catch (itk::ExceptionObject &ex)
   {
     MBI_INFO << ex;
     return ;
   }
 }
 
 void QmitkDiffusionTensorEstimation::StandardAlgorithmsFAButton()
 {
   itk::TimeProbe clock;
   QString status;
   const mitk::DataTreeFilter::Item* item
     = m_TensorVolumesDataTreeFilter->GetSelectedItem();
   if(!item)return;
 
   mitk::Image* vol =
     static_cast<mitk::Image*>(item->GetNode()->GetData());
   itk::Image<TensorPixelType, 3>::Pointer itkvol = itk::Image<TensorPixelType, 3>::New();
   mitk::CastToItkImage<TensorImageType>(vol, itkvol);
   std::string nodename = item->GetProperty("name");
 
   // COMPUTE FA
   clock.Start();
   MBI_INFO << "Computing FA ";
   mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
     "Computing FA for %s", nodename.c_str()));
   typedef TensorPixelType::RealValueType                 RealValueType;
   typedef itk::Image< RealValueType, 3 >                 FAImageType;
   typedef itk::TensorFractionalAnisotropyImageFilter<
     TensorImageType, FAImageType >                       FAFilterType;
   FAFilterType::Pointer fractionalAnisotropyFilter = FAFilterType::New();
   fractionalAnisotropyFilter->SetInput( itkvol );
 
   typedef itk::ShiftScaleImageFilter<FAImageType, FAImageType>
     ShiftScaleFilterType;
   ShiftScaleFilterType::Pointer multi =
     ShiftScaleFilterType::New();
   multi->SetShift(0);
   multi->SetScale(200);//itk::NumericTraits<RealValueType>::max()
   multi->SetInput(fractionalAnisotropyFilter->GetOutput());
   multi->Update();
   clock.Stop();
   MBI_DEBUG << "took " << clock.GetMeanTime() << "s.";
 
   // FA TO DATATREE
   mitk::Image::Pointer image = mitk::Image::New();
   image->InitializeByItk( multi->GetOutput() );
   image->SetVolume( multi->GetOutput()->GetBufferPointer() );
   mitk::DataNode::Pointer node=mitk::DataNode::New();
   node->SetData( image );
   mitk::DataStorage::GetInstance()->Add(node);
   SetDefaultNodeProperties(node, nodename.append(" FA"));
   node->SetProperty( "IsFAVolume", mitk::BoolProperty::New( true ) );
 
   mitk::StatusBar::GetInstance()->DisplayText("Computation complete.");
 
   m_DataTreeIterator->GetTree()->Modified();
-  m_MultiWidget->RequestUpdate();
+  this->GetRenderWindowPart()->RequestUpdate();
   TreeChanged();
   m_Controls->update();
 }
 
 void QmitkDiffusionTensorEstimation::StandardAlgorithmsRAButton()
 {
   itk::TimeProbe clock;
   QString status;
   const mitk::DataTreeFilter::Item* item
     = m_TensorVolumesDataTreeFilter->GetSelectedItem();
   if(!item)return;
 
   mitk::Image* vol =
     static_cast<mitk::Image*>(item->GetNode()->GetData());
   itk::Image<TensorPixelType, 3>::Pointer itkvol = itk::Image<TensorPixelType, 3>::New();
   mitk::CastToItkImage<TensorImageType>(vol, itkvol);
   std::string nodename = item->GetProperty("name");
 
   // COMPUTE RA
   clock.Start();
   MBI_INFO << "Computing RA ";
   mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
     "Computing RA for %s", nodename.c_str()));
   typedef TensorPixelType::RealValueType                 RealValueType;
   typedef itk::Image< RealValueType, 3 >                 RAImageType;
   typedef itk::TensorRelativeAnisotropyImageFilter<
     TensorImageType, RAImageType >                       RAFilterType;
   RAFilterType::Pointer relativeAnisotropyFilter = RAFilterType::New();
   relativeAnisotropyFilter->SetInput( itkvol );
   relativeAnisotropyFilter->Update();
   clock.Stop();
   MBI_DEBUG << "took " << clock.GetMeanTime() << "s.";
 
   // FA TO DATATREE
   mitk::Image::Pointer image = mitk::Image::New();
   image->InitializeByItk( relativeAnisotropyFilter->GetOutput() );
   image->SetVolume( relativeAnisotropyFilter->GetOutput()->GetBufferPointer() );
   mitk::DataNode::Pointer node=mitk::DataNode::New();
   node->SetData( image );
   mitk::DataStorage::GetInstance()->Add(node);
   SetDefaultNodeProperties(node, nodename.append(" RA"));
   node->SetProperty( "IsRAVolume", mitk::BoolProperty::New( true ) );
 
   mitk::StatusBar::GetInstance()->DisplayText("Computation complete.");
 
   m_DataTreeIterator->GetTree()->Modified();
-  m_MultiWidget->RequestUpdate();
+  this->GetRenderWindowPart()->RequestUpdate();
   TreeChanged();
   m_Controls->update();
 
 }
 
 void QmitkDiffusionTensorEstimation::StandardAlgorithmsDirectionButton()
 {
 
     itk::TimeProbe clock;
   QString status;
   const mitk::DataTreeFilter::Item* item
     = m_TensorVolumesDataTreeFilter->GetSelectedItem();
   if(!item)return;
 
   typedef itk::DiffusionTensor3D<TTensorPixelType> TensorType;
   typedef itk::Image<TensorType,3> TensorImgType;
   mitk::Image* vol =
     static_cast<mitk::Image*>(item->GetNode()->GetData());
   TensorImgType::Pointer itkvol = TensorImgType::New();
   mitk::CastToItkImage<TensorImgType>(vol, itkvol);
   std::string nodename = item->GetProperty("name");
 
   clock.Start();
   MBI_INFO << "Computing Diffusion Direction ";
   mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
     "Computing Diffusion Direction for %s", nodename.c_str()));
 
   typedef itk::DiffusionTensorPrincipleDirectionImageFilter<TTensorPixelType,TTensorPixelType>
     FilterType;
   FilterType::Pointer filter
     = FilterType::New();
   filter->SetInput(itkvol);
   filter->SetNumberOfThreads(4);
   filter->Update();
   itk::ImageRegionIterator<FilterType::OutputImageType>
     it (filter->GetOutput(),
     filter->GetOutput()->GetLargestPossibleRegion() );
   it = it.Begin();
 
   // VECTORFIELD
   MBI_DEBUG << "Converting to Vectorfield";
 
   typedef itk::Image<itk::Vector<TTensorPixelType,3>, 3> VecImgType2;
   VecImgType2::Pointer vecImg5 = VecImgType2::New();
   vecImg5->SetSpacing( itkvol->GetSpacing() );   // Set the image spacing
   vecImg5->SetOrigin( itkvol->GetOrigin() );     // Set the image origin
   vecImg5->SetDirection( itkvol->GetDirection() );  // Set the image direction
   vecImg5->SetLargestPossibleRegion( itkvol->GetLargestPossibleRegion());
   vecImg5->SetBufferedRegion( vecImg5->GetLargestPossibleRegion() );
   vecImg5->Allocate();
   itk::ImageRegionIterator<VecImgType2> ot5 (vecImg5, vecImg5->GetLargestPossibleRegion() );
   ot5 = ot5.Begin();
 
   typedef FilterType::OutputImageType::PixelType VecPixType;
   for (it = it.Begin(); !it.IsAtEnd(); ++it)
   {
     VecPixType vec = it.Get();
     itk::Vector<TTensorPixelType,3> pix;
     TTensorPixelType uvec[3] = {(TTensorPixelType)(vec[0]),(TTensorPixelType)(vec[1]),(TTensorPixelType)(vec[2])};
     //TTensorPixelType uvec[3] = {(TTensorPixelType)(vec[1]),(TTensorPixelType)(-vec[0]),(TTensorPixelType)(vec[2])};
     pix = uvec;
     ot5.Set(pix);
     ++ot5;
   }
 
   // Vectors TO DATATREE
   mitk::Image::Pointer image5 = mitk::Image::New();
   image5->InitializeByItk( vecImg5.GetPointer() );
   image5->SetVolume( vecImg5->GetBufferPointer() );
   mitk::DataNode::Pointer node5=mitk::DataNode::New();
   node5->SetData( image5 );
   node5->SetName( nodename.append(" vecs").c_str());
   mitk::DataStorage::GetInstance()->Add(node5);
 
   node5->SetProperty( "IsDirectionVolume", mitk::BoolProperty::New( true ) );
   node5->SetProperty( "NormalizeVecs", mitk::BoolProperty::New( true ) );
   node5->SetProperty( "Scale", mitk::FloatProperty::New( 1.0 ) );
   node5->SetProperty( "LineWidth", mitk::FloatProperty::New( 1 ) );
 
   mitk::VectorImageMapper2D::Pointer vecMapper5 =
     mitk::VectorImageMapper2D::New();
   node5->SetMapper(1,vecMapper5);
 
   m_DataTreeIterator->GetTree()->Modified();
-  m_MultiWidget->RequestUpdate();
+  this->GetRenderWindowPart()->RequestUpdate();
   TreeChanged();
   m_Controls->update();
 
 }
 
 void QmitkDiffusionTensorEstimation::QBallStandardAlgorithmsGFAButton()
 {
   itk::TimeProbe clock;
   QString status;
 
   const mitk::DataTreeFilter::ItemSet* selectedItems
     = m_QballVolumesDataTreeFilter->GetSelectedItems();
 
   int nrFiles = selectedItems->size();
   if (!nrFiles) return;
 
   mitk::DataTreeFilter::ItemSet::const_iterator itemiter( selectedItems->begin() );
   mitk::DataTreeFilter::ItemSet::const_iterator itemiterend( selectedItems->end() );
 
   std::vector<mitk::DataNode::Pointer> nodes;
   while ( itemiter != itemiterend ) // for all items
   {
 
     typedef itk::Vector<TTensorPixelType,odfsize> OdfVectorType;
     typedef itk::Image<OdfVectorType,3> OdfVectorImgType;
     mitk::Image* vol =
       static_cast<mitk::Image*>((*itemiter)->GetNode()->GetData());
     OdfVectorImgType::Pointer itkvol = OdfVectorImgType::New();
     mitk::CastToItkImage<OdfVectorImgType>(vol, itkvol);
 
     std::string nodename = (*itemiter)->GetProperty("name");
     ++itemiter;
 
     float p1 = m_Controls->m_QBallStandardAlgorithmsGFAParam1->text().toFloat();
     float p2 = m_Controls->m_QBallStandardAlgorithmsGFAParam2->text().toFloat();
 
     // COMPUTE RA
     clock.Start();
     MBI_INFO << "Computing GFA ";
     mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
       "Computing GFA for %s", nodename.c_str()));
     typedef OdfVectorType::ValueType                 RealValueType;
     typedef itk::Image< RealValueType, 3 >                 RAImageType;
     typedef itk::DiffusionQballGeneralizedFaImageFilter<TTensorPixelType,TTensorPixelType,odfsize>
       GfaFilterType;
     GfaFilterType::Pointer gfaFilter = GfaFilterType::New();
     gfaFilter->SetInput(itkvol);
     gfaFilter->SetNumberOfThreads(4);
 
     double scale = 1;
     std::string newname;
     newname.append(nodename);
     newname.append(" GFA");
     switch(m_Controls->m_QBallStandardAlgorithmsGFAMethod->currentItem())
     {
     case 0:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_STANDARD);
         newname.append("00");
         scale = 200.0;
         break;
       }
     case 1:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_QUANTILES_HIGH_LOW);
         newname.append("01");
         scale = 200.0;
         break;
       }
     case 2:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_QUANTILE_HIGH);
         newname.append("02");
         scale = 200.0;
         break;
       }
     case 3:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_MAX_ODF_VALUE);
         newname.append("03");
         scale = 200.0;
         break;
       }
     case 4:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_DECONVOLUTION_COEFFS);
         newname.append("04");
         scale = 200.0;
         break;
       }
     case 5:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_MIN_MAX_NORMALIZED_STANDARD);
         newname.append("05");
         scale = 200.0;
         break;
       }
     case 6:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_NORMALIZED_ENTROPY);
         newname.append("06");
         break;
       }
     case 7:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_NEMATIC_ORDER_PARAMETER);
         newname.append("07");
         scale = 200.0;
         break;
       }
     case 8:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_QUANTILES_LOW_HIGH);
         newname.append("08");
         scale = 200.0;
         break;
       }
     case 9:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_QUANTILE_LOW);
         newname.append("09");
         scale = 200.0;
         break;
       }
     case 10:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_MIN_ODF_VALUE);
         newname.append("10");
         scale = 200.0;
         break;
       }
     case 11:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_STD_BY_MAX);
         newname.append("11");
         scale = 200.0;
         break;
       }
     case 12:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_PRINCIPLE_CURVATURE);
         newname.append("12");
         gfaFilter->SetParam1(p1);
         scale = 200.0;
         break;
       }
     case 13:
       {
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_GENERALIZED_GFA);
         QString paramString;
         paramString = paramString.append(" K%1P%2").arg(p1).arg(p2);
         newname.append("13").append(paramString.ascii());
         gfaFilter->SetParam1(p1);
         gfaFilter->SetParam2(p2);
         scale = 200.0;
         break;
       }
     default:
       {
         newname.append("0");
         gfaFilter->SetComputationMethod(GfaFilterType::GFA_STANDARD);
         scale = 200.0;
       }
     }
     gfaFilter->Update();
     clock.Stop();
     MBI_DEBUG << "took " << clock.GetMeanTime() << "s.";
 
     typedef itk::Image<TTensorPixelType, 3> ImgType;
     ImgType::Pointer img = ImgType::New();
     img->SetSpacing( gfaFilter->GetOutput()->GetSpacing() );   // Set the image spacing
     img->SetOrigin( gfaFilter->GetOutput()->GetOrigin() );     // Set the image origin
     img->SetDirection( gfaFilter->GetOutput()->GetDirection() );  // Set the image direction
     img->SetLargestPossibleRegion( gfaFilter->GetOutput()->GetLargestPossibleRegion());
     img->SetBufferedRegion( gfaFilter->GetOutput()->GetLargestPossibleRegion() );
     img->Allocate();
     itk::ImageRegionIterator<ImgType> ot (img, img->GetLargestPossibleRegion() );
     ot = ot.Begin();
     itk::ImageRegionConstIterator<GfaFilterType::OutputImageType> it
       (gfaFilter->GetOutput(), gfaFilter->GetOutput()->GetLargestPossibleRegion() );
     it = it.Begin();
 
     for (it = it.Begin(); !it.IsAtEnd(); ++it)
     {
       GfaFilterType::OutputImageType::PixelType val = it.Get();
       ot.Set(val * scale);
       ++ot;
     }
 
 
     // GFA TO DATATREE
     mitk::Image::Pointer image = mitk::Image::New();
     image->InitializeByItk( img.GetPointer() );
     image->SetVolume( img->GetBufferPointer() );
     mitk::DataNode::Pointer node=mitk::DataNode::New();
     node->SetData( image );
     nodes.push_back(node);
     SetDefaultNodeProperties(node, newname.c_str());
     node->SetProperty( "IsGFAVolume", mitk::BoolProperty::New( true ) );
 
     mitk::StatusBar::GetInstance()->DisplayText("Computation complete.");
 
   }
 
   std::vector<mitk::DataNode::Pointer>::iterator nodeIt;
   for(nodeIt = nodes.begin(); nodeIt != nodes.end(); ++nodeIt)
     mitk::DataStorage::GetInstance()->Add(*nodeIt);
 
   m_DataTreeIterator->GetTree()->Modified();
-  m_MultiWidget->RequestUpdate();
+  this->GetRenderWindowPart()->RequestUpdate();
   TreeChanged();
   m_Controls->update();
 
 }
 
 void QmitkDiffusionTensorEstimation::QBallStandardAlgorithmsDirectionButton()
 {
 
   itk::TimeProbe clock;
   QString status;
   const mitk::DataTreeFilter::Item* item
     = m_QballVolumesDataTreeFilter->GetSelectedItem();
   if(!item)return;
 
   typedef itk::Vector<TTensorPixelType,odfsize> OdfVectorType;
   typedef itk::Image<OdfVectorType,3> OdfVectorImgType;
   mitk::Image* vol =
     static_cast<mitk::Image*>(item->GetNode()->GetData());
   OdfVectorImgType::Pointer itkvol = OdfVectorImgType::New();
   mitk::CastToItkImage<OdfVectorImgType>(vol, itkvol);
   std::string nodename = item->GetProperty("name");
 
   clock.Start();
   MBI_INFO << "Computing Diffusion Direction ";
   mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
     "Computing Diffusion Direction for %s", nodename.c_str()));
 
   typedef itk::DiffusionQballGeneralizedFaImageFilter<TTensorPixelType,TTensorPixelType,odfsize>
     GfaFilterType;
   GfaFilterType::Pointer gfaFilter = GfaFilterType::New();
   gfaFilter->SetInput(itkvol);
   gfaFilter->SetNumberOfThreads(4);
   gfaFilter->Update();
   itk::ImageRegionIterator<GfaFilterType::OutputImageType>
     itGfa (gfaFilter->GetOutput(),
     gfaFilter->GetOutput()->GetLargestPossibleRegion() );
   itGfa = itGfa.Begin();
 
   int numdir = m_Controls->m_QBallStandardAlgorithmsOrderSpinbox->value();
 
   typedef itk::DiffusionQballPrincipleDirectionsImageFilter<TTensorPixelType,TTensorPixelType,odfsize>
     PrincipleDirectionsFilterType;
   PrincipleDirectionsFilterType::Pointer principleDirectionsFilter
     = PrincipleDirectionsFilterType::New();
   principleDirectionsFilter->SetThreshold(m_Controls->m_QBallStandardAlgorithmsProbThreshEdit->text().toFloat());
   principleDirectionsFilter->SetNrDirectionToExtract(numdir);
   principleDirectionsFilter->SetInput(itkvol);
   principleDirectionsFilter->SetNumberOfThreads(m_Controls->m_QBallStandardAlgorithmsNumberThreadsSpinbox->value());
   principleDirectionsFilter->SetMultiplyGfa(false);
   principleDirectionsFilter->Update();
 
   itk::ImageRegionIterator<PrincipleDirectionsFilterType::OutputImageType>
     it (principleDirectionsFilter->GetOutput(),
     principleDirectionsFilter->GetOutput()->GetLargestPossibleRegion() );
 
   if(numdir == 0)
   {
 
     MBI_INFO << "Converting to RGB";
 
     typedef itk::Image<itk::RGBPixel<uchar>, 3> VecImgType;
     VecImgType::Pointer vecImg = VecImgType::New();
     vecImg->SetSpacing( itkvol->GetSpacing() );   // Set the image spacing
     vecImg->SetOrigin( itkvol->GetOrigin() );     // Set the image origin
     vecImg->SetDirection( itkvol->GetDirection() );  // Set the image direction
     vecImg->SetLargestPossibleRegion( itkvol->GetLargestPossibleRegion());
     vecImg->SetBufferedRegion( vecImg->GetLargestPossibleRegion() );
     vecImg->Allocate();
     itk::ImageRegionIterator<VecImgType> ot (vecImg, vecImg->GetLargestPossibleRegion() );
     ot = ot.Begin();
 
     typedef PrincipleDirectionsFilterType::OutputImageType::PixelType VecPixType;
     for (it = it.Begin(); !it.IsAtEnd(); ++it)
     {
       VecPixType vec = it.Get();
 
       itk::RGBPixel<uchar> pix;
       vec*=200*itGfa.Get();
       vec[0] = abs(vec[0]);
       vec[1] = abs(vec[1]);
       vec[2] = abs(vec[2]);
       if(vec[0] > 255 || vec[1] > 255 || vec[2] > 255)
       {
         // should never get in here
         double max = vec[0];
         max = max<vec[1] ? vec[1] : max;
         max = max<vec[2] ? vec[2] : max;
         vec /= max/255;
       }
       uchar uvec[3] = {(uchar)(vec[0]),(uchar)(vec[1]),(uchar)(vec[2])};
       pix = uvec;
       ot.Set(pix);
       ++ot;
       ++itGfa;
     }
 
     // RGB TO DATATREE
     mitk::Image::Pointer image2 = mitk::Image::New();
     image2->InitializeByItk( vecImg.GetPointer() );
     image2->SetVolume( vecImg->GetBufferPointer() );
     mitk::DataNode::Pointer node2=mitk::DataNode::New();
     node2->SetData( image2 );
     mitk::DataStorage::GetInstance()->Add(node2);
     switch(numdir)
     {
     case 0:
       {
         SetDefaultNodeProperties(node2, nodename.append(" PD0"));
         break;
       }
     case 1:
       {
         SetDefaultNodeProperties(node2, nodename.append(" PD1"));
       }
     case 2:
       {
         SetDefaultNodeProperties(node2, nodename.append(" PD2"));
       }
     default:
       {
         SetDefaultNodeProperties(node2, nodename.append(" PDn"));
       }
     }
 
     node2->SetProperty( "IsRGBVolume", mitk::BoolProperty::New( true ) );
 
   }
 
   // VECTORFIELD
   MBI_DEBUG << "Converting to Vectorfield";
 
   typedef itk::Image<itk::Vector<TTensorPixelType,3>, 3> VecImgType2;
   VecImgType2::Pointer vecImg5 = VecImgType2::New();
   vecImg5->SetSpacing( itkvol->GetSpacing() );   // Set the image spacing
   vecImg5->SetOrigin( itkvol->GetOrigin() );     // Set the image origin
   vecImg5->SetDirection( itkvol->GetDirection() );  // Set the image direction
   vecImg5->SetLargestPossibleRegion( itkvol->GetLargestPossibleRegion());
   vecImg5->SetBufferedRegion( vecImg5->GetLargestPossibleRegion() );
   vecImg5->Allocate();
   itk::ImageRegionIterator<VecImgType2> ot5 (vecImg5, vecImg5->GetLargestPossibleRegion() );
   ot5 = ot5.Begin();
 
   typedef PrincipleDirectionsFilterType::OutputImageType::PixelType VecPixType;
   for (it = it.Begin(); !it.IsAtEnd(); ++it)
   {
     VecPixType vec = it.Get();
     itk::Vector<TTensorPixelType,3> pix;
     TTensorPixelType uvec[3] = {(TTensorPixelType)(vec[0]),(TTensorPixelType)(vec[1]),(TTensorPixelType)(vec[2])};
     pix = uvec;
     ot5.Set(pix);
     ++ot5;
   }
 
   // Vectors TO DATATREE
   mitk::Image::Pointer image5 = mitk::Image::New();
   image5->InitializeByItk( vecImg5.GetPointer() );
   image5->SetVolume( vecImg5->GetBufferPointer() );
   mitk::DataNode::Pointer node5=mitk::DataNode::New();
   node5->SetData( image5 );
   mitk::DataStorage::GetInstance()->Add(node5);
   switch(numdir)
   {
   case 0:
     {
       SetDefaultNodeProperties(node5, nodename.append(" Vec0"));
       break;
     }
   case 1:
     {
       SetDefaultNodeProperties(node5, nodename.append(" Vec1"));
     }
   case 2:
     {
       SetDefaultNodeProperties(node5, nodename.append(" Vec2"));
     }
   default:
     {
       SetDefaultNodeProperties(node5, nodename.append(" Vecn"));
     }
   }
   node5->SetProperty( "IsDirectionVolume", mitk::BoolProperty::New( true ) );
   node5->SetProperty( "NormalizeVecs", mitk::BoolProperty::New( true ) );
   node5->SetProperty( "Scale", mitk::FloatProperty::New( 0.8 ) );
   node5->SetProperty( "LineWidth", mitk::FloatProperty::New( 3 ) );
 
   mitk::VectorImageMapper2D::Pointer vecMapper5 =
     mitk::VectorImageMapper2D::New();
   node5->SetMapper(1,vecMapper5);
 
   m_DataTreeIterator->GetTree()->Modified();
-  m_MultiWidget->RequestUpdate();
+  this->GetRenderWindowPart()->RequestUpdate();
   TreeChanged();
   m_Controls->update();
 
 }
 
 void QmitkDiffusionTensorEstimation::QBallStandardAlgorithmsDeconvolutionButton()
 {
 
   itk::TimeProbe clock;
   QString status;
   const mitk::DataTreeFilter::Item* item
     = m_QballVolumesDataTreeFilter->GetSelectedItem();
   if(!item)return;
 
   typedef itk::Vector<TTensorPixelType,odfsize> OdfVectorType;
   typedef itk::Image<OdfVectorType,3> OdfVectorImgType;
   mitk::Image* vol =
     static_cast<mitk::Image*>(item->GetNode()->GetData());
   OdfVectorImgType::Pointer itkvol = OdfVectorImgType::New();
   mitk::CastToItkImage<OdfVectorImgType>(vol, itkvol);
   std::string nodename = item->GetProperty("name");
 
   clock.Start();
   MBI_INFO << "Computing Diffusion Direction ";
   mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
     "Computing Diffusion Direction for %s", nodename.c_str()));
 
   typedef itk::DiffusionQballGeneralizedFaImageFilter<TTensorPixelType,TTensorPixelType,odfsize>
     GfaFilterType;
   GfaFilterType::Pointer gfaFilter = GfaFilterType::New();
   gfaFilter->SetInput(itkvol);
   gfaFilter->SetNumberOfThreads(4);
   gfaFilter->Update();
   itk::ImageRegionIterator<GfaFilterType::OutputImageType>
     itGfa (gfaFilter->GetOutput(),
     gfaFilter->GetOutput()->GetLargestPossibleRegion() );
   itGfa = itGfa.Begin();
 
   int numdirs = m_Controls->m_QBallStandardAlgorithmsDeconvolutionSpinbox->value();
 
   //vnl_matrix_fixed<double, nrconvkernels, odfsize>* kernels
   //  = new vnl_matrix_fixed<double, nrconvkernels, odfsize>();
   //itk::ImageRegionIterator<OdfVectorImgType> inIt(itkvol, itkvol->GetLargestPossibleRegion());
   //inIt.GoToBegin();
   //for(int i=0; i<nrconvkernels; i++)
   //{
   //  OdfVectorImgType::PixelType vec = inIt.Get();
   //  for(int j=0; j<odfsize; j++)
   //  {
   //    (*kernels)(i,j) = vec[j];
   //  }
   //  ++inIt;
   //}
 
   typedef itk::DiffusionQballSphericalDeconvolutionImageFilter<TTensorPixelType,TTensorPixelType,odfsize,nrconvkernels>
     DeconvolutionFilterType;
   DeconvolutionFilterType::Pointer devonvolutionFilter
     = DeconvolutionFilterType::New();
   devonvolutionFilter->SetFractionalThreshold(m_Controls->m_QBallStandardAlgorithmsDeconvolutionThreshEdit->text().toFloat());
   if(!m_Controls->m_QBallStandardAlgorithmsDeconvolutionAngResThresholdEdit->text().contains(QString("NaN")))
   {
     float angRes = m_Controls->m_QBallStandardAlgorithmsDeconvolutionAngResThresholdEdit->text().toFloat();
     angRes /= 360/DIFF_EST_PI;
     devonvolutionFilter->SetAngularResolutionThreshold(angRes);
   }
   devonvolutionFilter->SetSamplingQuantileStart(m_Controls->m_QBallStandardAlgorithmsDeconvQuantStart->text().toFloat());
   devonvolutionFilter->SetSamplingQuantileStep(m_Controls->m_QBallStandardAlgorithmsDeconvQuantStep->text().toFloat());
   devonvolutionFilter->SetMinimumNumberOfSamples(m_Controls->m_QBallStandardAlgorithmsDeconvQuantMinNr->text().toInt());
   devonvolutionFilter->SetIterateQuantiles(m_Controls->m_QBallStandardAlgorithmsDeconvQuantMulti->isChecked());
   devonvolutionFilter->SetNrDirectionsToExtract(numdirs);
   devonvolutionFilter->SetInput(itkvol);
   devonvolutionFilter->SetNumberOfThreads(m_Controls->m_QBallStandardAlgorithmsDeconvNumberThreadsSpinbox->value());
   devonvolutionFilter->SetGfaImage(gfaFilter->GetOutput());
   //devonvolutionFilter->SetPresetConvolutionKernels(kernels);
   devonvolutionFilter->Update();
 
   for(int i=0; i<numdirs; i++)
   {
     itk::ImageRegionIterator<DeconvolutionFilterType::OutputImageType>
       it (devonvolutionFilter->GetOutput(i),
       devonvolutionFilter->GetOutput()->GetLargestPossibleRegion() );
     it = it.Begin();
 
     if(i==0)
     {
       MBI_INFO << "Converting to RGB";
 
       typedef itk::Image<itk::RGBPixel<uchar>, 3> VecImgType;
       VecImgType::Pointer vecImg = VecImgType::New();
       vecImg->SetSpacing( itkvol->GetSpacing() );   // Set the image spacing
       vecImg->SetOrigin( itkvol->GetOrigin() );     // Set the image origin
       vecImg->SetDirection( itkvol->GetDirection() );  // Set the image direction
       vecImg->SetLargestPossibleRegion( itkvol->GetLargestPossibleRegion());
       vecImg->SetBufferedRegion( vecImg->GetLargestPossibleRegion() );
       vecImg->Allocate();
       itk::ImageRegionIterator<VecImgType> ot (vecImg, vecImg->GetLargestPossibleRegion() );
       ot = ot.Begin();
 
       typedef DeconvolutionFilterType::OutputImageType::PixelType VecPixType;
       for (it = it.Begin(); !it.IsAtEnd(); ++it)
       {
         VecPixType vec = it.Get();
         vnl_vector_fixed<TTensorPixelType, 3> vnlvec = vec.GetVnlVector();
         TTensorPixelType len = vnlvec.two_norm();
         vnlvec = vnlvec.normalize();
 
         itk::RGBPixel<uchar> pix;
         vnlvec*=200*itGfa.Get();
         vnlvec[0] = abs(vnlvec[0]);
         vnlvec[1] = abs(vnlvec[1]);
         vnlvec[2] = abs(vnlvec[2]);
         if(vnlvec[0] > 255 || vnlvec[1] > 255 || vnlvec[2] > 255)
         {
           //should never get in here
           double max = vnlvec[0];
           max = max<vnlvec[1] ? vnlvec[1] : max;
           max = max<vnlvec[2] ? vnlvec[2] : max;
           vnlvec /= max/255;
         }
         uchar uvec[3] = {(uchar)(vnlvec[0]),(uchar)(vnlvec[1]),(uchar)(vnlvec[2])};
         pix = uvec;
         ot.Set(pix);
         ++ot;
         ++itGfa;
       }
 
       // RGB TO DATATREE
       mitk::Image::Pointer image2 = mitk::Image::New();
       image2->InitializeByItk( vecImg.GetPointer() );
       image2->SetVolume( vecImg->GetBufferPointer() );
       mitk::DataNode::Pointer node2=mitk::DataNode::New();
       node2->SetData( image2 );
       mitk::DataStorage::GetInstance()->Add(node2);
       switch(i)
       {
       case 0:
         {
           SetDefaultNodeProperties(node2, nodename.append(" PD0"));
           break;
         }
       case 1:
         {
           SetDefaultNodeProperties(node2, nodename.append(" PD1"));
           break;
         }
       case 2:
         {
           SetDefaultNodeProperties(node2, nodename.append(" PD2"));
           break;
         }
       default:
         {
           SetDefaultNodeProperties(node2, nodename.append(" PDn"));
           break;
         }
       }
 
       node2->SetProperty( "IsRGBVolume", mitk::BoolProperty::New( true ) );
     }
 
     // VECTORFIELD
     MBI_INFO << "Converting to Vectorfield";
 
     typedef itk::Image<itk::Vector<TTensorPixelType,3>, 3> VecImgType2;
     VecImgType2::Pointer vecImg5 = VecImgType2::New();
     vecImg5->SetSpacing( itkvol->GetSpacing() );   // Set the image spacing
     vecImg5->SetOrigin( itkvol->GetOrigin() );     // Set the image origin
     vecImg5->SetDirection( itkvol->GetDirection() );  // Set the image direction
     vecImg5->SetLargestPossibleRegion( itkvol->GetLargestPossibleRegion());
     vecImg5->SetBufferedRegion( vecImg5->GetLargestPossibleRegion() );
     vecImg5->Allocate();
     itk::ImageRegionIterator<VecImgType2> ot5 (vecImg5, vecImg5->GetLargestPossibleRegion() );
     ot5 = ot5.Begin();
 
     typedef DeconvolutionFilterType::OutputImageType::PixelType VecPixType;
     for (it = it.Begin(); !it.IsAtEnd(); ++it)
     {
       VecPixType vec = it.Get();
       vnl_vector_fixed<TTensorPixelType, 3> vnlvec = vec.GetVnlVector();
       vnlvec = vnlvec.normalize();
 
       itk::Vector<TTensorPixelType,3> pix;
       TTensorPixelType uvec[3] = {(TTensorPixelType)(vnlvec[0]),(TTensorPixelType)(vnlvec[1]),(TTensorPixelType)(vnlvec[2])};
       pix = uvec;
       ot5.Set(pix);
       ++ot5;
     }
 
     // Vectors TO DATATREE
     mitk::Image::Pointer image5 = mitk::Image::New();
     image5->InitializeByItk( vecImg5.GetPointer() );
     image5->SetVolume( vecImg5->GetBufferPointer() );
     mitk::DataNode::Pointer node5=mitk::DataNode::New();
     node5->SetData( image5 );
     mitk::DataStorage::GetInstance()->Add(node5);
     switch(i)
     {
     case 0:
       {
         SetDefaultNodeProperties(node5, nodename.append(" Vec0"));
         break;
       }
     case 1:
       {
         SetDefaultNodeProperties(node5, nodename.append(" Vec1"));
         break;
       }
     case 2:
       {
         SetDefaultNodeProperties(node5, nodename.append(" Vec2"));
         break;
       }
     default:
       {
         SetDefaultNodeProperties(node5, nodename.append(" Vecn"));
         break;
       }
     }
     node5->SetProperty( "IsDirectionVolume", mitk::BoolProperty::New( true ) );
     node5->SetProperty( "NormalizeVecs", mitk::BoolProperty::New( true ) );
     node5->SetProperty( "Scale", mitk::FloatProperty::New( 0.8 ) );
     node5->SetProperty( "LineWidth", mitk::FloatProperty::New( 3 ) );
 
     mitk::VectorImageMapper2D::Pointer vecMapper5 =
       mitk::VectorImageMapper2D::New();
     node5->SetMapper(1,vecMapper5);
   }
   m_DataTreeIterator->GetTree()->Modified();
-  m_MultiWidget->RequestUpdate();
+  this->GetRenderWindowPart()->RequestUpdate();
   TreeChanged();
   m_Controls->update();
 
 }
 
 void QmitkDiffusionTensorEstimation::SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name)
 {
   node->SetProperty( "volumerendering", mitk::BoolProperty::New( false ) );
   node->SetProperty( "use color", mitk::BoolProperty::New( true ) );
   node->SetProperty( "texture interpolation", mitk::BoolProperty::New( true ) );
   node->SetProperty( "reslice interpolation", mitk::VtkResliceInterpolationProperty::New() );
   node->SetProperty( "layer", mitk::IntProperty::New(0));
   node->SetProperty( "in plane resample extent by geometry", mitk::BoolProperty::New( false ) );
   node->SetOpacity(1.0f);
   node->SetColor(1.0,1.0,1.0);
   node->SetVisibility(true);
 
   mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
   mitk::LevelWindow levelwindow;
   //  levelwindow.SetAuto( image );
   levWinProp->SetLevelWindow( levelwindow );
   node->GetPropertyList()->SetProperty( "levelwindow", levWinProp );
 
   // add a default rainbow lookup table for color mapping
   if(!node->GetProperty("LookupTable"))
   {
     mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New();
     vtkLookupTable* vtkLut = mitkLut->GetVtkLookupTable();
     vtkLut->SetHueRange(0.6667, 0.0);
     vtkLut->SetTableRange(0.0, 20.0);
     vtkLut->Build();
     mitk::LookupTableProperty::Pointer mitkLutProp = mitk::LookupTableProperty::New();
     mitkLutProp->SetLookupTable(mitkLut);
     node->SetProperty( "LookupTable", mitkLutProp );
   }
   if(!node->GetProperty("binary"))
     node->SetProperty( "binary", mitk::BoolProperty::New( false ) );
 
   // add a default transfer function
   mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
   node->SetProperty ( "TransferFunction", mitk::TransferFunctionProperty::New ( tf.GetPointer() ) );
 
   // set foldername as string property
   mitk::StringProperty::Pointer nameProp = mitk::StringProperty::New( name );
   node->SetProperty( "name", nameProp );
 }
 
 void QmitkDiffusionTensorEstimation::DirectionVolumesAngularErrorButton()
 {
   try
   {
 
     const mitk::DataTreeFilter::ItemSet* selectedItems
       = m_DirectionVolumesDataTreeFilter->GetSelectedItems();
     int nrFiles = selectedItems->size();
     if (nrFiles != 2) return;
 
     mitk::DataTreeFilter::ItemSet::const_iterator itemiter( selectedItems->begin() );
 
     mitk::Image::Pointer vol1 =
       static_cast<mitk::Image*>((*itemiter)->GetNode()->GetData());
     if( !vol1)return;
     std::string nodename1 = (*itemiter)->GetProperty("name");
 
     itemiter++;
 
     mitk::Image::Pointer vol2 =
       static_cast<mitk::Image*>((*itemiter)->GetNode()->GetData());
     if( !vol2)return;
     std::string nodename2 = (*itemiter)->GetProperty("name");
 
     typedef itk::Image<itk::Vector<TTensorPixelType,3>,3 > IType;
     IType::Pointer itkVol1 = IType::New();
     mitk::CastToItkImage<IType>(vol1, itkVol1);
 
     IType::Pointer itkVol2 = IType::New();
     mitk::CastToItkImage<IType>(vol2, itkVol2);
 
     typedef itk::VectorImagesAngularErrorImageFilter<TTensorPixelType,3> FilterType;
     FilterType::Pointer filter = FilterType::New();
     filter->SetInput(itkVol1);
     filter->SetImage2(itkVol2.GetPointer());
     filter->SetNumberOfThreads(4);
     filter->Update();
 
     // Angluar Error TO DATATREE
     mitk::Image::Pointer image = mitk::Image::New();
     image->InitializeByItk( filter->GetOutput() );
     image->SetVolume( filter->GetOutput()->GetBufferPointer() );
     mitk::DataNode::Pointer node=mitk::DataNode::New();
     node->SetData( image );
     mitk::DataStorage::GetInstance()->Add(node);
     SetDefaultNodeProperties(node, nodename1.append(" ").append(nodename2).append(" ERR"));
     node->SetProperty( "IsErrorVolume", mitk::BoolProperty::New( true ) );
 
     TreeChanged();
     m_Controls->update();
 
     QString status;
     mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Finished computing Angular Error"));
 
   }
   catch (itk::ExceptionObject &ex)
   {
     MBI_INFO << ex;
     return ;
   }
 
 }
 
 //void QmitkDiffusionTensorEstimation::DwiStandardAlgorithmsGFAButton()
 //{
 //
 //  itk::TimeProbe clock;
 //  QString status;
 //  const mitk::DataTreeFilter::Item* item
 //    = m_DiffusionVolumesDataTreeFilter->GetSelectedItem();
 //  if(!item)return;
 //
 //  typedef itk::Vector<TTensorPixelType,odfsize> OdfVectorType;
 //  typedef itk::Image<OdfVectorType,3> OdfVectorImgType;
 //  mitk::Image* vol =
 //    static_cast<mitk::Image*>(item->GetNode()->GetData());
 //  OdfVectorImgType::Pointer itkvol = OdfVectorImgType::New();
 //  mitk::CastToItkImage<OdfVectorImgType>(vol, itkvol);
 //  std::string nodename = item->GetProperty("name");
 //
 //  // COMPUTE RA
 //  clock.Start();
 //  std::cout << "Computing GFA ";
 //  mitk::StatusBar::GetInstance()->DisplayText(status.sprintf(
 //    "Computing GFA for %s", nodename.c_str()));
 //  typedef OdfVectorType::ValueType                 RealValueType;
 //  typedef itk::Image< RealValueType, 3 >                 RAImageType;
 //  typedef itk::DiffusionQballGeneralizedFaImageFilter<TTensorPixelType,TTensorPixelType,odfsize>
 //    GfaFilterType;
 //  GfaFilterType::Pointer gfaFilter = GfaFilterType::New();
 //  gfaFilter->SetInput(itkvol);
 //  gfaFilter->SetNumberOfThreads(4);
 //  switch(m_Controls->m_QBallStandardAlgorithmsGFAMethodSpinbox->value())
 //  {
 //  case 1:
 //    {
 //      gfaFilter->SetComputationMethod(GfaFilterType::STANDARD);
 //      break;
 //    }
 //  case 2:
 //    {
 //      gfaFilter->SetComputationMethod(GfaFilterType::QUANTILES_HIGH_LOW);
 //      break;
 //    }
 //  case 3:
 //    {
 //      gfaFilter->SetComputationMethod(GfaFilterType::QUANTILES_MIDDLE);
 //      break;
 //    }
 //  case 4:
 //    {
 //      gfaFilter->SetComputationMethod(GfaFilterType::MAX_ODF_VALUE);
 //      break;
 //    }
 //  case 5:
 //    {
 //      gfaFilter->SetComputationMethod(GfaFilterType::DECONVOLUTION_COEFFS);
 //      break;
 //    }
 //  default:
 //    {
 //      gfaFilter->SetComputationMethod(GfaFilterType::STANDARD);
 //    }
 //  }
 //  gfaFilter->Update();
 //  clock.Stop();
 //  std::cout << "took " << clock.GetMeanTime() << "s." << std::endl;
 //
 //  typedef itk::Image<TTensorPixelType, 3> ImgType;
 //  ImgType::Pointer img = ImgType::New();
 //  img->SetSpacing( gfaFilter->GetOutput()->GetSpacing() );   // Set the image spacing
 //  img->SetOrigin( gfaFilter->GetOutput()->GetOrigin() );     // Set the image origin
 //  img->SetDirection( gfaFilter->GetOutput()->GetDirection() );  // Set the image direction
 //  img->SetLargestPossibleRegion( gfaFilter->GetOutput()->GetLargestPossibleRegion());
 //  img->SetBufferedRegion( gfaFilter->GetOutput()->GetLargestPossibleRegion() );
 //  img->Allocate();
 //  itk::ImageRegionIterator<ImgType> ot (img, img->GetLargestPossibleRegion() );
 //  ot = ot.Begin();
 //  itk::ImageRegionConstIterator<GfaFilterType::OutputImageType> it
 //    (gfaFilter->GetOutput(), gfaFilter->GetOutput()->GetLargestPossibleRegion() );
 //  it = it.Begin();
 //
 //  for (it = it.Begin(); !it.IsAtEnd(); ++it)
 //  {
 //    GfaFilterType::OutputImageType::PixelType val = it.Get();
 //    ot.Set(val * 200);
 //    ++ot;
 //  }
 //
 //
 //  // GFA TO DATATREE
 //  mitk::Image::Pointer image = mitk::Image::New();
 //  image->InitializeByItk( img.GetPointer() );
 //  image->SetVolume( img->GetBufferPointer() );
 //  mitk::DataNode::Pointer node=mitk::DataNode::New();
 //  node->SetData( image );
 //  mitk::DataStorage::GetInstance()->Add(node);
 //  SetDefaultNodeProperties(node, nodename.append(" GFA"));
 //  node->SetProperty( "IsGFAVolume", mitk::BoolProperty::New( true ) );
 //
 //  mitk::StatusBar::GetInstance()->DisplayText("Computation complete.");
 //
 //  m_DataTreeIterator->GetTree()->Modified();
-//  m_MultiWidget->RequestUpdate();
+//  this->GetRenderWindowPart()->RequestUpdate();
 //  TreeChanged();
 //  m_Controls->update();
 //
 //}
 
 void QmitkDiffusionTensorEstimation::DiffusionVolumeSaveButton()
 {
   // GET SELECTED ITEM
   const mitk::DataTreeFilter::Item* selectedItem
     = m_DiffusionVolumesDataTreeFilter->GetSelectedItem();
   if( !selectedItem )
     return;
   mitk::DiffusionVolumes<DiffusionPixelType>::Pointer diffVolumes =
     static_cast<mitk::DiffusionVolumes<DiffusionPixelType>*>(selectedItem->GetNode()->GetData());
 
   std::string sName = selectedItem->GetNode()->GetName();
   QString qName;
   qName.sprintf("%s.nhdr",sName.c_str());
 
   // SELECT FILE DIALOG
   //QFileDialog::getSaveFileName()
   //QFileDialog* w = new QFileDialog( this->m_Controls, "Select Nrrd Outputfile", TRUE );
   //w->setMode( QFileDialog::AnyFile );
   //w->setFilter( "Nrrd Images (*.nrrd *.nhdr)" );
   //w->setName(qName);
   //if ( w->exec() != QDialog::Accepted )
   //  return;
   //QString filename = w->selectedFile();
 
   QString filename = QFileDialog::getSaveFileName(
     qName,
     "Nrrd Images (*.nrrd *.nhdr)",
     this->m_Controls,
     "save file dialog",
     "Select Nrrd Outputfile" );
 
   if ( !filename )
     return;
 
   // WRITING DWIs TO NRRD VOLUME
   typedef mitk::NrrdDiffusionVolumesWriter<DiffusionImageType> WriterType;
   WriterType::Pointer nrrdWriter = WriterType::New();
   nrrdWriter->SetInput( diffVolumes->GetImage() );
   nrrdWriter->SetDirections(diffVolumes->GetDirections());
   nrrdWriter->SetB_Value(diffVolumes->GetB_Value());
   nrrdWriter->SetFileName(filename.ascii());
   try
   {
     nrrdWriter->Update();
   }
   catch (itk::ExceptionObject e)
   {
     MBI_INFO << e;
   }
 }
 
 void QmitkDiffusionTensorEstimation::DiffusionVolumesLoadButton()
 {
   // SELECT FOLDER DIALOG
   QFileDialog* w = new QFileDialog( this->m_Controls, "Select DWI data file", TRUE );
   w->setMode( QFileDialog::ExistingFiles );
   w->setFilter( "Nrrd Images (*.nrrd *.nhdr)" );
 
   // RETRIEVE SELECTION
   if ( w->exec() != QDialog::Accepted )
     return;
 
   QStringList filenames = w->selectedFiles();
   QStringList::Iterator it = filenames.begin();
   while( it != filenames.end() ) {
     std::string filename = ( *it ).ascii();
     ++it;
 
     // READING NRRD DWI VOLUMES
     typedef mitk::NrrdDiffusionVolumesReader<DiffusionImageType> ReaderType;
     ReaderType::Pointer nrrdReader = ReaderType::New();
     nrrdReader->SetFileName(filename);
     try
     {
       nrrdReader->Update();
 
       // DWI TO DATATREE
       typedef mitk::DiffusionVolumes<DiffusionPixelType> DiffVolumesType;
       DiffVolumesType::Pointer diffVolumes = DiffVolumesType::New();
       diffVolumes->SetDirections(nrrdReader->GetDiffusionVectors());
       diffVolumes->SetB_Value(nrrdReader->GetB_Value());
       diffVolumes->SetImage(nrrdReader->GetOutput());
       mitk::DataNode::Pointer node=mitk::DataNode::New();
       node->SetData( diffVolumes );
       mitk::DataStorage::GetInstance()->Add(node);
       SetDefaultNodeProperties(node, itksys::SystemTools::GetFilenameName(filename));
 
       TreeChanged();
     }
     catch (itk::ExceptionObject e)
     {
       MBI_INFO << e;
     }
 
   }
 }
 
 void QmitkDiffusionTensorEstimation::DiffusionVolumesRemoveButton()
 {
   m_DiffusionVolumesDataTreeFilter->DeleteSelectedItems();
 }
 
 void QmitkDiffusionTensorEstimation::DiffusionVolumesSelectAll()
 {
   const mitk::DataTreeFilter::ItemList* items = m_DiffusionVolumesDataTreeFilter->GetItems();
 
   mitk::DataTreeFilter::ConstItemIterator itemiter( items->Begin() );
   mitk::DataTreeFilter::ConstItemIterator itemiterend( items->End() );
 
   while ( itemiter != itemiterend )
   {
     m_DiffusionVolumesDataTreeFilter->SelectItem(*itemiter);
     ++itemiter;
   }
 
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/deprecated/QmitkDiffusionTensorEstimation.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/deprecated/QmitkDiffusionTensorEstimation.h
index 4fb52f0e3d..81dae74b39 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/deprecated/QmitkDiffusionTensorEstimation.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/deprecated/QmitkDiffusionTensorEstimation.h
@@ -1,163 +1,158 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #if !defined(QmitkDiffusionTensorEstimation_H__INCLUDED)
 #define QmitkDiffusionTensorEstimation_H__INCLUDED
 
-#include "QmitkFunctionality.h"
+#include <QmitkAbstractView.h>
+#include <mitkILifecycleAwarePart.h>
 #include "mitkDiffusionVolumes.h"
 
-class QmitkStdMultiWidget;
 class QmitkDiffusionTensorEstimationControls;
 
 typedef short DiffusionPixelType;
 
 
 /*!
 \brief QmitkDiffusionTensorEstimation
 
-One needs to reimplement the methods CreateControlWidget(..), CreateMainWidget(..)
-and CreateAction(..) from QmitkFunctionality.
-
-\sa QmitkFunctionality
-\ingroup Functionalities
+One needs to reimplement the methods CreateControlWidget(..),
+and CreateAction(..).
 */
-class QmitkDiffusionTensorEstimation : public QmitkFunctionality
+class QmitkDiffusionTensorEstimation : public QmitkAbstractView, public mitk::ILifecycleAwarePart
 {
   Q_OBJECT
 
 public:
   /*!
   \brief default constructor
   */
-  QmitkDiffusionTensorEstimation(QObject *parent=0, const char *name=0, QmitkStdMultiWidget *mitkStdMultiWidget = NULL, mitk::DataTreeIteratorBase* dataIt = NULL);
+  QmitkDiffusionTensorEstimation(QObject *parent=0, const char *name=0, mitk::DataTreeIteratorBase* dataIt = NULL);
 
   /*!
   \brief default destructor
   */
   virtual ~QmitkDiffusionTensorEstimation();
 
   /*!
   \brief method for creating the widget containing the application   controls, like sliders, buttons etc.
   */
   virtual QWidget * CreateControlWidget(QWidget *parent);
 
-  /*!
-  \brief method for creating the applications main widget
-  */
-  virtual QWidget * CreateMainWidget(QWidget * parent);
-
   /*!
   \brief method for creating the connections of main and control widget
   */
   virtual void CreateConnections();
 
+  ///
+  /// Sets the focus to an internal widget.
+  ///
+  virtual void SetFocus() override;
+
   /*!
   \brief method for creating an QAction object, i.e. button & menu entry  @param parent the parent QWidget
   */
   virtual QAction * CreateAction(QActionGroup *parent);
 
-  virtual void Activated();
+  virtual void Activated() override;
+  virtual void Deactivated() override;
+  virtual void Visible() override;
+  virtual void Hidden() override;
 
   protected slots:
     void TreeChanged();
 
     void TensorVolumesSaveButton();
 
     void TensorVolumesLoadButton();
 
     void TensorVolumesRemoveButton();
 
     void QBallVolumesSaveButton();
 
     void QBallVolumesLoadButton();
 
     void QBallVolumesRemoveButton();
 
     void DirectionVolumesSaveButton();
 
     void DirectionVolumesLoadButton();
 
     void DirectionVolumesRemoveButton();
 
     void DirectionVolumesAngularErrorButton();
 
     void TensorEstimationTeemEstimateButton();
 
     void QBallReconstructionButton();
 
     void QBallReconstructionAnalyticalButton();
 
     void TensorEstimationButton();
 
     void StandardAlgorithmsFAButton();
 
     void StandardAlgorithmsRAButton();
 
     void StandardAlgorithmsDirectionButton();
 
     void QBallStandardAlgorithmsDirectionButton();
 
     void QBallStandardAlgorithmsDeconvolutionButton();
 
     void QBallStandardAlgorithmsGFAButton();
 
     void QBallVolumesVisualizeSelectedButton();
 
     void DiffusionVolumeSaveButton();
 
     void DiffusionVolumesLoadButton();
 
     void DiffusionVolumesRemoveButton();
 
     void DiffusionVolumesSelectAll();
 
     //void DwiStandardAlgorithmsGFAButton();
 
     void SetDefaultNodeProperties(mitk::DataNode::Pointer node, std::string name);
 
 protected:
-  /*!
-  * default main widget containing 4 windows showing 3
-  * orthogonal slices of the volume and a 3d render window
-  */
-  QmitkStdMultiWidget * m_MultiWidget;
 
   /*!
   * controls containing sliders for scrolling through the slices
   */
   QmitkDiffusionTensorEstimationControls * m_Controls;
 
   mitk::DataTreeFilter::Pointer m_DiffusionVolumesDataTreeFilter;
 
   mitk::DataTreeFilter::Pointer m_TensorVolumesDataTreeFilter;
 
   mitk::DataTreeFilter::Pointer m_QballVolumesDataTreeFilter;
 
   mitk::DataTreeFilter::Pointer m_DirectionVolumesDataTreeFilter;
 
   bool m_FilterInitialized;
 
   static const int odfsize;
 
   static const int nrconvkernels;
 
   template<int L>
   void ReconstructAnalytically(mitk::DiffusionVolumes<DiffusionPixelType>* vols,
     float lambda, std::string nodename, std::vector<mitk::DataNode::Pointer>* nodes);
 
 };
 #endif // !defined(QmitkDiffusionTensorEstimation_H__INCLUDED)