diff --git a/Modules/IGT/TrackingDevices/mitkInternalTrackingTool.cpp b/Modules/IGT/TrackingDevices/mitkInternalTrackingTool.cpp
index d9676fca30..128eabfc47 100644
--- a/Modules/IGT/TrackingDevices/mitkInternalTrackingTool.cpp
+++ b/Modules/IGT/TrackingDevices/mitkInternalTrackingTool.cpp
@@ -1,270 +1,279 @@
 /*===================================================================
 
 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 "mitkInternalTrackingTool.h"
 
 #include <itkMutexLockHolder.h>
 
 typedef itk::MutexLockHolder<itk::FastMutexLock> MutexLockHolder;
 
 mitk::InternalTrackingTool::InternalTrackingTool()
 : TrackingTool(),
 m_TrackingError(0.0f),
 m_Enabled(true),
 m_DataValid(false),
 m_ToolTipSet(false)
 {
   m_Position[0] = 0.0f;
   m_Position[1] = 0.0f;
   m_Position[2] = 0.0f;
   m_Orientation[0] = 0.0f;
   m_Orientation[1] = 0.0f;
   m_Orientation[2] = 0.0f;
   m_Orientation[3] = 0.0f;
   // this should not be necessary as the tools bring their own tooltip transformation
   m_ToolTip[0] = 0.0f;
   m_ToolTip[1] = 0.0f;
   m_ToolTip[2] = 0.0f;
   m_ToolTipRotation[0] = 0.0f;
   m_ToolTipRotation[1] = 0.0f;
   m_ToolTipRotation[2] = 0.0f;
   m_ToolTipRotation[3] = 1.0f;
 }
 
 mitk::InternalTrackingTool::~InternalTrackingTool()
 {
 }
 
 void mitk::InternalTrackingTool::PrintSelf(std::ostream& os, itk::Indent indent) const
 {
   Superclass::PrintSelf(os, indent);
 
   os << indent << "Position: " << m_Position << std::endl;
   os << indent << "Orientation: " << m_Orientation << std::endl;
   os << indent << "TrackingError: " << m_TrackingError << std::endl;
   os << indent << "Enabled: " << m_Enabled << std::endl;
   os << indent << "DataValid: " << m_DataValid << std::endl;
   os << indent << "ToolTip: " << m_ToolTip << std::endl;
   os << indent << "ToolTipRotation: " << m_ToolTipRotation << std::endl;
   os << indent << "ToolTipSet: " << m_ToolTipSet << std::endl;
 }
 
 void mitk::InternalTrackingTool::SetToolName(const char* _arg)
 {
   itkDebugMacro("setting  m_ToolName to " << _arg);
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   if ( _arg && (_arg == this->m_ToolName) )
   {
     return;
   }
   if (_arg)
   {
     this->m_ToolName= _arg;
   }
   else
   {
     this->m_ToolName= "";
   }
   this->Modified();
 }
 
 
 void mitk::InternalTrackingTool::SetToolName( const std::string _arg )
 {
   this->SetToolName(_arg.c_str());
 }
 
 
 void mitk::InternalTrackingTool::GetPosition(mitk::Point3D& position) const
 {
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   if (m_ToolTipSet)
     {
     // Compute the position of tool tip in the coordinate frame of the
     // tracking device: Rotate the position of the tip into the tracking
     // device coordinate frame then add to the position of the tracking
     // sensor
     vnl_vector<mitk::ScalarType> pos_vnl = m_Position.GetVnlVector() + m_Orientation.rotate( m_ToolTip.GetVnlVector() ) ;
 
     position[0] = pos_vnl[0];
     position[1] = pos_vnl[1];
     position[2] = pos_vnl[2];
     }
   else
     {
     position[0] = m_Position[0];
     position[1] = m_Position[1];
     position[2] = m_Position[2];
     }
   this->Modified();
 }
 
 
 void mitk::InternalTrackingTool::SetPosition(mitk::Point3D position)
 {
   itkDebugMacro("setting  m_Position to " << position);
 
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   m_Position = position;
   this->Modified();
 }
 
 
 void mitk::InternalTrackingTool::GetOrientation(mitk::Quaternion& orientation) const
 {
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   if (m_ToolTipSet)
     {
     // Compute the orientation of the tool tip in the coordinate frame of
     // the tracking device.
     //
     //   * m_Orientation is the orientation of the sensor relative to the transmitter
     //   * m_ToolTipRotation is the orientation of the tool tip relative to the sensor
     orientation =  m_Orientation * m_ToolTipRotation;
     }
   else
     {
     orientation = m_Orientation;
     }
 }
 
 void mitk::InternalTrackingTool::SetToolTip(mitk::Point3D toolTipPosition,
                                             mitk::Quaternion orientation,
                                             mitk::ScalarType eps)
 {
   if ( !Equal(m_ToolTip, toolTipPosition, eps) ||
        !Equal(m_ToolTipRotation, orientation, eps) )
   {
     if( (toolTipPosition[0] == 0) &&
         (toolTipPosition[1] == 0) &&
         (toolTipPosition[2] == 0) &&
         (orientation.x() == 0) &&
         (orientation.y() == 0) &&
         (orientation.z() == 0) &&
         (orientation.r() == 1))
     {
       m_ToolTipSet = false;
     }
     else
     {
       m_ToolTipSet = true;
     }
     m_ToolTip = toolTipPosition;
     m_ToolTipRotation = orientation;
     this->Modified();
   }
 }
 
+mitk::Point3D mitk::InternalTrackingTool::GetToolTip() const
+{
+  return m_ToolTip;
+}
+mitk::Quaternion mitk::InternalTrackingTool::GetToolTipOrientation() const
+{
+  return m_ToolTipRotation;
+}
+
 void mitk::InternalTrackingTool::SetOrientation(mitk::Quaternion orientation)
 {
   itkDebugMacro("setting  m_Orientation to " << orientation);
 
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   m_Orientation = orientation;
   this->Modified();
 
 }
 
 
 void mitk::InternalTrackingTool::SetTrackingError(float error)
 {
   itkDebugMacro("setting  m_TrackingError  to " << error);
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   if (error == m_TrackingError)
   {
     return;
   }
   m_TrackingError = error;
   this->Modified();
 }
 
 
 float mitk::InternalTrackingTool::GetTrackingError() const
 {
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   float r = m_TrackingError;
   return r;
 }
 
 
 bool mitk::InternalTrackingTool::Enable()
 {
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   if (m_Enabled == false)
   {
     this->m_Enabled = true;
     this->Modified();
   }
   return true;
 }
 
 
 bool mitk::InternalTrackingTool::Disable()
 {
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   if (m_Enabled == true)
   {
     this->m_Enabled = false;
     this->Modified();
   }
   return true;
 }
 
 
 bool mitk::InternalTrackingTool::IsEnabled() const
 {
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   return m_Enabled;
 }
 
 bool mitk::InternalTrackingTool::IsTooltipSet() const
 {
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   return m_ToolTipSet;
 }
 
 bool mitk::InternalTrackingTool::IsDataValid() const
 {
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   return m_DataValid;
 }
 
 
 void mitk::InternalTrackingTool::SetDataValid(bool _arg)
 {
   itkDebugMacro("setting m_DataValid to " << _arg);
   if (this->m_DataValid != _arg)
   {
     MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
     this->m_DataValid = _arg;
     this->Modified();
   }
 }
 
 
 void mitk::InternalTrackingTool::SetErrorMessage(const char* _arg)
 {
   itkDebugMacro("setting  m_ErrorMessage  to " << _arg);
   MutexLockHolder lock(*m_MyMutex); // lock and unlock the mutex
   if ((_arg == nullptr) || (_arg == this->m_ErrorMessage))
     return;
 
   if (_arg != nullptr)
     this->m_ErrorMessage = _arg;
   else
     this->m_ErrorMessage = "";
   this->Modified();
 }
diff --git a/Modules/IGT/TrackingDevices/mitkInternalTrackingTool.h b/Modules/IGT/TrackingDevices/mitkInternalTrackingTool.h
index de952cf0b8..d0a34cc476 100644
--- a/Modules/IGT/TrackingDevices/mitkInternalTrackingTool.h
+++ b/Modules/IGT/TrackingDevices/mitkInternalTrackingTool.h
@@ -1,80 +1,82 @@
 /*===================================================================
 
 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 MITKINTERNALTRACKINGTOOL_H_HEADER_INCLUDED_
 #define MITKINTERNALTRACKINGTOOL_H_HEADER_INCLUDED_
 
 #include <mitkTrackingTool.h>
 #include <MitkIGTExports.h>
 #include <mitkNumericTypes.h>
 #include <itkFastMutexLock.h>
 
 namespace mitk {
 
 
   /**Documentation
   * \brief implements TrackingTool interface
   *
   * This class is a complete TrackingTool implementation. It can either be used directly by
   * TrackingDevices, or be subclassed for more specific implementations.
   * mitk::MicroBirdTrackingDevice uses this class to manage its tools. Other tracking devices
   * uses specialized versions of this class (e.g. mitk::NDITrackingTool)
   *
   * \ingroup IGT
   */
   class MITKIGT_EXPORT InternalTrackingTool : public TrackingTool
   {
     friend class MicroBirdTrackingDevice; // Add all TrackingDevice subclasses that use InternalTrackingDevice directly
   public:
     mitkClassMacro(InternalTrackingTool, TrackingTool);
 
     virtual void PrintSelf(std::ostream& os, itk::Indent indent) const override;
 
     virtual void GetPosition(Point3D& position) const override;    ///< returns the current position of the tool as an array of three floats (in the tracking device coordinate system)
     virtual void GetOrientation(Quaternion& orientation) const override;  ///< returns the current orientation of the tool as a quaternion (in the tracking device coordinate system)
     virtual bool Enable() override;                                      ///< enablea the tool, so that it will be tracked. Returns true if enabling was successfull
     virtual bool Disable() override;                                     ///< disables the tool, so that it will not be tracked anymore. Returns true if disabling was successfull
     virtual bool IsEnabled() const override;                             ///< returns whether the tool is enabled or disabled
     virtual bool IsDataValid() const override;                           ///< returns true if the current position data is valid (no error during tracking, tracking error below threshold, ...)
     virtual float GetTrackingError() const override;                     ///< return one value that corresponds to the overall tracking error. The dimension of this value is specific to each tracking device
     virtual bool IsTooltipSet() const;                          ///< returns true if a tooltip is set, false if not
     virtual void SetToolName(const std::string _arg);           ///< Sets the name of the tool
     virtual void SetToolName(const char* _arg);                 ///< Sets the name of the tool
     virtual void SetPosition(Point3D position);           ///< sets the position
     virtual void SetOrientation(Quaternion orientation);  ///< sets the orientation as a quaternion
     virtual void SetTrackingError(float error);                 ///< sets the tracking error
     virtual void SetDataValid(bool _arg);                       ///< sets if the tracking data (position & Orientation) is valid
     virtual void SetErrorMessage(const char* _arg);             ///< sets the error message
     virtual void SetToolTip(Point3D toolTipPosition, Quaternion orientation = Quaternion(0,0,0,1), ScalarType eps=0.0) override; ///< defines a tool tip for this tool in tool coordinates. GetPosition() and GetOrientation() return the data of the tool tip if it is defined. By default no tooltip is defined.
+    Point3D GetToolTip() const; //Returns the tool tip in tool coordinates, which where set by SetToolTip
+    Quaternion GetToolTipOrientation() const;//Returns the tool tip orientation in tool coordinates, which where set by SetToolTip
 
   protected:
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
     InternalTrackingTool();
     virtual ~InternalTrackingTool();
 
     Point3D m_Position;      ///< holds the position of the tool
     Quaternion m_Orientation;   ///< holds the orientation of the tool
     float m_TrackingError;    ///< holds the tracking error of the tool
     bool m_Enabled;           ///< if true, tool is enabled and should receive tracking updates from the tracking device
     bool m_DataValid;         ///< if true, data in m_Position and m_Orientation is valid, e.g. true tracking data
     Point3D m_ToolTip;
     Quaternion m_ToolTipRotation;
     bool m_ToolTipSet;
   };
 } // namespace mitk
 #endif /* MITKINTERNALTRACKINGTOOL_H_HEADER_INCLUDED_ */
diff --git a/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.cpp b/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.cpp
index 0814f5f480..3ef829be6d 100644
--- a/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.cpp
@@ -1,275 +1,299 @@
 /*===================================================================
 
 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 "QmitkPolhemusTrackerWidget.h"
 
 #include <QFileDialog>
 #include <QScrollBar>
 #include <QMessageBox>
 
 #include <itksys/SystemTools.hxx>
 #include <Poco/Path.h>
 #include <QSettings>
 
 #include <mitkBaseRenderer.h>
 #include <mitkCameraController.h>
 #include "vtkRenderer.h"
 #include "vtkCamera.h"
 
 const std::string QmitkPolhemusTrackerWidget::VIEW_ID = "org.mitk.views.PolhemusTrackerWidget";
 
 QmitkPolhemusTrackerWidget::QmitkPolhemusTrackerWidget(QWidget* parent, Qt::WindowFlags f)
   : QmitkAbstractTrackingDeviceWidget(parent, f)
   , m_Controls(nullptr)
 {
 }
 void QmitkPolhemusTrackerWidget::Initialize()
 {
   InitializeSuperclassWidget();
   CreateQtPartControl(this);
 
   SetAdvancedSettingsEnabled(false);
   on_m_AdvancedSettings_clicked(); //hide advanced settings on setup
 }
 
 QmitkPolhemusTrackerWidget::~QmitkPolhemusTrackerWidget()
 {
   delete m_Controls;
 }
 
 void QmitkPolhemusTrackerWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkPolhemusTrackerWidget;
     m_Controls->setupUi(parent);
   }
 }
 
 void QmitkPolhemusTrackerWidget::OnToolStorageChanged()
 {
     this->m_TrackingDevice = nullptr;
     MITK_DEBUG<<"Resetting Polhemus Tracking Device, because tool storage changed.";
 }
 
 void QmitkPolhemusTrackerWidget::CreateConnections()
 {
   if (m_Controls)
   {
     connect((QObject*)(m_Controls->m_hemisphereTracking), SIGNAL(clicked()), this, SLOT(on_m_hemisphereTracking_clicked()));
     connect((QObject*)(m_Controls->m_ToggleHemisphere), SIGNAL(clicked()), this, SLOT(on_m_ToggleHemisphere_clicked()));
     connect((QObject*)(m_Controls->m_SetHemisphere), SIGNAL(clicked()), this, SLOT(on_m_SetHemisphere_clicked()));
     connect((QObject*)(m_Controls->m_GetHemisphere), SIGNAL(clicked()), this, SLOT(on_m_GetHemisphere_clicked()));
     connect((QObject*)(m_Controls->m_AdjustHemisphere), SIGNAL(clicked()), this, SLOT(on_m_AdjustHemisphere_clicked()));
     connect((QObject*)(m_Controls->m_AdvancedSettings), SIGNAL(clicked()), this, SLOT(on_m_AdvancedSettings_clicked()));
+    connect((QObject*)(m_Controls->m_ToggleToolTipCalibration), SIGNAL(clicked()), this, SLOT(on_m_ToggleToolTipCalibration_clicked()));
   }
 }
 
 mitk::TrackingDevice::Pointer QmitkPolhemusTrackerWidget::GetTrackingDevice()
 {
   if (m_TrackingDevice.IsNull())
   {
     m_TrackingDevice = mitk::PolhemusTrackingDevice::New();
     m_TrackingDevice->SetHemisphereTrackingEnabled(m_Controls->m_hemisphereTracking->isChecked());
   }
 
   return static_cast<mitk::TrackingDevice::Pointer>(m_TrackingDevice);
 }
 
 QmitkPolhemusTrackerWidget* QmitkPolhemusTrackerWidget::Clone(QWidget* parent) const
 {
   QmitkPolhemusTrackerWidget* clonedWidget = new QmitkPolhemusTrackerWidget(parent);
   clonedWidget->Initialize();
   return clonedWidget;
 }
 
 void QmitkPolhemusTrackerWidget::on_m_hemisphereTracking_clicked()
 {
   m_TrackingDevice->SetHemisphereTrackingEnabled(m_Controls->m_hemisphereTracking->isChecked());
 }
 
 void QmitkPolhemusTrackerWidget::on_m_ToggleHemisphere_clicked()
 {
   // Index 0 == All Tools == -1 for Polhemus interface; Index 2 == Tool 2 == 1 for Polhemus; etc...
   m_TrackingDevice->ToggleHemisphere(GetSelectedToolIndex());
 
   MITK_INFO << "Toggle Hemisphere for tool " << m_Controls->m_ToolSelection->currentText().toStdString();
 }
 
 void QmitkPolhemusTrackerWidget::on_m_SetHemisphere_clicked()
 {
   mitk::Vector3D _hemisphere;
   mitk::FillVector3D(_hemisphere, m_Controls->m_Hemisphere_X->value(), m_Controls->m_Hemisphere_Y->value(), m_Controls->m_Hemisphere_Z->value());
   m_TrackingDevice->SetHemisphere(GetSelectedToolIndex(), _hemisphere);
 
   //If you set a hemisphere vector which is unequal (0|0|0), this means, that there is no hemisphere tracking any more
   //disable the checkbox in case it was on before, so that it can be reactivated...
   if (_hemisphere.GetNorm() != 0)
     m_Controls->m_hemisphereTracking->setChecked(false);
 
   MITK_INFO << "Hemisphere set for tool " << m_Controls->m_ToolSelection->currentText().toStdString();
 }
 
 void QmitkPolhemusTrackerWidget::on_m_GetHemisphere_clicked()
 {
   mitk::Vector3D _hemisphere = m_TrackingDevice->GetHemisphere(GetSelectedToolIndex());
   m_Controls->m_Hemisphere_X->setValue(_hemisphere[0]);
   m_Controls->m_Hemisphere_Y->setValue(_hemisphere[1]);
   m_Controls->m_Hemisphere_Z->setValue(_hemisphere[2]);
 
   QString label;
 
   if (m_TrackingDevice->GetHemisphereTrackingEnabled(GetSelectedToolIndex()))
   {
     label = "HemisphereTracking is ON for tool ";
     label.append(m_Controls->m_ToolSelection->currentText());
   }
   else if (GetSelectedToolIndex() == -1)
   {
     label = "HemisphereTracking is OFF for at least one tool.";
   }
   else
   {
     label = "HemisphereTracking is OFF for tool ";
     label.append(m_Controls->m_ToolSelection->currentText());
   }
 
   m_Controls->m_StatusLabelHemisphereTracking->setText(label);
 
   MITK_INFO << "Updated SpinBox for Hemisphere of tool " << m_Controls->m_ToolSelection->currentText().toStdString();
 }
 
 void QmitkPolhemusTrackerWidget::on_m_AdjustHemisphere_clicked()
 {
   int _tool = GetSelectedToolIndex();
   QMessageBox msgBox;
   QString _text;
   if (_tool == -1)
   {
     _text.append("Adjusting hemisphere for all tools.");
     msgBox.setText(_text);
     _text.clear();
     _text = tr("Please make sure, that the entire tools (including tool tip AND sensor) are placed in the positive x hemisphere. Press 'Adjust hemisphere' if you are ready.");
     msgBox.setInformativeText(_text);
   }
   else
   {
     _text.append("Adjusting hemisphere for tool '");
     _text.append(m_Controls->m_ToolSelection->currentText());
     _text.append(tr("' at port %2.").arg(_tool));
     msgBox.setText(_text);
     _text.clear();
     _text = tr("Please make sure, that the entire tool (including tool tip AND sensor) is placed in the positive x hemisphere. Press 'Adjust hemisphere' if you are ready.");
     msgBox.setInformativeText(_text);
   }
 
   QPushButton *adjustButton = msgBox.addButton(tr("Adjust hemisphere"), QMessageBox::ActionRole);
   QPushButton *cancelButton = msgBox.addButton(QMessageBox::Cancel);
   msgBox.exec();
   if (msgBox.clickedButton() == adjustButton) {
     // adjust
     m_TrackingDevice->AdjustHemisphere(_tool);
     MITK_INFO << "Adjusting Hemisphere for tool " << m_Controls->m_ToolSelection->currentText().toStdString();
   }
   else if (msgBox.clickedButton() == cancelButton) {
     // abort
     MITK_INFO << "Cancel 'Adjust hemisphere'. No harm done...";
   }
 }
 
+void QmitkPolhemusTrackerWidget::on_m_ToggleToolTipCalibration_clicked()
+{
+  if (m_Controls->m_ToolSelection->currentIndex() != 0)
+  {
+    mitk::PolhemusTool* _tool = dynamic_cast<mitk::PolhemusTool*> (this->m_TrackingDevice->GetToolByName(m_Controls->m_ToolSelection->currentText().toStdString()));
+    mitk::Point3D tip = _tool->GetToolTip().GetVectorFromOrigin()*(-1.);
+    mitk::Quaternion quat = _tool->GetToolTipOrientation().inverse();
+    _tool->SetToolTip(tip, quat);
+  }
+  else
+  {
+    for (int i = 0; i < m_TrackingDevice->GetToolCount(); ++i)
+    {
+      mitk::PolhemusTool* _tool = dynamic_cast<mitk::PolhemusTool*> (this->m_TrackingDevice->GetTool(i));
+      mitk::Point3D tip = _tool->GetToolTip().GetVectorFromOrigin()*(-1.);
+      mitk::Quaternion quat = _tool->GetToolTipOrientation().inverse();
+      _tool->SetToolTip(tip, quat);
+    }
+  }
+}
+
 void QmitkPolhemusTrackerWidget::OnConnected(bool _success)
 {
   if (!_success)
   {
     this->m_TrackingDevice = nullptr;
     return;
   }
 
   SetAdvancedSettingsEnabled(true);
 
   if (m_TrackingDevice->GetToolCount() != m_Controls->m_ToolSelection->count())
   {
     m_Controls->m_ToolSelection->clear();
 
     m_Controls->m_ToolSelection->addItem("All Tools");
 
     for (int i = 0; i < m_TrackingDevice->GetToolCount(); ++i)
     {
       m_Controls->m_ToolSelection->addItem(m_TrackingDevice->GetTool(i)->GetToolName());
     }
   }
 }
 
 void QmitkPolhemusTrackerWidget::OnStartTracking(bool _success)
 {
   if (!_success)
     return;
   //Rotate mitk standard multi widget, so that the view matches the sensor. Positive x == right, y == front, z == down;
   mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetCameraController()->SetViewToPosterior();
   mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetVtkRenderer()->GetActiveCamera()->SetViewUp(0, 0, -1);
 
 }
 
 void QmitkPolhemusTrackerWidget::OnDisconnected(bool _success)
 {
   if (!_success)
     return;
   SetAdvancedSettingsEnabled(false);
 }
 
 void QmitkPolhemusTrackerWidget::SetAdvancedSettingsEnabled(bool _enable)
 {
   m_Controls->m_ToolSelection->setEnabled(_enable);
   m_Controls->label_toolsToChange->setEnabled(_enable);
   m_Controls->label_UpdateOnRequest->setEnabled(_enable);
   m_Controls->m_GetHemisphere->setEnabled(_enable);
   m_Controls->m_Hemisphere_X->setEnabled(_enable);
   m_Controls->m_Hemisphere_Y->setEnabled(_enable);
   m_Controls->m_Hemisphere_Z->setEnabled(_enable);
   m_Controls->m_SetHemisphere->setEnabled(_enable);
   m_Controls->m_ToggleHemisphere->setEnabled(_enable);
   m_Controls->m_AdjustHemisphere->setEnabled(_enable);
+  m_Controls->m_ToggleToolTipCalibration->setEnabled(_enable);
 }
 
 void QmitkPolhemusTrackerWidget::on_m_AdvancedSettings_clicked()
 {
   bool _enable = m_Controls->m_AdvancedSettings->isChecked();
   m_Controls->m_ToolSelection->setVisible(_enable);
   m_Controls->label_toolsToChange->setVisible(_enable);
   m_Controls->label_UpdateOnRequest->setVisible(_enable);
   m_Controls->m_GetHemisphere->setVisible(_enable);
   m_Controls->m_Hemisphere_X->setVisible(_enable);
   m_Controls->m_Hemisphere_Y->setVisible(_enable);
   m_Controls->m_Hemisphere_Z->setVisible(_enable);
   m_Controls->m_SetHemisphere->setVisible(_enable);
   m_Controls->m_ToggleHemisphere->setVisible(_enable);
   m_Controls->m_AdjustHemisphere->setVisible(_enable);
+  m_Controls->m_ToggleToolTipCalibration->setVisible(_enable);
   m_Controls->m_StatusLabelHemisphereTracking->setVisible(_enable);
 }
 
 int QmitkPolhemusTrackerWidget::GetSelectedToolIndex()
 {
   // Index 0 == All Tools == -1 for Polhemus interface; Index 1 == Tool 1 == 1 for Polhemus Interface; etc...
   int _index = m_Controls->m_ToolSelection->currentIndex() - 1;
   if (_index != -1)
   {
     //we need to find the internal Polhemus index for this tool. This is stored in the identifier of a navigation tool or as Port in PolhemusTool.
     mitk::PolhemusTool* _tool = dynamic_cast<mitk::PolhemusTool*>(m_TrackingDevice->GetToolByName(m_Controls->m_ToolSelection->currentText().toStdString()));
     _index = _tool->GetToolPort();
   }
   return _index;
 }
\ No newline at end of file
diff --git a/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.h b/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.h
index d2e7bbe970..56c0595f3d 100644
--- a/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.h
+++ b/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.h
@@ -1,95 +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 QmitkPolhemusTrackerWidget_H
 #define QmitkPolhemusTrackerWidget_H
 
 #include "ui_QmitkPolhemusTrackerWidget.h"
 
 #include "QmitkAbstractTrackingDeviceWidget.h"
 #include <mitkPolhemusTrackingDevice.h>
 
 
 /** Documentation:
  *   \brief Implementation of a configuration widget for Polhemus Tracking Devices.
  *
  *   \ingroup IGTUI
  */
 class MITKIGTUI_EXPORT QmitkPolhemusTrackerWidget : public QmitkAbstractTrackingDeviceWidget
 {
   Q_OBJECT // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
 
 public:
   static const std::string VIEW_ID;
 
   QmitkPolhemusTrackerWidget(QWidget* parent = 0, Qt::WindowFlags f = 0);
   ~QmitkPolhemusTrackerWidget();
 
   virtual void Initialize();
 
 signals:
 
   protected slots :
     void on_m_hemisphereTracking_clicked();
     void on_m_ToggleHemisphere_clicked();
     void on_m_SetHemisphere_clicked();
     void on_m_GetHemisphere_clicked();
     void on_m_AdjustHemisphere_clicked();
     void on_m_AdvancedSettings_clicked();
+    void on_m_ToggleToolTipCalibration_clicked();
 
 private:
 
   /// \brief Creation of the connections
   void CreateConnections();
 
   void CreateQtPartControl(QWidget *parent);
 
   void SetAdvancedSettingsEnabled(bool _enable);
 
   int GetSelectedToolIndex();
 
 protected:
   virtual QmitkPolhemusTrackerWidget* Clone(QWidget* parent) const;
 
   Ui::QmitkPolhemusTrackerWidget* m_Controls;
 
   mitk::PolhemusTrackingDevice::Pointer m_TrackingDevice;
 
 public:
   virtual mitk::TrackingDevice::Pointer GetTrackingDevice();
   /**
   * \brief This function is called, when in the TrackingToolboxView "Connect" was clicked and the device is successful connected.
   * Can e.g. be used to activate options of a tracking device only when it is connected.
   */
   virtual void OnConnected( bool _success);
   /**
   * \brief This function is called, when in the TrackingToolboxView "Disconnect" was clicked and the device is successful disconnected.
   * Can e.g. be used to activate/disactivate options of a tracking device.
   */
   virtual void OnDisconnected(bool _success);
   /**
   * \brief This function is called, when in the TrackingToolboxView "Start Tracking" was clicked and the device successfully started tracking.
   * Can e.g. be used to activate options of a tracking device only when tracking is started.
   */
   virtual void OnStartTracking(bool _success);
   /**
   * \brief This function is called, when anything in the ToolStorage changed, e.g. AddTool or EditTool.
   * ServiceListener is connected in the QmitkMITKIGTTrackingToolboxView.
   */
   virtual void OnToolStorageChanged();
 
 };
 #endif
diff --git a/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.ui b/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.ui
index 4203265d33..eca4075ca9 100644
--- a/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.ui
+++ b/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.ui
@@ -1,167 +1,174 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkPolhemusTrackerWidget</class>
  <widget class="QWidget" name="QmitkPolhemusTrackerWidget">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>475</width>
     <height>324</height>
    </rect>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_11">
    <item>
     <widget class="QLabel" name="polhemus_label">
      <property name="text">
       <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
 &lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
 p, li { white-space: pre-wrap; }
 &lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'MS Shell Dlg 2'; font-size:8pt; font-weight:400; font-style:normal;&quot;&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; text-decoration: underline;&quot;&gt;Polhemus Tracker&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
      </property>
     </widget>
    </item>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout_3">
      <item>
       <widget class="QCheckBox" name="m_hemisphereTracking">
        <property name="text">
         <string>Enable hemisphere tracking (for all tools)</string>
        </property>
        <property name="checked">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QCheckBox" name="m_AdvancedSettings">
        <property name="text">
         <string>Show Advanced Settings</string>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <widget class="Line" name="line">
      <property name="orientation">
       <enum>Qt::Horizontal</enum>
      </property>
     </widget>
    </item>
    <item>
     <layout class="QGridLayout" name="gridLayout_2">
      <item row="0" column="1">
       <widget class="QComboBox" name="m_ToolSelection"/>
      </item>
      <item row="0" column="0">
       <widget class="QLabel" name="label_toolsToChange">
        <property name="text">
         <string>Tools to change:</string>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <widget class="QLabel" name="label_UpdateOnRequest">
      <property name="text">
       <string>Spinbox values and label are only updated on request (click 'Get Hemisphere').</string>
      </property>
     </widget>
    </item>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout_2">
      <item>
       <widget class="QPushButton" name="m_GetHemisphere">
        <property name="text">
         <string>Get Hemisphere</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QSpinBox" name="m_Hemisphere_X">
        <property name="minimum">
         <number>-10</number>
        </property>
        <property name="maximum">
         <number>10</number>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QSpinBox" name="m_Hemisphere_Y">
        <property name="minimum">
         <number>-10</number>
        </property>
        <property name="maximum">
         <number>10</number>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QSpinBox" name="m_Hemisphere_Z">
        <property name="minimum">
         <number>-10</number>
        </property>
        <property name="maximum">
         <number>10</number>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QPushButton" name="m_SetHemisphere">
        <property name="text">
         <string>Set Hemisphere</string>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <widget class="QLabel" name="m_StatusLabelHemisphereTracking">
      <property name="text">
       <string/>
      </property>
     </widget>
    </item>
    <item>
     <layout class="QGridLayout" name="gridLayout"/>
    </item>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout">
      <item>
       <widget class="QPushButton" name="m_ToggleHemisphere">
        <property name="text">
         <string>Toggle Hemisphere</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QPushButton" name="m_AdjustHemisphere">
        <property name="text">
         <string>Adjust Hemisphere</string>
        </property>
       </widget>
      </item>
+     <item>
+      <widget class="QPushButton" name="m_ToggleToolTipCalibration">
+       <property name="text">
+        <string>Toggle Tool Tip Calibration</string>
+       </property>
+      </widget>
+     </item>
     </layout>
    </item>
    <item>
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>40</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <resources/>
  <connections/>
 </ui>