diff --git a/Modules/IGT/DataManagement/mitkNavigationTool.cpp b/Modules/IGT/DataManagement/mitkNavigationTool.cpp
index 1585080ecf..ad8f778aa5 100644
--- a/Modules/IGT/DataManagement/mitkNavigationTool.cpp
+++ b/Modules/IGT/DataManagement/mitkNavigationTool.cpp
@@ -1,336 +1,335 @@
 /*===================================================================
 
 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 "mitkNavigationTool.h"
 #include "mitkIGTException.h"
 #include "mitkNavigationData.h"
 #include "Poco/File.h"
 #include "mitkUnspecifiedTrackingTypeInformation.h"
-#include "mitkInternalTrackingTool.h"
 
 #include "vtkSphereSource.h"
 #include "vtkConeSource.h"
 #include "vtkLineSource.h"
 #include "vtkCylinderSource.h"
 #include "vtkTransformPolyDataFilter.h"
 #include <vtkAppendPolyData.h>
 #include "mitkTextAnnotation3D.h"
 #include "mitkManualPlacementAnnotationRenderer.h"
 #include "mitkBaseRenderer.h"
 
 mitk::NavigationTool::NavigationTool() : m_Identifier("None"),
 m_Type(mitk::NavigationTool::Unknown),
 m_CalibrationFile("none"),
 m_SerialNumber(""),
 m_TrackingDeviceType(mitk::UnspecifiedTrackingTypeInformation::GetTrackingDeviceName()),
 m_ToolRegistrationLandmarks(mitk::PointSet::New()),
 m_ToolCalibrationLandmarks(mitk::PointSet::New()),
 m_ToolTipOrientation(mitk::Quaternion(0, 0, 0, 1))
 {
   m_ToolTipPosition[0] = 0;
   m_ToolTipPosition[1] = 0;
   m_ToolTipPosition[2] = 0;
 
   m_ToolAxis[0] = 1;
   m_ToolAxis[1] = 0;
   m_ToolAxis[2] = 0;
 
   SetDefaultSurface();
 }
 
 itk::LightObject::Pointer mitk::NavigationTool::InternalClone() const
 {
   Self::Pointer tool = new Self(*this);
   tool->UnRegister();
   return tool.GetPointer();
 }
 
 mitk::NavigationTool::NavigationTool(const NavigationTool &other)
   : Superclass()
 {
   this->m_Identifier = other.m_Identifier;
   this->m_Type = other.m_Type;
   if (other.m_DataNode.IsNotNull())
   {
     this->m_DataNode = other.m_DataNode->Clone();
     this->m_DataNode->SetName(other.m_DataNode->GetName());
     if (other.m_DataNode->GetData())
     {
       this->m_DataNode->SetData(dynamic_cast<mitk::BaseData*>(other.m_DataNode->GetData()->Clone().GetPointer()));
     }
   }
 
   if (other.m_SpatialObject.IsNotNull())
     this->m_SpatialObject = other.m_SpatialObject->Clone();
   this->m_CalibrationFile = other.m_CalibrationFile;
   this->m_SerialNumber = other.m_SerialNumber;
   this->m_TrackingDeviceType = other.m_TrackingDeviceType;
   if (other.m_ToolRegistrationLandmarks.IsNotNull())
     this->m_ToolRegistrationLandmarks = other.m_ToolRegistrationLandmarks->Clone();
   if (other.m_ToolCalibrationLandmarks.IsNotNull())
     this->m_ToolCalibrationLandmarks = other.m_ToolCalibrationLandmarks->Clone();
   this->m_ToolTipPosition = other.m_ToolTipPosition;
   this->m_ToolTipOrientation = other.m_ToolTipOrientation;
   this->m_ToolAxis = other.m_ToolAxis;
 }
 
 mitk::NavigationTool::~NavigationTool()
 {
 }
 
 mitk::AffineTransform3D::Pointer mitk::NavigationTool::GetToolTipTransform()
 {
   mitk::NavigationData::Pointer returnValue = mitk::NavigationData::New();
   returnValue->SetPosition(this->m_ToolTipPosition);
   returnValue->SetOrientation(this->m_ToolTipOrientation);
   return returnValue->GetAffineTransform3D();
 }
 
 void mitk::NavigationTool::Graft(const DataObject *data)
 {
   // Attempt to cast data to an NavigationData
   const Self* nd;
   try
   {
     nd = dynamic_cast<const Self *>(data);
   }
   catch (...)
   {
     mitkThrowException(mitk::IGTException) << "mitk::NavigationData::Graft cannot cast "
       << typeid(data).name() << " to "
       << typeid(const Self *).name();
   }
   if (!nd)
   {
     // pointer could not be cast back down
     mitkThrowException(mitk::IGTException) << "mitk::NavigationData::Graft cannot cast "
       << typeid(data).name() << " to "
       << typeid(const Self *).name();
   }
   // Now copy anything that is needed
   m_Identifier = nd->GetIdentifier();
   m_Type = nd->GetType();
   m_DataNode->SetName(nd->GetDataNode()->GetName());
   m_DataNode->SetData(nd->GetDataNode()->GetData());
   m_SpatialObject = nd->GetSpatialObject();
   m_CalibrationFile = nd->GetCalibrationFile();
   m_SerialNumber = nd->GetSerialNumber();
   m_TrackingDeviceType = nd->GetTrackingDeviceType();
   m_ToolRegistrationLandmarks = nd->GetToolRegistrationLandmarks();
   m_ToolCalibrationLandmarks = nd->GetToolCalibrationLandmarks();
   m_ToolTipPosition = nd->GetToolTipPosition();
   m_ToolTipOrientation = nd->GetToolTipOrientation();
   m_ToolAxis = nd->GetToolAxis();
 }
 
 bool mitk::NavigationTool::IsToolTipSet()
 {
   if ((m_ToolTipPosition[0] == 0) &&
     (m_ToolTipPosition[1] == 0) &&
     (m_ToolTipPosition[2] == 0) &&
     (m_ToolTipOrientation.x() == 0) &&
     (m_ToolTipOrientation.y() == 0) &&
     (m_ToolTipOrientation.z() == 0) &&
     (m_ToolTipOrientation.r() == 1))
     return false;
   else return true;
 }
 
 void mitk::NavigationTool::SetCalibrationFile(const std::string filename)
 {
   //check if file does exist:
   if (filename == "")
   {
     m_CalibrationFile = "none";
   }
   else
   {
     Poco::File myFile(filename);
     if (myFile.exists())
       m_CalibrationFile = filename;
     else
       m_CalibrationFile = "none";
   }
 }
 
 std::string mitk::NavigationTool::GetToolName()
 {
   if (this->m_DataNode.IsNull()) { return ""; }
   else { return m_DataNode->GetName(); }
 }
 
 mitk::Surface::Pointer mitk::NavigationTool::GetToolSurface()
 {
   if (this->m_DataNode.IsNull()) { return nullptr; }
   else if (this->m_DataNode->GetData() == nullptr) { return nullptr; }
   else { return dynamic_cast<mitk::Surface*>(m_DataNode->GetData()); }
 }
 
 void mitk::NavigationTool::SetDefaultSurface()
 {
   if (m_DataNode.IsNull())
     m_DataNode = mitk::DataNode::New();
 
   mitk::Surface::Pointer mySphere = mitk::Surface::New();
 
   double axisLength = 5.;
 
   vtkSmartPointer<vtkSphereSource> vtkSphere = vtkSmartPointer<vtkSphereSource>::New();
   vtkSmartPointer<vtkConeSource> vtkCone = vtkSmartPointer<vtkConeSource>::New();
   vtkSmartPointer<vtkCylinderSource> vtkCylinder = vtkSmartPointer<vtkCylinderSource>::New();
   vtkSmartPointer<vtkPolyData> axis = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkLineSource> vtkLine = vtkSmartPointer<vtkLineSource>::New();
   vtkSmartPointer<vtkLineSource> vtkLine2 = vtkSmartPointer<vtkLineSource>::New();
   vtkSmartPointer<vtkLineSource> vtkLine3 = vtkSmartPointer<vtkLineSource>::New();
 
   vtkSmartPointer<vtkAppendPolyData> appendPolyData = vtkSmartPointer<vtkAppendPolyData>::New();
   vtkSmartPointer<vtkPolyData> surface = vtkSmartPointer<vtkPolyData>::New();
 
   //Y-Axis (start with y, cause cylinder is oriented in y by vtk default...)
   vtkCone->SetDirection(0, 1, 0);
   vtkCone->SetHeight(1.0);
   vtkCone->SetRadius(0.4f);
   vtkCone->SetResolution(16);
   vtkCone->SetCenter(0.0, axisLength, 0.0);
   vtkCone->Update();
 
   vtkCylinder->SetRadius(0.05);
   vtkCylinder->SetHeight(axisLength);
   vtkCylinder->SetCenter(0.0, 0.5*axisLength, 0.0);
   vtkCylinder->Update();
 
   appendPolyData->AddInputData(vtkCone->GetOutput());
   appendPolyData->AddInputData(vtkCylinder->GetOutput());
   appendPolyData->Update();
   axis->DeepCopy(appendPolyData->GetOutput());
 
   //y symbol
   vtkLine->SetPoint1(-0.5, axisLength + 2., 0.0);
   vtkLine->SetPoint2(0.0, axisLength + 1.5, 0.0);
   vtkLine->Update();
 
   vtkLine2->SetPoint1(0.5, axisLength + 2., 0.0);
   vtkLine2->SetPoint2(-0.5, axisLength + 1., 0.0);
   vtkLine2->Update();
 
   appendPolyData->AddInputData(vtkLine->GetOutput());
   appendPolyData->AddInputData(vtkLine2->GetOutput());
   appendPolyData->AddInputData(axis);
   appendPolyData->Update();
   surface->DeepCopy(appendPolyData->GetOutput());
 
   //X-axis
   vtkSmartPointer<vtkTransform> XTransform = vtkSmartPointer<vtkTransform>::New();
   XTransform->RotateZ(-90);
   vtkSmartPointer<vtkTransformPolyDataFilter> TrafoFilter = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
   TrafoFilter->SetTransform(XTransform);
   TrafoFilter->SetInputData(axis);
   TrafoFilter->Update();
 
   //x symbol
   vtkLine->SetPoint1(axisLength + 2., -0.5, 0.0);
   vtkLine->SetPoint2(axisLength + 1., 0.5, 0.0);
   vtkLine->Update();
 
   vtkLine2->SetPoint1(axisLength + 2., 0.5, 0.0);
   vtkLine2->SetPoint2(axisLength + 1., -0.5, 0.0);
   vtkLine2->Update();
 
   appendPolyData->AddInputData(vtkLine->GetOutput());
   appendPolyData->AddInputData(vtkLine2->GetOutput());
   appendPolyData->AddInputData(TrafoFilter->GetOutput());
   appendPolyData->AddInputData(surface);
   appendPolyData->Update();
   surface->DeepCopy(appendPolyData->GetOutput());
 
   //Z-axis
   vtkSmartPointer<vtkTransform> ZTransform = vtkSmartPointer<vtkTransform>::New();
   ZTransform->RotateX(90);
   TrafoFilter->SetTransform(ZTransform);
   TrafoFilter->SetInputData(axis);
   TrafoFilter->Update();
 
   //z symbol
   vtkLine->SetPoint1(-0.5, 0.0, axisLength + 2.);
   vtkLine->SetPoint2(0.5, 0.0, axisLength + 2.);
   vtkLine->Update();
 
   vtkLine2->SetPoint1(-0.5, 0.0, axisLength + 2.);
   vtkLine2->SetPoint2(0.5, 0.0, axisLength + 1.);
   vtkLine2->Update();
 
   vtkLine3->SetPoint1(0.5, 0.0, axisLength + 1.);
   vtkLine3->SetPoint2(-0.5, 0.0, axisLength + 1.);
   vtkLine3->Update();
 
   appendPolyData->AddInputData(vtkLine->GetOutput());
   appendPolyData->AddInputData(vtkLine2->GetOutput());
   appendPolyData->AddInputData(vtkLine3->GetOutput());
   appendPolyData->AddInputData(TrafoFilter->GetOutput());
   appendPolyData->AddInputData(surface);
   appendPolyData->Update();
   surface->DeepCopy(appendPolyData->GetOutput());
 
   //Center
   vtkSphere->SetRadius(0.5f);
   vtkSphere->SetCenter(0.0, 0.0, 0.0);
   vtkSphere->Update();
 
   appendPolyData->AddInputData(vtkSphere->GetOutput());
   appendPolyData->AddInputData(surface);
   appendPolyData->Update();
   surface->DeepCopy(appendPolyData->GetOutput());
 
   //Scale
   vtkSmartPointer<vtkTransform> ScaleTransform = vtkSmartPointer<vtkTransform>::New();
   ScaleTransform->Scale(20., 20., 20.);
 
   TrafoFilter->SetTransform(ScaleTransform);
   TrafoFilter->SetInputData(surface);
   TrafoFilter->Update();
 
   mySphere->SetVtkPolyData(TrafoFilter->GetOutput());
 
   //vtkCone->Delete();
   //vtkSphere->Delete();
   //vtkLine->Delete();
   //vtkLine2->Delete();
   //vtkLine3->Delete();
   //vtkCylinder->Delete();
   //ZTransform->Delete();
   //XTransform->Delete();
   //ScaleTransform->Delete();
   //TrafoFilter->Delete();
   //appendPolyData->Delete();
   //surface->Delete();
 
   this->GetDataNode()->SetData(mySphere);
 }
 
 std::string mitk::NavigationTool::GetStringWithAllToolInformation() const
 {
   std::stringstream _info;
   _info << "  Identifier: " << this->m_Identifier << "\n"
     << "  NavigationToolType: " << m_Type << "\n"
     << "  Calibration file: " << m_CalibrationFile << "\n"
     << "  Serial number: " << m_SerialNumber << "\n"
     << "  TrackingDeviceType: " << m_TrackingDeviceType << "\n"
     << "  ToolTip Position: " << m_ToolTipPosition << "\n"
     << "  ToolTip Orientation: " << m_ToolTipOrientation << "\n"
     << "  ToolTip Axis: " << m_ToolAxis;
 
   return _info.str();
-}
\ No newline at end of file
+}
diff --git a/Modules/IGT/DataManagement/mitkNavigationTool.h b/Modules/IGT/DataManagement/mitkNavigationTool.h
index d77d3ea8de..9ae3766aaa 100644
--- a/Modules/IGT/DataManagement/mitkNavigationTool.h
+++ b/Modules/IGT/DataManagement/mitkNavigationTool.h
@@ -1,212 +1,211 @@
 /*===================================================================
 
 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 NAVIGATIONTOOL_H_INCLUDED
 #define NAVIGATIONTOOL_H_INCLUDED
 
 //itk headers
 #include <itkObjectFactory.h>
 #include <itkSpatialObject.h>
 #include <itkDataObject.h>
 
 //mitk headers
 #include <mitkCommon.h>
 #include <mitkDataNode.h>
 #include <mitkPointSet.h>
-#include <mitkTrackingTool.h>
 #include <mitkTrackingTypes.h>
 #include <mitkSurface.h>
 #include <MitkIGTExports.h>
 
 namespace mitk {
   /**Documentation
   * \brief An object of this class represents a navigation tool in the view of the software.
   *        A few informations like an identifier, a toolname, a surface and a itk spatial
   *        object are stored in such an object. The classes NavigationToolReader and
   *        are availiable to write/read tools to/from the harddisc. If you need a collection
   *        of navigation tools the class NavigationToolStorage could be used.
   *
   * \ingroup IGT
   */
   class MITKIGT_EXPORT NavigationTool : public itk::DataObject
   {
   public:
 
     mitkClassMacroItkParent(NavigationTool,itk::DataObject);
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     enum NavigationToolType {Instrument, Fiducial, Skinmarker, Unknown};
 
     //## getter and setter ##
     //NavigationToolType:
     itkGetConstMacro(Type,NavigationToolType);
     itkSetMacro(Type,NavigationToolType);
 
     //Identifier:
     itkGetConstMacro(Identifier,std::string);
     itkSetMacro(Identifier,std::string);
 
     //Datatreenode:
     itkGetConstMacro(DataNode,mitk::DataNode::Pointer);
     itkSetMacro(DataNode,mitk::DataNode::Pointer);
 
     //SpatialObject:
     itkGetConstMacro(SpatialObject,itk::SpatialObject<3>::Pointer);
     itkSetMacro(SpatialObject,itk::SpatialObject<3>::Pointer);
 
     //CalibrationFile:
     itkGetConstMacro(CalibrationFile,std::string);
     void SetCalibrationFile(const std::string filename);
 
     //Tool tip definition:
     itkGetConstMacro(ToolTipPosition,mitk::Point3D);
     itkSetMacro(ToolTipPosition,mitk::Point3D);
     itkGetConstMacro(ToolTipOrientation,mitk::Quaternion);
     itkSetMacro(ToolTipOrientation,mitk::Quaternion);
 
     //Tool Axis definition:
     //default tool axis is along x axis, the tool axis must be normalized
     itkGetConstMacro(ToolAxis, mitk::Point3D);
     itkSetMacro(ToolAxis, mitk::Point3D);
 
 
     /** @return Returns the tooltip as transform object. */
     mitk::AffineTransform3D::Pointer GetToolTipTransform();
 
     /** @return Returns true if a tooltip is set, false if not. */
     bool IsToolTipSet();
 
     //Tool Landmarks:
     /** For overview, here are descriptons of the two types of tool landmarks:
      *
      *  tool calibration landmarks: These landmarks may be used clearly define the tools pose only by
      *  using landmarks in the tool coordinate system. E.g., two landmarks for a 5DoF tool and three
      *  landmarks for a 6DoF tool. These landmarks may be used, e.g., for a point based registration
      *  of a tool from image space to tracking space.
      *
      *  tool registration landmarks: These landmarks are designed for representing defined landmarks
      *  on a tools surface. The number of these landmarks might exeed the number of tool calibration
      *  landmarks for reasons of redundancy and averaging. They are used for, e.g., manually registering
      *  the pose of a tool by visual markers in a CT scan. If you would use these landmarks to do a
      *  point based registration from image space to tracking space later, you might overweight the
      *  tool because of two many landmarks compared to other markers.
      *
      *  @return Returns the tool registration landmarks which represent markers / special points on a
      *          tool that can be used for registration. The landmarks should be given in tool coordinates.
      *          If there are no landmarks defined for this tool the method returns an empty point set.
      */
     itkGetConstMacro(ToolRegistrationLandmarks,mitk::PointSet::Pointer);
     /** @brief  Sets the tool registration landmarks which represent markers / special points on a
      *          tool that can be used for registration. The landmarks should be given in tool coordinates.
      */
     itkSetMacro(ToolRegistrationLandmarks,mitk::PointSet::Pointer);
     /** @return Returns the tool calibration landmarks for calibration of the defined points in the
       *         tool coordinate system, e.g. 2 landmarks for a 5DoF tool and 3 landmarks for a 6DoF tool.
       */
     itkGetConstMacro(ToolCalibrationLandmarks,mitk::PointSet::Pointer);
     /** @brief  Sets the tool calibration landmarks for calibration of defined points in the
       *         tool coordinate system, e.g. 2 landmarks for a 5DoF tool and 3 landmarks for a 6DoF tool.
       */
     itkSetMacro(ToolCalibrationLandmarks,mitk::PointSet::Pointer);
 
     //SerialNumber:
     itkGetConstMacro(SerialNumber,std::string);
     itkSetMacro(SerialNumber,std::string);
     //TrackingDeviceType:
     itkGetConstMacro(TrackingDeviceType,mitk::TrackingDeviceType);
     itkSetMacro(TrackingDeviceType,mitk::TrackingDeviceType);
     //ToolName (only getter):
     /** @return Returns the name of this navigation tool. Returns an empty string if there is
      *          no name (for example because the data node has not been set yet).
      *
      *          Note: There is no setter for the name,
      *          because the name of the corresponding data node is used as tool name. So if you
      *          want to modify the name of this navigation tool only get the data node and modify
      *          its name.
      */
     std::string GetToolName();
     //ToolSurface (only getter):
     /** @return Returns the surface of this navigation tool. Returns nullptr if there is
      *          no surface (for example because the data node has not been set yet).
      *
      *          Note: There is no setter for the surface,
      *          because the surface is the data of the corresponding data node. So if you
      *          want to set a new surface only get the data node and modify its data.
      */
     mitk::Surface::Pointer GetToolSurface();
     /**
       * \brief Graft the data and information from one NavigationTool to another.
       *
       * Copies the content of data into this object.
       * This is a convenience method to setup a second NavigationTool object with all the meta
       * information of another NavigationTool object.
       * Note that this method is different than just using two
       * SmartPointers to the same NavigationTool object since separate DataObjects are
       * still maintained.
       */
     virtual void Graft(const DataObject *data) override;
 
 
     /**
     * Return all relevant information as string, e.g. to display all tool information
     */
     std::string GetStringWithAllToolInformation() const;
 
 
     void SetDefaultSurface();
 
     //#######################
 
   protected:
 
     NavigationTool();
     NavigationTool(const NavigationTool &other);
     ~NavigationTool();
     virtual itk::LightObject::Pointer InternalClone() const override;
 
     //## data structure of a navigation tool object ##
     std::string m_Identifier;
     NavigationToolType m_Type;
     /** @brief This DataNode holds a toolname and a tool surface */
     mitk::DataNode::Pointer m_DataNode;
     /** @brief This member variable holds a mathamatical description of the tool */
     itk::SpatialObject<3>::Pointer m_SpatialObject;
     /** @brief The path to the calibration file of the tool. */
     std::string m_CalibrationFile;
     /** @brief A unique serial number of the tool which is needed to identify the tool correctly. This is very important
       *        in case of the NDI Aurora System. */
     std::string m_SerialNumber;
     /** @brief   This member holds the tracking device type of the tool. */
     mitk::TrackingDeviceType m_TrackingDeviceType;
     /** @brief Holds landmarks for tool registration. */
     mitk::PointSet::Pointer m_ToolRegistrationLandmarks;
     /** @brief Holds landmarks for calibration of the defined points in the tool coordinate system,
       *        e.g. 2 landmarks for a 5DoF tool and 3 landmarks for a 6DoF tool.
       */
     mitk::PointSet::Pointer m_ToolCalibrationLandmarks;
     /** @brief Holds the position of the tool tip. */
     mitk::Point3D m_ToolTipPosition;
     /** @brief Holds the orientation of the tool tip. */
     mitk::Quaternion m_ToolTipOrientation;
 
     /** @brief Holds the axis of the tool. */
     mitk::Point3D m_ToolAxis;
     //#################################################
 
   };
 } // namespace mitk
 #endif //NAVIGATIONTOOL