diff --git a/Modules/IGT/CMakeLists.txt b/Modules/IGT/CMakeLists.txt
index 6e5613a720..8246566077 100644
--- a/Modules/IGT/CMakeLists.txt
+++ b/Modules/IGT/CMakeLists.txt
@@ -1,59 +1,67 @@
 include(MITKIGTHardware.cmake)
 
 if(MITK_USE_MICRON_TRACKER)
-  set(INCLUDE_DIRS_INTERNAL ${INCLUDE_DIRS_INTERNAL} ${MITK_MICRON_TRACKER_INCLUDE_DIR})
+  set(ADDITIONAL_INCLUDE_DIRS ${ADDITIONAL_INCLUDE_DIRS} ${MITK_MICRON_TRACKER_INCLUDE_DIR})
   set(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_MICRON_TRACKER_LIB})
 endif(MITK_USE_MICRON_TRACKER)
 
 if(MITK_USE_OPTITRACK_TRACKER)
-  set(INCLUDE_DIRS_INTERNAL ${INCLUDE_DIRS_INTERNAL} ${MITK_OPTITRACK_TRACKER_INCLUDE_DIR})
+  set(ADDITIONAL_INCLUDE_DIRS ${ADDITIONAL_INCLUDE_DIRS} ${MITK_OPTITRACK_TRACKER_INCLUDE_DIR})
   set(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_OPTITRACK_TRACKER_LIB})
   add_definitions( -DMITK_USE_OPTITRACK_TRACKER )
 endif(MITK_USE_OPTITRACK_TRACKER)
 
 if(MITK_USE_MICROBIRD_TRACKER)
-  set(INCLUDE_DIRS_INTERNAL ${INCLUDE_DIRS_INTERNAL} ${MITK_USE_MICROBIRD_TRACKER_INCLUDE_DIR})
+  set(ADDITIONAL_INCLUDE_DIRS ${ADDITIONAL_INCLUDE_DIRS} ${MITK_USE_MICROBIRD_TRACKER_INCLUDE_DIR})
   set(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_USE_MICROBIRD_TRACKER_LIB})
 endif(MITK_USE_MICROBIRD_TRACKER)
 
+if(MITK_USE_POLHEMUS_TRACKER)
+  set(ADDITIONAL_INCLUDE_DIRS ${ADDITIONAL_INCLUDE_DIRS} ${MITK_POLHEMUS_TRACKER_INCLUDE_DIR})
+  set(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_POLHEMUS_TRACKER_LIB})
+endif(MITK_USE_POLHEMUS_TRACKER)
+
+message(STATUS "ADDITIONAL_INCLUDE_DIRS" ${ADDITIONAL_INCLUDE_DIRS})
+message(STATUS "ADDITIONAL_LIBS" ${ADDITIONAL_LIBS})
+
 MITK_CREATE_MODULE(
   SUBPROJECTS MITK-IGT
-  INCLUDE_DIRS Algorithms Common DataManagement ExceptionHandling IO Rendering TrackingDevices TestingHelper
-  INTERNAL_INCLUDE_DIRS ${INCLUDE_DIRS_INTERNAL}
+  INCLUDE_DIRS Algorithms Common DataManagement ExceptionHandling IO Rendering TrackingDevices TestingHelper 
+  INTERNAL_INCLUDE_DIRS ${ADDITIONAL_INCLUDE_DIRS}
   DEPENDS MitkImageStatistics MitkSceneSerialization MitkIGTBase MitkOpenIGTLink
   PACKAGE_DEPENDS ITK|ITKRegistrationCommon tinyxml OpenIGTLink
-  ADDITIONAL_LIBS "${ADDITIONAL_LIBS}"
+  ADDITIONAL_LIBS ${ADDITIONAL_LIBS}
   #WARNINGS_AS_ERRORS disabled for release 2014-03 because of bug 17463
 )
 
 if(MitkIGT_IS_ENABLED)
   MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/ClaronMicron.stl )
   MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/IntuitiveDaVinci.stl )
   MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIAurora.stl )
   MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIAurora_Dome.stl )
   MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIAuroraCompactFG_Dome.stl )
   MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIAuroraPlanarFG_Dome.stl )
   MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIAuroraTabletopFG_Dome.stl )
   MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIAuroraTabletopFG_Prototype_Dome.stl )
   MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIPolarisOldModel.stl )
   MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIPolarisSpectra.stl )
   MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIPolarisSpectraExtendedPyramid.stl )
   MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIPolarisVicra.stl )
 endif()
 
 if(NOT MODULE_IS_ENABLED)
   message(STATUS "IGTTutorialStep1 won't be built. Missing: ${_RESULT}")
 else()
 ## create IGT config
 configure_file(mitkIGTConfig.h.in ${PROJECT_BINARY_DIR}/mitkIGTConfig.h @ONLY)
 
 # add test programm for serial communication classADD_EXECUTABLE(SerialCommunicationTest IGTTrackingDevices/mitkSerialCommunicationTest.cpp)target_link_libraries(SerialCommunicationTest mitkIGT Mitk tinyxml PocoXML)
 
 add_subdirectory(autoload/DeviceRegistry)
 
 add_subdirectory(Tutorial)
 
 add_subdirectory(Testing)
 
 endif()
 
diff --git a/Modules/IGT/MITKIGTHardware.cmake b/Modules/IGT/MITKIGTHardware.cmake
index a7f4ad4eea..21c9309de8 100644
--- a/Modules/IGT/MITKIGTHardware.cmake
+++ b/Modules/IGT/MITKIGTHardware.cmake
@@ -1,42 +1,49 @@
 #Begin MicronTracker Hardware
 option(MITK_USE_MICRON_TRACKER "Enable support for micron tracker hardware" OFF)
 #Begin Optitrack Hardware
 option(MITK_USE_OPTITRACK_TRACKER "Enable support for Optitrack tracker hardware" OFF)
 
+option(MITK_USE_POLHEMUS_TRACKER "Enable support for Polhemus tracker hardware" OFF)
+
 # only if MicronTracker is enabled
 if(MITK_USE_MICRON_TRACKER)
   find_library(MITK_MICRON_TRACKER_LIB MTC DOC "Path which contains the MT2 library.")
   get_filename_component(MICRON_TRACKER_SDK_DIR ${MITK_MICRON_TRACKER_LIB} PATH)
   find_path(MITK_MICRON_TRACKER_INCLUDE_DIR MTC.h ${MICRON_TRACKER_SDK_DIR} DOC  "Include directory of the MT2.")
   find_path(MITK_MICRON_TRACKER_TEMP_DIR . DOC "Any temporary directory which can be used by the MicronTracker2.")
   MITK_INSTALL(FILES ${MICRON_TRACKER_SDK_DIR}/MTC.dll  CONFIGURATIONS Release)
   MITK_INSTALL(FILES ${MICRON_TRACKER_SDK_DIR}/MTInterfaceDotNet.dll  CONFIGURATIONS Release)
   MITK_INSTALL(FILES ${MICRON_TRACKER_SDK_DIR}/PGRFlyCapture.dll  CONFIGURATIONS Release)
 ENDIF(MITK_USE_MICRON_TRACKER)
 #End MicronTracker Hardware
 
 #only if Optitrack is enabled
 if(MITK_USE_OPTITRACK_TRACKER)
   find_library(MITK_OPTITRACK_TRACKER_LIB NPTrackingTools DOC "Path which contains the Optitrack library. Please choose 32/64 bit version depending on your build.")
   find_path(MITK_OPTITRACK_TRACKER_INCLUDE_DIR NPTrackinTools.h DOC  "Include directory of the Optitrack library.")
   find_path(MITK_OPTITRACK_TRACKER_LIB_DIR NPTrackingTools.dll)
   MITK_INSTALL(FILES ${MITK_OPTITRACK_TRACKER_LIB_DIR}/NPTrackingTools.dll CONFIGURATIONS Release)
   MITK_INSTALL(FILES ${MITK_OPTITRACK_TRACKER_LIB_DIR}/NPTrackingToolsx64.dll CONFIGURATIONS Release)
 ENDIF(MITK_USE_OPTITRACK_TRACKER)
 #End Optitrack Hardware
 
+if(MITK_USE_POLHEMUS_TRACKER)
+  find_library(MITK_POLHEMUS_TRACKER_LIB PDI DOC "Path which contains the Polhemus library.")
+  find_path(MITK_POLHEMUS_TRACKER_INCLUDE_DIR PDI.h DOC  "Include directory of the Polhemus library.")
+ENDIF(MITK_USE_POLHEMUS_TRACKER)
+
 
 # only on Win32
 if(WIN32)
 
   #Begin Ascension MicroBird Hardware
   option(MITK_USE_MICROBIRD_TRACKER "Enable support for Ascension MicroBird tracker hardware" OFF)
   if(MITK_USE_MICROBIRD_TRACKER)
    add_definitions(-DMITK_USE_MICROBIRD_TRACKER)
    find_library(MITK_USE_MICROBIRD_TRACKER_LIB PCIBird3)
    get_filename_component(MICROBIRD_TRACKER_API_DIR ${MITK_USE_MICROBIRD_TRACKER_LIB} PATH)
    find_path(MITK_USE_MICROBIRD_TRACKER_INCLUDE_DIR PCIBird3.h ${MICROBIRD_TRACKER_API_DIR})
   endif(MITK_USE_MICROBIRD_TRACKER)
   #End MicroBird Hardware
 
 endif(WIN32)
diff --git a/Modules/IGT/Testing/CMakeLists.txt b/Modules/IGT/Testing/CMakeLists.txt
index b4271e69c1..94d9fef6af 100644
--- a/Modules/IGT/Testing/CMakeLists.txt
+++ b/Modules/IGT/Testing/CMakeLists.txt
@@ -1,31 +1,35 @@
 if(BUILD_TESTING)
  include(MITKIGTTrackingDeviceHardwareTesting.cmake)
 endif(BUILD_TESTING)
 
 MITK_CREATE_MODULE_TESTS()
 
 if(MITK_TRACKING_DEVICES_HARDWARE_TESTS_ENABLED)
 
   if(MITK_NDI_AURORA_CONNECTED)
     mitkAddCustomModuleTest(mitkNDIAuroraHardwareTest mitkNDIAuroraHardwareTest ${MITK_NDI_AURORA_COM_PORT})
   endif(MITK_NDI_AURORA_CONNECTED)
 
   if(MITK_NDI_POLARIS_CONNECTED)
     mitkAddCustomModuleTest(mitkNDIPolarisHardwareTest mitkNDIPolarisHardwareTest ${MITK_NDI_POLARIS_COM_PORT})
   endif(MITK_NDI_POLARIS_CONNECTED)
 
   if(MITK_CLARON_MICRONTRACKER_CONNECTED)
     mitkAddCustomModuleTest(mitkClaronTrackingDeviceHardwareTest  mitkClaronTrackingDeviceHardwareTest ${MITK_DATA_DIR}/IGT-Data/MicronTrackerToolfiles/Tool_11 ${MITK_DATA_DIR}/IGT-Data/MicronTrackerToolfiles/Tool_12 ${MITK_DATA_DIR}/IGT-Data/MicronTrackerToolfiles/Tool_13)
   endif(MITK_CLARON_MICRONTRACKER_CONNECTED)
 
+  if(MITK_POLHEMUS_CONNECTED)
+    mitkAddCustomModuleTest(mitkPolhemusTrackingDeviceHardwareTest  mitkPolhemusTrackingDeviceHardwareTest)
+  endif(MITK_POLHEMUS_CONNECTED)
+
 endif(MITK_TRACKING_DEVICES_HARDWARE_TESTS_ENABLED)
 
 option(MITK_IGT_READER_WRITER_TESTS_ENABLED "Enable additional reader/writer tests of the IGT module." OFF)
 mark_as_advanced(MITK_IGT_READER_WRITER_TESTS_ENABLED)
 
 if(MITK_IGT_READER_WRITER_TESTS_ENABLED)
   mitkAddCustomModuleTest(mitkNavigationToolReaderAndWriterTest mitkNavigationToolReaderAndWriterTest)
   mitkAddCustomModuleTest(mitkNavigationToolStorageDeserializerTest mitkNavigationToolStorageDeserializerTest)
   mitkAddCustomModuleTest(mitkNavigationToolStorageSerializerAndDeserializerIntegrationTest mitkNavigationToolStorageSerializerAndDeserializerIntegrationTest)
   mitkAddCustomModuleTest(mitkNavigationToolStorageSerializerTest mitkNavigationToolStorageSerializerTest)
 endif(MITK_IGT_READER_WRITER_TESTS_ENABLED)
diff --git a/Modules/IGT/Testing/MITKIGTTrackingDeviceHardwareTesting.cmake b/Modules/IGT/Testing/MITKIGTTrackingDeviceHardwareTesting.cmake
index 90986ca608..43565a7593 100644
--- a/Modules/IGT/Testing/MITKIGTTrackingDeviceHardwareTesting.cmake
+++ b/Modules/IGT/Testing/MITKIGTTrackingDeviceHardwareTesting.cmake
@@ -1,31 +1,32 @@
 option(MITK_TRACKING_DEVICES_HARDWARE_TESTS_ENABLED "Enable support for testing tracking device hardware (this hardware must be connected to the system)" OFF)
 mark_as_advanced(MITK_TRACKING_DEVICES_HARDWARE_TESTS_ENABLED)
 
 if(MITK_TRACKING_DEVICES_HARDWARE_TESTS_ENABLED)
   option(MITK_NDI_AURORA_CONNECTED "Turn on if an Aurora system is connected and should be tested." OFF)
   option(MITK_NDI_POLARIS_CONNECTED "Turn on if a Polaris system is connected and should be tested." OFF)
+  option(MITK_POLHEMUS_CONNECTED "Turn on if a Polhemus system is connected and should be tested." OFF)
   option(MITK_CLARON_MICRONTRACKER_CONNECTED "Turn on if a MicronTracker system is connected and should be tested." OFF)
   mark_as_advanced(MITK_NDI_AURORA_CONNECTED MITK_NDI_POLARIS_CONNECTED MITK_CLARON_MICRONTRACKER_CONNECTED MITK_CLARON_MICRONTRACKER_CONNECTED)
 endif(MITK_TRACKING_DEVICES_HARDWARE_TESTS_ENABLED)
 
 if(MITK_NDI_AURORA_CONNECTED)
 if(WIN32)
    set(MITK_NDI_AURORA_COM_PORT "1" CACHE STRING "Serial port where the system is connected.")
 else(WIN32)
    set(MITK_NDI_AURORA_COM_PORT "/dev/ttyS1" CACHE STRING "Device path where the system is connected. (e.g. /dev/ttyS6 or /dev/ttyUSB1)")
 endif(WIN32)
 endif(MITK_NDI_AURORA_CONNECTED)
 
 if(MITK_NDI_POLARIS_CONNECTED)
 if(WIN32)
    set(MITK_NDI_POLARIS_COM_PORT "1" CACHE STRING "Serial port where the system is connected.")
 else(WIN32)
    set(MITK_NDI_POLARIS_COM_PORT "/dev/ttyS1" CACHE STRING "Device path where the system is connected. (e.g. /dev/ttyS6 or /dev/ttyUSB1)")
 endif(WIN32)
 endif(MITK_NDI_POLARIS_CONNECTED)
 
 if(MITK_CLARON_MICRONTRACKER_CONNECTED)
 if(WIN32)
     find_path(MITK_MICRON_TRACKER_CALIBRATION_DIR BumbleBee_6400420.calib DOC "Path which contains the MT2 calibration file.")
 endif(WIN32)
 endif(MITK_CLARON_MICRONTRACKER_CONNECTED)
diff --git a/Modules/IGT/Testing/files.cmake b/Modules/IGT/Testing/files.cmake
index 3f3bb46b60..4be7accede 100644
--- a/Modules/IGT/Testing/files.cmake
+++ b/Modules/IGT/Testing/files.cmake
@@ -1,67 +1,75 @@
 set(MODULE_TESTS
    # IMPORTANT: If you plan to deactivate / comment out a test please write a bug number to the commented out line of code.
    #
    #     Example: #mitkMyTest #this test is commented out because of bug 12345
    #
    # It is important that the bug is open and that the test will be activated again before the bug is closed. This assures that
    # no test is forgotten after it was commented out. If there is no bug for your current problem, please add a new one and
    # mark it as critical.
 
    ################## ON THE FENCE TESTS #################################################
    # none
 
    ################## DISABLED TESTS #####################################################
 
 
    ################# RUNNING TESTS #######################################################
    mitkCameraVisualizationTest.cpp
    mitkClaronInterfaceTest.cpp
    mitkClaronToolTest.cpp
    mitkClaronTrackingDeviceTest.cpp
    mitkInternalTrackingToolTest.cpp
    mitkNavigationDataDisplacementFilterTest.cpp
    mitkNavigationDataLandmarkTransformFilterTest.cpp
    mitkNavigationDataObjectVisualizationFilterTest.cpp
    mitkNavigationDataSetTest.cpp
    mitkNavigationDataTest.cpp
    mitkNavigationDataRecorderTest.cpp
    mitkNavigationDataReferenceTransformFilterTest.cpp
    mitkNavigationDataSequentialPlayerTest.cpp
    mitkNavigationDataSetReaderWriterXMLTest.cpp
    mitkNavigationDataSetReaderWriterCSVTest.cpp
    mitkNavigationDataSourceTest.cpp
    mitkNavigationDataToMessageFilterTest.cpp
    mitkNavigationDataToNavigationDataFilterTest.cpp
    mitkNavigationDataToPointSetFilterTest.cpp
    mitkNavigationDataToIGTLMessageFilterTest.cpp
    mitkNavigationDataTransformFilterTest.cpp
    mitkNDIPassiveToolTest.cpp
    mitkNDIProtocolTest.cpp
    mitkNDITrackingDeviceTest.cpp
    mitkTimeStampTest.cpp
    mitkTrackingVolumeGeneratorTest.cpp
    mitkTrackingDeviceTest.cpp
    mitkTrackingToolTest.cpp
    mitkVirtualTrackingDeviceTest.cpp
    # mitkNavigationDataPlayerTest.cpp # random fails see bug 16485.
    # We decided to won't fix because of complete restructuring via bug 15959.
    mitkTrackingDeviceSourceTest.cpp
    mitkTrackingDeviceSourceConfiguratorTest.cpp
    mitkNavigationDataEvaluationFilterTest.cpp
    mitkTrackingTypesTest.cpp
    mitkOpenIGTLinkTrackingDeviceTest.cpp
    # ------------------ Navigation Tool Management Tests -------------------
    mitkNavigationToolStorageDeserializerTest.cpp # Activated experimentally on dart clients, see task T17303 for details.
    mitkNavigationToolStorageTest.cpp
    mitkNavigationToolTest.cpp
    # -----------------------------------------------------------------------
 )
 
 set(MODULE_CUSTOM_TESTS
   mitkNDIAuroraHardwareTest.cpp
   mitkNDIPolarisHardwareTest.cpp
   mitkClaronTrackingDeviceHardwareTest.cpp
   mitkNavigationToolReaderAndWriterTest.cpp #deactivated because of bug 18835
   mitkNavigationToolStorageSerializerAndDeserializerIntegrationTest.cpp # This test was disabled because of bug 17181.
   mitkNavigationToolStorageSerializerTest.cpp # This test was disabled because of bug 18671
+  #mitkPolhemusTrackingDeviceHardwareTest.cpp
 )
+
+if(MITK_USE_POLHEMUS_TRACKER)
+set(MODULE_CUSTOM_TESTS
+  ${MODULE_CUSTOM_TESTS}
+  mitkPolhemusTrackingDeviceHardwareTest.cpp
+)
+endif(MITK_USE_POLHEMUS_TRACKER)
diff --git a/Modules/IGT/Testing/mitkPolhemusTrackingDeviceHardwareTest.cpp b/Modules/IGT/Testing/mitkPolhemusTrackingDeviceHardwareTest.cpp
new file mode 100644
index 0000000000..5538870444
--- /dev/null
+++ b/Modules/IGT/Testing/mitkPolhemusTrackingDeviceHardwareTest.cpp
@@ -0,0 +1,65 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkPolhemusInterface.h"
+#include "mitkTestingMacros.h"
+#include "mitkStandardFileLocations.h"
+#include <mitkIGTConfig.h>
+
+// Testing
+#include "mitkTestingMacros.h"
+#include "mitkTestFixture.h"
+
+class mitkPolhemusTrackingDeviceHardwareTestSuite : public mitk::TestFixture
+{
+  CPPUNIT_TEST_SUITE(mitkPolhemusTrackingDeviceHardwareTestSuite);
+  // Test the append method
+  MITK_TEST(testInterface);
+  CPPUNIT_TEST_SUITE_END();
+
+
+public:
+  void setUp() override
+  {
+
+  }
+  void tearDown() override
+  {
+
+  }
+
+  void testInterface()
+  {
+    mitk::PolhemusInterface::Pointer myInterface = mitk::PolhemusInterface::New();
+    CPPUNIT_ASSERT_MESSAGE("Testing connection.", myInterface->Connect());
+    CPPUNIT_ASSERT_MESSAGE("Start tracking.", myInterface->StartTracking());
+
+    CPPUNIT_ASSERT_MESSAGE("Tracking 20 frames ...", true);
+    for (int i = 0; i < 20; i++)
+    {
+      std::vector<mitk::PolhemusInterface::trackingData> lastFrame = myInterface->GetLastFrame();
+      MITK_INFO << "Frame " << i;
+      for (int j = 0; j < lastFrame.size(); j++)
+      {
+        MITK_INFO << "[" << j << "]" << " Pos:" << lastFrame.at(j).pos << " Rot:" << lastFrame.at(j).rot;
+      }
+    }
+
+  }
+
+};
+
+MITK_TEST_SUITE_REGISTRATION(mitkPolhemusTrackingDeviceHardware)
diff --git a/Modules/IGT/TrackingDevices/mitkPolhemusInterface.cpp b/Modules/IGT/TrackingDevices/mitkPolhemusInterface.cpp
new file mode 100644
index 0000000000..26f1b570b8
--- /dev/null
+++ b/Modules/IGT/TrackingDevices/mitkPolhemusInterface.cpp
@@ -0,0 +1,200 @@
+/*===================================================================
+
+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 <mitkPolhemusInterface.h>
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+#include <PDI.h>
+
+BYTE  MotionBuf[0x1FA400];
+
+mitk::PolhemusInterface::PolhemusInterface()
+{
+	m_pdiDev = new CPDIdev();
+
+}
+
+mitk::PolhemusInterface::~PolhemusInterface()
+{
+	delete m_pdiDev;
+}
+
+bool mitk::PolhemusInterface::InitializeDevice()
+{
+  m_pdiDev->ResetTracker();
+  m_pdiDev->ResetSAlignment(-1);
+  m_pdiDev->Trace(TRUE, 7);
+  return true;
+}
+
+bool mitk::PolhemusInterface::SetupDevice()
+{
+  m_pdiDev->SetPnoBuffer(MotionBuf, 0x1FA400);
+  m_pdiDev->SetMetric(true); //use cm instead of inches
+
+  m_pdiDev->StartPipeExport();
+
+  CPDImdat pdiMDat;
+  pdiMDat.Empty();
+  pdiMDat.Append(PDI_MODATA_FRAMECOUNT);
+  pdiMDat.Append(PDI_MODATA_POS);
+  pdiMDat.Append(PDI_MODATA_ORI);
+  m_pdiDev->SetSDataList(-1, pdiMDat);
+
+  CPDIbiterr cBE;
+  m_pdiDev->GetBITErrs(cBE);
+
+  if (!(cBE.IsClear())) {m_pdiDev->ClearBITErrs();}
+
+  if (this->m_HemisphereTrackingEnabled) { m_pdiDev->SetSHemiTrack(-1); }
+  else { m_pdiDev->SetSHemisphere(-1, { (float)2.54,0,0 }); }
+
+  return true;
+}
+
+bool mitk::PolhemusInterface::StartTracking()
+{
+  LPCTSTR	szWindowClass = _T("PDIconsoleWinClass");
+  HINSTANCE hInst = GetModuleHandle(0);
+  HWND	hwnd = CreateWindowEx(
+    WS_EX_NOACTIVATE,//WS_EX_STATICEDGE, //
+    szWindowClass,
+    _T("MyWindowName"),
+    WS_POPUP,
+    0, 0, 1, 1,
+    HWND_MESSAGE,
+    0,
+    hInst,
+    0);
+
+  m_continousTracking = true;
+  return m_pdiDev->StartContPno(hwnd);
+}
+
+bool mitk::PolhemusInterface::StopTracking()
+{
+  m_continousTracking = false;
+  return true;
+}
+
+bool mitk::PolhemusInterface::Connect()
+{
+  if (!InitializeDevice()) { return false; }
+
+  if (m_pdiDev->CnxReady()) { return true; }
+  CPDIser	pdiSer;
+  m_pdiDev->SetSerialIF(&pdiSer);
+
+  ePiCommType eType = m_pdiDev->DiscoverCnx();
+  switch (eType)
+  {
+  case PI_CNX_USB:
+    MITK_INFO << "USB Connection: " << m_pdiDev->GetLastResultStr();
+    break;
+  case PI_CNX_SERIAL:
+    MITK_INFO << "Serial Connection: " << m_pdiDev->GetLastResultStr();
+    break;
+  default:
+    MITK_INFO << "DiscoverCnx result: " << m_pdiDev->GetLastResultStr();
+    break;
+  }
+
+  if (!SetupDevice()) { return false; }
+
+  return m_pdiDev->CnxReady();
+}
+
+bool mitk::PolhemusInterface::Disconnect()
+{
+  if (m_continousTracking)
+  {
+    m_continousTracking = false;
+    if (!m_pdiDev->Disconnect()) return false;
+  }
+  return true;
+}
+
+std::vector<mitk::PolhemusInterface::trackingData> mitk::PolhemusInterface::GetLastFrame()
+{
+  PBYTE pBuf;
+  DWORD dwSize;
+
+  //read one frame
+  if (!m_pdiDev->LastPnoPtr(pBuf, dwSize)) {MITK_WARN << m_pdiDev->GetLastResultStr();}
+
+  std::vector<mitk::PolhemusInterface::trackingData> returnValue = ParsePolhemusRawData(pBuf, dwSize);
+
+  if (returnValue.empty()) { MITK_WARN << "Cannot parse data / no tools present"; }
+
+  return returnValue;
+}
+
+unsigned int mitk::PolhemusInterface::GetNumberOfTools()
+{
+  if (m_continousTracking) return GetLastFrame().size();
+  else return GetSingleFrame().size();
+}
+
+std::vector<mitk::PolhemusInterface::trackingData> mitk::PolhemusInterface::GetSingleFrame()
+{
+  if (m_continousTracking) return std::vector<mitk::PolhemusInterface::trackingData>();
+
+  PBYTE pBuf;
+  DWORD dwSize;
+
+  //read one frame
+  if (!m_pdiDev->ReadSinglePnoBuf(pBuf, dwSize)) { MITK_WARN << m_pdiDev->GetLastResultStr(); }
+
+  return ParsePolhemusRawData(pBuf, dwSize);
+}
+
+std::vector<mitk::PolhemusInterface::trackingData> mitk::PolhemusInterface::ParsePolhemusRawData(PBYTE pBuf, DWORD dwSize)
+{
+  std::vector<mitk::PolhemusInterface::trackingData> returnValue;
+
+  DWORD i = 0;
+
+  while (i<dwSize)
+  {
+    BYTE ucSensor = pBuf[i + 2];
+    SHORT shSize = pBuf[i + 6];
+
+    // skip rest of header
+    i += 8;
+
+    PDWORD pFC = (PDWORD)(&pBuf[i]);
+    PFLOAT pPno = (PFLOAT)(&pBuf[i + 4]);
+
+    mitk::PolhemusInterface::trackingData currentTrackingData;
+
+    currentTrackingData.id = ucSensor;
+
+    currentTrackingData.pos[0] = pPno[0] * 10; //from cm to mm
+    currentTrackingData.pos[1] = pPno[1] * 10;
+    currentTrackingData.pos[2] = pPno[2] * 10;
+
+    double azimuthAngle = pPno[3] / 180 * M_PI; //from degree to rad
+    double elevationAngle = pPno[4] / 180 * M_PI;
+    double rollAngle = pPno[5] / 180 * M_PI;
+    vnl_quaternion<double> eulerQuat(rollAngle, elevationAngle, azimuthAngle);
+    currentTrackingData.rot = eulerQuat;
+
+    returnValue.push_back(currentTrackingData);
+    i += shSize;
+  }
+  return returnValue;
+}
diff --git a/Modules/IGT/TrackingDevices/mitkPolhemusInterface.h b/Modules/IGT/TrackingDevices/mitkPolhemusInterface.h
new file mode 100644
index 0000000000..28eea88760
--- /dev/null
+++ b/Modules/IGT/TrackingDevices/mitkPolhemusInterface.h
@@ -0,0 +1,117 @@
+/*===================================================================
+
+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 MITKPolhemusINTERFACE_H_HEADER_INCLUDED_
+#define MITKPolhemusINTERFACE_H_HEADER_INCLUDED_
+
+
+#include <vector>
+#include <string>
+
+#include <MitkIGTExports.h>
+#include "mitkCommon.h"
+
+#include <itkObject.h>
+#include <itkObjectFactory.h>
+
+#include <windows.h>
+#include <tchar.h>
+#include <string>
+
+#include <mitkNavigationData.h>
+
+class CPDIdev;
+
+namespace mitk
+{
+
+  /** Documentation:
+  *   \brief An object of this class represents the interface to Polhemus trackers.
+  *   \ingroup IGT
+  */
+  class MITKIGT_EXPORT PolhemusInterface : public itk::Object
+  {
+  public:
+
+    mitkClassMacroItkParent(PolhemusInterface,itk::Object);
+    itkFactorylessNewMacro(Self);
+    itkCloneMacro(Self);
+
+    struct trackingData
+    {
+      mitk::Point3D pos;
+      mitk::Quaternion rot;
+      BYTE id;
+    };
+
+    /**
+    * \brief Opens the connection to the device and makes it ready to track tools.
+    * \return Returns true if there is a connection to the device and the device is ready to track tools, false if not.
+    */
+    bool StartTracking();
+
+    /**
+    * \brief Clears all resources. After this method have been called the system isn't ready to track any longer.
+    * \return Returns true if the operation was succesful, false if not.
+    */
+    bool StopTracking();
+
+    bool Connect();
+
+    bool Disconnect();
+
+    /** @return Returns a single frame. Only works if the tracking device is not in continous tracking mode. Returns an empty vector in case of an error.*/
+    std::vector<trackingData> GetSingleFrame();
+
+    /** @return Returns the last frame when the tracking device is in continous tracking mode. Returns an empty vector in case of an error.*/
+    std::vector<trackingData> GetLastFrame();
+
+    /** @return Returns the number of tools. Returns 0 if no information is avialable.*/
+    unsigned int GetNumberOfTools();
+
+    /** Enables/disables hemisphere tracking for all sensors. */
+    itkSetMacro(HemisphereTrackingEnabled, bool);
+
+  protected:
+    /**
+    * \brief standard constructor
+    */
+    PolhemusInterface();
+    /**
+    * \brief standard destructor
+    */
+    ~PolhemusInterface();
+
+	/** Polhemus liberty/patriot tracker object*/
+    CPDIdev* m_pdiDev;
+	
+	/** Parses polhemus raw data to a collection of tracking data of single tools. */
+    std::vector<mitk::PolhemusInterface::trackingData> ParsePolhemusRawData(PBYTE pBuf, DWORD dwSize);
+
+    unsigned int m_numberOfTools;
+
+    bool m_continousTracking;
+
+    bool InitializeDevice();
+
+    bool SetupDevice();
+
+    bool m_HemisphereTrackingEnabled;
+
+
+  };
+}//mitk
+#endif
diff --git a/Modules/IGT/TrackingDevices/mitkPolhemusTool.cpp b/Modules/IGT/TrackingDevices/mitkPolhemusTool.cpp
new file mode 100644
index 0000000000..dfa34e5769
--- /dev/null
+++ b/Modules/IGT/TrackingDevices/mitkPolhemusTool.cpp
@@ -0,0 +1,25 @@
+/*===================================================================
+
+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 "mitkPolhemusTool.h"
+
+mitk::PolhemusTool::PolhemusTool() :InternalTrackingTool()
+{
+}
+
+mitk::PolhemusTool::~PolhemusTool(void)
+{
+}
diff --git a/Modules/IGT/TrackingDevices/mitkPolhemusTool.h b/Modules/IGT/TrackingDevices/mitkPolhemusTool.h
new file mode 100644
index 0000000000..0d16bebb10
--- /dev/null
+++ b/Modules/IGT/TrackingDevices/mitkPolhemusTool.h
@@ -0,0 +1,46 @@
+/*===================================================================
+
+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 MITKPolhemusTOOL_H_HEADER_INCLUDED_
+#define MITKPolhemusTOOL_H_HEADER_INCLUDED_
+
+#include <mitkPolhemusInterface.h>
+#include <mitkInternalTrackingTool.h>
+#include <itkFastMutexLock.h>
+
+namespace mitk
+{
+  class PolhemusTrackingDevice;
+  /** Documentation:
+  *   \brief  An object of this class represents a tool of a Polhemus tracking device.
+  *           A tool has to be added to a tracking device which will then
+  *           continuously update the tool coordinates.
+  *   \ingroup IGT
+  */
+  class MITKIGT_EXPORT PolhemusTool : public InternalTrackingTool
+  {
+  public:
+    friend class PolhemusTrackingDevice;
+    mitkClassMacro(PolhemusTool, InternalTrackingTool);
+
+  protected:
+    itkFactorylessNewMacro(Self)
+    itkCloneMacro(Self)
+    PolhemusTool();
+    virtual ~PolhemusTool();
+  };
+}//mitk
+#endif // MITKPolhemusTOOL_H_HEADER_INCLUDED_
diff --git a/Modules/IGT/TrackingDevices/mitkPolhemusTrackerTypeInformation.cpp b/Modules/IGT/TrackingDevices/mitkPolhemusTrackerTypeInformation.cpp
new file mode 100644
index 0000000000..a4e7bed526
--- /dev/null
+++ b/Modules/IGT/TrackingDevices/mitkPolhemusTrackerTypeInformation.cpp
@@ -0,0 +1,70 @@
+/*===================================================================
+
+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 "mitkPolhemusTrackerTypeInformation.h"
+
+#include "mitkPolhemusTrackingDevice.h"
+
+namespace mitk
+{
+  std::string PolhemusTrackerTypeInformation::GetTrackingDeviceName()
+  {
+    return "Polhemus tracker";
+  }
+
+  TrackingDeviceData PolhemusTrackerTypeInformation::GetDeviceDataPolhemusTrackerLiberty()
+  {
+    TrackingDeviceData data = { PolhemusTrackerTypeInformation::GetTrackingDeviceName(), "Polhemus Liberty Tracker", "cube", "X" };
+    return data;
+  }
+
+  PolhemusTrackerTypeInformation::PolhemusTrackerTypeInformation()
+  {
+    m_DeviceName = PolhemusTrackerTypeInformation::GetTrackingDeviceName();
+    m_TrackingDeviceData.push_back(GetDeviceDataPolhemusTrackerLiberty());
+  }
+
+  PolhemusTrackerTypeInformation::~PolhemusTrackerTypeInformation()
+  {
+  }
+
+  mitk::TrackingDeviceSource::Pointer PolhemusTrackerTypeInformation::CreateTrackingDeviceSource(
+    mitk::TrackingDevice::Pointer trackingDevice,
+    mitk::NavigationToolStorage::Pointer navigationTools,
+    std::string* errorMessage,
+    std::vector<int>* toolCorrespondencesInToolStorage)
+  {
+    mitk::TrackingDeviceSource::Pointer returnValue = mitk::TrackingDeviceSource::New();
+    mitk::PolhemusTrackingDevice::Pointer thisDevice = dynamic_cast<mitk::PolhemusTrackingDevice*>(trackingDevice.GetPointer());
+    *toolCorrespondencesInToolStorage = std::vector<int>();
+    //add the tools to the tracking device
+    for (int i = 0; i < navigationTools->GetToolCount(); i++)
+    {
+      mitk::NavigationTool::Pointer thisNavigationTool = navigationTools->GetTool(i);
+      toolCorrespondencesInToolStorage->push_back(i);
+      bool toolAddSuccess = thisDevice->AddTool(thisNavigationTool->GetToolName().c_str());
+      if (!toolAddSuccess)
+      {
+        //todo error handling
+        errorMessage->append("Can't add tool, is the toolfile valid?");
+        return NULL;
+      }
+      thisDevice->GetTool(i)->SetToolTip(thisNavigationTool->GetToolTipPosition(), thisNavigationTool->GetToolTipOrientation());
+    }
+    returnValue->SetTrackingDevice(thisDevice);
+    return returnValue;
+  }
+}
diff --git a/Modules/IGT/TrackingDevices/mitkPolhemusTrackerTypeInformation.h b/Modules/IGT/TrackingDevices/mitkPolhemusTrackerTypeInformation.h
new file mode 100644
index 0000000000..52b8647821
--- /dev/null
+++ b/Modules/IGT/TrackingDevices/mitkPolhemusTrackerTypeInformation.h
@@ -0,0 +1,45 @@
+/*===================================================================
+
+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 mitkPolhemusTrackerTypeInformation_h
+#define mitkPolhemusTrackerTypeInformation_h
+
+#include "mitkTrackingDeviceTypeInformation.h"
+
+namespace mitk
+{
+  /** Documentation:
+  *   \brief Type information for Polhemus Tracking Devices.
+  *
+  *   \ingroup IGTUI
+  */
+  class MITKIGT_EXPORT PolhemusTrackerTypeInformation : public TrackingDeviceTypeInformation
+  {
+  public:
+    PolhemusTrackerTypeInformation();
+    virtual ~PolhemusTrackerTypeInformation();
+
+    virtual TrackingDeviceSource::Pointer CreateTrackingDeviceSource(mitk::TrackingDevice::Pointer trackingDevice,
+      mitk::NavigationToolStorage::Pointer navigationTools,
+      std::string* errorMessage,
+      std::vector<int>* toolCorrespondencesInToolStorage) override;
+
+    static std::string GetTrackingDeviceName();
+    static TrackingDeviceData GetDeviceDataPolhemusTrackerLiberty();
+  };
+} // namespace mitk
+
+#endif //mitkPolhemusTrackerTypeInformation_h
diff --git a/Modules/IGT/TrackingDevices/mitkPolhemusTrackingDevice.cpp b/Modules/IGT/TrackingDevices/mitkPolhemusTrackingDevice.cpp
new file mode 100644
index 0000000000..98bd67f4f7
--- /dev/null
+++ b/Modules/IGT/TrackingDevices/mitkPolhemusTrackingDevice.cpp
@@ -0,0 +1,250 @@
+/*===================================================================
+
+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 "mitkPolhemusTrackingDevice.h"
+#include "mitkPolhemusTool.h"
+#include "mitkIGTConfig.h"
+#include "mitkIGTTimeStamp.h"
+#include "mitkIGTHardwareException.h"
+#include <itksys/SystemTools.hxx>
+#include <iostream>
+#include <itkMutexLockHolder.h>
+#include "mitkPolhemusTrackerTypeInformation.h"
+#include <vtkConeSource.h>
+
+typedef itk::MutexLockHolder<itk::FastMutexLock> MutexLockHolder;
+
+
+mitk::PolhemusTrackingDevice::PolhemusTrackingDevice(): mitk::TrackingDevice()
+{
+  //set the type of this tracking device
+  this->m_Data = mitk::PolhemusTrackerTypeInformation::GetDeviceDataPolhemusTrackerLiberty();
+
+  this->m_MultiThreader = itk::MultiThreader::New();
+  m_ThreadID = 0;
+
+  m_Device = mitk::PolhemusInterface::New();
+}
+
+mitk::PolhemusTrackingDevice::~PolhemusTrackingDevice()
+{
+}
+
+bool mitk::PolhemusTrackingDevice::IsDeviceInstalled()
+{
+  return true;
+}
+
+mitk::TrackingTool* mitk::PolhemusTrackingDevice::AddTool( const char* toolName)
+{
+  mitk::PolhemusTool::Pointer t = mitk::PolhemusTool::New();
+  t->SetToolName(toolName);
+  if (this->InternalAddTool(t) == false)
+    return nullptr;
+  return t.GetPointer();
+}
+
+bool mitk::PolhemusTrackingDevice::InternalAddTool(PolhemusTool::Pointer tool)
+{
+  m_AllTools.push_back(tool);
+  return true;
+}
+
+bool mitk::PolhemusTrackingDevice::StartTracking()
+{
+  bool success = m_Device->StartTracking();
+  if (success)
+  {
+    mitk::IGTTimeStamp::GetInstance()->Start(this);
+    this->SetState(Tracking);
+    m_ThreadID = m_MultiThreader->SpawnThread(this->ThreadStartTracking, this);    // start a new thread that executes the TrackTools() method
+    return true;
+  }
+  else
+  {
+    this->SetState(Ready);
+    mitkThrowException(mitk::IGTHardwareException) << "Error while trying to start the device!";
+  }
+  return success;
+}
+
+bool mitk::PolhemusTrackingDevice::StopTracking()
+{
+  return Superclass::StopTracking();
+}
+
+
+unsigned int mitk::PolhemusTrackingDevice::GetToolCount() const
+{
+  return (unsigned int)this->m_AllTools.size();
+}
+
+
+mitk::TrackingTool* mitk::PolhemusTrackingDevice::GetTool(unsigned int toolNumber) const
+{
+  if ( toolNumber >= this->GetToolCount())
+    return nullptr;
+  else
+    return this->m_AllTools[toolNumber];
+}
+
+
+bool mitk::PolhemusTrackingDevice::OpenConnection()
+{
+  //reset everything
+  if (m_Device.IsNull()) {m_Device = mitk::PolhemusInterface::New();}
+  m_Device->SetHemisphereTrackingEnabled(m_HemisphereTrackingEnabled);
+  m_Device->Connect();
+  this->SetState(Ready);
+  return true;
+}
+
+bool mitk::PolhemusTrackingDevice::CloseConnection()
+{
+  bool returnValue = true;
+  if (this->GetState() == Setup)
+    return true;
+
+  returnValue = m_Device->Disconnect();
+
+  this->SetState(Setup);
+  return returnValue;
+}
+
+
+mitk::PolhemusInterface* mitk::PolhemusTrackingDevice::GetDevice()
+{
+  return m_Device;
+}
+
+
+std::vector<mitk::PolhemusTool::Pointer> mitk::PolhemusTrackingDevice::GetAllTools()
+{
+  return this->m_AllTools;
+}
+
+
+void mitk::PolhemusTrackingDevice::TrackTools()
+{
+  try
+  {
+    /* lock the TrackingFinishedMutex to signal that the execution rights are now transfered to the tracking thread */
+    MutexLockHolder trackingFinishedLockHolder(*m_TrackingFinishedMutex); // keep lock until end of scope
+
+    bool localStopTracking;       // Because m_StopTracking is used by two threads, access has to be guarded by a mutex. To minimize thread locking, a local copy is used here
+    this->m_StopTrackingMutex->Lock();  // update the local copy of m_StopTracking
+    localStopTracking = this->m_StopTracking;
+    this->m_StopTrackingMutex->Unlock();
+    Sleep(100);//Wait a bit until the tracker is ready...
+
+    while ((this->GetState() == Tracking) && (localStopTracking == false))
+    {
+      std::vector<mitk::PolhemusInterface::trackingData> lastData = this->GetDevice()->GetLastFrame();
+
+      if (lastData.size() != m_AllTools.size())
+      {
+        MITK_WARN << "Tool count is corrupt. Aborting!";
+      }
+      else
+      {
+        std::vector<mitk::PolhemusTool::Pointer> allTools = this->GetAllTools();
+        for (int i = 0; i < allTools.size(); i++)
+        {
+          mitk::PolhemusTool::Pointer currentTool = allTools.at(i);
+          currentTool->SetDataValid(true);
+          currentTool->SetPosition(lastData.at(i).pos);
+          currentTool->SetOrientation(lastData.at(i).rot);
+          currentTool->SetIGTTimeStamp(mitk::IGTTimeStamp::GetInstance()->GetElapsed());
+        }
+      }
+      /* Update the local copy of m_StopTracking */
+      this->m_StopTrackingMutex->Lock();
+      localStopTracking = m_StopTracking;
+      this->m_StopTrackingMutex->Unlock();
+    }
+  }
+  catch(...)
+  {
+    this->StopTracking();
+    mitkThrowException(mitk::IGTHardwareException) << "Error while trying to track tools. Thread stopped.";
+  }
+}
+
+ITK_THREAD_RETURN_TYPE mitk::PolhemusTrackingDevice::ThreadStartTracking(void* pInfoStruct)
+{
+  /* extract this pointer from Thread Info structure */
+  struct itk::MultiThreader::ThreadInfoStruct * pInfo = (struct itk::MultiThreader::ThreadInfoStruct*)pInfoStruct;
+  if (pInfo == nullptr)
+  {
+    return ITK_THREAD_RETURN_VALUE;
+  }
+  if (pInfo->UserData == nullptr)
+  {
+    return ITK_THREAD_RETURN_VALUE;
+  }
+  PolhemusTrackingDevice *trackingDevice = (PolhemusTrackingDevice*)pInfo->UserData;
+
+  if (trackingDevice != nullptr)
+    trackingDevice->TrackTools();
+
+  return ITK_THREAD_RETURN_VALUE;
+}
+
+bool mitk::PolhemusTrackingDevice::AutoDetectToolsAvailable()
+{
+  return true;
+}
+
+mitk::NavigationToolStorage::Pointer mitk::PolhemusTrackingDevice::AutoDetectTools()
+{
+  this->OpenConnection();
+  std::vector<mitk::PolhemusInterface::trackingData> singeFrameData = this->m_Device->GetSingleFrame();
+  MITK_INFO << "Found " << singeFrameData.size() << " tools.";
+  this->CloseConnection();
+  mitk::NavigationToolStorage::Pointer returnValue = mitk::NavigationToolStorage::New();
+  for each (mitk::PolhemusInterface::trackingData t in singeFrameData)
+  {
+
+    mitk::DataNode::Pointer newNode = mitk::DataNode::New();
+    std::stringstream name;
+    name << "Sensor-" << ((int)t.id);
+    newNode->SetName(name.str());
+
+    mitk::Surface::Pointer myCone = 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();
+    myCone->SetVtkPolyData(vtkData->GetOutput());
+    vtkData->Delete();
+    newNode->SetData(myCone);
+
+    mitk::NavigationTool::Pointer newTool = mitk::NavigationTool::New();
+    newTool->SetDataNode(newNode);
+
+    std::stringstream identifier;
+    identifier << "AutoDetectedTool-" << ((int)t.id);
+    newTool->SetIdentifier(identifier.str());
+
+    newTool->SetTrackingDeviceType(mitk::PolhemusTrackerTypeInformation::GetDeviceDataPolhemusTrackerLiberty().Line);
+    returnValue->AddTool(newTool);
+  }
+  return returnValue;
+
+}
diff --git a/Modules/IGT/TrackingDevices/mitkPolhemusTrackingDevice.h b/Modules/IGT/TrackingDevices/mitkPolhemusTrackingDevice.h
new file mode 100644
index 0000000000..0d02827f2f
--- /dev/null
+++ b/Modules/IGT/TrackingDevices/mitkPolhemusTrackingDevice.h
@@ -0,0 +1,145 @@
+/*===================================================================
+
+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 MITKPolhemusTRACKINGDEVICE_H_HEADER_INCLUDED_
+#define MITKPolhemusTRACKINGDEVICE_H_HEADER_INCLUDED_
+
+
+#include <vector>
+#include <mitkIGTConfig.h>
+#include <mitkTrackingDevice.h>
+#include <mitkPolhemusTool.h>
+#include <itkMultiThreader.h>
+
+namespace mitk
+{
+  /** Documentation:
+  *   \brief An object of this class represents Polhemus tracking device. You can add tools to this
+  *          device, then open the connection and start tracking. The tracking device will then
+  *          continuously update the tool coordinates.
+  *   \ingroup IGT
+  */
+  class MITKIGT_EXPORT PolhemusTrackingDevice : public TrackingDevice
+  {
+  public:
+
+    mitkClassMacro(PolhemusTrackingDevice, TrackingDevice);
+    itkFactorylessNewMacro(Self)
+    itkCloneMacro(Self)
+
+    /**
+    * \brief Starts the tracking.
+    * \return Returns true if the tracking is started. Throws an exception if an error occures.
+    * @throw mitk::IGTHardwareException Throws an exception if there is an error during start tracking.
+    */
+    virtual bool StartTracking() override;
+
+    /**
+    * \brief Stops the tracking.
+    * \return Returns true if the tracking is stopped.
+    */
+    virtual bool StopTracking() override;
+
+    /**
+    * \brief Opens the connection to the device. This have to be done before the tracking is started.
+    * @throw mitk::IGTHardwareException Throws an exception if there is an error during open connection.
+    */
+    virtual bool OpenConnection() override;
+
+    /**
+    * \brief Closes the connection and clears all resources.
+    */
+    virtual bool CloseConnection() override;
+
+    /**
+    * \return Returns the number of tools which have been added to the device.
+    */
+    virtual unsigned int GetToolCount() const override;
+
+    /**
+    * \param toolNumber The number of the tool which should be given back.
+    * \return Returns the tool which the number "toolNumber". Returns NULL, if there is
+    * no tool with this number.
+    */
+    TrackingTool* GetTool(unsigned int toolNumber)  const override;
+
+
+    /**
+    * \brief Create a new Polhemus tool with toolName and add it to the list of tools
+    *
+    * This method will create a new PolhemusTool object,
+    * set the tool name toolName and then add it to the list of tools.
+    * It returns a pointer of type mitk::TrackingTool to the tool
+    * that can be used to read tracking data from it.
+    * This is the only way to add tools to PolhemusTrackingDevice.
+    *
+    * \warning adding tools is not possible in tracking mode, only in setup and ready.
+    */
+    mitk::TrackingTool* AddTool(const char* toolName);
+
+    bool IsDeviceInstalled();
+
+    /** @return Returns true if this device can autodetects its tools. */
+    virtual bool AutoDetectToolsAvailable();
+
+    /** Autodetects tools from this device and returns them as a navigation tool storage.
+    *  @return Returns the detected tools. Returns an empty storage if no tools are present
+    *          or if detection is not possible
+    */
+    virtual mitk::NavigationToolStorage::Pointer AutoDetectTools();
+
+    /** Enables/disables hemisphere tracking for all sensors. */
+    itkSetMacro(HemisphereTrackingEnabled, bool);
+
+  protected:
+    PolhemusTrackingDevice();
+    ~PolhemusTrackingDevice();
+
+    /**
+    * \brief Adds a tool to the tracking device.
+    *
+    * \param tool  The tool which will be added.
+    * \return Returns true if the tool has been added, false otherwise.
+    */
+    bool InternalAddTool(PolhemusTool::Pointer tool);
+
+    /**
+    * \brief This method tracks tools as long as the variable m_Mode is set to "Tracking".
+    * Tracking tools means grabbing frames from the camera an updating the tools.
+    * @throw mitk::IGTHardwareException Throws an exception if there is an error during tracking of tools.
+    */
+    void TrackTools();
+
+    /**
+    * \return Returns all tools of the tracking device.
+    */
+    std::vector<PolhemusTool::Pointer> GetAllTools();
+
+    /**
+    * \return Gives back the device which is represented by an object of the class PolhemusInterface.
+    */
+    PolhemusInterface* GetDevice();
+
+    static ITK_THREAD_RETURN_TYPE ThreadStartTracking(void* data);
+
+    std::vector<PolhemusTool::Pointer> m_AllTools; ///< vector holding all tools
+    PolhemusInterface::Pointer m_Device; ///< represents the interface to the tracking hardware
+    itk::MultiThreader::Pointer m_MultiThreader;
+    int m_ThreadID;
+    bool m_HemisphereTrackingEnabled;
+  };
+}//mitk
+#endif /* MITKPolhemusTRACKINGDEVICE_H_HEADER_INCLUDED_ */
diff --git a/Modules/IGT/autoload/DeviceRegistry/src/mitkIGTActivator.cpp b/Modules/IGT/autoload/DeviceRegistry/src/mitkIGTActivator.cpp
index b5608a31ab..8e34c40cd4 100644
--- a/Modules/IGT/autoload/DeviceRegistry/src/mitkIGTActivator.cpp
+++ b/Modules/IGT/autoload/DeviceRegistry/src/mitkIGTActivator.cpp
@@ -1,63 +1,70 @@
 /*===================================================================
 
 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 "mitkIGTConfig.h"
 #include "mitkIGTActivator.h"
 
 //All Tracking devices, which should be available by default
 #include "mitkNDIAuroraTypeInformation.h"
 #include "mitkNDIPolarisTypeInformation.h"
 #include "mitkVirtualTrackerTypeInformation.h"
 #include "mitkMicronTrackerTypeInformation.h"
 #include "mitkNPOptitrackTrackingTypeInformation.h"
 #include "mitkOpenIGTLinkTypeInformation.h"
+#ifdef MITK_USE_POLHEMUS_TRACKER
+#include "mitkPolhemusTrackerTypeInformation.h"
+#endif
 
 namespace mitk
 {
 
   IGTActivator::IGTActivator()
   {
   }
 
   IGTActivator::~IGTActivator()
   {
   }
 
   void IGTActivator::Load(us::ModuleContext*)
   {
     m_DeviceTypeCollection.RegisterTrackingDeviceType(new mitk::NDIAuroraTypeInformation());
     m_DeviceTypeCollection.RegisterTrackingDeviceType(new mitk::NDIPolarisTypeInformation());
     m_DeviceTypeCollection.RegisterTrackingDeviceType(new mitk::MicronTrackerTypeInformation());
     m_DeviceTypeCollection.RegisterTrackingDeviceType(new mitk::NPOptitrackTrackingTypeInformation());
     m_DeviceTypeCollection.RegisterTrackingDeviceType(new mitk::VirtualTrackerTypeInformation());
     m_DeviceTypeCollection.RegisterTrackingDeviceType(new mitk::OpenIGTLinkTypeInformation());
-    m_DeviceTypeCollection.RegisterAsMicroservice();
+#ifdef MITK_USE_POLHEMUS_TRACKER
+    m_DeviceTypeCollection.RegisterTrackingDeviceType(new mitk::PolhemusTrackerTypeInformation());
+#endif
+	m_DeviceTypeCollection.RegisterAsMicroservice();
   }
 
   void IGTActivator::Unload(us::ModuleContext*)
   {
     try
     {
       m_DeviceTypeCollection.UnRegisterMicroservice();
     }
     catch (std::exception& e)
     {
       MITK_WARN << "Unable to unregister IGT DeviceTypeCollection Microservice: "<<e.what();
     }
   }
 
 }
 
 US_EXPORT_MODULE_ACTIVATOR(mitk::IGTActivator)
diff --git a/Modules/IGT/files.cmake b/Modules/IGT/files.cmake
index 5b73185897..3632dac715 100644
--- a/Modules/IGT/files.cmake
+++ b/Modules/IGT/files.cmake
@@ -1,100 +1,112 @@
 set(CPP_FILES
 
   TestingHelper/mitkNavigationToolStorageTestHelper.cpp
 
   Algorithms/mitkNavigationDataDelayFilter.cpp
   Algorithms/mitkNavigationDataDisplacementFilter.cpp
   Algorithms/mitkNavigationDataEvaluationFilter.cpp
   Algorithms/mitkNavigationDataLandmarkTransformFilter.cpp
   Algorithms/mitkNavigationDataReferenceTransformFilter.cpp
   Algorithms/mitkNavigationDataSmoothingFilter.cpp
   Algorithms/mitkNavigationDataToMessageFilter.cpp
   Algorithms/mitkNavigationDataToNavigationDataFilter.cpp
   Algorithms/mitkNavigationDataToPointSetFilter.cpp
   Algorithms/mitkNavigationDataTransformFilter.cpp
   Algorithms/mitkNavigationDataToIGTLMessageFilter.cpp
   Algorithms/mitkIGTLMessageToNavigationDataFilter.cpp
 
   Common/mitkIGTTimeStamp.cpp
   Common/mitkSerialCommunication.cpp
 
   DataManagement/mitkNavigationDataSource.cpp
   DataManagement/mitkNavigationTool.cpp
   DataManagement/mitkNavigationToolStorage.cpp
   DataManagement/mitkTrackingDeviceSourceConfigurator.cpp
   DataManagement/mitkTrackingDeviceSource.cpp
   DataManagement/mitkTrackingDeviceTypeCollection.cpp
 
   ExceptionHandling/mitkIGTException.cpp
   ExceptionHandling/mitkIGTHardwareException.cpp
   ExceptionHandling/mitkIGTIOException.cpp
 
   IO/mitkNavigationDataPlayer.cpp
   IO/mitkNavigationDataPlayerBase.cpp
   IO/mitkNavigationDataRecorder.cpp
   IO/mitkNavigationDataRecorderDeprecated.cpp
   IO/mitkNavigationDataSequentialPlayer.cpp
   IO/mitkNavigationToolReader.cpp
   IO/mitkNavigationToolStorageSerializer.cpp
   IO/mitkNavigationToolStorageDeserializer.cpp
   IO/mitkNavigationToolWriter.cpp
   IO/mitkNavigationDataReaderInterface.cpp
 
   Rendering/mitkCameraVisualization.cpp
   Rendering/mitkNavigationDataObjectVisualizationFilter.cpp
   Rendering/mitkNavigationDataSliceVisualization.cpp
 
   TrackingDevices/mitkClaronTool.cpp
   TrackingDevices/mitkClaronTrackingDevice.cpp
   TrackingDevices/mitkInternalTrackingTool.cpp
   TrackingDevices/mitkNDIPassiveTool.cpp
   TrackingDevices/mitkNDIProtocol.cpp
   TrackingDevices/mitkNDITrackingDevice.cpp
   TrackingDevices/mitkTrackingDevice.cpp
   TrackingDevices/mitkTrackingTool.cpp
   TrackingDevices/mitkTrackingVolumeGenerator.cpp
   TrackingDevices/mitkVirtualTrackingDevice.cpp
   TrackingDevices/mitkVirtualTrackingTool.cpp
   TrackingDevices/mitkOptitrackErrorMessages.cpp
   TrackingDevices/mitkOptitrackTrackingDevice.cpp
   TrackingDevices/mitkOptitrackTrackingTool.cpp
   TrackingDevices/mitkOpenIGTLinkTrackingDevice.cpp
   TrackingDevices/mitkOpenIGTLinkTrackingTool.cpp
   TrackingDevices/mitkNDIAuroraTypeInformation.cpp
   TrackingDevices/mitkNDIPolarisTypeInformation.cpp
   TrackingDevices/mitkNPOptitrackTrackingTypeInformation.cpp
   TrackingDevices/mitkVirtualTrackerTypeInformation.cpp
   TrackingDevices/mitkMicronTrackerTypeInformation.cpp
   TrackingDevices/mitkOpenIGTLinkTypeInformation.cpp
   TrackingDevices/mitkUnspecifiedTrackingTypeInformation.cpp
+#  TrackingDevices/mitkPolhemusTrackingDevice.cpp
+#  TrackingDevices/mitkPolhemusTool.cpp
+#  TrackingDevices/mitkPolhemusTrackerTypeInformation.cpp
 )
 
 set(H_FILES
   DataManagement/mitkTrackingDeviceTypeInformation.h
   Common/mitkTrackingTypes.h
 )
 
 set(RESOURCE_FILES
   ClaronMicron.stl
   IntuitiveDaVinci.stl
   NDIAurora.stl
   NDIAurora_Dome.stl
   NDIAuroraCompactFG_Dome.stl
   NDIAuroraPlanarFG_Dome.stl
   NDIAuroraTabletopFG_Dome.stl
   NDIAuroraTabletopFG_Prototype_Dome.stl
   NDIPolarisOldModel.stl
   NDIPolarisSpectra.stl
   NDIPolarisSpectraExtendedPyramid.stl
   NDIPolarisVicra.stl
 )
 
 if(MITK_USE_MICRON_TRACKER)
   set(CPP_FILES ${CPP_FILES} TrackingDevices/mitkClaronInterface.cpp)
 else()
   set(CPP_FILES ${CPP_FILES} TrackingDevices/mitkClaronInterfaceStub.cpp)
 endif(MITK_USE_MICRON_TRACKER)
 
 if(MITK_USE_MICROBIRD_TRACKER)
   set(CPP_FILES ${CPP_FILES} TrackingDevices/mitkMicroBirdTrackingDevice.cpp)
 endif(MITK_USE_MICROBIRD_TRACKER)
+
+if(MITK_USE_POLHEMUS_TRACKER)
+  set(CPP_FILES ${CPP_FILES}
+  TrackingDevices/mitkPolhemusInterface.cpp
+  TrackingDevices/mitkPolhemusTrackingDevice.cpp
+  TrackingDevices/mitkPolhemusTool.cpp
+  TrackingDevices/mitkPolhemusTrackerTypeInformation.cpp
+)
+endif(MITK_USE_POLHEMUS_TRACKER)
diff --git a/Modules/IGT/mitkIGTConfig.h.in b/Modules/IGT/mitkIGTConfig.h.in
index ad400cded3..5680c76a27 100644
--- a/Modules/IGT/mitkIGTConfig.h.in
+++ b/Modules/IGT/mitkIGTConfig.h.in
@@ -1,9 +1,10 @@
 /*
   mitkIGTConfig.h
   this file is generated. Do not change!
 */
 
 #cmakedefine MITK_USE_MICRON_TRACKER
 #cmakedefine MITK_MICRON_TRACKER_TEMP_DIR "@MITK_MICRON_TRACKER_TEMP_DIR@"
 #cmakedefine MITK_MICRON_TRACKER_CALIBRATION_DIR "@MITK_MICRON_TRACKER_CALIBRATION_DIR@"
+#cmakedefine MITK_USE_POLHEMUS_TRACKER
 #define MITK_IGT_DATA_DIR "@MITK_DATA_DIR@/IGT-Data"
diff --git a/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.cpp b/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.cpp
new file mode 100644
index 0000000000..c1add0dd7a
--- /dev/null
+++ b/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.cpp
@@ -0,0 +1,85 @@
+/*===================================================================
+
+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 <mitkPolhemusTrackingDevice.h>
+
+#include <itksys/SystemTools.hxx>
+#include <Poco/Path.h>
+#include <QSettings>
+
+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);
+}
+
+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::CreateConnections()
+{
+  if (m_Controls)
+  {
+
+  }
+}
+
+mitk::TrackingDevice::Pointer QmitkPolhemusTrackerWidget::GetTrackingDevice()
+{
+  if (m_TrackingDevice.IsNull()) m_TrackingDevice = ConstructTrackingDevice();
+  return m_TrackingDevice;
+}
+
+
+mitk::TrackingDevice::Pointer QmitkPolhemusTrackerWidget::ConstructTrackingDevice()
+{
+  mitk::PolhemusTrackingDevice::Pointer newDevice = mitk::PolhemusTrackingDevice::New();
+  newDevice->SetHemisphereTrackingEnabled(m_Controls->m_hemisphereTracking->isChecked());
+  return static_cast<mitk::TrackingDevice::Pointer>(newDevice);
+}
+
+
+
+QmitkPolhemusTrackerWidget* QmitkPolhemusTrackerWidget::Clone(QWidget* parent) const
+{
+  QmitkPolhemusTrackerWidget* clonedWidget = new QmitkPolhemusTrackerWidget(parent);
+  clonedWidget->Initialize();
+  return clonedWidget;
+}
diff --git a/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.h b/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.h
new file mode 100644
index 0000000000..dfd41ec261
--- /dev/null
+++ b/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.h
@@ -0,0 +1,65 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef QmitkPolhemusTrackerWidget_H
+#define QmitkPolhemusTrackerWidget_H
+
+#include "ui_QmitkPolhemusTrackerWidget.h"
+
+#include "QmitkAbstractTrackingDeviceWidget.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();
+
+  mitk::TrackingDevice::Pointer GetTrackingDevice();
+
+  virtual void Initialize();
+
+signals:
+
+protected slots :
+
+private:
+
+  /// \brief Creation of the connections
+  void CreateConnections();
+
+  void CreateQtPartControl(QWidget *parent);
+
+protected:
+  virtual QmitkPolhemusTrackerWidget* Clone(QWidget* parent) const;
+
+  Ui::QmitkPolhemusTrackerWidget* m_Controls;
+
+  mitk::TrackingDevice::Pointer m_TrackingDevice;
+
+public:
+  virtual mitk::TrackingDevice::Pointer ConstructTrackingDevice();
+};
+#endif
diff --git a/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.ui b/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.ui
new file mode 100644
index 0000000000..9dee4ebd75
--- /dev/null
+++ b/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.ui
@@ -0,0 +1,52 @@
+<?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>181</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>
+    <widget class="QCheckBox" name="m_hemisphereTracking">
+     <property name="text">
+      <string>Enable hemisphere tracking</string>
+     </property>
+     <property name="checked">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </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>
diff --git a/Modules/IGTUI/autoload/ConfigurationWidgetRegistry/src/mitkIGTUIActivator.cpp b/Modules/IGTUI/autoload/ConfigurationWidgetRegistry/src/mitkIGTUIActivator.cpp
index c77300921b..4820db746c 100644
--- a/Modules/IGTUI/autoload/ConfigurationWidgetRegistry/src/mitkIGTUIActivator.cpp
+++ b/Modules/IGTUI/autoload/ConfigurationWidgetRegistry/src/mitkIGTUIActivator.cpp
@@ -1,70 +1,80 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
+#include "mitkIGTConfig.h"
 #include "mitkIGTUIActivator.h"
 
 //All Tracking devices, which should be available by default
 #include "mitkNDIAuroraTypeInformation.h"
 #include "mitkNDIPolarisTypeInformation.h"
 #include "mitkVirtualTrackerTypeInformation.h"
 #include "mitkMicronTrackerTypeInformation.h"
 #include "mitkNPOptitrackTrackingTypeInformation.h"
 #include "mitkOpenIGTLinkTypeInformation.h"
 
 //standard tracking devices, which always should be avaiable
 #include "QmitkNDIAuroraWidget.h"
 #include "QmitkNDIPolarisWidget.h"
 #include "QmitkMicronTrackerWidget.h"
 #include "QmitkNPOptitrackWidget.h"
 #include "QmitkVirtualTrackerWidget.h"
 #include "QmitkOpenIGTLinkWidget.h"
 
+// Polhemus tracking device
+#ifdef MITK_USE_POLHEMUS_TRACKER
+#include "mitkPolhemusTrackerTypeInformation.h"
+#include "QmitkPolhemusTrackerWidget.h"
+#endif
+
 namespace mitk
 {
   IGTUIActivator::IGTUIActivator()
   {
   }
 
   IGTUIActivator::~IGTUIActivator()
   {
   }
 
   void IGTUIActivator::Load(us::ModuleContext*)
   {
     m_DeviceWidgetCollection.RegisterAsMicroservice();
     //Add widgets of standard tracking devices
     m_DeviceWidgetCollection.RegisterTrackingDeviceWidget(mitk::NDIAuroraTypeInformation::GetTrackingDeviceName(), new QmitkNDIAuroraWidget);
     m_DeviceWidgetCollection.RegisterTrackingDeviceWidget(mitk::NDIPolarisTypeInformation::GetTrackingDeviceName(), new QmitkNDIPolarisWidget);
     m_DeviceWidgetCollection.RegisterTrackingDeviceWidget(mitk::MicronTrackerTypeInformation::GetTrackingDeviceName(), new QmitkMicronTrackerWidget);
     m_DeviceWidgetCollection.RegisterTrackingDeviceWidget(mitk::NPOptitrackTrackingTypeInformation::GetTrackingDeviceName(), new QmitkNPOptitrackWidget);
     m_DeviceWidgetCollection.RegisterTrackingDeviceWidget(mitk::VirtualTrackerTypeInformation::GetTrackingDeviceName(), new QmitkVirtualTrackerWidget);
     m_DeviceWidgetCollection.RegisterTrackingDeviceWidget(mitk::OpenIGTLinkTypeInformation::GetTrackingDeviceName(), new QmitkOpenIGTLinkWidget);
+#ifdef MITK_USE_POLHEMUS_TRACKER
+    m_DeviceWidgetCollection.RegisterTrackingDeviceWidget(mitk::PolhemusTrackerTypeInformation::GetTrackingDeviceName(), new QmitkPolhemusTrackerWidget);
+#endif
   }
 
   void IGTUIActivator::Unload(us::ModuleContext*)
   {
     try
     {
       m_DeviceWidgetCollection.UnRegisterMicroservice();
     }
     catch (std::exception& e)
     {
       MITK_WARN << "Unable to unregister IGTUI DeviceWidgetCollection Microservice: " << e.what();
     }
   }
 }
 
 US_EXPORT_MODULE_ACTIVATOR(mitk::IGTUIActivator)
\ No newline at end of file
diff --git a/Modules/IGTUI/files.cmake b/Modules/IGTUI/files.cmake
index a555fb4dea..9678e39cb4 100644
--- a/Modules/IGTUI/files.cmake
+++ b/Modules/IGTUI/files.cmake
@@ -1,108 +1,114 @@
 set(CPP_FILES
   Qmitk/QmitkTrackingDeviceWidget.cpp
   Qmitk/QmitkTrackingDeviceConfigurationWidget.cpp
   Qmitk/QmitkNDIConfigurationWidget.cpp
   Qmitk/QmitkFiducialRegistrationWidget.cpp
   Qmitk/QmitkNDIToolDelegate.cpp
   Qmitk/QmitkNavigationToolManagementWidget.cpp
   Qmitk/QmitkIGTLoggerWidget.cpp
   Qmitk/QmitkUpdateTimerWidget.cpp
   Qmitk/QmitkToolDistanceWidget.cpp
   Qmitk/QmitkToolTrackingStatusWidget.cpp
   Qmitk/QmitkTrackingSourcesCheckBoxPanelWidget.cpp
   Qmitk/QmitkIGTPlayerWidget.cpp
   Qmitk/QmitkIGTConnectionWidget.cpp
   Qmitk/QmitkToolSelectionWidget.cpp
   Qmitk/QmitkNavigationToolCreationWidget.cpp
   Qmitk/QmitkNavigationToolCreationAdvancedWidget.cpp
   Qmitk/QmitkNavigationDataSourceSelectionWidget.cpp
   Qmitk/QmitkInteractiveTransformationWidget.cpp
   Qmitk/QmitkNavigationToolStorageSelectionWidget.cpp
 
   Qmitk/QmitkNavigationDataPlayerControlWidget.cpp
   Qmitk/QmitkNavigationDataSequentialPlayerControlWidget.cpp
 
   Qmitk/QmitkNDIAuroraWidget.cpp
   Qmitk/QmitkNDIPolarisWidget.cpp
   Qmitk/QmitkMicronTrackerWidget.cpp
   Qmitk/QmitkNPOptitrackWidget.cpp
   Qmitk/QmitkVirtualTrackerWidget.cpp
   Qmitk/QmitkOpenIGTLinkWidget.cpp
 
   Qmitk/mitkTrackingDeviceWidgetCollection.cpp
   Qmitk/QmitkTrackingDeviceConfigurationWidgetScanPortsWorker.cpp
   Qmitk/QmitkTrackingDeviceConfigurationWidgetConnectionWorker.cpp
   Qmitk/QmitkNDIAbstractDeviceWidget.cpp
   Qmitk/QmitkAbstractTrackingDeviceWidget.cpp
 )
 
 set(UI_FILES
   Qmitk/QmitkNavigationToolManagementWidgetControls.ui
   Qmitk/QmitkTrackingDeviceConfigurationWidgetControls.ui
   Qmitk/QmitkNDIConfigurationWidget.ui
   Qmitk/QmitkFiducialRegistrationWidget.ui
   Qmitk/QmitkIGTLoggerWidgetControls.ui
   Qmitk/QmitkUpdateTimerWidgetControls.ui
   Qmitk/QmitkToolDistanceWidgetControls.ui
   Qmitk/QmitkToolTrackingStatusWidgetControls.ui
   Qmitk/QmitkTrackingSourcesCheckBoxPanelWidgetControls.ui
   Qmitk/QmitkIGTPlayerWidgetControls.ui
   Qmitk/QmitkIGTConnectionWidgetControls.ui
   Qmitk/QmitkToolSelectionWidgetControls.ui
   Qmitk/QmitkNavigationToolCreationWidget.ui
   Qmitk/QmitkNavigationToolCreationAdvancedWidgetControls.ui
   Qmitk/QmitkNavigationDataSourceSelectionWidgetControls.ui
   Qmitk/QmitkInteractiveTransformationWidgetControls.ui
   Qmitk/QmitkNavigationToolStorageSelectionWidgetControls.ui
 
   Qmitk/QmitkNavigationDataPlayerControlWidget.ui
   Qmitk/QmitkNavigationDataSequentialPlayerControlWidget.ui
 
   Qmitk/QmitkNDIAuroraWidget.ui
   Qmitk/QmitkNDIPolarisWidget.ui
   Qmitk/QmitkMicronTrackerWidget.ui
   Qmitk/QmitkNPOptitrackWidget.ui
   Qmitk/QmitkVirtualTrackerWidget.ui
   Qmitk/QmitkOpenIGTLinkWidget.ui
 )
 
 set(MOC_H_FILES
   Qmitk/QmitkNavigationToolManagementWidget.h
   Qmitk/QmitkTrackingDeviceWidget.h
   Qmitk/QmitkTrackingDeviceConfigurationWidget.h
   Qmitk/QmitkNDIConfigurationWidget.h
   Qmitk/QmitkFiducialRegistrationWidget.h
   Qmitk/QmitkNDIToolDelegate.h
   Qmitk/QmitkIGTLoggerWidget.h
   Qmitk/QmitkUpdateTimerWidget.h
   Qmitk/QmitkToolDistanceWidget.h
   Qmitk/QmitkToolTrackingStatusWidget.h
   Qmitk/QmitkTrackingSourcesCheckBoxPanelWidget.h
   Qmitk/QmitkIGTPlayerWidget.h
   Qmitk/QmitkIGTConnectionWidget.h
   Qmitk/QmitkToolSelectionWidget.h
   Qmitk/QmitkNavigationToolCreationWidget.h
   Qmitk/QmitkNavigationToolCreationAdvancedWidget.h
   Qmitk/QmitkNavigationDataSourceSelectionWidget.h
   Qmitk/QmitkInteractiveTransformationWidget.h
   Qmitk/QmitkNavigationToolStorageSelectionWidget.h
 
   Qmitk/QmitkNavigationDataPlayerControlWidget.h
   Qmitk/QmitkNavigationDataSequentialPlayerControlWidget.h
 
   Qmitk/QmitkNDIAuroraWidget.h
   Qmitk/QmitkNDIPolarisWidget.h
   Qmitk/QmitkMicronTrackerWidget.h
   Qmitk/QmitkNPOptitrackWidget.h
   Qmitk/QmitkVirtualTrackerWidget.h
   Qmitk/QmitkOpenIGTLinkWidget.h
 
   Qmitk/QmitkTrackingDeviceConfigurationWidgetScanPortsWorker.h
   Qmitk/QmitkTrackingDeviceConfigurationWidgetConnectionWorker.h
   Qmitk/QmitkNDIAbstractDeviceWidget.h
   Qmitk/QmitkAbstractTrackingDeviceWidget.h
 )
 
+if(MITK_USE_POLHEMUS_TRACKER)
+  set(CPP_FILES ${CPP_FILES} Qmitk/QmitkPolhemusTrackerWidget.cpp)
+  set(UI_FILES ${UI_FILES} Qmitk/QmitkPolhemusTrackerWidget.ui)
+  set(MOC_H_FILES ${MOC_H_FILES} Qmitk/QmitkPolhemusTrackerWidget.h)
+endif(MITK_USE_POLHEMUS_TRACKER)
+
 set(QRC_FILES
   resources/IGTUI.qrc
 )