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"