diff --git a/Modules/IGTUI/Qmitk/QmitkIGTCommonHelper.cpp b/Modules/IGTUI/Qmitk/QmitkIGTCommonHelper.cpp
new file mode 100644
index 0000000000..b5ca3695ea
--- /dev/null
+++ b/Modules/IGTUI/Qmitk/QmitkIGTCommonHelper.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 <QmitkIGTCommonHelper.h>
+#include <QSettings>
+#include <QFileInfo>
+
+const std::string QmitkIGTCommonHelper::VIEW_ID = "org.mitk.views.igtcommonhelper";
+
+void QmitkIGTCommonHelper::SetLastFileSavePath(const QString &str)
+{
+ QSettings settings;
+ settings.beginGroup(QString::fromStdString(QmitkIGTCommonHelper::VIEW_ID));
+ settings.setValue("LastFileSavePath",QVariant(str));
+ settings.endGroup();
+}
+
+void QmitkIGTCommonHelper::SetLastFileSavePathByFileName(const QString &str)
+{
+ QFileInfo file(str);
+ SetLastFileSavePath(file.absolutePath());
+}
+
+const QString QmitkIGTCommonHelper::GetLastFileSavePath()
+{
+ QString path = "";
+ QSettings settings;
+ settings.beginGroup(QString::fromStdString(QmitkIGTCommonHelper::VIEW_ID));
+ path = settings.value("LastFileSavePath",QString("")).toString();
+ settings.endGroup();
+
+ return path;
+}
+
+void QmitkIGTCommonHelper::SetLastFileLoadPath(const QString &str)
+{
+ QSettings settings;
+ settings.beginGroup(QString::fromStdString(QmitkIGTCommonHelper::VIEW_ID));
+ settings.setValue("LastFileLoadPath",QVariant(str));
+ settings.endGroup();
+}
+
+void QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(const QString &str)
+{
+ QFileInfo file(str);
+ SetLastFileLoadPath(file.absolutePath());
+}
+
+const QString QmitkIGTCommonHelper::GetLastFileLoadPath()
+{
+ QString path = "";
+ QSettings settings;
+ settings.beginGroup(QString::fromStdString(QmitkIGTCommonHelper::VIEW_ID));
+ path = settings.value("LastFileLoadPath",QString("")).toString();
+ settings.endGroup();
+
+ return path;
+}
diff --git a/Modules/IGTUI/Qmitk/QmitkIGTCommonHelper.h b/Modules/IGTUI/Qmitk/QmitkIGTCommonHelper.h
new file mode 100644
index 0000000000..486569833b
--- /dev/null
+++ b/Modules/IGTUI/Qmitk/QmitkIGTCommonHelper.h
@@ -0,0 +1,47 @@
+/*===================================================================
+
+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 QmitkIGTCommonHelper_H
+#define QmitkIGTCommonHelper_H
+
+#include "MitkIGTUIExports.h"
+#include <QString>
+
+ /** Documentation:
+ * \brief Simple and fast access to a pre-configured TrackingDeviceSource.
+ *
+ * \ingroup IGTUI
+ */
+class MITKIGTUI_EXPORT QmitkIGTCommonHelper
+{
+
+public:
+
+ static const std::string VIEW_ID;
+
+ static void SetLastFileSavePath(const QString& str);
+
+ static void SetLastFileSavePathByFileName(const QString& str);
+
+ static const QString GetLastFileSavePath();
+
+ static void SetLastFileLoadPath(const QString& str);
+
+ static void SetLastFileLoadPathByFileName(const QString& str);
+
+ static const QString GetLastFileLoadPath();
+};
+#endif
+
diff --git a/Modules/IGTUI/Qmitk/QmitkIGTConnectionWidget.cpp b/Modules/IGTUI/Qmitk/QmitkIGTConnectionWidget.cpp
index 49ff862922..48596f3d74 100644
--- a/Modules/IGTUI/Qmitk/QmitkIGTConnectionWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkIGTConnectionWidget.cpp
@@ -1,213 +1,215 @@
/*===================================================================
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 "QmitkIGTConnectionWidget.h"
#include "QmitkTrackingDeviceConfigurationWidget.h"
#include "mitkClaronTrackingDevice.h"
#include "mitkNDITrackingDevice.h"
#include "mitkOptitrackTrackingDevice.h"
#include "mitkNavigationToolStorageDeserializer.h"
#include "mitkTrackingDeviceSourceConfigurator.h"
+#include "QmitkIGTCommonHelper.h"
#include <QFileDialog>
#include <QMessageBox>
const std::string QmitkIGTConnectionWidget::VIEW_ID = "org.mitk.views.igtconnectionwidget";
QmitkIGTConnectionWidget::QmitkIGTConnectionWidget(QWidget* parent, Qt::WindowFlags f)
: QWidget(parent, f)
{
m_Controls = NULL;
CreateQtPartControl(this);
CreateConnections();
m_TrackingDevice = NULL;
m_TrackingDeviceSource = NULL;
m_NavigationToolStorage = NULL;
m_DataStorage = NULL;
m_ErrorMessage = "";
}
QmitkIGTConnectionWidget::~QmitkIGTConnectionWidget()
{
}
void QmitkIGTConnectionWidget::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkIGTConnectionWidgetControls;
m_Controls->setupUi(parent);
}
}
void QmitkIGTConnectionWidget::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_Controls->connectButton), SIGNAL(clicked()), this, SLOT(OnConnect()) );
}
}
void QmitkIGTConnectionWidget::OnConnect()
{
if (m_Controls->connectButton->isChecked()) // Load tools and connect tracking device
{
m_Controls->connectButton->setChecked(false);
// create TrackingDevice
m_TrackingDevice = m_Controls->trackingDeviceConfigurationWidget->GetTrackingDevice();
if (m_TrackingDevice.IsNotNull())
{
- QString fileName = QFileDialog::getOpenFileName(NULL,tr("Open Navigation tool storage"), "/", tr("Toolfile (*.tfl)"));
+ QString fileName = QFileDialog::getOpenFileName(NULL,tr("Open Navigation tool storage"), QmitkIGTCommonHelper::GetLastFileLoadPath(), tr("Toolfile (*.tfl)"));
+ QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(fileName);
if (LoadToolfile(fileName))
{
// Create TrackingDeviceSource and add tools
mitk::TrackingDeviceSourceConfigurator::Pointer myTrackingDeviceSourceFactory =
mitk::TrackingDeviceSourceConfigurator::New(this->m_NavigationToolStorage,m_TrackingDevice);
m_TrackingDeviceSource = myTrackingDeviceSourceFactory->CreateTrackingDeviceSource();
m_TrackingDeviceSource->Connect();
m_TrackingDeviceSource->StartTracking();
// change button text
m_Controls->connectButton->setText("Disconnect");
m_Controls->connectButton->setChecked(true);
// disable configuration widget
m_Controls->trackingDeviceConfigurationWidget->setEnabled(false);
// emit connected signal
emit TrackingDeviceConnected();
}
else
{
QString error(m_ErrorMessage.c_str());
QMessageBox::warning(NULL,"Warning",error);
// reset button to unchecked
m_Controls->connectButton->setChecked(false);
// remove tool nodes from DataStorage
this->RemoveToolNodes();
// reset NavigationToolStorage
m_NavigationToolStorage = NULL;
}
}
else
{
// reset button to unchecked
m_Controls->connectButton->setChecked(false);
MITK_ERROR<<"Could not create TrackingDevice";
}
}
else // Disconnect tracking device
{
// disconnect TrackingDeviceSource
if (m_TrackingDeviceSource.IsNotNull())
{
m_TrackingDeviceSource->StopTracking();
m_TrackingDeviceSource->Disconnect();
}
// remove tool nodes from DataStorage
this->RemoveToolNodes();
// reset members
m_NavigationToolStorage = NULL;
m_TrackingDevice = NULL;
m_TrackingDeviceSource = NULL;
// change button text
m_Controls->connectButton->setText("Connect");
// enable configuration widget
m_Controls->trackingDeviceConfigurationWidget->setEnabled(true);
// emit disconnected signal
emit TrackingDeviceDisconnected();
}
}
bool QmitkIGTConnectionWidget::LoadToolfile(QString qFilename)
{
if (m_DataStorage.IsNotNull())
{
std::string filename = qFilename.toStdString();
mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(this->m_DataStorage);
mitk::NavigationToolStorage::Pointer tempStorage = myDeserializer->Deserialize(filename);
m_NavigationToolStorage = tempStorage;
if (tempStorage.IsNull())
{
m_ErrorMessage = myDeserializer->GetErrorMessage();
return false;
}
// check if there are tools in the storage
mitk::TrackingDeviceType lastDevice;
if (tempStorage->GetToolCount()>0)
{
lastDevice = tempStorage->GetTool(0)->GetTrackingDeviceType();
}
else
{
m_ErrorMessage = "Error: Didn't find a tool in the storage. Do you want to navigate without even an instrument?";
return false;
}
//check if all tools are from the same device
for (int i=1; i<tempStorage->GetToolCount(); i++)
{
if (lastDevice!=tempStorage->GetTool(i)->GetTrackingDeviceType())
{
m_ErrorMessage = "Error: Toolfile contains tools of different tracking devices which is not acceptable for this application.";
return false;
}
else lastDevice = tempStorage->GetTool(i)->GetTrackingDeviceType();
}
// check if tracking device typ of tools corresponds with chosen tracking device
if (m_TrackingDevice->GetType()!=tempStorage->GetTool(0)->GetTrackingDeviceType())
{
m_ErrorMessage = "Tools are not compliant with this tracking device. Please use correct toolfile for specified device.";
return false;
}
m_NavigationToolStorage = tempStorage;
return true;
}
else
{
m_ErrorMessage = "Error: No DataStorage available! Make sure the widget is initialized with a DataStorage";
return false;
}
}
void QmitkIGTConnectionWidget::RemoveToolNodes()
{
for (int i=0; i<m_NavigationToolStorage->GetToolCount(); i++)
{
mitk::DataNode::Pointer currentNode = m_NavigationToolStorage->GetTool(i)->GetDataNode();
if (currentNode.IsNotNull())
{
m_DataStorage->Remove(currentNode);
}
}
}
mitk::TrackingDeviceSource::Pointer QmitkIGTConnectionWidget::GetTrackingDeviceSource()
{
return m_TrackingDeviceSource;
}
void QmitkIGTConnectionWidget::SetDataStorage( mitk::DataStorage::Pointer dataStorage )
{
m_DataStorage = dataStorage;
}
mitk::NavigationToolStorage::Pointer QmitkIGTConnectionWidget::GetNavigationToolStorage()
{
return m_NavigationToolStorage;
}
diff --git a/Modules/IGTUI/Qmitk/QmitkIGTPlayerWidget.cpp b/Modules/IGTUI/Qmitk/QmitkIGTPlayerWidget.cpp
index 5f8fbf1aa1..1357f5c542 100644
--- a/Modules/IGTUI/Qmitk/QmitkIGTPlayerWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkIGTPlayerWidget.cpp
@@ -1,573 +1,575 @@
/*===================================================================
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 "QmitkIGTPlayerWidget.h"
//mitk headers
#include "mitkTrackingTypes.h"
#include <mitkSurface.h>
#include <mitkNavigationToolReader.h>
#include <mitkNavigationToolWriter.h>
#include <mitkNavigationToolStorage.h>
#include <mitkNavigationToolStorageDeserializer.h>
#include <mitkNavigationToolStorageSerializer.h>
#include <mitkIGTException.h>
#include <mitkIOUtil.h>
+#include <QmitkIGTCommonHelper.h>
//qt headers
#include <qfiledialog.h>
#include <qmessagebox.h>
#include <qtimer.h>
QmitkIGTPlayerWidget::QmitkIGTPlayerWidget(QWidget* parent, Qt::WindowFlags f)
: QWidget(parent, f),
m_RealTimePlayer(mitk::NavigationDataPlayer::New()),
m_SequentialPlayer(mitk::NavigationDataSequentialPlayer::New()),
m_StartTime(-1.0),
m_CurrentSequentialPointNumber(0),
m_Controls(new Ui::QmitkIGTPlayerWidgetControls)
{
m_Controls->setupUi(this);
m_PlayingTimer = new QTimer(this); // initialize update timer
CreateConnections();
m_Controls->samplePositionHorizontalSlider->setVisible(false);
this->ResetLCDNumbers(); // reset lcd numbers at start
}
QmitkIGTPlayerWidget::~QmitkIGTPlayerWidget()
{
m_PlayingTimer->stop();
delete m_Controls;
}
void QmitkIGTPlayerWidget::CreateConnections()
{
connect( (QObject*)(m_Controls->playPushButton), SIGNAL(clicked(bool)), this, SLOT(OnPlayButtonClicked(bool)) ); // play button
connect( (QObject*)(m_PlayingTimer), SIGNAL(timeout()), this, SLOT(OnPlaying()) ); // update timer
connect( (QObject*) (m_Controls->beginPushButton), SIGNAL(clicked()), this, SLOT(OnGoToBegin()) ); // reset player and go to begin
connect( (QObject*) (m_Controls->stopPushButton), SIGNAL(clicked()), this, SLOT(OnGoToEnd()) ); // reset player
// pass this widgets protected combobox signal to public signal
connect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
// pass this widgets protected checkbox signal to public signal
connect( m_Controls->splineModeCheckBox, SIGNAL(toggled(bool)), this, SIGNAL(SignalSplineModeToggled(bool)) );
//connect( m_Controls->sequencialModeCheckBox, SIGNAL(toggled(bool)), this, SLOT(OnSequencialModeToggled(bool)) );
connect( m_Controls->samplePositionHorizontalSlider, SIGNAL(sliderPressed()), this, SLOT(OnSliderPressed()) );
connect( m_Controls->samplePositionHorizontalSlider, SIGNAL(sliderReleased()), this, SLOT(OnSliderReleased()) );
connect( m_Controls->m_OpenFileButton, SIGNAL(clicked()), this, SLOT(OnOpenFileButtonPressed()) );
}
bool QmitkIGTPlayerWidget::IsTrajectoryInSplineMode()
{
return m_Controls->splineModeCheckBox->isChecked();
}
bool QmitkIGTPlayerWidget::CheckInputFileValid()
{
QFile file(m_CmpFilename);
// check if file exists
if(!file.exists())
{
QMessageBox::warning(NULL, "IGTPlayer: Error", "No valid input file was loaded. Please load input file first!");
return false;
}
return true;
}
unsigned int QmitkIGTPlayerWidget::GetNumberOfTools()
{
unsigned int result = 0;
if(this->GetCurrentPlaybackMode() == RealTimeMode)
{
if(m_RealTimePlayer.IsNotNull())
result = m_RealTimePlayer->GetNumberOfOutputs();
}
else if(this->GetCurrentPlaybackMode() == SequentialMode)
{
if(m_SequentialPlayer.IsNotNull())
result = m_SequentialPlayer->GetNumberOfOutputs();
}
// at the moment this works only if player is initialized
return result;
}
void QmitkIGTPlayerWidget::SetUpdateRate(unsigned int msecs)
{
m_PlayingTimer->setInterval((int) msecs); // set update timer update rate
}
void QmitkIGTPlayerWidget::OnPlayButtonClicked(bool checked)
{
if ( ! checked )
{
if ( this->GetCurrentPlaybackMode() == RealTimeMode )
{
m_RealTimePlayer->StopPlaying();
}
else if ( this->GetCurrentPlaybackMode() == SequentialMode )
{
// m_SequentialPlayer->
}
}
if(CheckInputFileValid()) // no playing possible without valid input file
{
switch ( this->GetCurrentPlaybackMode() )
{
case RealTimeMode:
{
break;
}
case SequentialMode:
{
break;
}
}
PlaybackMode currentMode = this->GetCurrentPlaybackMode();
bool isRealTimeMode = currentMode == RealTimeMode;
bool isSequentialMode = currentMode == SequentialMode;
if(checked) // play
{
if( (isRealTimeMode && m_RealTimePlayer.IsNull()) || (isSequentialMode && m_SequentialPlayer.IsNull())) // start play
{
mitk::NavigationDataSet::Pointer navigationDataSet;
try
{
navigationDataSet = dynamic_cast<mitk::NavigationDataSet*> (mitk::IOUtil::LoadBaseData(m_CmpFilename.toStdString()).GetPointer());
}
catch(mitk::IGTException)
{
std::string errormessage = "Error during start playing. Invalid or wrong file?";
QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
m_Controls->playPushButton->setChecked(false);
m_RealTimePlayer = NULL;
return;
}
if(isRealTimeMode)
{
m_RealTimePlayer = mitk::NavigationDataPlayer::New();
m_RealTimePlayer->SetNavigationDataSet(navigationDataSet);
try
{
m_RealTimePlayer->StartPlaying();
}
catch(mitk::IGTException)
{
std::string errormessage = "Error during start playing. Invalid or wrong file?";
QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
m_Controls->playPushButton->setChecked(false);
m_RealTimePlayer = NULL;
return;
}
}
else if(isSequentialMode)
{
m_SequentialPlayer = mitk::NavigationDataSequentialPlayer::New();
try
{
m_SequentialPlayer->SetNavigationDataSet(navigationDataSet);
}
catch(mitk::IGTException)
{
std::string errormessage = "Error during start playing. Invalid or wrong file type?";
QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
m_Controls->playPushButton->setChecked(false);
m_RealTimePlayer = NULL;
return;
}
m_Controls->samplePositionHorizontalSlider->setMinimum(0);
m_Controls->samplePositionHorizontalSlider->setMaximum(m_SequentialPlayer->GetNumberOfSnapshots());
m_Controls->samplePositionHorizontalSlider->setEnabled(true);
}
m_PlayingTimer->start(100);
emit SignalPlayingStarted();
}
else // resume play
{
if(isRealTimeMode)
m_RealTimePlayer->Resume();
m_PlayingTimer->start(100);
emit SignalPlayingResumed();
}
}
else // pause
{
if(isRealTimeMode)
m_RealTimePlayer->Pause();
m_PlayingTimer->stop();
emit SignalPlayingPaused();
}
}
else
{
m_Controls->playPushButton->setChecked(false); // uncheck play button if file unvalid
}
}
QmitkIGTPlayerWidget::PlaybackMode QmitkIGTPlayerWidget::GetCurrentPlaybackMode()
{
/*if(m_Controls->sequencialModeCheckBox->isChecked())
return SequentialMode;
else*/
return RealTimeMode;
}
QTimer* QmitkIGTPlayerWidget::GetPlayingTimer()
{
return m_PlayingTimer;
}
void QmitkIGTPlayerWidget::OnStopPlaying()
{
this->StopPlaying();
}
void QmitkIGTPlayerWidget::StopPlaying()
{
m_PlayingTimer->stop();
emit SignalPlayingStopped();
if(m_RealTimePlayer.IsNotNull())
m_RealTimePlayer->StopPlaying();
m_StartTime = -1; // set starttime back
m_CurrentSequentialPointNumber = 0;
m_Controls->samplePositionHorizontalSlider->setSliderPosition(m_CurrentSequentialPointNumber);
m_Controls->sampleLCDNumber->display(static_cast<int>(m_CurrentSequentialPointNumber));
this->ResetLCDNumbers();
m_Controls->playPushButton->setChecked(false); // set play button unchecked
}
void QmitkIGTPlayerWidget::OnPlaying()
{
switch ( this->GetCurrentPlaybackMode() )
{
case RealTimeMode:
{
if ( m_RealTimePlayer.IsNull() ) { return; }
if ( m_StartTime < 0 )
{
// get playback start time
m_StartTime = m_RealTimePlayer->GetOutput()->GetTimeStamp();
}
if( ! m_RealTimePlayer->IsAtEnd() )
{
m_RealTimePlayer->Update(); // update player
int msc = (int) (m_RealTimePlayer->GetOutput()->GetTimeStamp() - m_StartTime);
// calculation for playing time display
int ms = msc % 1000;
msc = (msc - ms) / 1000;
int s = msc % 60;
int min = (msc-s) / 60;
// set lcd numbers
m_Controls->msecLCDNumber->display(ms);
m_Controls->secLCDNumber->display(s);
m_Controls->minLCDNumber->display(min);
emit SignalPlayerUpdated(); // player successfully updated
}
else
{
this->StopPlaying(); // if player is at EOF
}
break;
}
case SequentialMode:
{
if ( m_SequentialPlayer.IsNull() ) { return; }
if ( m_CurrentSequentialPointNumber < m_SequentialPlayer->GetNumberOfSnapshots() )
{
m_SequentialPlayer->Update(); // update sequential player
m_Controls->samplePositionHorizontalSlider->setSliderPosition(m_CurrentSequentialPointNumber++); // refresh slider position
m_Controls->sampleLCDNumber->display(static_cast<int>(m_CurrentSequentialPointNumber));
//for debugging purposes
//std::cout << "Sample: " << m_CurrentSequentialPointNumber << " X: " << m_SequentialPlayer->GetOutput()->GetPosition()[0] << " Y: " << m_SequentialPlayer->GetOutput()->GetPosition()[1] << " Y: " << m_SequentialPlayer->GetOutput()->GetPosition()[2] << std::endl;
emit SignalPlayerUpdated(); // player successfully updated
}
else
{
this->StopPlaying(); // if player is at EOF
}
break;
}
}
}
const std::vector<mitk::NavigationData::Pointer> QmitkIGTPlayerWidget::GetNavigationDatas()
{
std::vector<mitk::NavigationData::Pointer> navDatas;
if(this->GetCurrentPlaybackMode() == RealTimeMode && m_RealTimePlayer.IsNotNull())
{
for(unsigned int i=0; i < m_RealTimePlayer->GetNumberOfOutputs(); ++i)
{
navDatas.push_back(m_RealTimePlayer->GetOutput(i)); // push back current navigation data for each tool
}
}
else if(this->GetCurrentPlaybackMode() == SequentialMode && m_SequentialPlayer.IsNotNull())
{
for(unsigned int i=0; i < m_SequentialPlayer->GetNumberOfOutputs(); ++i)
{
navDatas.push_back(m_SequentialPlayer->GetOutput(i)); // push back current navigation data for each tool
}
}
return navDatas;
}
const mitk::PointSet::Pointer QmitkIGTPlayerWidget::GetNavigationDatasPointSet()
{
mitk::PointSet::Pointer result = mitk::PointSet::New();
mitk::PointSet::PointType pointType;
PlaybackMode currentMode = this->GetCurrentPlaybackMode();
bool isRealTimeMode = currentMode == RealTimeMode;
bool isSequentialMode = currentMode == SequentialMode;
if( (isRealTimeMode && m_RealTimePlayer.IsNotNull()) || (isSequentialMode && m_SequentialPlayer.IsNotNull()))
{
int numberOfOutputs = 0;
if(isRealTimeMode)
numberOfOutputs = m_RealTimePlayer->GetNumberOfOutputs();
else if(isSequentialMode)
numberOfOutputs = m_SequentialPlayer->GetNumberOfOutputs();
for(unsigned int i=0; i < m_RealTimePlayer->GetNumberOfOutputs(); ++i)
{
mitk::NavigationData::PositionType position;
if(isRealTimeMode)
position = m_RealTimePlayer->GetOutput(i)->GetPosition();
else if(isSequentialMode)
position = m_SequentialPlayer->GetOutput(i)->GetPosition();
pointType[0] = position[0];
pointType[1] = position[1];
pointType[2] = position[2];
result->InsertPoint(i,pointType); // insert current ND as Pointtype in PointSet for return
}
}
return result;
}
const mitk::PointSet::PointType QmitkIGTPlayerWidget::GetNavigationDataPoint(unsigned int index)
{
if( index > this->GetNumberOfTools() || index < 0 )
throw std::out_of_range("Tool Index out of range!");
PlaybackMode currentMode = this->GetCurrentPlaybackMode();
bool isRealTimeMode = currentMode == RealTimeMode;
bool isSequentialMode = currentMode == SequentialMode;
// create return PointType from current ND for tool index
mitk::PointSet::PointType result;
if( (isRealTimeMode && m_RealTimePlayer.IsNotNull()) || (isSequentialMode && m_SequentialPlayer.IsNotNull()))
{
mitk::NavigationData::PositionType position;
if(isRealTimeMode)
position = m_RealTimePlayer->GetOutput(index)->GetPosition();
else if(isSequentialMode)
position = m_SequentialPlayer->GetOutput(index)->GetPosition();
result[0] = position[0];
result[1] = position[1];
result[2] = position[2];
}
return result;
}
/*void QmitkIGTPlayerWidget::SetRealTimePlayer( mitk::NavigationDataPlayer::Pointer player )
{
if(player.IsNotNull())
m_RealTimePlayer = player;
}
void QmitkIGTPlayerWidget::SetSequentialPlayer( mitk::NavigationDataSequentialPlayer::Pointer player )
{
if(player.IsNotNull())
m_SequentialPlayer = player;
}*/
void QmitkIGTPlayerWidget::OnOpenFileButtonPressed()
{
- QString filename = QFileDialog::getOpenFileName(this, "Load tracking data", QDir::currentPath(),"XML files (*.xml)");
+ QString filename = QFileDialog::getOpenFileName(this, "Load tracking data", QmitkIGTCommonHelper::GetLastFileLoadPath(),"XML files (*.xml)");
QFile file(filename);
+ QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(filename);
// if something went wrong or user pressed cancel in the save dialog
if ( filename.isEmpty() || ! file.exists() )
{
QMessageBox::warning(NULL, "Warning", QString("Please enter valid path. Using previous path again."));
return;
}
m_CmpFilename = filename;
this->OnGoToEnd(); /// stops playing and resets lcd numbers
m_Controls->m_ActiveFileLabel->setText(m_CmpFilename);
emit SignalInputFileChanged();
mitk::NavigationDataSet::Pointer navigationDataSet = dynamic_cast<mitk::NavigationDataSet*> (mitk::IOUtil::LoadBaseData(m_CmpFilename.toStdString()).GetPointer());
m_RealTimePlayer->SetNavigationDataSet(navigationDataSet);
m_SequentialPlayer->SetNavigationDataSet(navigationDataSet);
m_Controls->m_PlayerControlsGroupBox->setEnabled(true);
}
void QmitkIGTPlayerWidget::OnGoToEnd()
{
this->StopPlaying();
// reset lcd numbers
this->ResetLCDNumbers();
}
void QmitkIGTPlayerWidget::OnGoToBegin()
{
// stop player manual so no PlayingStopped()
m_PlayingTimer->stop();
if(this->GetCurrentPlaybackMode() == RealTimeMode && m_RealTimePlayer.IsNotNull())
{
m_RealTimePlayer->StopPlaying();
m_RealTimePlayer = NULL; // set player to NULL so it can be initialized again if playback is called afterwards
}
m_StartTime = -1; // set starttime back
//reset view elements
m_Controls->playPushButton->setChecked(false);
this->ResetLCDNumbers();
}
void QmitkIGTPlayerWidget::ResetLCDNumbers()
{
m_Controls->minLCDNumber->display(QString("00"));
m_Controls->secLCDNumber->display(QString("00"));
m_Controls->msecLCDNumber->display(QString("000"));
}
void QmitkIGTPlayerWidget::SetTrajectoryNames(const QStringList toolNames)
{
QComboBox* cBox = m_Controls->trajectorySelectComboBox;
if(cBox->count() > 0)
this->ClearTrajectorySelectCombobox();
// before making changed to QComboBox it is recommended to disconnet it's SIGNALS and SLOTS
disconnect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
if(!toolNames.isEmpty())
m_Controls->trajectorySelectComboBox->insertItems(0, toolNames); // adding current tool names to combobox
// reconnect after performed changes
connect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
}
int QmitkIGTPlayerWidget::GetResolution()
{
return m_Controls->resolutionSpinBox->value(); // return currently selected trajectory resolution
}
void QmitkIGTPlayerWidget::ClearTrajectorySelectCombobox()
{
// before making changed to QComboBox it is recommended to disconnet it's SIGNALS and SLOTS
disconnect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
m_Controls->trajectorySelectComboBox->clear();
// reconnect after performed changes
connect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
}
void QmitkIGTPlayerWidget::OnSequencialModeToggled(bool toggled)
{
this->StopPlaying(); // stop playing when mode is changed
if(toggled)
{
m_Controls->samplePositionHorizontalSlider->setEnabled(true); // enable slider if sequential mode
}
else if(!toggled)
{
m_Controls->samplePositionHorizontalSlider->setSliderPosition(0); // set back and disable slider
m_Controls->samplePositionHorizontalSlider->setDisabled(true);
}
}
void QmitkIGTPlayerWidget::OnSliderReleased()
{
int currentSliderValue = m_Controls->samplePositionHorizontalSlider->value(); // current slider value selected through user movement
if(currentSliderValue > m_CurrentSequentialPointNumber) // at the moment only forward scrolling is possible
{
unsigned int snapshotNumber = currentSliderValue;
m_SequentialPlayer->GoToSnapshot(snapshotNumber); // move player to selected snapshot
m_CurrentSequentialPointNumber = currentSliderValue;
m_Controls->sampleLCDNumber->display(currentSliderValue); // update lcdnumber in widget
}
else
m_Controls->samplePositionHorizontalSlider->setValue(m_CurrentSequentialPointNumber);
}
void QmitkIGTPlayerWidget::OnSliderPressed()
{
if(m_Controls->playPushButton->isChecked()) // check if widget is playing
m_Controls->playPushButton->click(); // perform click to pause the play
}
diff --git a/Modules/IGTUI/Qmitk/QmitkMicronTrackerWidget.cpp b/Modules/IGTUI/Qmitk/QmitkMicronTrackerWidget.cpp
index cfc52b776e..9422e1eeac 100644
--- a/Modules/IGTUI/Qmitk/QmitkMicronTrackerWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkMicronTrackerWidget.cpp
@@ -1,168 +1,171 @@
/*===================================================================
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 "QmitkMicronTrackerWidget.h"
#include <QFileDialog>
#include <QScrollBar>
#include <mitkClaronTrackingDevice.h>
#include <itksys/SystemTools.hxx>
#include <Poco/Path.h>
#include <QSettings>
+#include <QmitkIGTCommonHelper.h>
+
const std::string QmitkMicronTrackerWidget::VIEW_ID = "org.mitk.views.NDIMicronTrackerWidget";
QmitkMicronTrackerWidget::QmitkMicronTrackerWidget(QWidget* parent, Qt::WindowFlags f)
: QmitkAbstractTrackingDeviceWidget(parent, f)
, m_Controls(nullptr)
{
}
void QmitkMicronTrackerWidget::Initialize()
{
InitializeSuperclassWidget();
CreateQtPartControl(this);
CreateConnections();
m_MTCalibrationFile = "";
}
QmitkMicronTrackerWidget::~QmitkMicronTrackerWidget()
{
delete m_Controls;
}
void QmitkMicronTrackerWidget::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkMicronTrackerWidget;
m_Controls->setupUi(parent);
}
}
void QmitkMicronTrackerWidget::CreateConnections()
{
if (m_Controls)
{
connect((QObject*)(m_Controls->m_testConnectionMicronTracker), SIGNAL(clicked()), this, SLOT(TestConnection()));
connect((QObject*)(m_Controls->m_SetMTCalibrationFile), SIGNAL(clicked()), this, SLOT(SetMTCalibrationFileClicked()));
}
}
void QmitkMicronTrackerWidget::ResetOutput()
{
m_Controls->m_outputTextMicronTracker->setHtml("<body style=\" font-family:\'MS Shell Dlg 2\'; font-size:7pt; font-weight:400; font-style:normal;\" bgcolor=black><span style=\"color:#ffffff;\"><u>output:</u>");
}
void QmitkMicronTrackerWidget::AddOutput(std::string s)
{
m_Controls->m_outputTextMicronTracker->setHtml(QString(s.c_str()));
m_Controls->m_outputTextMicronTracker->verticalScrollBar()->setValue(m_Controls->m_outputTextMicronTracker->verticalScrollBar()->maximum());
}
mitk::TrackingDevice::Pointer QmitkMicronTrackerWidget::ConstructTrackingDevice()
{
mitk::ClaronTrackingDevice::Pointer newDevice = mitk::ClaronTrackingDevice::New();
if (this->m_MTCalibrationFile.empty()) //if configuration file for MicronTracker is empty: load default
{
mitk::ClaronTrackingDevice::Pointer tempDevice = mitk::ClaronTrackingDevice::New();
m_MTCalibrationFile = tempDevice->GetCalibrationDir();
Poco::Path myPath = Poco::Path(m_MTCalibrationFile.c_str());
m_Controls->m_MTCalibrationFile->setText("Calibration File: " + QString(myPath.getFileName().c_str()));
}
if (!this->m_MTCalibrationFile.empty())
{
//extract path from calibration file and set the calibration dir of the device
std::string path = itksys::SystemTools::GetFilenamePath(m_MTCalibrationFile);
newDevice->SetCalibrationDir(path);
}
else
AddOutput("<br>Warning: Calibration file is not set!");
return static_cast<mitk::TrackingDevice::Pointer>(newDevice);
}
void QmitkMicronTrackerWidget::StoreUISettings()
{
std::string id = "org.mitk.modules.igt.ui.trackingdeviceconfigurationwidget";
if (this->GetPersistenceService()) // now save the settings using the persistence service
{
mitk::PropertyList::Pointer propList = this->GetPersistenceService()->GetPropertyList(id);
propList->Set("MTCalibrationFile", m_MTCalibrationFile);
}
else // QSettings as a fallback if the persistence service is not available
{
QSettings settings;
settings.beginGroup(QString::fromStdString(id));
settings.setValue("mTCalibrationFile", QVariant(QString::fromStdString(m_MTCalibrationFile)));
settings.endGroup();
}
}
void QmitkMicronTrackerWidget::LoadUISettings()
{
std::string id = "org.mitk.modules.igt.ui.trackingdeviceconfigurationwidget";
if (this->GetPersistenceService())
{
mitk::PropertyList::Pointer propList = this->GetPersistenceService()->GetPropertyList(id);
if (propList.IsNull())
{
MITK_ERROR << "Property list for this UI (" << id << ") is not available, could not load UI settings!"; return;
}
propList->Get("MTCalibrationFile", m_MTCalibrationFile);
}
else
{
// QSettings as a fallback if the persistence service is not available
QSettings settings;
settings.beginGroup(QString::fromStdString(id));
m_MTCalibrationFile = settings.value("mTCalibrationFile", "").toString().toStdString();
settings.endGroup();
}
m_Controls->m_MTCalibrationFile->setText("Calibration File: " + QString::fromStdString(m_MTCalibrationFile));
}
bool QmitkMicronTrackerWidget::IsDeviceInstalled()
{
return mitk::ClaronTrackingDevice::New()->IsDeviceInstalled();
}
void QmitkMicronTrackerWidget::SetMTCalibrationFileClicked()
{
- std::string filename = QFileDialog::getOpenFileName(NULL, tr("Open Calibration File"), "/", "*.*").toLatin1().data();
+ std::string filename = QFileDialog::getOpenFileName(NULL, tr("Open Calibration File"), QmitkIGTCommonHelper::GetLastFileLoadPath(), "*.*").toLatin1().data();
if (filename == "") { return; }
else
{
+ QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(QString::fromStdString(filename));
m_MTCalibrationFile = filename;
Poco::Path myPath = Poco::Path(m_MTCalibrationFile.c_str());
m_Controls->m_MTCalibrationFile->setText("Calibration File: " + QString(myPath.getFileName().c_str()));
}
}
QmitkMicronTrackerWidget* QmitkMicronTrackerWidget::Clone(QWidget* parent) const
{
QmitkMicronTrackerWidget* clonedWidget = new QmitkMicronTrackerWidget(parent);
clonedWidget->Initialize();
clonedWidget->m_MTCalibrationFile = m_MTCalibrationFile;
m_Controls->m_MTCalibrationFile->setText("Calibration File: " + QString::fromStdString(m_MTCalibrationFile));
return clonedWidget;
}
diff --git a/Modules/IGTUI/Qmitk/QmitkNDIConfigurationWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNDIConfigurationWidget.cpp
index fc45ba998f..d86f6f7f2d 100644
--- a/Modules/IGTUI/Qmitk/QmitkNDIConfigurationWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNDIConfigurationWidget.cpp
@@ -1,886 +1,893 @@
/*===================================================================
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 "QmitkNDIConfigurationWidget.h"
#include <QTableWidget>
#include <QMessageBox>
#include <QFileDialog>
#include <QInputDialog>
#include <QDir>
#include <QFileInfo>
#include <mitkNavigationToolWriter.h>
#include <mitkNavigationToolReader.h>
#include <mitkIGTException.h>
#include <mitkIOUtil.h>
+#include <QmitkIGTCommonHelper.h>
#include "QmitkCustomVariants.h"
//#include <QtConcurrentMap>
#include "QmitkNDIToolDelegate.h"
#include "mitkNDIAuroraTypeInformation.h"
#include "mitkNDIPolarisTypeInformation.h"
/* VIEW MANAGEMENT */
QmitkNDIConfigurationWidget::QmitkNDIConfigurationWidget(QWidget* parent)
: QWidget(parent), m_Controls(NULL), m_Tracker(NULL), m_Source(NULL),
m_Delegate(NULL), m_SROMCellDefaultText("<click to load SROM file>"), m_RepresentatonCellDefaultText("<click to select representation>")
{
this->CreateQtPartControl(this);
}
QmitkNDIConfigurationWidget::~QmitkNDIConfigurationWidget()
{
m_Controls = NULL;
m_Tracker = NULL;
m_Source = NULL;
}
void QmitkNDIConfigurationWidget::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkNDIConfigurationWidget;
m_Controls->setupUi(parent);
QStringList comPorts;
#ifdef WIN32
comPorts << "COM1" << "COM2" << "COM3" << "COM4" << "COM5" << "COM6" << "COM7" << "COM8" << "COM9";
#else
comPorts << "/dev/ttyS1" << "/dev/ttyS2" << "/dev/ttyS3" << "/dev/ttyS4" << "/dev/ttyS5" << "/dev/ttyUSB0" << "/dev/ttyUSB1" << "/dev/ttyUSB2" << "/dev/ttyUSB3";
#endif
m_Controls->m_ComPortSelector->addItems(comPorts);
m_Delegate = new QmitkNDIToolDelegate(m_Controls->m_ToolTable);
m_Delegate->SetDataStorage(NULL); //needs to be set later using the setter methods
m_Delegate->SetPredicate(NULL);
m_Delegate->SetTypes(QStringList());
m_Controls->m_ToolTable->setItemDelegate(m_Delegate);
this->CreateConnections();
this->HidePolarisOptionsGroupbox(true);
this->HideAuroraOptionsGroupbox(true);
}
}
void QmitkNDIConfigurationWidget::CreateConnections()
{
connect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnConnect()));
connect(m_Controls->m_DiscoverToolsBtn, SIGNAL(clicked()), this, SLOT(OnDiscoverTools()));
connect(m_Controls->m_AddToolBtn, SIGNAL(clicked()), this, SLOT(OnAddPassiveTool()));
connect(m_Controls->m_DisoverDevicesBtn, SIGNAL(clicked()), this, SLOT(OnDiscoverDevices()));
connect(m_Controls->m_ToolTable->model(), SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this, SLOT(UpdateTrackerFromToolTable(const QModelIndex &, const QModelIndex &)));
connect(m_Controls->m_DisoverDevicesBtnInfo, SIGNAL(clicked()), this, SLOT(OnDisoverDevicesBtnInfo()));
connect(m_Controls->m_SaveToolPushButton, SIGNAL(clicked()), this, SLOT(OnSaveTool()) );
connect(m_Controls->m_LoadToolPushButton, SIGNAL(clicked()), this, SLOT(OnLoadTool()) );
}
void QmitkNDIConfigurationWidget::OnConnect()
{
if (m_Tracker.IsNotNull())
{
m_Tracker->CloseConnection();
m_Tracker = NULL;
}
this->CreateTracker();
this->SetupTracker();
bool okay = false;
try
{
okay = m_Tracker->OpenConnection();
}
catch(mitk::IGTException &e)
{
QMessageBox::warning(NULL, "Error", QString("Connection failed, error message: ") + e.GetDescription());
m_Tracker->CloseConnection();
this->m_Tracker = NULL;
}
if (okay)
{
// show/hide options according to connected device
if(m_Tracker->GetType() == mitk::NDIPolarisTypeInformation::GetTrackingDeviceName())
{
this->HideAuroraOptionsGroupbox(true);
this->HidePolarisOptionsGroupbox(false);
}
else if (m_Tracker->GetType() == mitk::NDIAuroraTypeInformation::GetTrackingDeviceName())
{
this->HidePolarisOptionsGroupbox(true);
this->HideAuroraOptionsGroupbox(false);
}
this->UpdateWidgets();
this->UpdateToolTable();
connect(m_Controls->m_ToolTable, SIGNAL(cellChanged(int,int)), this, SLOT(OnTableCellChanged(int,int)));
emit ToolsAdded(this->GetToolNamesList());
emit Connected();
}
else
{
QMessageBox::warning(NULL, "Error", QString("Connection failed due to an unknown reason!"));
m_Tracker->CloseConnection();
this->m_Tracker = NULL;
}
}
void QmitkNDIConfigurationWidget::OnDisconnect()
{
if (m_Tracker.IsNull())
return;
m_Tracker->CloseConnection();
m_Tracker = NULL;
disconnect(m_Controls->m_ToolTable, SIGNAL(cellChanged(int,int)), this, SLOT(OnTableCellChanged(int,int)));
m_Controls->m_ToolSelectionComboBox->clear();
this->UpdateToolTable();
this->UpdateWidgets();
emit ToolsAdded(this->GetToolNamesList());
emit Disconnected();
this->HidePolarisOptionsGroupbox(true);
this->HideAuroraOptionsGroupbox(true);
}
void QmitkNDIConfigurationWidget::UpdateWidgets()
{
m_Controls->m_DeviceStatus->setText(this->GetStatusText());
if (m_Tracker.IsNull()) // not connected to tracker
{
m_Controls->m_Connect->setText("Connect");
m_Controls->m_lConnection->setText("III. Enable connection to device ");
disconnect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnDisconnect()));
connect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnConnect()));
m_Controls->m_DiscoverToolsBtn->setDisabled(true);
m_Controls->m_AddToolBtn->setDisabled(true);
return;
}
if (m_Tracker->GetState() == mitk::TrackingDevice::Setup)
{
m_Controls->m_Connect->setText("Connect");
m_Controls->m_lConnection->setText("III. Enable connection to device ");
disconnect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnDisconnect()));
connect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnConnect()));
m_Controls->m_DiscoverToolsBtn->setDisabled(true);
m_Controls->m_AddToolBtn->setDisabled(true);
return;
}
if ((m_Tracker->GetState() == mitk::TrackingDevice::Ready) || (m_Tracker->GetState() == mitk::TrackingDevice::Tracking))
{
m_Controls->m_Connect->setText("Disconnect");
m_Controls->m_lConnection->setText("III. Disable connection to device ");
disconnect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnConnect()));
connect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnDisconnect()));
m_Controls->m_DiscoverToolsBtn->setEnabled(true);
m_Controls->m_AddToolBtn->setEnabled(true);
}
}
QString QmitkNDIConfigurationWidget::GetStatusText()
{
if (m_Tracker.IsNull())
return QString("Not connected");
QString devName = QString::fromStdString(m_Tracker->GetType());
if (m_Tracker->GetState() == mitk::TrackingDevice::Ready)
return QString("Connected to %1 on %2. Device is ready.").arg(devName).arg(m_Tracker->GetDeviceName());
if (m_Tracker->GetState() == mitk::TrackingDevice::Tracking)
return QString("%1 is tracking.").arg(devName);
return QString("");
}
void QmitkNDIConfigurationWidget::OnDiscoverTools()
{
if (m_Tracker.IsNull())
{
QMessageBox::warning(NULL, "Error", QString("Connection failed. No tracking device found."));
return;
}
m_Tracker->DiscoverWiredTools();
this->UpdateToolTable();
emit ToolsAdded(this->GetToolNamesList());
}
void QmitkNDIConfigurationWidget::OnAddPassiveTool()
{
if (m_Tracker.IsNull())
this->CreateTracker();
- QStringList filenames = QFileDialog::getOpenFileNames(this, "Select NDI SROM file", QDir::currentPath(),"NDI SROM files (*.rom)");
+ QStringList filenames = QFileDialog::getOpenFileNames(this, "Select NDI SROM file", QmitkIGTCommonHelper::GetLastFileLoadPath(),"NDI SROM files (*.rom)");
if (filenames.isEmpty())
{
this->m_Tracker = NULL;
return;
}
+
+ QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(filenames.at(0));
+
foreach(QString fileName, filenames)
{
//QString toolName = QInputDialog::getText(this, "Enter a name for the tool", "Name of the tool: ", QLineEdit::Normal, QFileInfo(filename).baseName(), &ok);
//if (ok == false || toolName.isEmpty())
// return;
m_Tracker->AddTool(QFileInfo(fileName).baseName().toLatin1(), fileName.toLatin1());
m_Tracker->Modified();
}
emit ToolsAdded(this->GetToolNamesList());
this->UpdateToolTable();
}
void QmitkNDIConfigurationWidget::CreateTracker()
{
m_Tracker = mitk::NDITrackingDevice::New();
}
void QmitkNDIConfigurationWidget::SetupTracker()
{
if (m_Tracker.IsNull())
return;
m_Tracker->SetDeviceName(this->GetDeviceName());
m_Tracker->SetBaudRate(mitk::SerialCommunication::BaudRate115200);
}
std::string QmitkNDIConfigurationWidget::GetDeviceName() const
{
if (m_Controls == NULL)
return NULL;
QString deviceName = m_Controls->m_ComPortSelector->currentText();
#if WIN32
deviceName.prepend("\\\\.\\"); // always prepend "\\.\ to all COM ports, to be able to connect to ports > 9"
#endif
return deviceName.toStdString();
}
void QmitkNDIConfigurationWidget::SetDeviceName( const char* dev )
{
if (m_Controls == NULL)
return;
m_Controls->m_ComPortSelector->setCurrentIndex(m_Controls->m_ComPortSelector->findText(dev));
}
void QmitkNDIConfigurationWidget::UpdateToolTable()
{
//disconnect(m_Controls->m_ToolTable, SIGNAL(itemChanged(QTableWidgetItem*)), this, SLOT(OnTableItemChanged(QTableWidgetItem*))); // stop listening to table changes
disconnect(m_Controls->m_ToolTable->model(), SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this, SLOT(UpdateTrackerFromToolTable(const QModelIndex &, const QModelIndex &)));
disconnect(m_Controls->m_ToolTable, SIGNAL( clicked ( const QModelIndex & )), this, SLOT ( OnTableItemClicked( const QModelIndex & )));
m_Controls->m_ToolTable->clearContents();
m_Controls->m_ToolTable->setRowCount(0);
if (m_Tracker.IsNull() || (m_Controls == NULL))
return;
m_Controls->m_ToolSelectionComboBox->clear();
m_Controls->m_ToolTable->setRowCount(m_Tracker->GetToolCount());
for (unsigned int i = 0; i < m_Tracker->GetToolCount(); ++i)
{
mitk::TrackingTool* t = m_Tracker->GetTool(i);
if (t == NULL)
{
m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::IndexCol, new QTableWidgetItem("INVALID")); // Index
continue;
}
m_Controls->m_ToolSelectionComboBox->addItem(m_Tracker->GetTool(i)->GetToolName());
m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::IndexCol, new QTableWidgetItem(QString::number(i))); // Index
m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::NameCol, new QTableWidgetItem(t->GetToolName())); // Name
if (dynamic_cast<mitk::NDIPassiveTool*>(t)->GetSROMDataLength() > 0)
m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::SROMCol, new QTableWidgetItem("SROM file loaded")); // SROM file
else
m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::SROMCol, new QTableWidgetItem(m_SROMCellDefaultText)); // SROM file
m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::TypeCol, new QTableWidgetItem("<click to set type>")); // Type
if (t->IsEnabled())
m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::StatusCol, new QTableWidgetItem("Enabled")); // Status
else
m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::StatusCol, new QTableWidgetItem("Disabled")); // Status
m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::NodeCol, new QTableWidgetItem("<click to select node>")); // Node
m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::RepCol, new QTableWidgetItem(m_RepresentatonCellDefaultText)); // Representation
/* set read-only/editable flags */
m_Controls->m_ToolTable->item(i, QmitkNDIToolDelegate::IndexCol)->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled); // Index
m_Controls->m_ToolTable->item(i, QmitkNDIToolDelegate::NodeCol)->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled); // Name
m_Controls->m_ToolTable->item(i, QmitkNDIToolDelegate::SROMCol)->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled); // SROM file
m_Controls->m_ToolTable->item(i, QmitkNDIToolDelegate::TypeCol)->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled); // Type
m_Controls->m_ToolTable->item(i, QmitkNDIToolDelegate::StatusCol)->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled); // Status
m_Controls->m_ToolTable->item(i, QmitkNDIToolDelegate::NodeCol)->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled); // Node
m_Controls->m_ToolTable->item(i, QmitkNDIToolDelegate::RepCol)->setFlags(Qt::NoItemFlags); // Representation surface file
}
m_Controls->m_ToolTable->resizeColumnsToContents();
//connect(m_Controls->m_ToolTable, SIGNAL(itemChanged(QTableWidgetItem*)), this, SLOT(OnTableItemChanged(QTableWidgetItem*))); // listen to table changes again
connect(m_Controls->m_ToolTable->model(), SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this, SLOT(UpdateTrackerFromToolTable(const QModelIndex &, const QModelIndex &)));
connect(m_Controls->m_ToolTable, SIGNAL( clicked ( const QModelIndex & )), this, SLOT ( OnTableItemClicked( const QModelIndex & )));
}
void QmitkNDIConfigurationWidget::OnDiscoverDevices()
{
PortDeviceMap portsAndDevices;
QString status = "Scanning ";
#ifdef WIN32
QString devName;
for (unsigned int i = 1; i < 40; ++i)
{
if (i<10)
devName = QString("COM%1").arg(i);
else
devName = QString("\\\\.\\COM%1").arg(i); // prepend "\\.\ to COM ports >9, to be able to allow connection"
portsAndDevices[devName];
status += QString("COM%1").arg(i) + ", ";
}
#else //linux/posix systems
for(unsigned int i = 1; i < 6; ++i)
{
QString devName = QString("/dev/ttyS%1").arg(i);
portsAndDevices[devName];
status += devName + ", ";
}
for(unsigned int i = 0; i <7; ++i)
{
QString devName = QString("/dev/ttyUSB%1").arg(i);
portsAndDevices[devName];
status += devName + ", ";
}
#endif
status.chop(2); // remove last ", "
status += " for NDI tracking devices...";
m_Controls->m_DeviceStatus->setText(status);
ScanPortsForNDITrackingDevices(portsAndDevices);
m_Controls->m_ComPortSelector->clear();
QString result = "The following tracking devices were found:<BR/>\n";
for (PortDeviceMap::const_iterator it = portsAndDevices.begin(); it != portsAndDevices.end(); ++it)
{
QString tmpComPort = it.key();
if (tmpComPort.startsWith("\\"))
{
tmpComPort.remove(0,4); // remove "\\.\" for nice ui visualisation
}
result += tmpComPort + ": ";
if (mitk::NDIPolarisTypeInformation::GetTrackingDeviceName() == it.value() || mitk::NDIAuroraTypeInformation::GetTrackingDeviceName() == it.value())
{
result += QString::fromStdString(it.value());
result += "<BR/>\n";
m_Controls->m_ComPortSelector->addItem(tmpComPort);
}
else
{
result += "No NDI tracking device found<BR/>\n";
}
}
//QMessageBox::information(NULL, "Tracking Device Discovery", result);
m_Controls->m_DeviceStatus->setText(result);
}
mitk::TrackingDeviceType QmitkNDIConfigurationWidget::ScanPort(QString port)
{
mitk::NDITrackingDevice::Pointer tracker = mitk::NDITrackingDevice::New();
tracker->SetDeviceName(port.toStdString());
return tracker->TestConnection();
}
void QmitkNDIConfigurationWidget::ScanPortsForNDITrackingDevices( PortDeviceMap& portsAndDevices )
{
// Iterative scanning:
for (PortDeviceMap::iterator it = portsAndDevices.begin(); it != portsAndDevices.end(); ++it)
it.value() = this->ScanPort(it.key());
// \Todo: use parallel scanning
//QtConcurrent::blockingMap( portsAndDevices.begin(), portsAndDevices.end(), ScanPort );
//MITK_INFO << portsAndDevices;
}
QStringList QmitkNDIConfigurationWidget::GetToolNamesList()
{
QStringList toolNames;
if (m_Tracker.IsNull())
return toolNames;
for (unsigned int i = 0; i < m_Tracker->GetToolCount(); ++i)
{
mitk::TrackingTool* t = m_Tracker->GetTool(i);
if (t == NULL)
continue;
toolNames << t->GetToolName();
}
return toolNames;
}
mitk::NDITrackingDevice* QmitkNDIConfigurationWidget::GetTracker() const
{
return m_Tracker.GetPointer();
}
void QmitkNDIConfigurationWidget::SetToolTypes(const QStringList& types)
{
m_Delegate->SetTypes(types);
}
void QmitkNDIConfigurationWidget::SetDataStorage(mitk::DataStorage* ds)
{
m_Delegate->SetDataStorage(ds);
}
void QmitkNDIConfigurationWidget::SetPredicate(mitk::NodePredicateBase::Pointer p)
{
m_Delegate->SetPredicate(p);
}
void QmitkNDIConfigurationWidget::SetTagPropertyName( const std::string& name )
{
m_Delegate->SetTagPropertyName(name);
}
void QmitkNDIConfigurationWidget::SetTagProperty( mitk::BaseProperty::Pointer prop )
{
m_Delegate->SetTagProperty(prop);
}
void QmitkNDIConfigurationWidget::OnTableItemClicked(const QModelIndex & topLeft )
{
QString filename;
QTableWidgetItem* filenameItem;
switch (topLeft.column())
{
case QmitkNDIToolDelegate::RepCol:
- filename = QFileDialog::getOpenFileName(this, "Select Surface File", QDir::currentPath(),"STL files (*.stl)");
+ filename = QFileDialog::getOpenFileName(this, "Select Surface File", QmitkIGTCommonHelper::GetLastFileLoadPath(),"STL files (*.stl)");
+ QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(filename);
filenameItem = new QTableWidgetItem(filename);
m_Controls->m_ToolTable->setItem( topLeft.row(), topLeft.column(), filenameItem );
if(QFileInfo(filename).exists())
{
mitk::Surface::Pointer surface = this->LoadSurfaceFromSTLFile(filename);
if(surface.IsNotNull())
emit RepresentationChanged( topLeft.row(), surface);
}
break;
default:
break;
}
}
void QmitkNDIConfigurationWidget::UpdateTrackerFromToolTable(const QModelIndex & topLeft, const QModelIndex & /*bottomRight*/)
{
//Colums ID doesn't have to be processed.
if (topLeft.column()<1)
return;
if (m_Tracker.IsNull())
return;
if (topLeft.row() >= (int) m_Tracker->GetToolCount())
return;
QAbstractItemModel* model = m_Controls->m_ToolTable->model();
//define topleft contains row and column; row 0 is tool 0; column is index =0, Name =1, SROMFileName = 2; Type = 3; Status = 4; Node (?) = 5
//only update the changed item
mitk::NDIPassiveTool* tool = dynamic_cast<mitk::NDIPassiveTool*> (m_Tracker->GetTool(topLeft.row()));
if (tool == NULL)
return;
switch (topLeft.column())
{
case QmitkNDIToolDelegate::IndexCol: //index
break;
case QmitkNDIToolDelegate::NameCol: //name
tool->SetToolName(model->data(model->index(topLeft.row(), 1)).toString().toLatin1());
emit ToolsChanged();
break;
case QmitkNDIToolDelegate::SROMCol: //SROM File Name
{
QString romfile = model->data(model->index(topLeft.row(), QmitkNDIToolDelegate::SROMCol)).toString();
if (QFileInfo(romfile).exists())
tool->LoadSROMFile(romfile.toLatin1());
m_Tracker->UpdateTool(tool);
break;
}
//TODO: Add Node Status and Type here as well
default:
break;
}
}
const QString QmitkNDIConfigurationWidget::GetToolType( unsigned int index ) const
{
if (m_Controls == NULL)
return QString("");
QAbstractItemModel* model = m_Controls->m_ToolTable->model();
QModelIndex modelIndex = model->index(index, QmitkNDIToolDelegate::TypeCol);
if (modelIndex.isValid() == false)
return QString("");
return model->data(modelIndex).toString();
}
const QString QmitkNDIConfigurationWidget::GetToolName( unsigned int index ) const
{
if (m_Controls == NULL)
return QString("");
QAbstractItemModel* model = m_Controls->m_ToolTable->model();
QModelIndex modelIndex = model->index(index, QmitkNDIToolDelegate::NameCol);
if (modelIndex.isValid() == false)
return QString("");
return model->data(modelIndex).toString();
}
QMap<QString, unsigned int> QmitkNDIConfigurationWidget::GetToolAndTypes() const
{
QMap<QString, unsigned int> map;
if (m_Controls == NULL)
return map;
QAbstractItemModel* model = m_Controls->m_ToolTable->model();
for (int i = 0; i < model->rowCount(); ++i)
{
QModelIndex indexIndex = model->index(i, QmitkNDIToolDelegate::IndexCol);
QModelIndex typeIndex = model->index(i, QmitkNDIToolDelegate::TypeCol);
if ((indexIndex.isValid() == false) || (typeIndex.isValid() == false))
continue;
map.insert(model->data(typeIndex).toString(), model->data(indexIndex).toUInt());
}
return map;
}
QList<unsigned int> QmitkNDIConfigurationWidget::GetToolsByToolType( QString toolType ) const
{
QList<unsigned int> list;
if (m_Controls == NULL)
return list;
QAbstractItemModel* model = m_Controls->m_ToolTable->model();
for (int i = 0; i < model->rowCount(); ++i)
{
QModelIndex indexIndex = model->index(i, QmitkNDIToolDelegate::IndexCol);
QModelIndex typeIndex = model->index(i, QmitkNDIToolDelegate::TypeCol);
if ((indexIndex.isValid() == false) || (typeIndex.isValid() == false))
continue;
if (model->data(typeIndex).toString() == toolType)
list.append(model->data(indexIndex).toUInt());
}
return list;
}
mitk::DataNode* QmitkNDIConfigurationWidget::GetNode( unsigned int index ) const
{
if (m_Controls == NULL)
return NULL;
QAbstractItemModel* model = m_Controls->m_ToolTable->model();
QVariant data = model->data(model->index(index, QmitkNDIToolDelegate::NodeCol), QmitkNDIToolDelegate::OrganNodeRole);
return data.value<mitk::DataNode*>();
}
void QmitkNDIConfigurationWidget::HidePolarisOptionsGroupbox( bool on )
{
m_Controls->m_gbPolarisOptions->setHidden(on);
}
void QmitkNDIConfigurationWidget::HideAuroraOptionsGroupbox( bool on )
{
m_Controls->m_gbAuroraOptions->setHidden(on);
}
void QmitkNDIConfigurationWidget::ShowToolRepresentationColumn()
{
int cols = m_Controls->m_ToolTable->columnCount();
//checking if representation column is inserted at right index
if(cols != QmitkNDIToolDelegate::RepCol)
{
//throw std::exception("Representation Column is not inserted at it's designated index!");
return;
}
m_Controls->m_ToolTable->insertColumn(cols); // insert new column at end of table
m_Controls->m_ToolTable->setHorizontalHeaderItem(QmitkNDIToolDelegate::RepCol, new QTableWidgetItem(QString("Representation"))); // inser column header for new colum
//m_Controls->m_ToolTable->setEditTriggers(QAbstractItemView::EditTrigger::NoEditTriggers);
int rows = m_Controls->m_ToolTable->rowCount();
// make all representation colum items not editable
for(int i=0; i < rows; ++i)
{
m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::RepCol, new QTableWidgetItem("<click to select representation>")); // Representation
m_Controls->m_ToolTable->item(i,QmitkNDIToolDelegate::RepCol)->setFlags(Qt::NoItemFlags);
}
//connect(m_Controls->m_ToolTable, SIGNAL( clicked ( const QModelIndex & )), this, SLOT ( OnTableItemClicked( const QModelIndex & )));
}
void QmitkNDIConfigurationWidget::OnDisoverDevicesBtnInfo()
{
QMessageBox *infoBox = new QMessageBox(this);
infoBox->setText("Click \"Scan Ports\" to get a list of all connected NDI tracking devices. This will clear the selection menu below and add the ports for discovered NDI tracking devices. Use this function, if a port is not listed.");
infoBox->exec();
delete infoBox;
}
void QmitkNDIConfigurationWidget::OnTableCellChanged(int row, int column)
{
if(m_Tracker.IsNull())
return;
QString toolName;
switch (column)
{
case QmitkNDIToolDelegate::NameCol:
toolName = m_Controls->m_ToolTable->item(row,column)->text();
m_Controls->m_ToolSelectionComboBox->setItemText(row, toolName);
emit SignalToolNameChanged(row, toolName);
break;
default:
break;
}
}
void QmitkNDIConfigurationWidget::OnSaveTool()
{
if(m_Tracker.IsNull() || m_Tracker->GetToolCount() <= 0)
return;
int currId = m_Controls->m_ToolSelectionComboBox->currentIndex();
QString filename = QFileDialog::getSaveFileName(NULL, "Save NDI-Tool", QString(QString(m_Tracker->GetTool(currId)->GetToolName())),"NDI Tracking Tool file(*.ntf)");
mitk::TrackingTool* selectedTool = m_Tracker->GetTool(currId);
if(filename.isEmpty())
return;
mitk::NavigationTool::Pointer navTool = mitk::NavigationTool::New();
mitk::NavigationToolWriter::Pointer toolWriter = mitk::NavigationToolWriter::New();
try {
toolWriter->DoWrite(filename.toStdString(), this->GenerateNavigationTool(selectedTool));
}
catch( ... )
{
QMessageBox::warning(NULL, "Saving Tool Error", QString("An error occured! Could not save tool!\n\n"));
MBI_ERROR<<"Could not save tool surface!";
MBI_ERROR<< toolWriter->GetErrorMessage();
QFile maybeCorruptFile(filename);
if(maybeCorruptFile.exists())
maybeCorruptFile.remove();
}
emit SignalSavedTool(currId, filename);
}
void QmitkNDIConfigurationWidget::OnLoadTool()
{
if(m_Tracker.IsNull() || m_Tracker->GetToolCount() <= 0)
return;
- QString filename = QFileDialog::getOpenFileName(NULL, "Load NDI-Tools", QDir::currentPath(),"NDI Tracking Tool file(*.ntf)");
+ QString filename = QFileDialog::getOpenFileName(NULL, "Load NDI-Tools", QmitkIGTCommonHelper::GetLastFileLoadPath(),"NDI Tracking Tool file(*.ntf)");
int currId = m_Controls->m_ToolSelectionComboBox->currentIndex();
if(filename.isEmpty())
return;
+ QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(filename);
+
mitk::DataNode::Pointer toolNode;
mitk::NavigationToolReader::Pointer toolReader = mitk::NavigationToolReader::New();
mitk::NavigationTool::Pointer navTool;
try {
navTool = toolReader->DoRead(filename.toStdString());
}
catch( ... )
{
QMessageBox::warning(NULL, "Loading Tool Error", QString("An error occured! Could not load tool!\n\n"));
MBI_ERROR<<"Could not load tool surface!";
MBI_ERROR<< toolReader->GetErrorMessage();
}
int currSelectedToolID = m_Controls->m_ToolSelectionComboBox->currentIndex();
// name
m_Controls->m_ToolTable->item(currSelectedToolID,QmitkNDIToolDelegate::NameCol)->setText(navTool->GetToolName().c_str());
dynamic_cast<mitk::NDIPassiveTool*>(m_Tracker->GetTool(currSelectedToolID))->SetToolName(navTool->GetToolName().c_str()); // also setting name to tool directly
//calibration file (.srom) filename
m_Controls->m_ToolTable->item(currSelectedToolID,QmitkNDIToolDelegate::SROMCol)->setText(navTool->GetCalibrationFile().c_str());
//type
if(navTool->GetType() == mitk::NavigationTool::Instrument)
m_Controls->m_ToolTable->item(currSelectedToolID,QmitkNDIToolDelegate::TypeCol)->setText("Instrument");
else if(navTool->GetType() == mitk::NavigationTool::Fiducial)
m_Controls->m_ToolTable->item(currSelectedToolID,QmitkNDIToolDelegate::TypeCol)->setText("Fiducial");
else if(navTool->GetType() == mitk::NavigationTool::Skinmarker)
m_Controls->m_ToolTable->item(currSelectedToolID,QmitkNDIToolDelegate::TypeCol)->setText("Skinmarker");
else
m_Controls->m_ToolTable->item(currSelectedToolID,QmitkNDIToolDelegate::TypeCol)->setText("Unknown");
//representation
m_Controls->m_ToolTable->item(currSelectedToolID,QmitkNDIToolDelegate::SROMCol)->setText(m_RepresentatonCellDefaultText);
emit SignalLoadTool(currId, navTool->GetDataNode());
}
mitk::NavigationTool::Pointer QmitkNDIConfigurationWidget::GenerateNavigationTool(mitk::TrackingTool* tool)
{
mitk::NavigationTool::Pointer navTool = mitk::NavigationTool::New();
mitk::NDIPassiveTool::Pointer passiveTool = dynamic_cast<mitk::NDIPassiveTool*>(tool);
if(passiveTool.IsNull())
throw std::runtime_error("Could not cast TrackingTool to PassiveTool");
int currSelectedToolID = m_Controls->m_ToolSelectionComboBox->currentIndex();
QString sromFileName = m_Controls->m_ToolTable->item(currSelectedToolID, QmitkNDIToolDelegate::SROMCol)->text();
QString surfaceFileName = m_Controls->m_ToolTable->item(currSelectedToolID, QmitkNDIToolDelegate::RepCol)->text();
//calibration file (.srom) filename
QFile sromFile(sromFileName);
if(sromFile.exists())
navTool->SetCalibrationFile(sromFileName.toStdString());
//serial number
navTool->SetSerialNumber(passiveTool->GetSerialNumber());
// name and surface as dataNode
mitk::DataNode::Pointer node = mitk::DataNode::New();
mitk::Surface::Pointer toolSurface;
try{
toolSurface = this->LoadSurfaceFromSTLFile(surfaceFileName);
}
catch( ... )
{
QMessageBox::warning(NULL, "Loading Surface Error", QString("An error occured! Could not load surface from .stl file!\n\n"));
MBI_ERROR<<"Could not load .stl tool surface!";
}
if(toolSurface.IsNotNull())
{
node->SetData(toolSurface);
node->SetName(tool->GetToolName());
}
navTool->SetDataNode(node);
// type
mitk::NavigationTool::NavigationToolType type;
QString currentToolType = m_Controls->m_ToolTable->item(currSelectedToolID,QmitkNDIToolDelegate::TypeCol)->text();
if(currentToolType.compare("Instrument") == 0)
type = mitk::NavigationTool::Instrument;
else if(currentToolType.compare("Fiducial") == 0)
type = mitk::NavigationTool::Fiducial;
else if(currentToolType.compare("Skinmarker") == 0)
type = mitk::NavigationTool::Skinmarker;
else
type = mitk::NavigationTool::Unknown;
navTool->SetType(type);
return navTool;
}
mitk::Surface::Pointer QmitkNDIConfigurationWidget::LoadSurfaceFromSTLFile(QString surfaceFilename)
{
mitk::Surface::Pointer toolSurface;
QFile surfaceFile(surfaceFilename);
if(surfaceFile.exists())
{
try{
toolSurface = mitk::IOUtil::LoadSurface(surfaceFilename.toStdString().c_str());
}
catch(std::exception& e )
{
MBI_ERROR<<"Could not load surface for tool!";
MBI_ERROR<< e.what();
throw e;
}
}
return toolSurface;
}
void QmitkNDIConfigurationWidget::EnableAddToolsButton(bool enable) {
m_Controls->m_AddToolBtn->setEnabled(enable);
}
void QmitkNDIConfigurationWidget::EnableDiscoverNewToolsButton(bool enable) {
m_Controls->m_DiscoverToolsBtn->setEnabled(enable);
}
diff --git a/Modules/IGTUI/Qmitk/QmitkNPOptitrackWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNPOptitrackWidget.cpp
index 156ea72622..a594650739 100644
--- a/Modules/IGTUI/Qmitk/QmitkNPOptitrackWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNPOptitrackWidget.cpp
@@ -1,120 +1,122 @@
/*===================================================================
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 "QmitkNPOptitrackWidget.h"
#include "mitkOptitrackTrackingDevice.h"
#include "mitkNPOptitrackTrackingTypeInformation.h"
+#include "QmitkIGTCommonHelper.h"
#include <QFileDialog>
#include <QScrollBar>
#include <Poco/Path.h>
const std::string QmitkNPOptitrackWidget::VIEW_ID = "org.mitk.views.NPOptitrackWidget";
QmitkNPOptitrackWidget::QmitkNPOptitrackWidget(QWidget* parent, Qt::WindowFlags f)
: QmitkAbstractTrackingDeviceWidget(parent, f)
, m_Controls(nullptr)
{
}
void QmitkNPOptitrackWidget::Initialize()
{
InitializeSuperclassWidget();
CreateQtPartControl(this);
CreateConnections();
}
QmitkNPOptitrackWidget::~QmitkNPOptitrackWidget()
{
delete m_Controls;
}
void QmitkNPOptitrackWidget::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkNPOptitrackWidget;
m_Controls->setupUi(parent);
}
}
void QmitkNPOptitrackWidget::CreateConnections()
{
if (m_Controls)
{
connect((QObject*)(m_Controls->m_testConnectionOptitrack), SIGNAL(clicked()), this, SLOT(TestConnection()));
connect((QObject*)(m_Controls->m_SetOptitrackCalibrationFile), SIGNAL(clicked()), this, SLOT(SetOptitrackCalibrationFileClicked()));
}
}
void QmitkNPOptitrackWidget::ResetOutput()
{
m_Controls->m_outputTextOptitrack->setHtml("<body style=\" font-family:\'MS Shell Dlg 2\'; font-size:7pt; font-weight:400; font-style:normal;\" bgcolor=black><span style=\"color:#ffffff;\"><u>output:</u>");
}
void QmitkNPOptitrackWidget::AddOutput(std::string s)
{
m_Controls->m_outputTextOptitrack->setHtml(QString(s.c_str()));
m_Controls->m_outputTextOptitrack->verticalScrollBar()->setValue(m_Controls->m_outputTextOptitrack->verticalScrollBar()->maximum());
}
mitk::TrackingDevice::Pointer QmitkNPOptitrackWidget::ConstructTrackingDevice()
{
// Create the Tracking Device
mitk::OptitrackTrackingDevice::Pointer tempTrackingDevice = mitk::OptitrackTrackingDevice::New();
// Set the calibration File
tempTrackingDevice->SetCalibrationPath(m_OptitrackCalibrationFile);
//Set the camera parameters
tempTrackingDevice->SetExp(m_Controls->m_OptitrackExp->value());
tempTrackingDevice->SetLed(m_Controls->m_OptitrackLed->value());
tempTrackingDevice->SetThr(m_Controls->m_OptitrackThr->value());
tempTrackingDevice->SetType(mitk::NPOptitrackTrackingTypeInformation::GetTrackingDeviceName());
return static_cast<mitk::TrackingDevice::Pointer>(tempTrackingDevice);
}
bool QmitkNPOptitrackWidget::IsDeviceInstalled()
{
return mitk::OptitrackTrackingDevice::New()->IsDeviceInstalled();
}
void QmitkNPOptitrackWidget::SetOptitrackCalibrationFileClicked()
{
- std::string filename = QFileDialog::getOpenFileName(NULL, tr("Open Calibration File"), "/", "*.*").toLatin1().data();
+ std::string filename = QFileDialog::getOpenFileName(NULL, tr("Open Calibration File"), QmitkIGTCommonHelper::GetLastFileLoadPath(), "*.*").toLatin1().data();
if (filename == "") { return; }
else
{
+ QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(QString::fromStdString(filename));
m_OptitrackCalibrationFile = filename;
Poco::Path myPath = Poco::Path(m_OptitrackCalibrationFile.c_str());
m_Controls->m_OptitrackCalibrationFile->setText("Calibration File: " + QString(myPath.getFileName().c_str()));
}
}
QmitkNPOptitrackWidget* QmitkNPOptitrackWidget::Clone(QWidget* parent) const
{
QmitkNPOptitrackWidget* clonedWidget = new QmitkNPOptitrackWidget(parent);
clonedWidget->Initialize();
clonedWidget->m_OptitrackCalibrationFile = this->m_OptitrackCalibrationFile;
clonedWidget->m_Controls->m_OptitrackCalibrationFile->setText(m_Controls->m_OptitrackCalibrationFile->text());
clonedWidget->m_Controls->m_OptitrackExp->setValue(m_Controls->m_OptitrackExp->value());
clonedWidget->m_Controls->m_OptitrackLed->setValue(m_Controls->m_OptitrackLed->value());
clonedWidget->m_Controls->m_OptitrackThr->setValue(m_Controls->m_OptitrackThr->value());
return clonedWidget;
}
diff --git a/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp
index ced1b89512..b2e6943286 100644
--- a/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp
@@ -1,336 +1,340 @@
/*===================================================================
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 "QmitkNavigationToolCreationWidget.h"
//mitk headers
#include <mitkTrackingTypes.h>
#include <mitkSurface.h>
#include <mitkNavigationData.h>
#include <mitkRenderingManager.h>
#include "mitkTrackingDeviceTypeCollection.h"
//qt headers
#include <qfiledialog.h>
#include <qmessagebox.h>
#include <QDialog>
#include <mitkIOUtil.h>
+#include <QmitkIGTCommonHelper.h>
//poco headers
#include <Poco/Path.h>
// vtk
#include <vtkSphereSource.h>
#include <vtkConeSource.h>
const std::string QmitkNavigationToolCreationWidget::VIEW_ID = "org.mitk.views.navigationtoolcreationwizardwidget";
QmitkNavigationToolCreationWidget::QmitkNavigationToolCreationWidget(QWidget* parent, Qt::WindowFlags f)
: QWidget(parent, f)
{
m_Controls = NULL;
m_AdvancedWidget = new QmitkNavigationToolCreationAdvancedWidget(this);
m_AdvancedWidget->setWindowFlags(Qt::Tool | Qt::WindowStaysOnTopHint);
m_AdvancedWidget->setWindowTitle("Tool Creation Advanced Options");
m_AdvancedWidget->setModal(false);
CreateQtPartControl(this);
CreateConnections();
RefreshTrackingDeviceCollection();
}
QmitkNavigationToolCreationWidget::~QmitkNavigationToolCreationWidget()
{
m_Controls->m_CalibrationLandmarksList->SetPointSetNode(NULL);
m_Controls->m_RegistrationLandmarksList->SetPointSetNode(NULL);
delete m_AdvancedWidget;
}
void QmitkNavigationToolCreationWidget::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkNavigationToolCreationWidgetControls;
m_Controls->setupUi(parent);
}
}
void QmitkNavigationToolCreationWidget::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_Controls->m_cancel), SIGNAL(clicked()), this, SLOT(OnCancel()) );
connect( (QObject*)(m_Controls->m_finished), SIGNAL(clicked()), this, SLOT(OnFinished()) );
connect( (QObject*)(m_Controls->m_LoadSurface), SIGNAL(clicked()), this, SLOT(OnLoadSurface()) );
connect( (QObject*)(m_Controls->m_LoadCalibrationFile), SIGNAL(clicked()), this, SLOT(OnLoadCalibrationFile()) );
connect( (QObject*)(m_Controls->m_ShowAdvancedOptionsPB), SIGNAL(toggled(bool)), this, SLOT(OnShowAdvancedOptions(bool)) );
connect( (QObject*)(m_AdvancedWidget), SIGNAL(DialogCloseRequested()), this, SLOT(OnProcessDialogCloseRequest()) );
connect( (QObject*)(m_AdvancedWidget), SIGNAL(RetrieveDataForManualToolTipManipulation()), this, SLOT(OnRetrieveDataForManualTooltipManipulation()) );
connect( m_Controls->m_Surface_Use_Other, SIGNAL(toggled(bool)), this, SLOT(OnSurfaceUseOtherToggled(bool)));
}
}
void QmitkNavigationToolCreationWidget::Initialize(mitk::DataStorage* dataStorage, const std::string& supposedIdentifier, const std::string& supposedName)
{
m_DataStorage = dataStorage;
//initialize UI components
m_Controls->m_SurfaceChooser->SetDataStorage(m_DataStorage);
m_Controls->m_SurfaceChooser->SetAutoSelectNewItems(true);
m_Controls->m_SurfaceChooser->SetPredicate(mitk::NodePredicateDataType::New("Surface"));
//set default data
m_Controls->m_ToolNameEdit->setText(supposedName.c_str());
m_Controls->m_CalibrationFileName->setText("none");
m_Controls->m_Surface_Use_Sphere->setChecked(true);
m_AdvancedWidget->SetDataStorage(m_DataStorage);
m_Controls->m_IdentifierEdit->setText(supposedIdentifier.c_str());
this->InitializeUIToolLandmarkLists();
m_Controls->m_CalibrationLandmarksList->EnableEditButton(false);
m_Controls->m_RegistrationLandmarksList->EnableEditButton(false);
}
void QmitkNavigationToolCreationWidget::SetTrackingDeviceType(mitk::TrackingDeviceType type, bool changeable)
{
int index = m_Controls->m_TrackingDeviceTypeChooser->findText(QString::fromStdString(type));
if (index >= 0)
{
m_Controls->m_TrackingDeviceTypeChooser->setCurrentIndex(index);
}
}
mitk::NavigationTool::Pointer QmitkNavigationToolCreationWidget::GetCreatedTool()
{
return m_CreatedTool;
}
//##################################################################################
//############################## slots ############################
//##################################################################################
void QmitkNavigationToolCreationWidget::OnFinished()
{
//here we create a new tool
m_CreatedTool = mitk::NavigationTool::New();
//create DataNode...
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
if(m_Controls->m_Surface_Use_Sphere->isChecked())
{
//create small sphere and use it as surface
mitk::Surface::Pointer mySphere = 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();
mySphere->SetVtkPolyData(vtkData->GetOutput());
vtkData->Delete();
newNode->SetData(mySphere);
}
else
{
newNode->SetData(m_Controls->m_SurfaceChooser->GetSelectedNode()->GetData());
}
newNode->SetName(m_Controls->m_ToolNameEdit->text().toLatin1());
m_CreatedTool->SetDataNode(newNode);
//fill NavigationTool object
m_CreatedTool->SetCalibrationFile(m_Controls->m_CalibrationFileName->text().toLatin1().data());
m_CreatedTool->SetIdentifier(m_Controls->m_IdentifierEdit->text().toLatin1().data());
m_CreatedTool->SetSerialNumber(m_Controls->m_SerialNumberEdit->text().toLatin1().data());
//Tracking Device
m_CreatedTool->SetTrackingDeviceType(m_Controls->m_TrackingDeviceTypeChooser->currentText().toStdString());
//ToolType
if (m_Controls->m_ToolTypeChooser->currentText()=="Instrument") m_CreatedTool->SetType(mitk::NavigationTool::Instrument);
else if (m_Controls->m_ToolTypeChooser->currentText()=="Fiducial") m_CreatedTool->SetType(mitk::NavigationTool::Fiducial);
else if (m_Controls->m_ToolTypeChooser->currentText()=="Skinmarker") m_CreatedTool->SetType(mitk::NavigationTool::Skinmarker);
else m_CreatedTool->SetType(mitk::NavigationTool::Unknown);
//Tool Tip
mitk::NavigationData::Pointer tempND = mitk::NavigationData::New(m_AdvancedWidget->GetManipulatedToolTip());
m_CreatedTool->SetToolTipOrientation(tempND->GetOrientation());
m_CreatedTool->SetToolTipPosition(tempND->GetPosition());
//Tool Landmarks
mitk::PointSet::Pointer toolCalLandmarks, toolRegLandmarks;
GetUIToolLandmarksLists(toolCalLandmarks,toolRegLandmarks);
m_CreatedTool->SetToolCalibrationLandmarks(toolCalLandmarks);
m_CreatedTool->SetToolRegistrationLandmarks(toolRegLandmarks);
emit NavigationToolFinished();
}
void QmitkNavigationToolCreationWidget::OnCancel()
{
m_CreatedTool = NULL;
emit Canceled();
}
void QmitkNavigationToolCreationWidget::OnLoadSurface()
{
- std::string filename = QFileDialog::getOpenFileName(NULL,tr("Open Surface"), "/", tr("STL (*.stl)")).toLatin1().data();
+ std::string filename = QFileDialog::getOpenFileName(NULL,tr("Open Surface"), QmitkIGTCommonHelper::GetLastFileLoadPath(), tr("STL (*.stl)")).toLatin1().data();
+ QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(QString::fromStdString(filename));
try
{
mitk::IOUtil::Load(filename.c_str(), *m_DataStorage);
}
catch (mitk::Exception &e)
{
MITK_ERROR << "Exception occured: " << e.what();
}
}
void QmitkNavigationToolCreationWidget::OnLoadCalibrationFile()
{
- m_Controls->m_CalibrationFileName->setText(QFileDialog::getOpenFileName(NULL,tr("Open Calibration File"), "/", "*.*"));
+ QString fileName = QFileDialog::getOpenFileName(NULL,tr("Open Calibration File"), QmitkIGTCommonHelper::GetLastFileLoadPath(), "*.*");
+ QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(fileName);
+ m_Controls->m_CalibrationFileName->setText(fileName);
}
void QmitkNavigationToolCreationWidget::SetDefaultData(mitk::NavigationTool::Pointer DefaultTool)
{
m_Controls->m_ToolNameEdit->setText(QString(DefaultTool->GetDataNode()->GetName().c_str()));
m_Controls->m_IdentifierEdit->setText(QString(DefaultTool->GetIdentifier().c_str()));
m_Controls->m_SerialNumberEdit->setText(QString(DefaultTool->GetSerialNumber().c_str()));
m_AdvancedWidget->SetDefaultTooltip( DefaultTool->GetToolTipTransform() );
int index = m_Controls->m_TrackingDeviceTypeChooser->findText(QString::fromStdString(DefaultTool->GetTrackingDeviceType()));
if (index >= 0)
{
m_Controls->m_TrackingDeviceTypeChooser->setCurrentIndex(index);
}
m_Controls->m_CalibrationFileName->setText(QString(DefaultTool->GetCalibrationFile().c_str()));
m_Controls->m_Surface_Use_Other->setChecked(true);
switch(DefaultTool->GetType())
{
case mitk::NavigationTool::Instrument:
m_Controls->m_ToolTypeChooser->setCurrentIndex(0); break;
case mitk::NavigationTool::Fiducial:
m_Controls->m_ToolTypeChooser->setCurrentIndex(1); break;
case mitk::NavigationTool::Skinmarker:
m_Controls->m_ToolTypeChooser->setCurrentIndex(2); break;
case mitk::NavigationTool::Unknown:
m_Controls->m_ToolTypeChooser->setCurrentIndex(3); break;
}
m_Controls->m_SurfaceChooser->SetSelectedNode(DefaultTool->GetDataNode());
FillUIToolLandmarkLists(DefaultTool->GetToolCalibrationLandmarks(),DefaultTool->GetToolRegistrationLandmarks());
}
//##################################################################################
//############################## internal help methods #############################
//##################################################################################
void QmitkNavigationToolCreationWidget::MessageBox(std::string s)
{
QMessageBox msgBox;
msgBox.setText(s.c_str());
msgBox.exec();
}
void QmitkNavigationToolCreationWidget::OnShowAdvancedOptions(bool state)
{
if(state)
{
m_AdvancedWidget->show();
m_AdvancedWidget->SetDefaultTooltip(m_AdvancedWidget->GetManipulatedToolTip()); //use the last one, if there is one
m_AdvancedWidget->ReInitialize();
// reinit the views with the new nodes
mitk::DataStorage::SetOfObjects::ConstPointer rs = m_DataStorage->GetAll();
mitk::TimeGeometry::Pointer bounds = m_DataStorage->ComputeBoundingGeometry3D(rs, "visible"); // initialize the views to the bounding geometry
mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
}
else
{
m_AdvancedWidget->hide();
}
}
void QmitkNavigationToolCreationWidget::OnProcessDialogCloseRequest()
{
m_AdvancedWidget->hide();
m_Controls->m_ShowAdvancedOptionsPB->setChecked(false);
}
void QmitkNavigationToolCreationWidget::OnRetrieveDataForManualTooltipManipulation()
{
if(m_Controls->m_Surface_Use_Sphere->isChecked())
{
m_AdvancedWidget->SetToolTipSurface(true);
}
else
{
m_AdvancedWidget->SetToolTipSurface(false,
dynamic_cast<mitk::DataNode*>(m_Controls->m_SurfaceChooser->GetSelectedNode().GetPointer()));
}
}
void QmitkNavigationToolCreationWidget::OnSurfaceUseOtherToggled(bool checked)
{
m_Controls->m_LoadSurface->setEnabled(checked);
}
void QmitkNavigationToolCreationWidget::FillUIToolLandmarkLists(mitk::PointSet::Pointer calLandmarks, mitk::PointSet::Pointer regLandmarks)
{
m_calLandmarkNode->SetData(calLandmarks);
m_regLandmarkNode->SetData(regLandmarks);
m_Controls->m_CalibrationLandmarksList->SetPointSetNode(m_calLandmarkNode);
m_Controls->m_RegistrationLandmarksList->SetPointSetNode(m_regLandmarkNode);
}
void QmitkNavigationToolCreationWidget::GetUIToolLandmarksLists(mitk::PointSet::Pointer& calLandmarks, mitk::PointSet::Pointer& regLandmarks)
{
calLandmarks = dynamic_cast<mitk::PointSet*>(m_calLandmarkNode->GetData());
regLandmarks = dynamic_cast<mitk::PointSet*>(m_regLandmarkNode->GetData());
}
void QmitkNavigationToolCreationWidget::InitializeUIToolLandmarkLists()
{
m_calLandmarkNode = mitk::DataNode::New();
m_regLandmarkNode = mitk::DataNode::New();
FillUIToolLandmarkLists(mitk::PointSet::New(),mitk::PointSet::New());
}
void QmitkNavigationToolCreationWidget::RefreshTrackingDeviceCollection()
{
us::ModuleContext* context = us::GetModuleContext();
std::vector<us::ServiceReference<mitk::TrackingDeviceTypeCollection> > refs = context->GetServiceReferences<mitk::TrackingDeviceTypeCollection>();
if (refs.empty())
{
MITK_WARN << "No tracking device service found!";
return;
}
mitk::TrackingDeviceTypeCollection* _DeviceTypeCollection = context->GetService<mitk::TrackingDeviceTypeCollection>(refs.front());
for (auto name : _DeviceTypeCollection->GetTrackingDeviceTypeNames())
{
//if the device is not included yet, add name to comboBox and widget to stackedWidget
if (m_Controls->m_TrackingDeviceTypeChooser->findText(QString::fromStdString(name)) == -1)
{
m_Controls->m_TrackingDeviceTypeChooser->addItem(QString::fromStdString(name));
}
}
}
diff --git a/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.cpp
index a0e0f9d703..d8a7bd19c8 100644
--- a/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.cpp
@@ -1,396 +1,418 @@
/*===================================================================
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 "QmitkNavigationToolManagementWidget.h"
//mitk headers
#include "mitkTrackingTypes.h"
#include <mitkSurface.h>
#include <mitkNavigationToolReader.h>
#include <mitkNavigationToolWriter.h>
#include <mitkNavigationToolStorage.h>
#include <mitkNavigationToolStorageDeserializer.h>
#include <mitkNavigationToolStorageSerializer.h>
+#include <QmitkIGTCommonHelper.h>
//qt headers
#include <qfiledialog.h>
#include <qinputdialog.h>
#include <qmessagebox.h>
+#include <qsettings.h>
//poco headers
#include <Poco/Path.h>
const std::string QmitkNavigationToolManagementWidget::VIEW_ID = "org.mitk.views.navigationtoolmanagementwidget";
QmitkNavigationToolManagementWidget::QmitkNavigationToolManagementWidget(QWidget* parent, Qt::WindowFlags f)
: QWidget(parent, f)
{
m_Controls = NULL;
CreateQtPartControl(this);
CreateConnections();
}
QmitkNavigationToolManagementWidget::~QmitkNavigationToolManagementWidget()
{
}
void QmitkNavigationToolManagementWidget::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkNavigationToolManagementWidgetControls;
m_Controls->setupUi(parent);
}
//Disable StorageControls in the beginning, because there is no storage to edit
DisableStorageControls();
}
void QmitkNavigationToolManagementWidget::OnLoadTool()
{
if (m_NavigationToolStorage->isLocked())
{
MessageBox("Storage is locked, cannot modify it. Maybe the tracking device which uses this storage is connected. If you want to modify the storage please disconnect the device first.");
return;
}
mitk::NavigationToolReader::Pointer myReader = mitk::NavigationToolReader::New();
- std::string filename = QFileDialog::getOpenFileName(NULL, tr("Add Navigation Tool"), "/", "*.IGTTool").toLatin1().data();
+ std::string filename = QFileDialog::getOpenFileName(NULL,tr("Add Navigation Tool"), QmitkIGTCommonHelper::GetLastFileLoadPath(), "*.IGTTool").toLatin1().data();
+ QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(QString::fromStdString(filename));
if (filename == "") return;
mitk::NavigationTool::Pointer readTool = myReader->DoRead(filename);
if (readTool.IsNull()) MessageBox("Error: " + myReader->GetErrorMessage());
else
{
if (!m_NavigationToolStorage->AddTool(readTool))
{
MessageBox("Error: Can't add tool!");
m_DataStorage->Remove(readTool->GetDataNode());
}
UpdateToolTable();
m_NavigationToolStorage->UpdateMicroservice();
}
}
void QmitkNavigationToolManagementWidget::OnSaveTool()
{
//if no item is selected, show error message:
if (m_Controls->m_ToolList->currentItem() == NULL) { MessageBox("Error: Please select tool first!"); return; }
- mitk::NavigationToolWriter::Pointer myWriter = mitk::NavigationToolWriter::New();
- std::string filename = QFileDialog::getSaveFileName(NULL, tr("Save Navigation Tool"), "/", "*.IGTTool").toLatin1().data();
- filename.append(".IGTTool");
- if (filename == "") return;
- if (!myWriter->DoWrite(filename, m_NavigationToolStorage->GetTool(m_Controls->m_ToolList->currentIndex().row())))
- MessageBox("Error: " + myWriter->GetErrorMessage());
+ mitk::NavigationToolWriter::Pointer myWriter = mitk::NavigationToolWriter::New();
+ std::string filename = QFileDialog::getSaveFileName(NULL,tr("Save Navigation Tool"), QmitkIGTCommonHelper::GetLastFileSavePath(), "*.IGTTool").toLatin1().data();
+ QmitkIGTCommonHelper::SetLastFileSavePathByFileName(QString::fromStdString(filename));
+ filename.append(".IGTTool");
+ if (filename == "") return;
+ if (!myWriter->DoWrite(filename,m_NavigationToolStorage->GetTool(m_Controls->m_ToolList->currentIndex().row())))
+ MessageBox("Error: "+ myWriter->GetErrorMessage());
}
void QmitkNavigationToolManagementWidget::CreateConnections()
{
if (m_Controls)
{
//main widget page:
connect((QObject*)(m_Controls->m_AddTool), SIGNAL(clicked()), this, SLOT(OnAddTool()));
connect((QObject*)(m_Controls->m_DeleteTool), SIGNAL(clicked()), this, SLOT(OnDeleteTool()));
connect((QObject*)(m_Controls->m_EditTool), SIGNAL(clicked()), this, SLOT(OnEditTool()));
connect((QObject*)(m_Controls->m_MoveToolUp), SIGNAL(clicked()), this, SLOT(OnMoveToolUp()));
connect((QObject*)(m_Controls->m_MoveToolDown), SIGNAL(clicked()), this, SLOT(OnMoveToolDown()));
connect((QObject*)(m_Controls->m_LoadStorage), SIGNAL(clicked()), this, SLOT(OnLoadStorage()));
connect((QObject*)(m_Controls->m_SaveStorage), SIGNAL(clicked()), this, SLOT(OnSaveStorage()));
connect((QObject*)(m_Controls->m_LoadTool), SIGNAL(clicked()), this, SLOT(OnLoadTool()));
connect((QObject*)(m_Controls->m_SaveTool), SIGNAL(clicked()), this, SLOT(OnSaveTool()));
connect((QObject*)(m_Controls->m_CreateNewStorage), SIGNAL(clicked()), this, SLOT(OnCreateStorage()));
//widget page "add tool":
connect((QObject*)(m_Controls->m_ToolCreationWidget), SIGNAL(Canceled()), this, SLOT(OnAddToolCancel()));
connect((QObject*)(m_Controls->m_ToolCreationWidget), SIGNAL(NavigationToolFinished()), this, SLOT(OnAddToolSave()));
}
}
void QmitkNavigationToolManagementWidget::Initialize(mitk::DataStorage* dataStorage)
{
m_DataStorage = dataStorage;
m_Controls->m_ToolCreationWidget->Initialize(m_DataStorage, "Tool0");
}
void QmitkNavigationToolManagementWidget::LoadStorage(mitk::NavigationToolStorage::Pointer storageToLoad)
{
if (storageToLoad.IsNotNull())
{
m_NavigationToolStorage = storageToLoad;
m_Controls->m_StorageName->setText(m_NavigationToolStorage->GetName().c_str());
EnableStorageControls();
}
else
{
m_NavigationToolStorage = NULL;
DisableStorageControls();
}
UpdateToolTable();
m_NavigationToolStorage->UpdateMicroservice();
}
//##################################################################################
//############################## slots: main widget ################################
//##################################################################################
void QmitkNavigationToolManagementWidget::OnMoveToolUp()
{
if (m_NavigationToolStorage.IsNotNull())
{
int toolIndex = m_Controls->m_ToolList->currentIndex().row();
if (toolIndex >= 0)
{
mitk::NavigationTool::Pointer currentNavigationTool = m_NavigationToolStorage->GetTool(toolIndex);
if (currentNavigationTool.IsNotNull())
{
std::string currentIdentifier = currentNavigationTool->GetIdentifier();
int NewNumber = m_Controls->m_ToolList->currentIndex().row() - 1;
if (NewNumber < 0) { MITK_WARN << "Cannot move tool up because it is on the top!"; }
else { m_NavigationToolStorage->AssignToolNumber(currentIdentifier, NewNumber); }
UpdateToolTable();
m_NavigationToolStorage->UpdateMicroservice();
}
}
}
}
void QmitkNavigationToolManagementWidget::OnMoveToolDown()
{
if (m_NavigationToolStorage.IsNotNull())
{
int toolIndex = m_Controls->m_ToolList->currentIndex().row();
if (toolIndex >= 0)
{
mitk::NavigationTool::Pointer currentNavigationTool = m_NavigationToolStorage->GetTool(toolIndex);
if (currentNavigationTool.IsNotNull())
{
std::string currentIdentifier = currentNavigationTool->GetIdentifier();
int NewNumber = m_Controls->m_ToolList->currentIndex().row() + 1;
if (NewNumber >= m_NavigationToolStorage->GetToolCount()) { MITK_WARN << "Cannot move tool down because it is the last tool in this storage!"; }
else { m_NavigationToolStorage->AssignToolNumber(currentIdentifier, NewNumber); }
UpdateToolTable();
m_NavigationToolStorage->UpdateMicroservice();
}
}
}
}
void QmitkNavigationToolManagementWidget::OnAddTool()
{
if (m_NavigationToolStorage->isLocked())
{
MessageBox("Storage is locked, cannot modify it. Maybe the tracking device which uses this storage is connected. If you want to modify the storage please disconnect the device first.");
return;
}
QString defaultIdentifier = "NavigationTool#" + QString::number(m_NavigationToolStorage->GetToolCount());
QString defaultName = "NavigationTool" + QString::number(m_NavigationToolStorage->GetToolCount());
m_Controls->m_ToolCreationWidget->Initialize(m_DataStorage, defaultIdentifier.toStdString(), defaultName.toStdString());
m_edit = false;
m_Controls->m_MainWidgets->setCurrentIndex(1);
m_NavigationToolStorage->UpdateMicroservice();
}
void QmitkNavigationToolManagementWidget::OnDeleteTool()
{
//first: some checks
if (m_NavigationToolStorage->isLocked())
{
MessageBox("Storage is locked, cannot modify it. Maybe the tracking device which uses this storage is connected. If you want to modify the storage please disconnect the device first.");
return;
}
else if (m_Controls->m_ToolList->currentItem() == NULL) //if no item is selected, show error message:
{
MessageBox("Error: Please select tool first!");
return;
}
m_DataStorage->Remove(m_NavigationToolStorage->GetTool(m_Controls->m_ToolList->currentIndex().row())->GetDataNode());
m_NavigationToolStorage->DeleteTool(m_Controls->m_ToolList->currentIndex().row());
UpdateToolTable();
m_NavigationToolStorage->UpdateMicroservice();
}
void QmitkNavigationToolManagementWidget::OnEditTool()
{
if (m_NavigationToolStorage->isLocked())
{
MessageBox("Storage is locked, cannot modify it. Maybe the tracking device which uses this storage is connected. If you want to modify the storage please disconnect the device first.");
return;
}
else if (m_Controls->m_ToolList->currentItem() == NULL) //if no item is selected, show error message:
{
MessageBox("Error: Please select tool first!");
return;
}
mitk::NavigationTool::Pointer selectedTool = m_NavigationToolStorage->GetTool(m_Controls->m_ToolList->currentIndex().row());
m_Controls->m_ToolCreationWidget->SetDefaultData(selectedTool);
m_NavigationToolStorage->SetName("test");
m_edit = true;
m_Controls->m_MainWidgets->setCurrentIndex(1);
m_NavigationToolStorage->UpdateMicroservice();
}
void QmitkNavigationToolManagementWidget::OnCreateStorage()
{
QString storageName = QInputDialog::getText(NULL, "Storage Name", "Name of the new tool storage:");
if (storageName.isNull()) return;
m_NavigationToolStorage = mitk::NavigationToolStorage::New(this->m_DataStorage);
m_NavigationToolStorage->SetName(storageName.toStdString());
m_Controls->m_StorageName->setText(m_NavigationToolStorage->GetName().c_str());
EnableStorageControls();
emit NewStorageAdded(m_NavigationToolStorage, storageName.toStdString());
}
void QmitkNavigationToolManagementWidget::OnLoadStorage()
{
mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(m_DataStorage);
std::string filename = QFileDialog::getOpenFileName(NULL, tr("Open Navigation Tool Storage"), "/", tr("IGT Tool Storage (*.IGTToolStorage)")).toStdString();
if (filename == "") return;
try
{
- mitk::NavigationToolStorage::Pointer tempStorage = myDeserializer->Deserialize(filename);
+ mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(m_DataStorage);
+ std::string filename = QFileDialog::getOpenFileName(NULL, tr("Open Navigation Tool Storage"), QmitkIGTCommonHelper::GetLastFileLoadPath(), tr("IGT Tool Storage (*.IGTToolStorage)")).toStdString();
+ if (filename == "") return;
+
+ QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(QString::fromStdString(filename));
- if (tempStorage.IsNull()) MessageBox("Error" + myDeserializer->GetErrorMessage());
- else
+ try
+ {
+ mitk::NavigationToolStorage::Pointer tempStorage = myDeserializer->Deserialize(filename);
+
+ if (tempStorage.IsNull()) MessageBox("Error" + myDeserializer->GetErrorMessage());
+ else
+ {
+ Poco::Path myPath = Poco::Path(filename.c_str());
+ tempStorage->SetName(myPath.getFileName()); //set the filename as name for the storage, so the user can identify it
+ this->LoadStorage(tempStorage);
+ emit NewStorageAdded(m_NavigationToolStorage,myPath.getFileName());
+ m_NavigationToolStorage->UpdateMicroservice();
+ }
+ }
+ catch (const mitk::Exception& exception)
{
- Poco::Path myPath = Poco::Path(filename.c_str());
- tempStorage->SetName(myPath.getFileName()); //set the filename as name for the storage, so the user can identify it
- this->LoadStorage(tempStorage);
- emit NewStorageAdded(m_NavigationToolStorage, myPath.getFileName());
+ MessageBox(exception.GetDescription());
}
}
catch (const mitk::Exception& exception)
{
MessageBox(exception.GetDescription());
}
m_NavigationToolStorage->UpdateMicroservice();
}
void QmitkNavigationToolManagementWidget::OnSaveStorage()
-{
- //read in filename
- QString filename = QFileDialog::getSaveFileName(NULL, tr("Save Navigation Tool Storage"), "/", tr("IGT Tool Storage (*.IGTToolStorage)"));
- if (filename.isEmpty()) return; //canceled by the user
+ {
+ QFileDialog *fileDialog = new QFileDialog;
+ fileDialog->setDefaultSuffix("IGTToolStorage");
+ QString suffix = "IGT Tool Storage (*.IGTToolStorage)";
+ QString filename = fileDialog->getSaveFileName(NULL, tr("Save Navigation Tool Storage"), QmitkIGTCommonHelper::GetLastFileSavePath(), suffix, &suffix);
- // add file extension if it wasn't added by the file dialog
- if (filename.right(15) != ".IGTToolStorage") { filename += ".IGTToolStorage"; }
+ if (filename.isEmpty()) return; //canceled by the user
+ // check file suffix
+ QFileInfo file(filename);
+ if(file.suffix().isEmpty()) filename += ".IGTToolStorage";
//serialize tool storage
mitk::NavigationToolStorageSerializer::Pointer mySerializer = mitk::NavigationToolStorageSerializer::New();
if (!mySerializer->Serialize(filename.toStdString(), m_NavigationToolStorage))
{
MessageBox("Error: " + mySerializer->GetErrorMessage());
return;
+ QmitkIGTCommonHelper::SetLastFileSavePath(file.absolutePath());
}
Poco::Path myPath = Poco::Path(filename.toStdString());
m_Controls->m_StorageName->setText(QString::fromStdString(myPath.getFileName()));
}
//##################################################################################
//############################## slots: add tool widget ############################
//##################################################################################
void QmitkNavigationToolManagementWidget::OnAddToolSave()
{
mitk::NavigationTool::Pointer newTool = m_Controls->m_ToolCreationWidget->GetCreatedTool();
if (m_edit) //here we edit a existing tool
{
mitk::NavigationTool::Pointer editedTool = m_NavigationToolStorage->GetTool(m_Controls->m_ToolList->currentIndex().row());
editedTool->Graft(newTool);
}
else //here we create a new tool
{
m_NavigationToolStorage->AddTool(newTool);
}
UpdateToolTable();
m_Controls->m_MainWidgets->setCurrentIndex(0);
m_NavigationToolStorage->UpdateMicroservice();
}
void QmitkNavigationToolManagementWidget::OnAddToolCancel()
{
m_Controls->m_MainWidgets->setCurrentIndex(0);
}
//##################################################################################
//############################## private help methods ##############################
//##################################################################################
void QmitkNavigationToolManagementWidget::UpdateToolTable()
{
m_Controls->m_ToolList->clear();
if (m_NavigationToolStorage.IsNull()) return;
for (int i = 0; i < m_NavigationToolStorage->GetToolCount(); i++)
{
QString currentTool = "Tool" + QString::number(i) + ": " + QString(m_NavigationToolStorage->GetTool(i)->GetDataNode()->GetName().c_str()) + " ";
currentTool += "(" + QString::fromStdString(m_NavigationToolStorage->GetTool(i)->GetTrackingDeviceType()) + "/";
switch (m_NavigationToolStorage->GetTool(i)->GetType())
{
case mitk::NavigationTool::Instrument:
currentTool += "Instrument)"; break;
case mitk::NavigationTool::Fiducial:
currentTool += "Fiducial)"; break;
case mitk::NavigationTool::Skinmarker:
currentTool += "Skinmarker)"; break;
default:
currentTool += "Unknown)";
}
m_Controls->m_ToolList->addItem(currentTool);
}
}
void QmitkNavigationToolManagementWidget::MessageBox(std::string s)
{
QMessageBox msgBox;
msgBox.setText(s.c_str());
msgBox.exec();
}
void QmitkNavigationToolManagementWidget::DisableStorageControls()
{
m_Controls->m_StorageName->setText("<none>");
m_Controls->m_AddTool->setEnabled(false);
m_Controls->m_LoadTool->setEnabled(false);
m_Controls->m_MoveToolUp->setEnabled(false);
m_Controls->m_MoveToolDown->setEnabled(false);
m_Controls->m_selectedLabel->setEnabled(false);
m_Controls->m_DeleteTool->setEnabled(false);
m_Controls->m_EditTool->setEnabled(false);
m_Controls->m_SaveTool->setEnabled(false);
m_Controls->m_ToolList->setEnabled(false);
m_Controls->m_SaveStorage->setEnabled(false);
m_Controls->m_ToolLabel->setEnabled(false);
}
void QmitkNavigationToolManagementWidget::EnableStorageControls()
{
m_Controls->m_AddTool->setEnabled(true);
m_Controls->m_LoadTool->setEnabled(true);
m_Controls->m_MoveToolUp->setEnabled(true);
m_Controls->m_MoveToolDown->setEnabled(true);
m_Controls->m_selectedLabel->setEnabled(true);
m_Controls->m_DeleteTool->setEnabled(true);
m_Controls->m_EditTool->setEnabled(true);
m_Controls->m_SaveTool->setEnabled(true);
m_Controls->m_ToolList->setEnabled(true);
m_Controls->m_SaveStorage->setEnabled(true);
m_Controls->m_ToolLabel->setEnabled(true);
}
\ No newline at end of file
diff --git a/Modules/IGTUI/files.cmake b/Modules/IGTUI/files.cmake
index 9678e39cb4..df2e5e6088 100644
--- a/Modules/IGTUI/files.cmake
+++ b/Modules/IGTUI/files.cmake
@@ -1,114 +1,116 @@
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
+ Qmitk/QmitkIGTCommonHelper.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
+ Qmitk/QmitkIGTCommonHelper.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
)