diff --git a/Modules/IGT/TrackingDevices/mitkPolhemusInterface.cpp b/Modules/IGT/TrackingDevices/mitkPolhemusInterface.cpp index 2e80ddb018..6c957dc378 100644 --- a/Modules/IGT/TrackingDevices/mitkPolhemusInterface.cpp +++ b/Modules/IGT/TrackingDevices/mitkPolhemusInterface.cpp @@ -1,111 +1,121 @@ /*=================================================================== 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 BYTE MotionBuf[0x1FA400]; mitk::PolhemusInterface::PolhemusInterface() { + m_pdiDev.Trace(TRUE, 7); m_pdiDev.SetPnoBuffer(MotionBuf, 0x1FA400); + m_pdiDev.SetMetric(true); //use cm instead of inches + CPDImdat pdiMDat; + pdiMDat.Empty(); + pdiMDat.Append(PDI_MODATA_FRAMECOUNT); + pdiMDat.Append(PDI_MODATA_POS); + pdiMDat.Append(PDI_MODATA_ORI); + m_pdiDev.SetSDataList(-1, pdiMDat); + + DWORD dwFrameSize = 8 + 12 + 12 + 4; } mitk::PolhemusInterface::~PolhemusInterface() { } bool mitk::PolhemusInterface::StartTracking() { //return m_pdiDev.StartContPno(0); return true; } bool mitk::PolhemusInterface::StopTracking() { return true; } bool mitk::PolhemusInterface::Connect() { m_pdiDev.Trace(TRUE, 7); if (m_pdiDev.CnxReady()) { return true; } 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; } return m_pdiDev.CnxReady(); } bool mitk::PolhemusInterface::Disconnect() { m_pdiDev.Disconnect(); return false; } std::vector mitk::PolhemusInterface::GetLastFrame() { PBYTE pBuf; DWORD dwSize; //read one frame if (!m_pdiDev.ReadSinglePnoBuf(pBuf, dwSize)) {MITK_WARN << m_pdiDev.GetLastResultStr();} 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/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..f969eb7e3c --- /dev/null +++ b/Modules/IGT/TrackingDevices/mitkPolhemusTrackingDevice.cpp @@ -0,0 +1,202 @@ +/*=================================================================== + +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" + +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() +{ + Superclass::StopTracking(); + this->SetState(Ready); + return true; +} + + +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->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(); + + 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!"; + return; + } + + std::vector allTools = this->GetAllTools(); + for(int i=0; iSetDataValid(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; +} diff --git a/Modules/IGT/TrackingDevices/mitkPolhemusTrackingDevice.h b/Modules/IGT/TrackingDevices/mitkPolhemusTrackingDevice.h new file mode 100644 index 0000000000..01165ce83a --- /dev/null +++ b/Modules/IGT/TrackingDevices/mitkPolhemusTrackingDevice.h @@ -0,0 +1,132 @@ +/*=================================================================== + +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(); + + 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; + }; +}//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..5d48a323e0 100644 --- a/Modules/IGT/autoload/DeviceRegistry/src/mitkIGTActivator.cpp +++ b/Modules/IGT/autoload/DeviceRegistry/src/mitkIGTActivator.cpp @@ -1,63 +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 "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" +#include "mitkPolhemusTrackerTypeInformation.h" 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.RegisterTrackingDeviceType(new mitk::PolhemusTrackerTypeInformation()); 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() +{ + +} + +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 = mitk::PolhemusTrackingDevice::New(); + return m_TrackingDevice; +} + + +mitk::TrackingDevice::Pointer QmitkPolhemusTrackerWidget::ConstructTrackingDevice() +{ + mitk::PolhemusTrackingDevice::Pointer newDevice = mitk::PolhemusTrackingDevice::New(); + return static_cast(newDevice); +} + + + +QmitkPolhemusTrackerWidget* QmitkPolhemusTrackerWidget::Clone(QWidget* parent) const +{ + QmitkPolhemusTrackerWidget* clonedWidget = new QmitkPolhemusTrackerWidget(parent); + + 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..25f26037c7 --- /dev/null +++ b/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.ui @@ -0,0 +1,42 @@ + + + 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> + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + + diff --git a/Modules/IGTUI/autoload/ConfigurationWidgetRegistry/src/mitkIGTUIActivator.cpp b/Modules/IGTUI/autoload/ConfigurationWidgetRegistry/src/mitkIGTUIActivator.cpp index c77300921b..8d4a7f8d88 100644 --- a/Modules/IGTUI/autoload/ConfigurationWidgetRegistry/src/mitkIGTUIActivator.cpp +++ b/Modules/IGTUI/autoload/ConfigurationWidgetRegistry/src/mitkIGTUIActivator.cpp @@ -1,70 +1,73 @@ /*=================================================================== 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 "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" +#include "mitkPolhemusTrackerTypeInformation.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" +#include "QmitkPolhemusTrackerWidget.h" 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); + m_DeviceWidgetCollection.RegisterTrackingDeviceWidget(mitk::PolhemusTrackerTypeInformation::GetTrackingDeviceName(), new QmitkPolhemusTrackerWidget); } 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 )