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 + +// 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 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 +#define _USE_MATH_DEFINES +#include + +#include + +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::GetLastFrame() +{ + PBYTE pBuf; + DWORD dwSize; + + //read one frame + if (!m_pdiDev->LastPnoPtr(pBuf, dwSize)) {MITK_WARN << m_pdiDev->GetLastResultStr();} + + std::vector 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::GetSingleFrame() +{ + if (m_continousTracking) return std::vector(); + + 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::ParsePolhemusRawData(PBYTE pBuf, DWORD dwSize) +{ + std::vector returnValue; + + DWORD i = 0; + + while (i 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 +#include + +#include +#include "mitkCommon.h" + +#include +#include + +#include +#include +#include + +#include + +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 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 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 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 +#include +#include + +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* toolCorrespondencesInToolStorage) + { + mitk::TrackingDeviceSource::Pointer returnValue = mitk::TrackingDeviceSource::New(); + mitk::PolhemusTrackingDevice::Pointer thisDevice = dynamic_cast(trackingDevice.GetPointer()); + *toolCorrespondencesInToolStorage = std::vector(); + //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* 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 +#include +#include +#include "mitkPolhemusTrackerTypeInformation.h" +#include + +typedef itk::MutexLockHolder 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::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 lastData = this->GetDevice()->GetLastFrame(); + + if (lastData.size() != m_AllTools.size()) + { + MITK_WARN << "Tool count is corrupt. Aborting!"; + } + else + { + std::vector 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 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 +#include +#include +#include +#include + +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 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 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: "< +#include + +#include + +#include +#include +#include + +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(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 @@ + + + QmitkPolhemusTrackerWidget + + + + 0 + 0 + 475 + 181 + + + + + + + <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd"> +<html><head><meta name="qrichtext" content="1" /><style type="text/css"> +p, li { white-space: pre-wrap; } +</style></head><body style=" font-family:'MS Shell Dlg 2'; font-size:8pt; font-weight:400; font-style:normal;"> +<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" text-decoration: underline;">Polhemus Tracker</span></p></body></html> + + + + + + + Enable hemisphere tracking + + + true + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + + 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 )