diff --git a/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.cpp b/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.cpp
index f2a84146b2..19cf73cf49 100644
--- a/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.cpp
@@ -1,230 +1,226 @@
 /*===================================================================
 
 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 "QmitkInteractiveTransformationWidget.h"
 
 // mitk includes
 #include "mitkRenderingManager.h"
 #include "mitkNavigationData.h"
 
 // vtk includes
 #include "vtkMatrix4x4.h"
 #include "vtkLinearTransform.h"
 
 const std::string QmitkInteractiveTransformationWidget::VIEW_ID = "org.mitk.views.interactivetransformationwidget";
 
 QmitkInteractiveTransformationWidget::QmitkInteractiveTransformationWidget(QWidget* parent, Qt::WindowFlags f)
   : QWidget(parent, f), m_Controls(nullptr), m_Geometry(nullptr), m_ResetGeometry(nullptr)
 {
   CreateQtPartControl(this);
   CreateConnections();
 }
 
 QmitkInteractiveTransformationWidget::~QmitkInteractiveTransformationWidget()
 {
 }
 
 void QmitkInteractiveTransformationWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkInteractiveTransformationWidgetControls;
     m_Controls->setupUi(parent);
   }
 }
 
 void QmitkInteractiveTransformationWidget::CreateConnections()
 {
   if (m_Controls)
   {
     // translations
     connect(m_Controls->m_XTransSlider, &QSlider::valueChanged, m_Controls->m_XTransSpinBox, &QSpinBox::setValue);
     connect(m_Controls->m_XTransSpinBox, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), m_Controls->m_XTransSlider, &QSlider::setValue);
     connect(m_Controls->m_XTransSlider, &QSlider::valueChanged, this, &QmitkInteractiveTransformationWidget::OnXTranslationValueChanged);
 
     connect(m_Controls->m_YTransSlider, &QSlider::valueChanged, m_Controls->m_YTransSpinBox, &QSpinBox::setValue);
     connect(m_Controls->m_YTransSpinBox, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), m_Controls->m_YTransSlider, &QSlider::setValue);
     connect(m_Controls->m_YTransSlider, &QSlider::valueChanged, this, &QmitkInteractiveTransformationWidget::OnYTranslationValueChanged);
 
     connect(m_Controls->m_ZTransSlider, &QSlider::valueChanged, m_Controls->m_ZTransSpinBox, &QSpinBox::setValue);
     connect(m_Controls->m_ZTransSpinBox, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), m_Controls->m_ZTransSlider, &QSlider::setValue);
     connect(m_Controls->m_ZTransSlider, &QSlider::valueChanged, this, &QmitkInteractiveTransformationWidget::OnZTranslationValueChanged);
 
     // rotations
     connect(m_Controls->m_XRotSlider, &QSlider::valueChanged, m_Controls->m_XRotSpinBox, &QSpinBox::setValue);
     connect(m_Controls->m_XRotSpinBox, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), m_Controls->m_XRotSlider, &QSlider::setValue);
     connect(m_Controls->m_XRotSlider, &QSlider::valueChanged, this, &QmitkInteractiveTransformationWidget::OnXRotationValueChanged);
 
     connect(m_Controls->m_YRotSlider, &QSlider::valueChanged, m_Controls->m_YRotSpinBox, &QSpinBox::setValue);
     connect(m_Controls->m_YRotSpinBox, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), m_Controls->m_YRotSlider, &QSlider::setValue);
     connect(m_Controls->m_YRotSlider, &QSlider::valueChanged, this, &QmitkInteractiveTransformationWidget::OnYRotationValueChanged);
 
     connect(m_Controls->m_ZRotSlider, &QSlider::valueChanged, m_Controls->m_ZRotSpinBox, &QSpinBox::setValue);
     connect(m_Controls->m_ZRotSpinBox, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), m_Controls->m_ZRotSlider, &QSlider::setValue);
     connect(m_Controls->m_ZRotSlider, &QSlider::valueChanged, this, &QmitkInteractiveTransformationWidget::OnZRotationValueChanged);
 
     connect((QObject*)(m_Controls->m_ResetPB), SIGNAL(clicked()), this, SLOT(OnResetGeometryToIdentity()));
     connect((QObject*)(m_Controls->m_RevertChanges), SIGNAL(clicked()), this, SLOT(OnRevertChanges()));
     connect((QObject*)(m_Controls->m_UseManipulatedToolTipPB), SIGNAL(clicked()), this, SLOT(OnApplyManipulatedToolTip()));
   }
 }
 
 void QmitkInteractiveTransformationWidget::SetGeometryPointer(mitk::BaseGeometry::Pointer geometry)
 {
   m_Geometry = geometry;
   m_ResetGeometry = geometry->Clone(); //Remember the original values to be able to reset and abort everything
 }
 
 void QmitkInteractiveTransformationWidget::SetValues(const mitk::AffineTransform3D::Pointer _defaultValues)
 {
   m_Geometry->SetIndexToWorldTransform(_defaultValues);
 
   //Set toolTip values in gui, slider will be adapted from spinbox via signal -> valueChanged
   m_Controls->m_XTransSpinBox->setValue(_defaultValues->GetOffset()[0]);
   m_Controls->m_YTransSpinBox->setValue(_defaultValues->GetOffset()[1]);
   m_Controls->m_ZTransSpinBox->setValue(_defaultValues->GetOffset()[2]);
 
   //first: some conversion
   mitk::NavigationData::Pointer transformConversionHelper = mitk::NavigationData::New(_defaultValues);
   double eulerAlphaDegrees = transformConversionHelper->GetOrientation().rotation_euler_angles()[0] / vnl_math::pi * 180;
   double eulerBetaDegrees = transformConversionHelper->GetOrientation().rotation_euler_angles()[1] / vnl_math::pi * 180;
   double eulerGammaDegrees = transformConversionHelper->GetOrientation().rotation_euler_angles()[2] / vnl_math::pi * 180;
 
   m_Controls->m_XRotSpinBox->setValue(eulerAlphaDegrees);
   m_Controls->m_YRotSpinBox->setValue(eulerBetaDegrees);
   m_Controls->m_ZRotSpinBox->setValue(eulerGammaDegrees);
 
   //Update view
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
-mitk::BaseGeometry::Pointer QmitkInteractiveTransformationWidget::GetGeometry()
-{
-  return m_Geometry;
-}
-
 /////////////////////////////////////////////////////////////////////////////////////////////
 // Section to allow interactive positioning of the moving surface
 /////////////////////////////////////////////////////////////////////////////////////////////
 
 void QmitkInteractiveTransformationWidget::OnXTranslationValueChanged(int v)
 {
   mitk::Vector3D translationParams;
   translationParams[0] = v;
   translationParams[1] = m_Controls->m_YTransSlider->value();
   translationParams[2] = m_Controls->m_ZTransSlider->value();
   m_Geometry->SetOrigin(translationParams);
 
   //Update view
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkInteractiveTransformationWidget::OnYTranslationValueChanged(int v)
 {
   mitk::Vector3D translationParams;
   translationParams[0] = m_Controls->m_XTransSlider->value();
   translationParams[1] = v;
   translationParams[2] = m_Controls->m_ZTransSlider->value();
   m_Geometry->SetOrigin(translationParams);
 
   //Update view
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkInteractiveTransformationWidget::OnZTranslationValueChanged(int v)
 {
   mitk::Vector3D translationParams;
   translationParams[0] = m_Controls->m_XTransSlider->value();
   translationParams[1] = m_Controls->m_YTransSlider->value();
   translationParams[2] = v;
   m_Geometry->SetOrigin(translationParams);
 
   //Update view
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkInteractiveTransformationWidget::OnXRotationValueChanged(int v)
 {
   mitk::Vector3D rotationParams;
   rotationParams[0] = v;
   rotationParams[1] = m_Controls->m_YRotSlider->value();
   rotationParams[2] = m_Controls->m_ZRotSlider->value();
 
   this->Rotate(rotationParams);
 }
 
 void QmitkInteractiveTransformationWidget::OnYRotationValueChanged(int v)
 {
   mitk::Vector3D rotationParams;
   rotationParams[0] = m_Controls->m_XRotSlider->value();
   rotationParams[1] = v;
   rotationParams[2] = m_Controls->m_ZRotSlider->value();
 
   this->Rotate(rotationParams);
 }
 
 void QmitkInteractiveTransformationWidget::OnZRotationValueChanged(int v)
 {
   mitk::Vector3D rotationParams;
   rotationParams[0] = m_Controls->m_XRotSlider->value();
   rotationParams[1] = m_Controls->m_YRotSlider->value();
   rotationParams[2] = v;
 
   this->Rotate(rotationParams);
 }
 
 void QmitkInteractiveTransformationWidget::Rotate(mitk::Vector3D rotateVector)
 {
   //0: from degrees to radians
   double radianX = rotateVector[0] * vnl_math::pi / 180;
   double radianY = rotateVector[1] * vnl_math::pi / 180;
   double radianZ = rotateVector[2] * vnl_math::pi / 180;
 
   //1: from euler angles to quaternion
   mitk::Quaternion rotation(radianX, radianY, radianZ);
 
   //2: Conversion to navigation data / transform
   mitk::NavigationData::Pointer rotationTransform = mitk::NavigationData::New(m_Geometry->GetIndexToWorldTransform());
   rotationTransform->SetOrientation(rotation);
 
   m_Geometry->SetIndexToWorldTransform(rotationTransform->GetAffineTransform3D());
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkInteractiveTransformationWidget::OnResetGeometryToIdentity()
 {
   // reset the input to its initial state.
   m_Geometry->SetIdentity();
 
   //Todo Slider anpassen
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkInteractiveTransformationWidget::OnRevertChanges()
 {
   // reset the input to its initial state.
   m_Geometry->SetIndexToWorldTransform(m_ResetGeometry->GetIndexToWorldTransform());
 
   //Todo Slider anpassen
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkInteractiveTransformationWidget::OnApplyManipulatedToolTip()
 {
-  emit ApplyManipulatedToolTip(m_Geometry);
+  mitk::AffineTransform3D::Pointer toolTip = m_Geometry->GetIndexToWorldTransform();
+  emit EditToolTipFinished(toolTip);
 }
\ No newline at end of file
diff --git a/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.h b/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.h
index 397e7cef47..0d1846e1e4 100644
--- a/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.h
+++ b/Modules/IGTUI/Qmitk/QmitkInteractiveTransformationWidget.h
@@ -1,88 +1,86 @@
 /*===================================================================
 
 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 QmitkInteractiveTransformationWidget_H
 #define QmitkInteractiveTransformationWidget_H
 
 //QT headers
 #include <QWidget>
 
 //Mitk headers
 #include "MitkIGTUIExports.h"
 #include "mitkVector.h"
 #include "mitkGeometry3D.h"
 
 //ui header
 #include "ui_QmitkInteractiveTransformationWidgetControls.h"
 
  /** Documentation:
   *   \brief An object of this class offers an UI to create a widget to access the advance tool creation options.
   *
   *
   *   \ingroup IGTUI
   */
 class MITKIGTUI_EXPORT QmitkInteractiveTransformationWidget : public QWidget
 {
   Q_OBJECT
 
   public:
     static const std::string VIEW_ID;
 
     QmitkInteractiveTransformationWidget(QWidget* parent = nullptr, Qt::WindowFlags f = nullptr);
     ~QmitkInteractiveTransformationWidget();
 
     /** Sets the geometry which will be modified by this widget. Default values may be
      *  provided by the second variable. These values will be applied to the geometry
      *  in the beginning and the UI will also hold these values.
      */
     void SetGeometryPointer(mitk::BaseGeometry::Pointer geometry);
 
     void SetValues(const mitk::AffineTransform3D::Pointer _defaultValues);
 
-    mitk::BaseGeometry::Pointer GetGeometry();
-
   protected slots:
     void OnZTranslationValueChanged( int v );
     void OnYTranslationValueChanged( int v );
     void OnXTranslationValueChanged( int v );
     void OnZRotationValueChanged( int v );
     void OnYRotationValueChanged( int v );
     void OnXRotationValueChanged( int v );
     void OnResetGeometryToIdentity();
     void OnRevertChanges();
     void OnApplyManipulatedToolTip();
 
 signals:
-    void ApplyManipulatedToolTip(mitk::BaseGeometry::Pointer geometry);
+    void EditToolTipFinished(mitk::AffineTransform3D::Pointer toolTip);
 
   protected:
 
     virtual void CreateConnections();
 
     virtual void CreateQtPartControl(QWidget *parent);
 
     /*! \brief Method performs the rotation.
     \params rotateVector New rotation to be combined with geometry. */
     void Rotate(mitk::Vector3D rotateVector);
 
     // Member variables
     Ui::QmitkInteractiveTransformationWidgetControls* m_Controls;
 
     mitk::BaseGeometry::Pointer m_Geometry;         ///< \brief The geometry that is manipulated
     mitk::BaseGeometry::Pointer m_ResetGeometry;    ///< \brief Lifeline to reset to the original geometry
 
 };
 #endif // QmitkInteractiveTransformationWidget_H
diff --git a/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp
index 69522c02a9..0c917674c9 100644
--- a/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp
@@ -1,398 +1,395 @@
 /*===================================================================
 
 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 "QmitkNavigationToolCreationWidget.h"
 
 //mitk headers
 #include <mitkTrackingTypes.h>
 #include <mitkSurface.h>
 #include <mitkNavigationData.h>
 #include <mitkRenderingManager.h>
 #include "mitkTrackingDeviceTypeCollection.h"
 
+
 //qt headers
 #include <qfiledialog.h>
 #include <qmessagebox.h>
-#include <QDialog>
 #include <mitkIOUtil.h>
 #include <QmitkIGTCommonHelper.h>
+#include <QDialogButtonBox>
 
 //poco headers
 #include <Poco/Path.h>
 
 // vtk
 #include <vtkSphereSource.h>
 #include <vtkConeSource.h>
 
 const std::string QmitkNavigationToolCreationWidget::VIEW_ID = "org.mitk.views.navigationtoolcreationwizardwidget";
 
 QmitkNavigationToolCreationWidget::QmitkNavigationToolCreationWidget(QWidget* parent, Qt::WindowFlags f)
   : QWidget(parent, f)
 {
+  m_ToolToBeEdited = mitk::NavigationTool::New();
+  m_FinalTool = mitk::NavigationTool::New();
+  m_ToolTransformationWidget = new QmitkInteractiveTransformationWidget();
+
   m_Controls = NULL;
   CreateQtPartControl(this);
   CreateConnections();
 
-  m_ToolToBeEdited = mitk::NavigationTool::New();
-  m_FinalTool = mitk::NavigationTool::New();
-
+  this->InitializeUIToolLandmarkLists();
   Initialize(nullptr, "");
 
   //Default values, which are not stored in tool
   m_Controls->m_CalibrationFileName->setText("none");
   m_Controls->m_Surface_Use_Sphere->setChecked(true);
 
-  this->InitializeUIToolLandmarkLists();
   m_Controls->m_CalibrationLandmarksList->EnableEditButton(false);
   m_Controls->m_RegistrationLandmarksList->EnableEditButton(false);
 
   RefreshTrackingDeviceCollection();
 }
 
 QmitkNavigationToolCreationWidget::~QmitkNavigationToolCreationWidget()
 {
   m_Controls->m_CalibrationLandmarksList->SetPointSetNode(NULL);
   m_Controls->m_RegistrationLandmarksList->SetPointSetNode(NULL);
+  delete m_ToolTransformationWidget;
 }
 
 void QmitkNavigationToolCreationWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkNavigationToolCreationWidgetControls;
     m_Controls->setupUi(parent);
   }
 }
 
 void QmitkNavigationToolCreationWidget::CreateConnections()
 {
   if (m_Controls)
   {
     connect((QObject*)(m_Controls->m_TrackingDeviceTypeChooser), SIGNAL(currentIndexChanged(int index)), this, SLOT(GetGuiElements()));
     connect((QObject*)(m_Controls->m_ToolNameEdit), SIGNAL(textChanged(const QString &text)), this, SLOT(GetGuiElements()));
     connect((QObject*)(m_Controls->m_ToolTypeChooser), SIGNAL(currentIndexChanged(int index)), this, SLOT(GetGuiElements()));
     connect((QObject*)(m_Controls->m_IdentifierEdit), SIGNAL(textChanged(const QString &text)), this, SLOT(GetGuiElements()));
     connect((QObject*)(m_Controls->m_SerialNumberEdit), SIGNAL(textChanged(const QString &text)), this, SLOT(GetGuiElements()));
     connect((QObject*)(m_Controls->m_ToolAxisX), SIGNAL(valueChanged()), this, SLOT(GetGuiElements()));
     connect((QObject*)(m_Controls->m_ToolAxisY), SIGNAL(valueChanged()), this, SLOT(GetGuiElements()));
     connect((QObject*)(m_Controls->m_ToolAxisZ), SIGNAL(valueChanged()), this, SLOT(GetGuiElements()));
 
     //Buttons
     connect((QObject*)(m_Controls->m_LoadCalibrationFile), SIGNAL(clicked()), this, SLOT(OnLoadCalibrationFile()));
     connect(m_Controls->m_Surface_Use_Other, SIGNAL(toggled(bool)), this, SLOT(OnSurfaceUseOtherToggled()));
     connect((QObject*)(m_Controls->m_LoadSurface), SIGNAL(clicked()), this, SLOT(OnLoadSurface()));
     connect((QObject*)(m_Controls->m_EditToolTip), SIGNAL(clicked()), this, SLOT(OnEditToolTip()));
 
+    connect((QObject*)(m_ToolTransformationWidget), SIGNAL(EditToolTipFinished(mitk::AffineTransform3D::Pointer toolTip)), this, 
+      SLOT(OnEditToolTipFinished(mitk::AffineTransform3D::Pointer toolTip)));
+
     connect((QObject*)(m_Controls->m_cancel), SIGNAL(clicked()), this, SLOT(OnCancel()));
     connect((QObject*)(m_Controls->m_finished), SIGNAL(clicked()), this, SLOT(OnFinished()));
   }
 }
 
 void QmitkNavigationToolCreationWidget::Initialize(mitk::DataStorage* dataStorage, const std::string& supposedIdentifier, const std::string& supposedName)
 {
   m_DataStorage = dataStorage;
   //initialize UI components
   m_Controls->m_SurfaceChooser->SetDataStorage(m_DataStorage);
   m_Controls->m_SurfaceChooser->SetAutoSelectNewItems(true);
   m_Controls->m_SurfaceChooser->SetPredicate(mitk::NodePredicateDataType::New("Surface"));
 
   //Create new tool, which should be edited/created
   m_ToolToBeEdited = nullptr;//Reset
   m_ToolToBeEdited = mitk::NavigationTool::New();//Reinitialize
   m_ToolToBeEdited->SetIdentifier(supposedIdentifier);
 
   //Create the default cone surface. Can be changed later on...
   //create DataNode...
   mitk::DataNode::Pointer newNode = mitk::DataNode::New();
+  newNode->SetName(supposedName);
+  m_ToolToBeEdited->SetDataNode(newNode);//ToDo: Data storage ok?
 
-  //create small sphere and use it as surface
+  SetConeAsToolSurface();
+
+  this->SetDefaultData(m_ToolToBeEdited);
+}
+
+void QmitkNavigationToolCreationWidget::SetConeAsToolSurface()
+{
+  //create small cone and use it as surface
   mitk::Surface::Pointer mySphere = mitk::Surface::New();
   vtkConeSource *vtkData = vtkConeSource::New();
   vtkData->SetAngle(5.0);
   vtkData->SetResolution(50);
   vtkData->SetHeight(6.0f);
   vtkData->SetRadius(2.0f);
   vtkData->SetCenter(0.0, 0.0, 0.0);
   vtkData->Update();
   mySphere->SetVtkPolyData(vtkData->GetOutput());
   vtkData->Delete();
-  newNode->SetData(mySphere);
-
-  newNode->SetName(supposedName);
-
-  m_ToolToBeEdited->SetDataNode(newNode);//ToDo: Data storage ok?
-
-  this->SetDefaultData(m_ToolToBeEdited);
+  m_ToolToBeEdited->GetDataNode()->SetData(mySphere);
 }
 
 void QmitkNavigationToolCreationWidget::SetDefaultData(mitk::NavigationTool::Pointer DefaultTool)
 {
   //Set Members. This can either be the new initialized tool from call of Initialize() or a tool which already exists in the toolStorage
-  m_ToolToBeEdited = DefaultTool->Clone();//Todo implement clone function!!!!
+  //TODO m_ToolToBeEdited = DefaultTool->Clone();//Todo implement clone function!!!!
 
   //Set all gui variables
   SetGuiElements();
 }
 
 void QmitkNavigationToolCreationWidget::SetGuiElements()
 {
   //Block signals, so that we don't call SetGuiElements again. This is undone at the end o this function!
   this->blockSignals(true);
 
   //DeviceType
   int index = m_Controls->m_TrackingDeviceTypeChooser->findText(QString::fromStdString(m_ToolToBeEdited->GetTrackingDeviceType()));
   if (index >= 0)
   {
     m_Controls->m_TrackingDeviceTypeChooser->setCurrentIndex(index);
   }
 
   m_Controls->m_ToolNameEdit->setText(QString(m_ToolToBeEdited->GetDataNode()->GetName().c_str()));
   m_Controls->m_CalibrationFileName->setText(QString(m_ToolToBeEdited->GetCalibrationFile().c_str()));
 
 
   m_Controls->m_SurfaceChooser->SetSelectedNode(m_ToolToBeEdited->GetDataNode());
   FillUIToolLandmarkLists(m_ToolToBeEdited->GetToolCalibrationLandmarks(), m_ToolToBeEdited->GetToolRegistrationLandmarks());
 
   switch (m_ToolToBeEdited->GetType())
   {
   case mitk::NavigationTool::Instrument:
     m_Controls->m_ToolTypeChooser->setCurrentIndex(0); break;
   case mitk::NavigationTool::Fiducial:
     m_Controls->m_ToolTypeChooser->setCurrentIndex(1); break;
   case mitk::NavigationTool::Skinmarker:
     m_Controls->m_ToolTypeChooser->setCurrentIndex(2); break;
   case mitk::NavigationTool::Unknown:
     m_Controls->m_ToolTypeChooser->setCurrentIndex(3); break;
   }
 
   m_Controls->m_IdentifierEdit->setText(QString(m_ToolToBeEdited->GetIdentifier().c_str()));
   m_Controls->m_SerialNumberEdit->setText(QString(m_ToolToBeEdited->GetSerialNumber().c_str()));
 
   m_Controls->m_ToolAxisX->setValue(m_ToolToBeEdited->GetToolAxis()[0]);
   m_Controls->m_ToolAxisY->setValue(m_ToolToBeEdited->GetToolAxis()[1]);
   m_Controls->m_ToolAxisZ->setValue(m_ToolToBeEdited->GetToolAxis()[2]);
   QString _label = "(" +
     QString::number(m_ToolToBeEdited->GetToolTipPosition()[0], 'f', 1) + ", " +
     QString::number(m_ToolToBeEdited->GetToolTipPosition()[1], 'f', 1) + ", " +
     QString::number(m_ToolToBeEdited->GetToolTipPosition()[2], 'f', 1) + "), quat: [" +
     QString::number(m_ToolToBeEdited->GetToolTipOrientation()[0], 'f', 2) + ", " +
     QString::number(m_ToolToBeEdited->GetToolTipOrientation()[1], 'f', 2) + ", " +
     QString::number(m_ToolToBeEdited->GetToolTipOrientation()[2], 'f', 2) + ", " +
     QString::number(m_ToolToBeEdited->GetToolTipOrientation()[3], 'f', 2) + "]";
   m_Controls->m_ToolTipLabel->setText(_label);
 
   //Undo block signals. Don't remove it, if signals are still blocked at the beginning of this function!
   this->blockSignals(false);
 }
 
-void QmitkNavigationToolCreationWidget::OnLoadCalibrationFile()
+void QmitkNavigationToolCreationWidget::OnSurfaceUseOtherToggled()
 {
-  m_ToolToBeEdited->SetCalibrationFile(m_Controls->m_CalibrationFileName->text().toLatin1().data());
+  m_Controls->m_LoadSurface->setEnabled(m_Controls->m_Surface_Use_Other->isChecked());
+  if (m_Controls->m_Surface_Use_Sphere->isChecked())
+    SetConeAsToolSurface();
 }
 
-void QmitkNavigationToolCreationWidget::OnSurfaceUseOtherToggled()
+void QmitkNavigationToolCreationWidget::OnLoadSurface()
 {
-  //TODO
+  std::string filename = QFileDialog::getOpenFileName(NULL, tr("Open Surface"), QmitkIGTCommonHelper::GetLastFileLoadPath(), tr("STL (*.stl)")).toLatin1().data();
+  QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(QString::fromStdString(filename));
+  try
+  {
+    mitk::IOUtil::Load(filename.c_str(), *m_DataStorage);
+  }
+  catch (mitk::Exception &e)
+  {
+    MITK_ERROR << "Exception occured: " << e.what();
+  }
+  //Todo: ist der neue Knoten automatisch der erste oder wie bekomme ich denß
+  m_ToolToBeEdited->GetDataNode()->SetData(m_Controls->m_SurfaceChooser->GetSelectedNode()->GetData());
 }
-void QmitkNavigationToolCreationWidget::OnLoadSurface()
+
+void QmitkNavigationToolCreationWidget::OnLoadCalibrationFile()
 {
-  //TODO
+  QString fileName = QFileDialog::getOpenFileName(NULL, tr("Open Calibration File"), QmitkIGTCommonHelper::GetLastFileLoadPath(), "*.*");
+  QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(fileName);
+  m_Controls->m_CalibrationFileName->setText(fileName);
+  m_ToolToBeEdited->SetCalibrationFile(fileName.toStdString());
 }
 void QmitkNavigationToolCreationWidget::GetValuesFromGuiElements()
 {
 
   //Tracking Device
   m_ToolToBeEdited->SetTrackingDeviceType(m_Controls->m_TrackingDeviceTypeChooser->currentText().toStdString());
   m_ToolToBeEdited->GetDataNode()->SetName(m_Controls->m_ToolNameEdit->text().toStdString());
 
   //Tool Landmarks
   mitk::PointSet::Pointer toolCalLandmarks, toolRegLandmarks;
   GetUIToolLandmarksLists(toolCalLandmarks, toolRegLandmarks);
   m_ToolToBeEdited->SetToolCalibrationLandmarks(toolCalLandmarks);
   m_ToolToBeEdited->SetToolRegistrationLandmarks(toolRegLandmarks);
 
   //Advanced
   if (m_Controls->m_ToolTypeChooser->currentText() == "Instrument") m_ToolToBeEdited->SetType(mitk::NavigationTool::Instrument);
   else if (m_Controls->m_ToolTypeChooser->currentText() == "Fiducial") m_ToolToBeEdited->SetType(mitk::NavigationTool::Fiducial);
   else if (m_Controls->m_ToolTypeChooser->currentText() == "Skinmarker") m_ToolToBeEdited->SetType(mitk::NavigationTool::Skinmarker);
   else m_FinalTool->SetType(mitk::NavigationTool::Unknown);
 
   m_ToolToBeEdited->SetIdentifier(m_Controls->m_IdentifierEdit->text().toLatin1().data());
   m_ToolToBeEdited->SetSerialNumber(m_Controls->m_SerialNumberEdit->text().toLatin1().data());
 
   //Tool Axis
   mitk::Point3D toolAxis;
   toolAxis.SetElement(0, (m_Controls->m_ToolAxisX->value()));
   toolAxis.SetElement(1, (m_Controls->m_ToolAxisY->value()));
   toolAxis.SetElement(2, (m_Controls->m_ToolAxisZ->value()));
   m_ToolToBeEdited->SetToolAxis(toolAxis);
 }
 
 mitk::NavigationTool::Pointer QmitkNavigationToolCreationWidget::GetCreatedTool()
 {
   return m_FinalTool;
 }
 
 
 void QmitkNavigationToolCreationWidget::OnFinished()
 {
   //here we create a new tool
   m_FinalTool = m_ToolToBeEdited->Clone();
 
 
   emit NavigationToolFinished();
 }
 
 void QmitkNavigationToolCreationWidget::OnCancel()
 {
   Initialize(nullptr,"");//Reset everything to a fresh tool, like it was done in the constructor
   emit Canceled();
 }
 
-void QmitkNavigationToolCreationWidget::OnLoadSurface()
+
+void QmitkNavigationToolCreationWidget::SetTrackingDeviceType(mitk::TrackingDeviceType type, bool changeable /*= true*/)
 {
-  std::string filename = QFileDialog::getOpenFileName(NULL, tr("Open Surface"), QmitkIGTCommonHelper::GetLastFileLoadPath(), tr("STL (*.stl)")).toLatin1().data();
-  QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(QString::fromStdString(filename));
-  try
-  {
-    mitk::IOUtil::Load(filename.c_str(), *m_DataStorage);
-  }
-  catch (mitk::Exception &e)
+  //Adapt Gui
+  int index = m_Controls->m_TrackingDeviceTypeChooser->findText(QString::fromStdString(type));
+
+  if (index >= 0)
   {
-    MITK_ERROR << "Exception occured: " << e.what();
+    m_Controls->m_TrackingDeviceTypeChooser->setCurrentIndex(index);
   }
-}
 
-void QmitkNavigationToolCreationWidget::OnLoadCalibrationFile()
-{
-  QString fileName = QFileDialog::getOpenFileName(NULL, tr("Open Calibration File"), QmitkIGTCommonHelper::GetLastFileLoadPath(), "*.*");
-  QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(fileName);
-  m_Controls->m_CalibrationFileName->setText(fileName);
-  m_ToolToBeEdited->SetCalibrationFile(fileName.toStdString());
-}
+  m_Controls->m_TrackingDeviceTypeChooser->setEditable(changeable);
 
+  //Set data to member
+  m_ToolToBeEdited->SetTrackingDeviceType(type);
+}
 
 
 //##################################################################################
 //############################## internal help methods #############################
 //##################################################################################
 void QmitkNavigationToolCreationWidget::MessageBox(std::string s)
 {
   QMessageBox msgBox;
   msgBox.setText(s.c_str());
   msgBox.exec();
 }
 
-void QmitkNavigationToolCreationWidget::OnShowEditToolTipOptions(bool state)
+void QmitkNavigationToolCreationWidget::OnEditToolTip()
 {
-  if (state)
-  {
-    if (!m_AdvancedWidget)
-    {
-      m_AdvancedWidget = new QmitkNavigationToolCreationAdvancedWidget(this);
-      m_AdvancedWidget->setWindowFlags(Qt::Tool | Qt::WindowStaysOnTopHint);
-      m_AdvancedWidget->setWindowTitle("Tool Creation Advanced Options");
-      m_AdvancedWidget->setModal(false);
-    }
+  m_ToolTransformationWidget->SetGeometryPointer(m_ToolToBeEdited->GetDataNode()->GetData()->GetGeometry());
+  m_ToolTransformationWidget->SetValues(m_ToolToBeEdited->GetToolTipTransform());
 
-    m_AdvancedWidget->SetDefaultTooltip(m_ToolToBeEdited->GetToolTipTransform());
 
-    // reinit the views with the new nodes
-    mitk::DataStorage::SetOfObjects::ConstPointer rs = m_DataStorage->GetAll();
-    mitk::TimeGeometry::Pointer bounds = m_DataStorage->ComputeBoundingGeometry3D(rs, "visible");    // initialize the views to the bounding geometry
-    mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
-  }
-  else
-  {
-    delete m_AdvancedWidget;
-  }
+
+  QVBoxLayout *mainLayout = new QVBoxLayout;
+  mainLayout->addWidget(m_ToolTransformationWidget);
+  m_ToolEditDialog.setLayout(mainLayout);
+  m_ToolEditDialog.setWindowTitle("Edit Tool Tip and Tool Orientation");
+  m_ToolEditDialog.open();
 }
 
-void QmitkNavigationToolCreationWidget::OnProcessDialogCloseRequest()
+void QmitkNavigationToolCreationWidget::OnEditToolTipFinished(mitk::AffineTransform3D::Pointer toolTip)
 {
-  //This function is called, when the toolTipEdit view is closed. Either by cancle in the
-  delete m_AdvancedWidget;
+  m_ToolEditDialog.close();
+  //This function is called, when the toolTipEdit view is closed.
+  m_ToolToBeEdited->SetToolTipPosition(toolTip->GetOffset());
+  mitk::NavigationData::Pointer tempND = mitk::NavigationData::New(toolTip);//Convert to Navigation data for simple transversion to quaternion
+  m_ToolToBeEdited->SetToolTipOrientation(tempND->GetOrientation());
 
   //Update Label
-  mitk::AffineTransform3D::Pointer tooltip = m_AdvancedWidget->GetManipulatedToolTip();
-  mitk::NavigationData::Pointer transformConversionHelper = mitk::NavigationData::New(tooltip);
   QString _label = "(" +
-    QString::number(tooltip->GetOffset()[0], 'f', 1) + ", " +
-    QString::number(tooltip->GetOffset()[1], 'f', 1) + ", " +
-    QString::number(tooltip->GetOffset()[2], 'f', 1) + "), quat: [" +
-    QString::number(transformConversionHelper->GetOrientation()[0], 'f', 2) + ", " +
-    QString::number(transformConversionHelper->GetOrientation()[1], 'f', 2) + ", " +
-    QString::number(transformConversionHelper->GetOrientation()[2], 'f', 2) + ", " +
-    QString::number(transformConversionHelper->GetOrientation()[3], 'f', 2) + "]";
+    QString::number(m_ToolToBeEdited->GetToolTipPosition()[0], 'f', 1) + ", " +
+    QString::number(m_ToolToBeEdited->GetToolTipPosition()[1], 'f', 1) + ", " +
+    QString::number(m_ToolToBeEdited->GetToolTipPosition()[2], 'f', 1) + "), quat: [" +
+    QString::number(m_ToolToBeEdited->GetToolTipOrientation()[0], 'f', 2) + ", " +
+    QString::number(m_ToolToBeEdited->GetToolTipOrientation()[1], 'f', 2) + ", " +
+    QString::number(m_ToolToBeEdited->GetToolTipOrientation()[2], 'f', 2) + ", " +
+    QString::number(m_ToolToBeEdited->GetToolTipOrientation()[3], 'f', 2) + "]";
   m_Controls->m_ToolTipLabel->setText(_label);
 }
 
-void QmitkNavigationToolCreationWidget::OnRetrieveDataForManualTooltipManipulation()
-{
-  if (m_Controls->m_Surface_Use_Sphere->isChecked())
-  {
-    m_AdvancedWidget->SetToolTipSurface(true);
-  }
-  else
-  {
-    m_AdvancedWidget->SetToolTipSurface(false,
-      dynamic_cast<mitk::DataNode*>(m_Controls->m_SurfaceChooser->GetSelectedNode().GetPointer()));
-  }
-}
-
 
 void QmitkNavigationToolCreationWidget::FillUIToolLandmarkLists(mitk::PointSet::Pointer calLandmarks, mitk::PointSet::Pointer regLandmarks)
 {
   m_calLandmarkNode->SetData(calLandmarks);
   m_regLandmarkNode->SetData(regLandmarks);
   m_Controls->m_CalibrationLandmarksList->SetPointSetNode(m_calLandmarkNode);
   m_Controls->m_RegistrationLandmarksList->SetPointSetNode(m_regLandmarkNode);
 }
 
 void QmitkNavigationToolCreationWidget::GetUIToolLandmarksLists(mitk::PointSet::Pointer& calLandmarks, mitk::PointSet::Pointer& regLandmarks)
 {
   calLandmarks = dynamic_cast<mitk::PointSet*>(m_calLandmarkNode->GetData());
   regLandmarks = dynamic_cast<mitk::PointSet*>(m_regLandmarkNode->GetData());
 }
 
 void QmitkNavigationToolCreationWidget::InitializeUIToolLandmarkLists()
 {
   m_calLandmarkNode = mitk::DataNode::New();
   m_regLandmarkNode = mitk::DataNode::New();
   FillUIToolLandmarkLists(mitk::PointSet::New(), mitk::PointSet::New());
 }
 
 void QmitkNavigationToolCreationWidget::RefreshTrackingDeviceCollection()
 {
   us::ModuleContext* context = us::GetModuleContext();
   std::vector<us::ServiceReference<mitk::TrackingDeviceTypeCollection> > refs = context->GetServiceReferences<mitk::TrackingDeviceTypeCollection>();
   if (refs.empty())
   {
     MITK_WARN << "No tracking device service found!";
     return;
   }
   mitk::TrackingDeviceTypeCollection* _DeviceTypeCollection = context->GetService<mitk::TrackingDeviceTypeCollection>(refs.front());
 
   for (auto name : _DeviceTypeCollection->GetTrackingDeviceTypeNames())
   {
     //if the device is not included yet, add name to comboBox and widget to stackedWidget
     if (m_Controls->m_TrackingDeviceTypeChooser->findText(QString::fromStdString(name)) == -1)
     {
       m_Controls->m_TrackingDeviceTypeChooser->addItem(QString::fromStdString(name));
     }
   }
 }
\ No newline at end of file
diff --git a/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.h b/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.h
index 1b6163c024..b6c76061c2 100644
--- a/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.h
+++ b/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.h
@@ -1,135 +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 QmitkNavigationToolCreationWidget_H
 #define QmitkNavigationToolCreationWidget_H
 
 //QT headers
 #include <QWidget>
 
 //mitk headers
 #include "MitkIGTUIExports.h"
 #include <mitkNavigationTool.h>
 #include <mitkNavigationToolStorage.h>
 #include <mitkNodePredicateDataType.h>
+#include "QmitkInteractiveTransformationWidget.h"
+
+#include <QDialog>
 
 //Microservices
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usServiceProperties.h>
 #include <usModuleContext.h>
 
 //ui header
 #include "ui_QmitkNavigationToolCreationWidget.h"
 
 /** Documentation:
  *   \brief An object of this class offers an UI to create or modify NavigationTools.
  *
  *          Be sure to call the initialize method before you start the widget
  *          otherwise some errors might occure.
  *
  *   \ingroup IGTUI
  */
 class MITKIGTUI_EXPORT QmitkNavigationToolCreationWidget : public QWidget
 {
   Q_OBJECT
 
 public:
   static const std::string VIEW_ID;
 
   /** @brief Initializes the widget.
     * @param dataStorage  The data storage is needed to offer the possibility to choose surfaces from the data storage for tool visualization.
     * @param supposedIdentifier This Identifier is supposed for the user. It is needed because every identifier in a navigation tool storage must be unique and we don't know the others.
     */
   void Initialize(mitk::DataStorage* dataStorage, const std::string &supposedIdentifier, const std::string &supposedName = "NewTool");
 
   /** @brief Sets the default tracking device type. You may also define if it is changeable or not.*/
   void SetTrackingDeviceType(mitk::TrackingDeviceType type, bool changeable = true);
 
   /** @brief Sets the default data of all input fields. The default data is used from the default tool which is given as parameter. */
   void SetDefaultData(mitk::NavigationTool::Pointer DefaultTool);
 
   QmitkNavigationToolCreationWidget(QWidget* parent = 0, Qt::WindowFlags f = 0);
   ~QmitkNavigationToolCreationWidget();
 
   /** @return Returns the created tool. Returns NULL if no tool was created yet. */
   mitk::NavigationTool::Pointer GetCreatedTool();
 
 signals:
 
   /** @brief This signal is emitted if the user finished the creation of the tool. */
   void NavigationToolFinished();
 
   /** @brief This signal is emitted if the user canceled the creation of the tool. */
   void Canceled();
 
   protected slots:
 
 
   void OnLoadCalibrationFile();
   void OnSurfaceUseOtherToggled();
   void OnLoadSurface();
   void OnEditToolTip();
+  void OnEditToolTipFinished(mitk::AffineTransform3D::Pointer toolTip);
 
   void OnCancel();
   void OnFinished();
 
   void GetValuesFromGuiElements();
 
 private:
 
   //############## private help methods #######################
   /** Shows a message box with the given message s. */
   void MessageBox(std::string s);
 
   /** Set the tool landmark lists in the UI.*/
   void FillUIToolLandmarkLists(mitk::PointSet::Pointer calLandmarks, mitk::PointSet::Pointer regLandmarks);
 
   /** Returns the tool landmark lists from the UI.
   * @param[out] calLandmarks Returns a pointer to the calibration landmarks point set.
   * @param[out] regLandmarks Returns a pointer to the registration landmarks point set.
   */
   void GetUIToolLandmarksLists(mitk::PointSet::Pointer& calLandmarks, mitk::PointSet::Pointer& regLandmarks);
 
   /** Initializes the tool landmark lists in the UI. */
   void InitializeUIToolLandmarkLists();
   void RefreshTrackingDeviceCollection();
 
   void SetGuiElements();
 
+  void SetConeAsToolSurface();
+
 protected:
   /// \brief Creation of the connections
   virtual void CreateConnections();
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   Ui::QmitkNavigationToolCreationWidgetControls* m_Controls;
 
   /** @brief this pointer holds the tool which is edited. If finished is clicked, it will be copied to the final tool, if it is cancled, it is reseted and not used. 
       This can be regarded as the clipboard for all changes.  */
   mitk::NavigationTool::Pointer m_ToolToBeEdited;
 
   /** @brief this pointer holds the tool which is created and returned */
   mitk::NavigationTool::Pointer m_FinalTool;
 
+  QDialog m_ToolEditDialog;
+  QmitkInteractiveTransformationWidget* m_ToolTransformationWidget;
+
   /** @brief holds the DataStorage */
   mitk::DataStorage* m_DataStorage;
 
 
   /** Hold the data nodes which are needed for the landmark widgets. */
   mitk::DataNode::Pointer m_calLandmarkNode, m_regLandmarkNode;
 };
 #endif
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/IGTNavigationToolCalibration.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/IGTNavigationToolCalibration.cpp
index 8539210ecf..b8b4554d4d 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/IGTNavigationToolCalibration.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/IGTNavigationToolCalibration.cpp
@@ -1,721 +1,721 @@
 /*===================================================================
 
 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 <numeric>
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "IGTNavigationToolCalibration.h"
 
 // mitk
 #include <mitkNavigationToolWriter.h>
 #include <mitkTrackingDeviceSource.h>
 #include <mitkTrackingDevice.h>
 #include <mitkTrackingTool.h>
 #include <mitkQuaternionAveraging.h>
 #include <mitkPivotCalibration.h>
 #include <mitkNavigationData.h>
 
 // Qt
 #include <QMessageBox>
 #include <qfiledialog.h>
 
 //vtk
 #include <vtkSphereSource.h>
 
 
 
 const std::string IGTNavigationToolCalibration::VIEW_ID = "org.mitk.views.igtnavigationtoolcalibration";
 
 IGTNavigationToolCalibration::IGTNavigationToolCalibration()
 {}
 
 IGTNavigationToolCalibration::~IGTNavigationToolCalibration()
 {
   //The following code is required due to a bug in the point list widget.
   //If this is removed, MITK crashes when closing the view:
   m_Controls.m_RegistrationLandmarkWidget->SetPointSetNode(NULL);
   m_Controls.m_CalibrationLandmarkWidget->SetPointSetNode(NULL);
 }
 
 void IGTNavigationToolCalibration::SetFocus()
 {
 
 }
 
 void IGTNavigationToolCalibration::OnToolCalibrationMethodChanged(int index)
 {
   //if pivot calibration (3) or manual(0) is chosen only calibration pointer is needed
   if (index == 0 || index == 3) {
 
     if (!CheckInitialization(false)) {
       return;
     }
   }
   else{
     if (!CheckInitialization()) { return; }
   }
 
   UpdateManualToolTipCalibrationView();
   m_Controls.m_CalibrationMethodsWidget->setCurrentIndex(index);
   m_IndexCurrentCalibrationMethod = index;
 }
 
 void IGTNavigationToolCalibration::CreateQtPartControl(QWidget *parent)
 {
   //initialize manual tool editing widget
-  m_ManualToolTipEditWidget = new QmitkNavigationToolCreationAdvancedWidget(parent);
-  m_ManualToolTipEditWidget->setWindowFlags(Qt::Tool | Qt::WindowStaysOnTopHint);
-  m_ManualToolTipEditWidget->setWindowTitle("Edit Tool Tip Manually");
-  m_ManualToolTipEditWidget->setModal(false);
-  m_ManualToolTipEditWidget->SetDataStorage(this->GetDataStorage());
+  //m_ManualToolTipEditWidget = new QmitkNavigationToolCreationAdvancedWidget(parent);
+  //m_ManualToolTipEditWidget->setWindowFlags(Qt::Tool | Qt::WindowStaysOnTopHint);
+  //m_ManualToolTipEditWidget->setWindowTitle("Edit Tool Tip Manually");
+  //m_ManualToolTipEditWidget->setModal(false);
+  //m_ManualToolTipEditWidget->SetDataStorage(this->GetDataStorage());
 
   m_TrackingTimer = new QTimer(this);
 
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
   connect(m_Controls.m_SetToolToCalibrate, SIGNAL(clicked()), this, SLOT(SetToolToCalibrate()));
   connect(m_Controls.m_SetPointer, SIGNAL(clicked()), this, SLOT(SetCalibrationPointer()));
   connect(m_TrackingTimer, SIGNAL(timeout()), this, SLOT(UpdateTrackingTimer()));
   connect(m_Controls.m_AddLandmark, SIGNAL(clicked()), this, SLOT(AddLandmark()));
   connect(m_Controls.m_SaveCalibratedTool, SIGNAL(clicked()), this, SLOT(SaveCalibratedTool()));
   connect(m_Controls.m_AddPivotPose, SIGNAL(clicked()), this, SLOT(OnAddPivotPose()));
   connect(m_Controls.m_ComputePivot, SIGNAL(clicked()), this, SLOT(OnComputePivot()));
   connect(m_Controls.m_UseComputedPivotPoint, SIGNAL(clicked()), this, SLOT(OnUseComputedPivotPoint()));
   connect(m_Controls.m_StartEditTooltipManually, SIGNAL(clicked()), this, SLOT(OnStartManualToolTipCalibration()));
   connect(m_Controls.m_GetPositions, SIGNAL(clicked()), this, SLOT(OnGetPositions()));
   connect(m_Controls.m_ToolAxis_X, SIGNAL(valueChanged(double)), this, SLOT(OnToolAxisSpinboxChanged()));
   connect(m_Controls.m_ToolAxis_Y, SIGNAL(valueChanged(double)), this, SLOT(OnToolAxisSpinboxChanged()));
   connect(m_Controls.m_ToolAxis_Z, SIGNAL(valueChanged(double)), this, SLOT(OnToolAxisSpinboxChanged()));
   connect(m_Controls.m_CalibrateToolAxis, SIGNAL(clicked()), this, SLOT(OnCalibrateToolAxis()));
-  connect((QObject*)(m_ManualToolTipEditWidget), SIGNAL(RetrieveDataForManualToolTipManipulation()), this, SLOT(OnRetrieveDataForManualTooltipManipulation()));
-  connect((QObject*)(m_ManualToolTipEditWidget), SIGNAL(DialogCloseRequested()), this, SLOT(OnProcessManualTooltipEditDialogCloseRequest()));
+  //connect((QObject*)(m_ManualToolTipEditWidget), SIGNAL(RetrieveDataForManualToolTipManipulation()), this, SLOT(OnRetrieveDataForManualTooltipManipulation()));
+  //connect((QObject*)(m_ManualToolTipEditWidget), SIGNAL(DialogCloseRequested()), this, SLOT(OnProcessManualTooltipEditDialogCloseRequest()));
   connect(m_Controls.m_CalibrationMethodComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnToolCalibrationMethodChanged(int)));
 
   connect((QObject*)(m_Controls.m_RunCalibrationButton), SIGNAL(clicked()), (QObject*) this, SLOT(OnRunSingleRefToolCalibrationClicked()));
   connect((QObject*)(m_Controls.m_CollectNavigationDataButton), SIGNAL(clicked()), (QObject*) this, SLOT(OnLoginSingleRefToolNavigationDataClicked()));
   connect((QObject*)(m_Controls.m_SetNewToolTipPosButton), SIGNAL(clicked()), (QObject*) this, SLOT(OnSetNewToolTipPosButtonClicked()));
 
   m_IDToolToCalibrate = -1;
   m_IDCalibrationPointer = -1;
   m_IndexCurrentCalibrationMethod = -1;
   m_OnLoginSingleRefToolNavigationDataClicked = false;
   m_NumberOfNavigationDataCounter = 0;
   m_NumberOfNavigationData = -1;
 
   //for pivot calibration
   m_OnAddPivotPoseClicked = false;
   PivotCount = 0;
   m_PivotPoses = std::vector<mitk::NavigationData::Pointer>();
 
   m_CalibrationLandmarks = mitk::PointSet::New();
   m_CalibrationLandmarksNode = mitk::DataNode::New();
   m_CalibrationLandmarksNode->SetData(m_CalibrationLandmarks);
   m_Controls.m_CalibrationLandmarkWidget->SetPointSetNode(m_CalibrationLandmarksNode);
 
   m_RegistrationLandmarks = mitk::PointSet::New();
   m_RegistrationLandmarksNode = mitk::DataNode::New();
   m_RegistrationLandmarksNode->SetData(m_RegistrationLandmarks);
   m_Controls.m_RegistrationLandmarkWidget->SetPointSetNode(m_RegistrationLandmarksNode);
 
   m_ToolSurfaceInToolCoordinatesDataNode = mitk::DataNode::New();
   m_ToolSurfaceInToolCoordinatesDataNode->SetName("ToolSurface(ToolCoordinates)");
 
   m_LoggedNavigationDataDifferences = std::vector< mitk::NavigationData::Pointer >();
 }
 
 
 void IGTNavigationToolCalibration::OnRunSingleRefToolCalibrationClicked()
 {
   if (!CheckInitialization()) { return; }
 
   mitk::NavigationData::Pointer ToolTipTransform = mitk::NavigationData::New();
 
   if (m_Controls.m_CalibratePosition->isChecked())
   {
     //1: Compute mean translational offset vector
     m_ResultOffsetVector.Fill(0);
     for (std::vector<mitk::Point3D>::iterator vecIter = m_LoggedNavigationDataOffsets.begin(); vecIter != m_LoggedNavigationDataOffsets.end(); vecIter++)
     {
       m_ResultOffsetVector[0] = m_ResultOffsetVector[0] + (*vecIter)[0];
       m_ResultOffsetVector[1] = m_ResultOffsetVector[1] + (*vecIter)[1];
       m_ResultOffsetVector[2] = m_ResultOffsetVector[2] + (*vecIter)[2];
     }
     m_ResultOffsetVector[0] = m_ResultOffsetVector[0] / m_LoggedNavigationDataOffsets.size();
     m_ResultOffsetVector[1] = m_ResultOffsetVector[1] / m_LoggedNavigationDataOffsets.size();
     m_ResultOffsetVector[2] = m_ResultOffsetVector[2] / m_LoggedNavigationDataOffsets.size();
 
     this->m_Controls.m_ResultOfCalibration->setText(
       QString("x: ") + QString(QString::number(m_ResultOffsetVector[0], 103, 3)) +
       QString("; y: ") + (QString::number(m_ResultOffsetVector[1], 103, 3)) +
       QString("; z: ") + (QString::number(m_ResultOffsetVector[2], 103, 3)));
 
 
     ToolTipTransform->SetPosition(m_ResultOffsetVector);
   }
 
 
   if (m_Controls.m_CalibrateOrientation->isChecked())
   {
     //2: Compute mean orientation
     mitk::Quaternion meanOrientation;
     std::vector <mitk::Quaternion> allOrientations = std::vector <mitk::Quaternion>();
     for (int i = 0; i < m_LoggedNavigationDataDifferences.size(); i++) { allOrientations.push_back(m_LoggedNavigationDataDifferences.at(i)->GetOrientation()); }
     meanOrientation = mitk::QuaternionAveraging::CalcAverage(allOrientations);
     this->m_Controls.m_ResultOfCalibrationOrientation->setText(
       QString("qx: ") + QString(QString::number(meanOrientation.x(), 103, 3)) +
       QString("; qy: ") + (QString::number(meanOrientation.y(), 103, 3)) +
       QString("; qz: ") + (QString::number(meanOrientation.z(), 103, 3)) +
       QString("; qr: ") + (QString::number(meanOrientation.r(), 103, 3)));
 
     ToolTipTransform->SetOrientation(meanOrientation);
   }
 
   MITK_INFO << "Computed calibration: ";
   MITK_INFO << "Translation Vector: " << ToolTipTransform->GetPosition();
   MITK_INFO << "Quaternion: (" << ToolTipTransform->GetOrientation() << ")";
   MITK_INFO << "Euler Angles [rad]: (" << ToolTipTransform->GetOrientation().rotation_euler_angles() << ")";
   MITK_INFO << "Matrix:";
   vnl_matrix_fixed<double, 3, 3> rotMatrix = ToolTipTransform->GetOrientation().rotation_matrix_transpose();
   MITK_INFO << rotMatrix[0][0] << " " << rotMatrix[0][1] << " " << rotMatrix[0][2] << std::endl;
   MITK_INFO << rotMatrix[1][0] << " " << rotMatrix[1][1] << " " << rotMatrix[1][2] << std::endl;
   MITK_INFO << rotMatrix[2][0] << " " << rotMatrix[2][1] << " " << rotMatrix[2][2] << std::endl;
 
   //3: write everything into the final tool tip transform and save it as member (it will be written to the tool later on)
   mitk::NavigationData::Pointer ToolTipInTrackingCoordinates = mitk::NavigationData::New();
   ToolTipInTrackingCoordinates->Compose(ToolTipTransform);
   ToolTipInTrackingCoordinates->Compose(m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate));
   ShowToolTipPreview(ToolTipInTrackingCoordinates);
   m_Controls.m_SetNewToolTipPosButton->setEnabled(true);
   m_ComputedToolTipTransformation = ToolTipTransform;
 
 }
 
 void IGTNavigationToolCalibration::OnLoginSingleRefToolNavigationDataClicked()
 {
   if (!CheckInitialization()) { return; }
   m_OnLoginSingleRefToolNavigationDataClicked = true;
   m_Controls.m_CollectNavigationDataButton->setEnabled(false);
   m_NumberOfNavigationData = m_Controls.m_NumberOfNavigationDataToCollect->value();
   MITK_INFO << "Collecting " << m_NumberOfNavigationData << " NavigationData ... " << endl;
 }
 
 void IGTNavigationToolCalibration::LoginSingleRefToolNavigationData()
 {
   if (!CheckInitialization()) { return; }
 
   if (m_NumberOfNavigationDataCounter < m_NumberOfNavigationData)
   {
     //update label text
     QString labelText = "Collecting Data: " + QString::number(m_NumberOfNavigationDataCounter);
     m_Controls.m_CollectionStatus->setText(labelText);
 
     mitk::NavigationData::Pointer referenceTool = m_NavigationDataSourceOfCalibrationPointer->GetOutput(m_IDCalibrationPointer);
     mitk::NavigationData::Pointer toolToCalibrate = m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate);
 
     //compute difference:
     // differenceND = toolToCalibrate^-1 * referenceTool
     mitk::NavigationData::Pointer differenceND = mitk::NavigationData::New();
     differenceND->Compose(referenceTool);
     differenceND->Compose(toolToCalibrate->GetInverse());
 
     //inverse mode...
     if (m_Controls.m_InvertQuaternions->isChecked())
     {
       // negate identity matrix to directly show parameters that will set up in NDI 6D Software Architect
       differenceND = differenceND->GetInverse();
     }
 
     //save difference in member
     m_LoggedNavigationDataOffsets.push_back(differenceND->GetPosition());
     m_LoggedNavigationDataDifferences.push_back(differenceND);
     m_NumberOfNavigationDataCounter++;
   }
 
   if (m_NumberOfNavigationDataCounter == m_NumberOfNavigationData)
   {
     m_NumberOfNavigationDataCounter = 0;
     m_OnLoginSingleRefToolNavigationDataClicked = false;
     m_Controls.m_CollectNavigationDataButton->setEnabled(true);
     m_Controls.m_RunCalibrationButton->setEnabled(true);
     MITK_INFO << "Collecting " << m_NumberOfNavigationData << " NavigationData ... Finished" << endl;
     QString labelText = "Collected " + QString::number(m_NumberOfNavigationData) + " data samples!";
     m_Controls.m_CollectionStatus->setText(labelText);
   }
 }
 
 void IGTNavigationToolCalibration::OnSetNewToolTipPosButtonClicked()
 {
   ApplyToolTipTransform(m_ComputedToolTipTransformation);
   RemoveToolTipPreview();
 }
 
 void IGTNavigationToolCalibration::ClearOldPivot()
 {
   mitk::NavigationData::Pointer tempND = mitk::NavigationData::New();
   this->ApplyToolTipTransform(tempND);
   UpdateManualToolTipCalibrationView();
-  m_ManualToolTipEditWidget->hide(); //TODO
+  //m_ManualToolTipEditWidget->hide(); //TODO
   this->GetDataStorage()->Remove(m_ToolSurfaceInToolCoordinatesDataNode);
 }
 void IGTNavigationToolCalibration::OnAddPivotPose()
 {
   ClearOldPivot();
   //When the collect Poses Button is Clicked 
   m_OnAddPivotPoseClicked = true;
   m_NumberOfNavigationData = m_Controls.m_PosesToCollect->value();
 
 }
 
 void IGTNavigationToolCalibration::AddPivotPose()
 {
   //Save the poses to be used in computation 
   if (PivotCount < m_NumberOfNavigationData)
   {
     mitk::NavigationData::Pointer currentPose = mitk::NavigationData::New();
     currentPose->Graft(m_Controls.m_SelectionWidget->GetSelectedNavigationDataSource()->GetOutput(m_IDToolToCalibrate));
     m_PivotPoses.push_back(currentPose);
     m_Controls.m_PoseNumber->setText(QString::number(m_PivotPoses.size()));
     PivotCount++;
   }
   if (PivotCount == m_NumberOfNavigationData)
   {
     m_OnAddPivotPoseClicked = false;
   }
 }
 
 void IGTNavigationToolCalibration::OnComputePivot()
 {
 
   mitk::PivotCalibration::Pointer myPivotCalibration = mitk::PivotCalibration::New();
   for (int i = 0; i < this->m_PivotPoses.size(); i++)
   {
     myPivotCalibration->AddNavigationData(m_PivotPoses.at(i));
   }
   QString resultString;
   if (myPivotCalibration->ComputePivotResult())
   {
 
     mitk::NavigationData::Pointer markerTransformationTrackingCoordinates = m_PivotPoses.at(0);
 
     //Get computed pivot transfromation in tool coordinates
 
 
     mitk::NavigationData::Pointer ToolTipToTool = mitk::NavigationData::New();
     ToolTipToTool->SetPosition(myPivotCalibration->GetResultPivotPoint());
     ToolTipToTool->SetOrientation(myPivotCalibration->GetResultPivotRotation());
     mitk::NavigationData::Pointer TrackerToTool = mitk::NavigationData::New();
     TrackerToTool->SetOrientation(markerTransformationTrackingCoordinates->GetOrientation());
     TrackerToTool->SetPosition(markerTransformationTrackingCoordinates->GetPosition());
     TrackerToTool->Compose(ToolTipToTool);
 
     // Compute pivot point in relation to marker transformation for preview
     mitk::NavigationData::Pointer ToolTipToTracker = mitk::NavigationData::New();
     ToolTipToTracker->Compose(ToolTipToTool);
     ToolTipToTracker->Compose(markerTransformationTrackingCoordinates);
 
     //add the preview node to the data storage
     ShowToolTipPreview(ToolTipToTracker);
 
     //parse result string
     resultString = QString("Pivot computation succeeded!\n")
       + QString("RMS Error: ") + QString::number(myPivotCalibration->GetResultRMSError()) + QString("\n")
       + QString("Pivot Point: ") + QString::number(myPivotCalibration->GetResultPivotPoint()[0]) + ";" + QString::number(myPivotCalibration->GetResultPivotPoint()[1]) + ";" + QString::number(myPivotCalibration->GetResultPivotPoint()[2]) + QString("\n")
       + QString("Pivot Rotation: ") + QString::number(myPivotCalibration->GetResultPivotRotation()[0]) + ";" + QString::number(myPivotCalibration->GetResultPivotRotation()[1]) + ";" + QString::number(myPivotCalibration->GetResultPivotRotation()[2]) + ";" + QString::number(myPivotCalibration->GetResultPivotRotation()[3]) + QString("\n");
 
     //finally: save results to member variable
     m_ComputedToolTipTransformation = ToolTipToTool;
 
 
     //enable button to use the computed point with the tool
     m_Controls.m_UseComputedPivotPoint->setEnabled(true);
   }
   else
   {
     resultString = "Pivot computation failed!";
   }
   MITK_INFO << resultString.toStdString().c_str();
   m_Controls.m_ResultText->setText(resultString);
 
 }
 void IGTNavigationToolCalibration::UpdatePivotCount()
 {
   PivotCount = 0;
   while (!m_PivotPoses.empty())
   {
     m_PivotPoses.pop_back();
   }
   m_Controls.m_PoseNumber->setText(QString::number(PivotCount));
 }
 
 void IGTNavigationToolCalibration::OnUseComputedPivotPoint()
 {
   RemoveToolTipPreview();
   QString resultString = QString("Pivoted tool tip transformation was written to the tool ") + m_ToolToCalibrate->GetToolName().c_str();
   ApplyToolTipTransform(m_ComputedToolTipTransformation, resultString.toStdString());
   m_Controls.m_ResultText->setText(resultString);
   UpdatePivotCount();
 }
 
 void IGTNavigationToolCalibration::ApplyToolTipTransform(mitk::NavigationData::Pointer ToolTipTransformInToolCoordinates, std::string message)
 {
   if (!CheckInitialization(false)) { return; }
 
   //Update tool in tool storage
   m_ToolToCalibrate->SetToolTipPosition(ToolTipTransformInToolCoordinates->GetPosition());
   m_ToolToCalibrate->SetToolTipOrientation(ToolTipTransformInToolCoordinates->GetOrientation());
 
   //And also update tracking device, so the transform is directly used
   mitk::TrackingDeviceSource::Pointer trackingDeviceSource;
   try
   {
     trackingDeviceSource = dynamic_cast<mitk::TrackingDeviceSource*>(m_NavigationDataSourceOfToolToCalibrate.GetPointer());
     mitk::TrackingTool::Pointer TrackingToolToCalibrate = trackingDeviceSource->GetTrackingDevice()->GetTool(m_IDToolToCalibrate);
     TrackingToolToCalibrate->SetToolTip(ToolTipTransformInToolCoordinates->GetPosition(), ToolTipTransformInToolCoordinates->GetOrientation());
   }
   catch (std::exception& e)
   {
     MITK_ERROR << "Error while trying to set the tool tip to the running tracking device. Aborting! (" << e.what() << ")";
   }
   MITK_INFO << message;
 }
 
 void IGTNavigationToolCalibration::ShowToolTipPreview(mitk::NavigationData::Pointer ToolTipInTrackingCoordinates)
 {
   mitk::DataNode::Pointer m_ToolTipPointPreview = mitk::DataNode::New();
   m_ToolTipPointPreview->SetName("Modified Tool Tip Preview");
   mitk::Color blue;
   blue.SetBlue(1);
   m_ToolTipPointPreview->SetColor(blue);
   mitk::Surface::Pointer mySphere = mitk::Surface::New();
   vtkSphereSource *vtkData = vtkSphereSource::New();
   vtkData->SetRadius(3.0f);
   vtkData->SetCenter(0.0, 0.0, 0.0);
   vtkData->Update();
   mySphere->SetVtkPolyData(vtkData->GetOutput());
   vtkData->Delete();
   m_ToolTipPointPreview->SetData(mySphere);
   m_ToolTipPointPreview->GetData()->GetGeometry()->SetIndexToWorldTransform(ToolTipInTrackingCoordinates->GetAffineTransform3D());
   this->GetDataStorage()->Add(m_ToolTipPointPreview);
 }
 
 void IGTNavigationToolCalibration::RemoveToolTipPreview()
 {
   this->GetDataStorage()->Remove(m_ToolTipPointPreview.GetPointer());
 }
 void IGTNavigationToolCalibration::UpdateManualToolTipCalibrationView()
 {
   if (m_ToolToCalibrate.IsNull()) { return; }
   //parse human readable transformation data and display it
   std::stringstream translation;
   std::stringstream orientation;
   translation << m_ToolToCalibrate->GetToolTipPosition();
   orientation << "Quaternion: (" << m_ToolToCalibrate->GetToolTipOrientation() << ")" << std::endl;
   orientation << std::endl;
   orientation << "Euler Angles [rad]: (" << m_ToolToCalibrate->GetToolTipOrientation().rotation_euler_angles() << ")" << std::endl;
   orientation << std::endl;
   orientation << "Matrix:" << std::endl;
   vnl_matrix_fixed<double, 3, 3> rotMatrix = m_ToolToCalibrate->GetToolTipOrientation().rotation_matrix_transpose();
   orientation << rotMatrix[0][0] << " " << rotMatrix[0][1] << " " << rotMatrix[0][2] << std::endl;
   orientation << rotMatrix[1][0] << " " << rotMatrix[1][1] << " " << rotMatrix[1][2] << std::endl;
   orientation << rotMatrix[2][0] << " " << rotMatrix[2][1] << " " << rotMatrix[2][2] << std::endl;
   m_Controls.m_ManualCurrentTranslation->setText(translation.str().c_str());
   m_Controls.m_ManualCurrentOrientation->setPlainText(orientation.str().c_str());
 }
 
 void IGTNavigationToolCalibration::OnStartManualToolTipCalibration()
 {
   if (!CheckInitialization(false)) { return; }
-  m_ManualToolTipEditWidget->SetToolTipSurface(false, m_ToolToCalibrate->GetDataNode());
-  m_ManualToolTipEditWidget->show(); //TODO
-  m_ManualToolTipEditWidget->SetDefaultTooltip(m_ToolToCalibrate->GetToolTipTransform());
-  m_ManualToolTipEditWidget->ReInitialize();
+  //m_ManualToolTipEditWidget->SetToolTipSurface(false, m_ToolToCalibrate->GetDataNode());
+  //m_ManualToolTipEditWidget->show(); //TODO
+  //m_ManualToolTipEditWidget->SetDefaultTooltip(m_ToolToCalibrate->GetToolTipTransform());
+  //m_ManualToolTipEditWidget->ReInitialize();
 }
 
 void IGTNavigationToolCalibration::OnRetrieveDataForManualTooltipManipulation()
 {
   this->GetDataStorage()->Add(m_ToolSurfaceInToolCoordinatesDataNode);
-  m_ManualToolTipEditWidget->SetToolTipSurface(false, m_ToolSurfaceInToolCoordinatesDataNode);
+  //m_ManualToolTipEditWidget->SetToolTipSurface(false, m_ToolSurfaceInToolCoordinatesDataNode);
 }
 
 void IGTNavigationToolCalibration::OnProcessManualTooltipEditDialogCloseRequest()
 {
-  mitk::NavigationData::Pointer tempND = mitk::NavigationData::New(m_ManualToolTipEditWidget->GetManipulatedToolTip());
-  this->ApplyToolTipTransform(tempND);
-  UpdateManualToolTipCalibrationView();
-  m_ManualToolTipEditWidget->hide(); //TODO
-  this->GetDataStorage()->Remove(m_ToolSurfaceInToolCoordinatesDataNode);
+  //mitk::NavigationData::Pointer tempND = mitk::NavigationData::New(m_ManualToolTipEditWidget->GetManipulatedToolTip());
+  //this->ApplyToolTipTransform(tempND);
+  //UpdateManualToolTipCalibrationView();
+  //m_ManualToolTipEditWidget->hide(); //TODO
+  //this->GetDataStorage()->Remove(m_ToolSurfaceInToolCoordinatesDataNode);
 }
 
 void IGTNavigationToolCalibration::OnGetPositions()
 {
   if (!CheckInitialization(true)) { return; }
 
   //Navigation Data from Tool which should be calibrated
   if (!m_AxisCalibration_ToolToCalibrate)
     m_AxisCalibration_ToolToCalibrate = mitk::NavigationData::New();
   m_AxisCalibration_ToolToCalibrate->Graft(m_Controls.m_SelectionWidget->GetSelectedNavigationDataSource()->GetOutput(m_IDToolToCalibrate));
 
   //Navigation Data from calibration pointer tool
   if (!m_AxisCalibration_NavDataCalibratingTool)
     m_AxisCalibration_NavDataCalibratingTool = mitk::NavigationData::New();
   m_AxisCalibration_NavDataCalibratingTool->Graft(m_Controls.m_SelectionWidget->GetSelectedNavigationDataSource()->GetOutput(m_IDCalibrationPointer));
 
   MITK_DEBUG << "Positions for tool axis calibration:";
   MITK_DEBUG << "    ToolTip: " << m_AxisCalibration_ToolToCalibrate->GetPosition() << ",";
   MITK_DEBUG << "    Rotation: \n" << m_AxisCalibration_ToolToCalibrate->GetRotationMatrix();
   MITK_DEBUG << "    End of the tool: " << m_AxisCalibration_NavDataCalibratingTool->GetPosition();
 
   QString _label = "Position recorded: " + QString::number(m_AxisCalibration_NavDataCalibratingTool->GetPosition()[0], 'f', 1) + ", "
     + QString::number(m_AxisCalibration_NavDataCalibratingTool->GetPosition()[1], 'f', 1) + ", "
     + QString::number(m_AxisCalibration_NavDataCalibratingTool->GetPosition()[2], 'f', 1);
   m_Controls.m_ToolAxisPositionLabel->setText(_label);
 }
 
 void IGTNavigationToolCalibration::OnCalibrateToolAxis()
 {
   if (!m_AxisCalibration_ToolToCalibrate || !m_AxisCalibration_NavDataCalibratingTool)
   {
     MITK_ERROR << "Please record position first.";
     return;
   }
 
   //Calculate the tool tip
   //here is an explanation, what is happening here:
   /*
   The axis is equal to the (tool tip) minus the (end of the tool) in tool coordinates of the tool which should be calibrated.
   The tool tip in tool coordinates is zero (definition of the tip).
   The end of the tool is recorded by the calibration pointer's position and is transformed using the inverse of the tool which should be calibrated.
   Normalize it.
   */
   m_CalibratedToolAxis = -m_AxisCalibration_ToolToCalibrate->GetInverse()->TransformPoint(m_AxisCalibration_NavDataCalibratingTool->GetPosition()).GetVectorFromOrigin();
   MITK_DEBUG << "Tool Endpoint in Tool coordinates: " << m_CalibratedToolAxis;
   m_CalibratedToolAxis.Normalize();
   MITK_DEBUG << "Tool Axis: " << m_CalibratedToolAxis;
 
   m_ToolToCalibrate->SetToolAxis(m_CalibratedToolAxis);
 
   //Update GUI
   QString calibratedToolAxisString = "Tool Axis: " + QString::number(m_CalibratedToolAxis.GetElement(0), 'f', 3) + ", " +
     QString::number(m_CalibratedToolAxis.GetElement(1), 'f', 3) + ", " + QString::number(m_CalibratedToolAxis.GetElement(2), 'f', 3);
   m_Controls.m_ToolAxisCalibrationLabel->setText(calibratedToolAxisString);
 
   //Block QT signals, we don't want to emit SpinboxChanged on the first value to overwrite the next ones
   m_Controls.m_ToolAxis_X->blockSignals(true); m_Controls.m_ToolAxis_Y->blockSignals(true); m_Controls.m_ToolAxis_Z->blockSignals(true);
   m_Controls.m_ToolAxis_X->setValue(m_CalibratedToolAxis[0]);
   m_Controls.m_ToolAxis_Y->setValue(m_CalibratedToolAxis[1]);
   m_Controls.m_ToolAxis_Z->setValue(m_CalibratedToolAxis[2]);
   m_Controls.m_ToolAxis_X->blockSignals(false); m_Controls.m_ToolAxis_Y->blockSignals(false); m_Controls.m_ToolAxis_Z->blockSignals(false);
 }
 
 void IGTNavigationToolCalibration::OnToolAxisSpinboxChanged()
 {
   m_CalibratedToolAxis.SetElement(0, m_Controls.m_ToolAxis_X->value());
   m_CalibratedToolAxis.SetElement(1, m_Controls.m_ToolAxis_Y->value());
   m_CalibratedToolAxis.SetElement(2, m_Controls.m_ToolAxis_Z->value());
   m_ToolToCalibrate->SetToolAxis(m_CalibratedToolAxis);
   MITK_INFO << "Tool axis changed to " << m_CalibratedToolAxis;
 }
 
 void IGTNavigationToolCalibration::SetToolToCalibrate()
 {
   m_IDToolToCalibrate = m_Controls.m_SelectionWidget->GetSelectedToolID();
   if (m_IDToolToCalibrate == -1) //no valid tool to calibrate
   {
     m_Controls.m_CalToolLabel->setText("<none>");
     m_Controls.m_StatusWidgetToolToCalibrate->RemoveStatusLabels();
     m_TrackingTimer->stop();
   }
   else
   {
     m_ToolToCalibrate = m_Controls.m_SelectionWidget->GetSelectedNavigationTool();
     m_NavigationDataSourceOfToolToCalibrate = m_Controls.m_SelectionWidget->GetSelectedNavigationDataSource();
     m_Controls.m_CalToolLabel->setText(m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate)->GetName());
     //initialize widget
     m_Controls.m_StatusWidgetToolToCalibrate->RemoveStatusLabels();
     m_Controls.m_StatusWidgetToolToCalibrate->SetShowPositions(true);
     m_Controls.m_StatusWidgetToolToCalibrate->SetTextAlignment(Qt::AlignLeft);
     m_Controls.m_StatusWidgetToolToCalibrate->AddNavigationData(m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate));
     m_Controls.m_StatusWidgetToolToCalibrate->ShowStatusLabels();
     //initialize manual tool tip calibration view
     UpdateManualToolTipCalibrationView();
     //save tool surface in tool coordinates for further editing
     mitk::Surface::Pointer ToolSurface = dynamic_cast<mitk::Surface*>(m_ToolToCalibrate->GetDataNode()->GetData())->Clone();
     m_ToolSurfaceInToolCoordinatesDataNode->SetData(ToolSurface);
     m_ToolSurfaceInToolCoordinatesDataNode->GetData()->GetGeometry()->SetIdentity();
 
     //Set the default needle axis
     m_CalibratedToolAxis = m_ToolToCalibrate->GetToolAxis().GetVectorFromOrigin();
     //Block QT signals, we don't want to emit SpinboxChanged on the first value to overwrite the next ones
     m_Controls.m_ToolAxis_X->blockSignals(true); m_Controls.m_ToolAxis_Y->blockSignals(true); m_Controls.m_ToolAxis_Z->blockSignals(true);
     m_Controls.m_ToolAxis_X->setValue(m_CalibratedToolAxis[0]);
     m_Controls.m_ToolAxis_Y->setValue(m_CalibratedToolAxis[1]);
     m_Controls.m_ToolAxis_Z->setValue(m_CalibratedToolAxis[2]);
     m_Controls.m_ToolAxis_X->blockSignals(false); m_Controls.m_ToolAxis_Y->blockSignals(false); m_Controls.m_ToolAxis_Z->blockSignals(false);
 
     //start updating timer for status widgets, etc.
     if (!m_TrackingTimer->isActive()) m_TrackingTimer->start(100);
   }
 }
 
 void IGTNavigationToolCalibration::SetCalibrationPointer()
 {
   m_IDCalibrationPointer = m_Controls.m_SelectionWidget->GetSelectedToolID();
   if (m_IDCalibrationPointer == -1)
   {
     m_Controls.m_PointerLabel->setText("<none>");
     m_Controls.m_StatusWidgetCalibrationPointer->RemoveStatusLabels();
     m_TrackingTimer->stop();
   }
   else
   {
     m_NavigationDataSourceOfCalibrationPointer = m_Controls.m_SelectionWidget->GetSelectedNavigationDataSource();
     m_Controls.m_PointerLabel->setText(m_NavigationDataSourceOfCalibrationPointer->GetOutput(m_IDCalibrationPointer)->GetName());
     //initialize widget
     m_Controls.m_StatusWidgetCalibrationPointer->RemoveStatusLabels();
     m_Controls.m_StatusWidgetCalibrationPointer->SetShowPositions(true);
     m_Controls.m_StatusWidgetCalibrationPointer->SetTextAlignment(Qt::AlignLeft);
     m_Controls.m_StatusWidgetCalibrationPointer->AddNavigationData(m_NavigationDataSourceOfCalibrationPointer->GetOutput(m_IDCalibrationPointer));
     m_Controls.m_StatusWidgetCalibrationPointer->ShowStatusLabels();
     if (!m_TrackingTimer->isActive()) m_TrackingTimer->start(100);
   }
 }
 
 void IGTNavigationToolCalibration::UpdateOffsetCoordinates()
 {
   if (m_NavigationDataSourceOfCalibrationPointer.IsNull() || m_NavigationDataSourceOfToolToCalibrate.IsNull())
   {
     return;
   }
 
   mitk::NavigationData::Pointer referenceToolND = m_NavigationDataSourceOfCalibrationPointer->GetOutput(m_IDCalibrationPointer);
   mitk::NavigationData::Pointer toolToCalibrateND = m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate);
 
   if (referenceToolND->IsDataValid() && toolToCalibrateND->IsDataValid())
   {
     //computation: difference between both tools (in tool coordinates)
     //differenceND = toolToCalibrateND^-1 * referenceToolND
     mitk::NavigationData::Pointer differenceND = mitk::NavigationData::New();
     differenceND->Compose(referenceToolND);
     differenceND->Compose(toolToCalibrateND->GetInverse());
 
     //display this orientation in the UI
     m_Controls.m_OffsetCoordinates->setText(
       QString("x: ") + QString(QString::number(differenceND->GetPosition()[0], 103, 3)) +
       QString("; y: ") + (QString::number(differenceND->GetPosition()[1], 103, 3)) +
       QString("; z: ") + (QString::number(differenceND->GetPosition()[2], 103, 3)));
 
     m_Controls.m_OrientationOffsetCoordinates->setText(
       QString("qx: ") + QString(QString::number(differenceND->GetOrientation().x(), 103, 3)) +
       QString("; qy: ") + (QString::number(differenceND->GetOrientation().y(), 103, 3)) +
       QString("; qz: ") + (QString::number(differenceND->GetOrientation().z(), 103, 3)) +
       QString("; qr: ") + (QString::number(differenceND->GetOrientation().r(), 103, 3)));
 
     //also update preview if active
     if (m_ToolTipPointPreview.IsNotNull()) //NOT WORKING! TODO: fix or remove!
     {
       mitk::NavigationData::Pointer ToolTipTransform = mitk::NavigationData::New();
       ToolTipTransform->SetPosition(m_ResultOffsetVector);
       mitk::NavigationData::Pointer ToolTipInTrackingCoordinates = mitk::NavigationData::New(); //maybe store as for better peformance...
       ToolTipInTrackingCoordinates->Compose(m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate));
       ToolTipInTrackingCoordinates->Compose(ToolTipTransform);
       m_ToolTipPointPreview->GetData()->GetGeometry()->SetIndexToWorldTransform(ToolTipInTrackingCoordinates->GetAffineTransform3D());
     }
   }
 }
 
 void IGTNavigationToolCalibration::UpdateTrackingTimer()
 {
   m_Controls.m_StatusWidgetToolToCalibrate->Refresh();
   m_Controls.m_StatusWidgetCalibrationPointer->Refresh();
 
   if (m_OnLoginSingleRefToolNavigationDataClicked) LoginSingleRefToolNavigationData();
 
   if (m_OnAddPivotPoseClicked) AddPivotPose();
 
   // 1 == Single Reference Calibration Method
   if (m_IndexCurrentCalibrationMethod == 1) UpdateOffsetCoordinates();
 
 }
 
 void IGTNavigationToolCalibration::AddLandmark()
 {
   if (!CheckInitialization()) { return; }
   mitk::NavigationData::Pointer navDataTool = m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate);
   mitk::Point3D landmark = m_NavigationDataSourceOfCalibrationPointer->GetOutput(m_IDCalibrationPointer)->GetPosition();
 
   //convert to itk transform
   itk::Vector<double, 3> translation;
   for (int k = 0; k < 3; k++) translation[k] = navDataTool->GetPosition()[k];
   itk::Matrix<double, 3, 3> rotation;
   for (int k = 0; k < 3; k++) for (int l = 0; l < 3; l++) rotation[k][l] = navDataTool->GetOrientation().rotation_matrix_transpose()[k][l];
   rotation = rotation.GetTranspose();
   itk::Vector<double> landmarkItk;
   landmarkItk[0] = landmark[0];
   landmarkItk[1] = landmark[1];
   landmarkItk[2] = landmark[2];
 
   //compute landmark in tool coordinates
   itk::Matrix<double, 3, 3> rotationInverse;
   for (int k = 0; k < 3; k++) for (int l = 0; l < 3; l++) rotationInverse[k][l] = rotation.GetInverse()[k][l];
   landmarkItk = rotationInverse * (landmarkItk - translation);
 
   //convert back and add landmark to pointset
   landmark[0] = landmarkItk[0];
   landmark[1] = landmarkItk[1];
   landmark[2] = landmarkItk[2];
   m_RegistrationLandmarks->InsertPoint(m_RegistrationLandmarks->GetSize(), landmark);
 }
 
 void IGTNavigationToolCalibration::SaveCalibratedTool()
 {
   if (m_ToolToCalibrate.IsNotNull())
   {
     mitk::NavigationTool::Pointer calibratedTool = m_ToolToCalibrate;
     calibratedTool->SetToolCalibrationLandmarks(this->m_CalibrationLandmarks);
     calibratedTool->SetToolRegistrationLandmarks(this->m_RegistrationLandmarks);
     mitk::NavigationToolWriter::Pointer myWriter = mitk::NavigationToolWriter::New();
     std::string filename = QFileDialog::getSaveFileName(NULL, tr("Save Navigation Tool"), "/", "*.IGTTool").toUtf8().data();
     filename.append(".IGTTool");
     if (filename == "") return;
     if (myWriter->DoWrite(filename, calibratedTool)) MITK_INFO << "Saved calibrated tool to file " << filename;
     else MITK_WARN << "Can't write tool to file " << filename;
   }
   else
   {
     MITK_ERROR << "Did not find navigation tool storage of calibrated tool, aborting!";
   }
 }
 
 bool IGTNavigationToolCalibration::CheckInitialization(bool CalibrationPointerRequired)
 {
   if ((m_IDToolToCalibrate == -1) ||
     ((CalibrationPointerRequired) &&
     (m_IDCalibrationPointer == -1)
     )
     )
   {
     QMessageBox msgBox;
     msgBox.setText("Tool to calibrate and/or calibration pointer not initialized, cannot proceed!");
     msgBox.exec();
     return false;
   }
   else { return true; }
 }
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/IGTNavigationToolCalibration.h b/Plugins/org.mitk.gui.qt.igttracking/src/internal/IGTNavigationToolCalibration.h
index 60af975a58..0f52510ed3 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/IGTNavigationToolCalibration.h
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/IGTNavigationToolCalibration.h
@@ -1,142 +1,142 @@
 /*===================================================================
 
 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 IGTNavigationToolCalibration_h
 #define IGTNavigationToolCalibration_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 
 #include <mitkNavigationData.h>
-#include <QmitkNavigationToolCreationAdvancedWidget.h>
+
 
 #include "ui_IGTNavigationToolCalibrationControls.h"
 
 #include <mitkNavigationDataRecorder.h>
 
 //QT headers
 #include <QTimer>
 
 
 /*!
   \brief IGTNavigationToolCalibration
 
   \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
   \ingroup ${plugin_target}_internal
   */
 class IGTNavigationToolCalibration : 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:
 
   IGTNavigationToolCalibration();
 
   virtual ~IGTNavigationToolCalibration();
 
   static const std::string VIEW_ID;
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   protected slots:
 
 
   void OnAddPivotPose();
   void OnComputePivot();
   void OnUseComputedPivotPoint();
   void SetToolToCalibrate();
   void SetCalibrationPointer();
   void UpdateTrackingTimer();
   void AddLandmark();
   void SaveCalibratedTool();
   void OnToolCalibrationMethodChanged(int index);
   void OnStartManualToolTipCalibration();
   void OnRetrieveDataForManualTooltipManipulation();
   void OnProcessManualTooltipEditDialogCloseRequest();
   void OnRunSingleRefToolCalibrationClicked();
   void OnLoginSingleRefToolNavigationDataClicked();
   void OnSetNewToolTipPosButtonClicked();
   void OnGetPositions();
   void OnCalibrateToolAxis();
   void OnToolAxisSpinboxChanged();
 
 protected:
 
   virtual void SetFocus();
 
   void UpdateOffsetCoordinates();
 
   int m_IndexCurrentCalibrationMethod;
 
   Ui::IGTNavigationToolCalibrationControls m_Controls;
 
   //some general members
   mitk::NavigationTool::Pointer m_ToolToCalibrate; //<<< tool that will be calibrated
   int m_IDToolToCalibrate; //<<< id of tool that will be calibrated (of the navigation data source)
   mitk::NavigationDataSource::Pointer m_NavigationDataSourceOfToolToCalibrate; //<<< navigation data source of the tool that will be calibrated
   mitk::NavigationDataSource::Pointer m_NavigationDataSourceOfCalibrationPointer; //<<< navigation data source of the calibration pointer
   mitk::DataNode::Pointer m_ToolSurfaceInToolCoordinatesDataNode; //<<< holds the tool surface in tool coordinates (for preview purposes)
   int m_IDCalibrationPointer; //<<< id of the calibration pointer (of the corresponding navigation data source)
   QTimer* m_TrackingTimer; //<<< tracking timer that updates the status widgets
   void ApplyToolTipTransform(mitk::NavigationData::Pointer ToolTipTransformInToolCoordinates, std::string message = "Tool was updated with the calibrated tool tip!"); //<<< applys the given tool tip transform to the tool to calibrate
   bool CheckInitialization(bool CalibrationPointerRequired = true); //<<< checks if the tool to calibrate and (if required) the calibration pointer is initialized. Displays a warning and returns false if not.
   mitk::NavigationData::Pointer m_ComputedToolTipTransformation; //<<< holds the new tooltip transformation after it was computed to write it into the tool later
 
   // members and helper methods for pivot tool calibration
   std::vector<mitk::NavigationData::Pointer> m_PivotPoses;
   void AddPivotPose();
   void ClearOldPivot();
   void UpdatePivotCount();
   bool  m_OnAddPivotPoseClicked;
   int PivotCount;
 
   // members and helper methods for manual tool calibration
   void UpdateManualToolTipCalibrationView();
-  QmitkNavigationToolCreationAdvancedWidget* m_ManualToolTipEditWidget;
+  //QmitkNavigationToolCreationAdvancedWidget* m_ManualToolTipEditWidget;
 
   // members and helper methods for single reference tool calibration
   void LoginSingleRefToolNavigationData();
   std::vector< mitk::Point3D > m_LoggedNavigationDataOffsets;
   std::vector< mitk::NavigationData::Pointer > m_LoggedNavigationDataDifferences;
   bool m_OnLoginSingleRefToolNavigationDataClicked;
   int m_NumberOfNavigationData;
   int m_NumberOfNavigationDataCounter;
   mitk::Point3D m_ResultOffsetVector;
 
   // members and helper methods for tool tip preview
   mitk::DataNode::Pointer m_ToolTipPointPreview; //<<< Data node of the tool tip preview
   void ShowToolTipPreview(mitk::NavigationData::Pointer ToolTipInTrackingCoordinates); //<<< Adds a preview of the tool tip into the data storage
   void RemoveToolTipPreview(); //<<< Removes the preview
 
   // members for the tool landmark calibration
   mitk::PointSet::Pointer m_CalibrationLandmarks;
   mitk::DataNode::Pointer m_CalibrationLandmarksNode;
   mitk::PointSet::Pointer m_RegistrationLandmarks;
   mitk::DataNode::Pointer m_RegistrationLandmarksNode;
 
   //members and helper methods for tool axis calibration 
   mitk::Vector3D m_CalibratedToolAxis;
   mitk::NavigationData::Pointer  m_AxisCalibration_ToolToCalibrate;
   mitk::NavigationData::Pointer  m_AxisCalibration_NavDataCalibratingTool;
 
 };
 
 #endif // IGTNavigationToolCalibration_h