diff --git a/Modules/IGT/MITKIGTHardware.cmake b/Modules/IGT/MITKIGTHardware.cmake
index 21c9309de8..b18e590db4 100644
--- a/Modules/IGT/MITKIGTHardware.cmake
+++ b/Modules/IGT/MITKIGTHardware.cmake
@@ -1,49 +1,48 @@
 #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/TrackingDevices/mitkClaronTrackingDevice.cpp b/Modules/IGT/TrackingDevices/mitkClaronTrackingDevice.cpp
index dce85d5488..11278a00fc 100644
--- a/Modules/IGT/TrackingDevices/mitkClaronTrackingDevice.cpp
+++ b/Modules/IGT/TrackingDevices/mitkClaronTrackingDevice.cpp
@@ -1,333 +1,331 @@
 /*===================================================================
 
 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 "mitkClaronTrackingDevice.h"
 #include "mitkClaronTool.h"
 #include "mitkIGTConfig.h"
 #include "mitkIGTTimeStamp.h"
 #include "mitkIGTHardwareException.h"
 #include <itksys/SystemTools.hxx>
 #include <iostream>
 #include <itkMutexLockHolder.h>
+#include <mitkIOUtil.h>
 #include <mitkMicronTrackerTypeInformation.h>
 
 typedef itk::MutexLockHolder<itk::FastMutexLock> MutexLockHolder;
 
 
 mitk::ClaronTrackingDevice::ClaronTrackingDevice(): mitk::TrackingDevice()
 {
   //set the type of this tracking device
   this->m_Data = mitk::MicronTrackerTypeInformation::GetDeviceDataMicronTrackerH40();
 
   this->m_MultiThreader = itk::MultiThreader::New();
   m_ThreadID = 0;
 
   m_Device = mitk::ClaronInterface::New();
-  //############################# standard directories (from cmake) ##################################
+  //############################# standard directories ##################################
   if (m_Device->IsMicronTrackerInstalled())
   {
-#ifdef MITK_MICRON_TRACKER_TEMP_DIR
-    m_ToolfilesDir = std::string(MITK_MICRON_TRACKER_TEMP_DIR);
-    m_ToolfilesDir.append("/MT-tools");
-#endif
+	m_ToolfilesDir = mitk::IOUtil::CreateTemporaryDirectory();
 #ifdef MITK_MICRON_TRACKER_CALIBRATION_DIR
     m_CalibrationDir = std::string(MITK_MICRON_TRACKER_CALIBRATION_DIR);
 #endif
   }
   else
   {
     m_ToolfilesDir = "Error - No Microntracker installed";
     m_CalibrationDir = "Error - No Microntracker installed";
   }
   //##################################################################################################
   m_Device->Initialize(m_CalibrationDir, m_ToolfilesDir);
 }
 
 bool mitk::ClaronTrackingDevice::IsDeviceInstalled()
 {
   mitk::ClaronInterface::Pointer tempInterface = mitk::ClaronInterface::New();
   return tempInterface->IsMicronTrackerInstalled();
 }
 
 
 mitk::ClaronTrackingDevice::~ClaronTrackingDevice()
 {
 }
 
 
 mitk::TrackingTool* mitk::ClaronTrackingDevice::AddTool( const char* toolName, const char* fileName )
 {
   mitk::ClaronTool::Pointer t = mitk::ClaronTool::New();
   if (t->LoadFile(fileName) == false)
   {
     return nullptr;
   }
   t->SetToolName(toolName);
   if (this->InternalAddTool(t) == false)
     return nullptr;
   return t.GetPointer();
 }
 
 
 bool mitk::ClaronTrackingDevice::InternalAddTool(ClaronTool::Pointer tool)
 {
   m_AllTools.push_back(tool);
   return true;
 }
 
 
 std::vector<mitk::ClaronTool::Pointer> mitk::ClaronTrackingDevice::DetectTools()
 {
   std::vector<mitk::ClaronTool::Pointer> returnValue;
   std::vector<claronToolHandle> allHandles = m_Device->GetAllActiveTools();
   for (auto iter = allHandles.begin(); iter != allHandles.end(); ++iter)
   {
     ClaronTool::Pointer newTool = ClaronTool::New();
     newTool->SetToolName(m_Device->GetName(*iter));
     newTool->SetCalibrationName(m_Device->GetName(*iter));
     newTool->SetToolHandle(*iter);
     returnValue.push_back(newTool);
   }
   return returnValue;
 }
 
 
 bool mitk::ClaronTrackingDevice::StartTracking()
 {
 
   //By Alfred: next line because no temp directory is set if MicronTracker is not installed
   if (!m_Device->IsMicronTrackerInstalled())
     return false;
   //##################################################################################
 
   //be sure that the temp-directory is empty at start: delete all files in the tool files directory
   itksys::SystemTools::RemoveADirectory(m_ToolfilesDir.c_str());
   itksys::SystemTools::MakeDirectory(m_ToolfilesDir.c_str());
 
   //copy all toolfiles into the temp directory
   for (unsigned int i=0; i<m_AllTools.size(); i++)
   {
     itksys::SystemTools::CopyAFile(m_AllTools[i]->GetFile().c_str(), m_ToolfilesDir.c_str());
   }
   this->SetState(Tracking);            // go to mode Tracking
   this->m_StopTrackingMutex->Lock();  // update the local copy of m_StopTracking
   this->m_StopTracking = false;
   this->m_StopTrackingMutex->Unlock();
 
   //restart the Microntracker, so it will load the new tool files
   m_Device->StopTracking();
   m_Device->Initialize(m_CalibrationDir,m_ToolfilesDir);
 
   if (m_Device->StartTracking())
   {
     mitk::IGTTimeStamp::GetInstance()->Start(this);
     m_ThreadID = m_MultiThreader->SpawnThread(this->ThreadStartTracking, this);    // start a new thread that executes the TrackTools() method
     return true;
   }
   else
     {mitkThrowException(mitk::IGTHardwareException) << "Error while trying to start the device!";}
 }
 
 
 bool mitk::ClaronTrackingDevice::StopTracking()
 {
   Superclass::StopTracking();
   //delete all files in the tool files directory
   itksys::SystemTools::RemoveADirectory(m_ToolfilesDir.c_str());
   return true;
 }
 
 
 unsigned int mitk::ClaronTrackingDevice::GetToolCount() const
 {
   return (unsigned int)this->m_AllTools.size();
 }
 
 
 mitk::TrackingTool* mitk::ClaronTrackingDevice::GetTool(unsigned int toolNumber) const
 {
   if ( toolNumber >= this->GetToolCount())
     return nullptr;
   else
     return this->m_AllTools[toolNumber];
 }
 
 
 bool mitk::ClaronTrackingDevice::OpenConnection()
 {
   bool returnValue;
   //Create the temp directory
   itksys::SystemTools::MakeDirectory(m_ToolfilesDir.c_str());
 
   m_Device->Initialize(m_CalibrationDir,m_ToolfilesDir);
   returnValue = m_Device->StartTracking();
 
   if (returnValue)
   {
     this->SetState(Ready);
   }
   else
   {
     //reset everything
     if (m_Device.IsNull())
     {
       m_Device = mitk::ClaronInterface::New();
       m_Device->Initialize(m_CalibrationDir, m_ToolfilesDir);
     }
     m_Device->StopTracking();
     this->SetState(Setup);
     mitkThrowException(mitk::IGTHardwareException) << "Error while trying to open connection to the MicronTracker.";
   }
   return returnValue;
 }
 
 
 bool mitk::ClaronTrackingDevice::CloseConnection()
 {
   bool returnValue = true;
   if (this->GetState() == Setup)
     return true;
 
   returnValue = m_Device->StopTracking();
 
   //delete the temporary directory
   itksys::SystemTools::RemoveADirectory(m_ToolfilesDir.c_str());
 
   this->SetState(Setup);
   return returnValue;
 }
 
 
 mitk::ClaronInterface* mitk::ClaronTrackingDevice::GetDevice()
 {
   return m_Device;
 }
 
 
 std::vector<mitk::ClaronTool::Pointer> mitk::ClaronTrackingDevice::GetAllTools()
 {
   return this->m_AllTools;
 }
 
 
 void mitk::ClaronTrackingDevice::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();
 
     while ((this->GetState() == Tracking) && (localStopTracking == false))
     {
       this->GetDevice()->GrabFrame();
 
       std::vector<mitk::ClaronTool::Pointer> detectedTools = this->DetectTools();
       std::vector<mitk::ClaronTool::Pointer> allTools = this->GetAllTools();
       std::vector<mitk::ClaronTool::Pointer>::iterator itAllTools;
       for(itAllTools = allTools.begin(); itAllTools != allTools.end(); itAllTools++)
       {
         mitk::ClaronTool::Pointer currentTool = *itAllTools;
         //test if current tool was detected
         std::vector<mitk::ClaronTool::Pointer>::iterator itDetectedTools;
         bool foundTool = false;
         for(itDetectedTools = detectedTools.begin(); itDetectedTools != detectedTools.end(); itDetectedTools++)
         {
           mitk::ClaronTool::Pointer aktuDet = *itDetectedTools;
           std::string tempString(currentTool->GetCalibrationName());
           if (tempString.compare(aktuDet->GetCalibrationName())==0)
           {
             currentTool->SetToolHandle(aktuDet->GetToolHandle());
             foundTool = true;
           }
         }
         if (!foundTool)
         {
           currentTool->SetToolHandle(0);
         }
 
         if (currentTool->GetToolHandle() != 0)
         {
           currentTool->SetDataValid(true);
           //get tip position of tool:
           std::vector<double> pos_vector = this->GetDevice()->GetTipPosition(currentTool->GetToolHandle());
           //write tip position into tool:
           mitk::Point3D pos;
           pos[0] = pos_vector[0];
           pos[1] = pos_vector[1];
           pos[2] = pos_vector[2];
           currentTool->SetPosition(pos);
           //get tip quaternion of tool
           std::vector<double> quat = this->GetDevice()->GetTipQuaternions(currentTool->GetToolHandle());
           //write tip quaternion into tool
           mitk::Quaternion orientation(quat[1], quat[2], quat[3], quat[0]);
           currentTool->SetOrientation(orientation);
 
           //TODO: read the timestamp data from the tracking device interface
           currentTool->SetIGTTimeStamp(mitk::IGTTimeStamp::GetInstance()->GetElapsed());
         }
         else
         {
           mitk::Point3D origin;
           origin.Fill(0);
           currentTool->SetPosition(origin);
           currentTool->SetOrientation(mitk::Quaternion(0,0,0,0));
           currentTool->SetDataValid(false);
         }
       }
       /* 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.";
   }
 }
 
 
 bool mitk::ClaronTrackingDevice::IsMicronTrackerInstalled()
 {
   return this->m_Device->IsMicronTrackerInstalled();
 }
 
 
 ITK_THREAD_RETURN_TYPE mitk::ClaronTrackingDevice::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;
   }
   ClaronTrackingDevice *trackingDevice = (ClaronTrackingDevice*)pInfo->UserData;
 
   if (trackingDevice != nullptr)
     trackingDevice->TrackTools();
 
   return ITK_THREAD_RETURN_VALUE;
 }
diff --git a/Modules/IGT/mitkIGTConfig.h.in b/Modules/IGT/mitkIGTConfig.h.in
index 5680c76a27..c76df88a23 100644
--- a/Modules/IGT/mitkIGTConfig.h.in
+++ b/Modules/IGT/mitkIGTConfig.h.in
@@ -1,10 +1,9 @@
 /*
   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"