diff --git a/Modules/IGT/TrackingDevices/mitkPolhemusTrackingDevice.cpp b/Modules/IGT/TrackingDevices/mitkPolhemusTrackingDevice.cpp
index 95ceb41457..c05d70f7dd 100644
--- a/Modules/IGT/TrackingDevices/mitkPolhemusTrackingDevice.cpp
+++ b/Modules/IGT/TrackingDevices/mitkPolhemusTrackingDevice.cpp
@@ -1,332 +1,332 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "mitkPolhemusTrackingDevice.h"
#include "mitkPolhemusTool.h"
#include "mitkIGTConfig.h"
#include "mitkIGTTimeStamp.h"
#include "mitkIGTHardwareException.h"
#include <itksys/SystemTools.hxx>
#include <iostream>
#include <itkMutexLockHolder.h>
#include "mitkPolhemusTrackerTypeInformation.h"
#include <vtkConeSource.h>
typedef itk::MutexLockHolder<itk::FastMutexLock> MutexLockHolder;
mitk::PolhemusTrackingDevice::PolhemusTrackingDevice() : mitk::TrackingDevice()
{
//set the type of this tracking device
this->m_Data = mitk::PolhemusTrackerTypeInformation::GetDeviceDataPolhemusTrackerLiberty();
this->m_MultiThreader = itk::MultiThreader::New();
m_ThreadID = 0;
m_Device = mitk::PolhemusInterface::New();
}
mitk::PolhemusTrackingDevice::~PolhemusTrackingDevice()
{
}
bool mitk::PolhemusTrackingDevice::IsDeviceInstalled()
{
return true;
}
mitk::TrackingTool* mitk::PolhemusTrackingDevice::AddTool(const char* toolName, int toolPort)
{
//Only add tool if port isn't already used.
for (auto _tool : m_AllTools)
{
if (_tool->GetToolPort() == toolPort)
{
MITK_DEBUG << "There is already a tool connected to this port. Returning existing tool";
return _tool;
}
}
mitk::PolhemusTool::Pointer t = mitk::PolhemusTool::New();
t->SetToolName(toolName);
t->SetToolPort(toolPort);
if (this->InternalAddTool(t) == false)
return nullptr;
return t.GetPointer();
}
bool mitk::PolhemusTrackingDevice::InternalAddTool(PolhemusTool::Pointer tool)
{
m_AllTools.push_back(tool);
return true;
}
bool mitk::PolhemusTrackingDevice::StartTracking()
{
bool success = m_Device->StartTracking();
if (success)
{
mitk::IGTTimeStamp::GetInstance()->Start(this);
this->SetState(Tracking);
this->m_StopTrackingMutex->Lock();
this->m_StopTracking = false;
this->m_StopTrackingMutex->Unlock();
m_ThreadID = m_MultiThreader->SpawnThread(this->ThreadStartTracking, this); // start a new thread that executes the TrackTools() method
return true;
}
else
{
this->SetState(Ready);
mitkThrowException(mitk::IGTHardwareException) << "Error while trying to start the device!";
}
return success;
}
bool mitk::PolhemusTrackingDevice::StopTracking()
{
m_Device->StopTracking();
return Superclass::StopTracking();
}
unsigned int mitk::PolhemusTrackingDevice::GetToolCount() const
{
return (unsigned int)this->m_AllTools.size();
}
mitk::TrackingTool* mitk::PolhemusTrackingDevice::GetTool(unsigned int toolNumber) const
{
if (toolNumber >= this->GetToolCount())
return nullptr;
else
return this->m_AllTools[toolNumber];
}
bool mitk::PolhemusTrackingDevice::OpenConnection()
{
//reset everything
if (m_Device.IsNull()) { m_Device = mitk::PolhemusInterface::New(); }
if (!m_Device->Connect()) //Connect the device, if it fails, throw an error.
{
MITK_ERROR << "Cannot connect Polhemus device!";
CloseConnection();
return false;
}
//Ready must be set here, 'cause if tools don't match we need to be able to disconnect.
this->SetState(Ready);
//check if connected ports of Polhemus matches the tools in the toolStorage.
std::vector<int> toolPorts = m_Device->GetToolPorts();
//first, check size.
if (this->GetToolCount() != toolPorts.size())
{
MITK_ERROR << "Cannot connect device, number of tools in toolstorage doesn't match the number of tools connected to Polhemus device!";
CloseConnection();
return false;
}
//second, check if toolStorage identifier is included in this port.
for (auto _tool : m_AllTools)
{
if (std::find(toolPorts.begin(), toolPorts.end(), _tool->GetToolPort()) == toolPorts.end())
{
MITK_ERROR << "Cannot connect device, tool " << _tool->GetToolPort() << " is not connected to its port.";
CloseConnection();
return false;
}
else
{
//erase this port to avoid that two tools want to connect to the same port.
toolPorts.erase(std::find(toolPorts.begin(), toolPorts.end(), _tool->GetToolPort()));
}
}
m_Device->SetHemisphereTrackingEnabled(m_HemisphereTrackingEnabled);
return true;
}
bool mitk::PolhemusTrackingDevice::CloseConnection()
{
bool returnValue = true;
if (this->GetState() == Setup)
return true;
returnValue = m_Device->Disconnect();
this->SetState(Setup);
return returnValue;
}
mitk::PolhemusInterface* mitk::PolhemusTrackingDevice::GetDevice()
{
return m_Device;
}
std::vector<mitk::PolhemusTool::Pointer> mitk::PolhemusTrackingDevice::GetAllTools()
{
return this->m_AllTools;
}
void mitk::PolhemusTrackingDevice::TrackTools()
{
try
{
/* lock the TrackingFinishedMutex to signal that the execution rights are now transfered to the tracking thread */
MutexLockHolder trackingFinishedLockHolder(*m_TrackingFinishedMutex); // keep lock until end of scope
bool localStopTracking; // Because m_StopTracking is used by two threads, access has to be guarded by a mutex. To minimize thread locking, a local copy is used here
this->m_StopTrackingMutex->Lock(); // update the local copy of m_StopTracking
localStopTracking = this->m_StopTracking;
this->m_StopTrackingMutex->Unlock();
Sleep(100);//Wait a bit until the tracker is ready...
while ((this->GetState() == Tracking) && (localStopTracking == false))
{
std::vector<mitk::PolhemusInterface::trackingData> lastData = this->GetDevice()->GetLastFrame();
if (lastData.size() != m_AllTools.size())
{
- MITK_WARN << "Tool count is corrupt. Aborting!";
+ MITK_WARN << "Tool count is corrupt. Hardware gives " << lastData.size() << " tools, MITK expects " << m_AllTools.size() << " tools. Aborting!";
}
else
{
std::vector<mitk::PolhemusTool::Pointer> allTools = this->GetAllTools();
for (int i = 0; i < allTools.size(); i++)
{
mitk::PolhemusTool::Pointer currentTool = allTools.at(i);
currentTool->SetDataValid(true);
currentTool->SetPosition(lastData.at(i).pos);
currentTool->SetOrientation(lastData.at(i).rot);
currentTool->SetIGTTimeStamp(mitk::IGTTimeStamp::GetInstance()->GetElapsed());
}
}
/* Update the local copy of m_StopTracking */
this->m_StopTrackingMutex->Lock();
localStopTracking = m_StopTracking;
this->m_StopTrackingMutex->Unlock();
}
}
catch (...)
{
this->StopTracking();
mitkThrowException(mitk::IGTHardwareException) << "Error while trying to track tools. Thread stopped.";
}
}
ITK_THREAD_RETURN_TYPE mitk::PolhemusTrackingDevice::ThreadStartTracking(void* pInfoStruct)
{
/* extract this pointer from Thread Info structure */
struct itk::MultiThreader::ThreadInfoStruct * pInfo = (struct itk::MultiThreader::ThreadInfoStruct*)pInfoStruct;
if (pInfo == nullptr)
{
return ITK_THREAD_RETURN_VALUE;
}
if (pInfo->UserData == nullptr)
{
return ITK_THREAD_RETURN_VALUE;
}
PolhemusTrackingDevice *trackingDevice = (PolhemusTrackingDevice*)pInfo->UserData;
if (trackingDevice != nullptr)
trackingDevice->TrackTools();
return ITK_THREAD_RETURN_VALUE;
}
bool mitk::PolhemusTrackingDevice::AutoDetectToolsAvailable()
{
return true;
}
mitk::NavigationToolStorage::Pointer mitk::PolhemusTrackingDevice::AutoDetectTools()
{
std::vector<mitk::PolhemusInterface::trackingData> singeFrameData = this->m_Device->AutoDetectTools();
MITK_INFO << "Found " << singeFrameData.size() << " tools.";
mitk::NavigationToolStorage::Pointer returnValue = mitk::NavigationToolStorage::New();
for each (mitk::PolhemusInterface::trackingData t in singeFrameData)
{
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
std::stringstream name;
name << "Sensor-" << ((int)t.id);
newNode->SetName(name.str());
mitk::Surface::Pointer myCone = mitk::Surface::New();
vtkConeSource *vtkData = vtkConeSource::New();
vtkData->SetAngle(5.0);
vtkData->SetResolution(50);
vtkData->SetHeight(6.0f);
vtkData->SetRadius(2.0f);
vtkData->SetCenter(0.0, 0.0, 0.0);
vtkData->Update();
myCone->SetVtkPolyData(vtkData->GetOutput());
vtkData->Delete();
newNode->SetData(myCone);
mitk::NavigationTool::Pointer newTool = mitk::NavigationTool::New();
newTool->SetDataNode(newNode);
//The identifier defines, which plug is used (e.g. "Sens 2" --> 2).
std::stringstream identifier;
identifier << ((int)t.id);
newTool->SetIdentifier(identifier.str());
newTool->SetTrackingDeviceType(mitk::PolhemusTrackerTypeInformation::GetDeviceDataPolhemusTrackerLiberty().Line);
returnValue->AddTool(newTool);
}
return returnValue;
}
void mitk::PolhemusTrackingDevice::SetHemisphereTrackingEnabled(bool _HemisphereTrackingEnabled)
{
//We need to remember if HemisphereTracking is switch on for this reason:
/* m_Device->SetHemi works only if the device is connected. However, GUI can also change if it is not connected.
In this case, we remember it in the m_HemisphereTrackingEnabled variable. And when connecting, we know, which
status is wanted from the user by GUI.
*/
m_HemisphereTrackingEnabled = _HemisphereTrackingEnabled;
this->m_Device->SetHemisphereTrackingEnabled(_HemisphereTrackingEnabled);
}
void mitk::PolhemusTrackingDevice::ToggleHemisphere(int _tool)
{
this->m_Device->ToggleHemisphere(_tool);
}
void mitk::PolhemusTrackingDevice::SetHemisphere(int _tool, mitk::Vector3D _hemisphere)
{
//If you set a hemisphere vector which is unequal (0|0|0), this means, that there is no hemisphere tracking any more
//disable the option, so that it can be reactivated... Also if it is just a single tool.
if (_hemisphere.GetNorm() != 0)
m_HemisphereTrackingEnabled = false;
this->m_Device->SetHemisphere(_tool, _hemisphere);
}
mitk::Vector3D mitk::PolhemusTrackingDevice::GetHemisphere(int _tool)
{
return this->m_Device->GetHemisphere(_tool);
}
bool mitk::PolhemusTrackingDevice::GetHemisphereTrackingEnabled(int _tool)
{
return this->m_Device->GetHemisphereTrackingEnabled(_tool);
}
void mitk::PolhemusTrackingDevice::AdjustHemisphere(int _tool)
{
return this->m_Device->AdjustHemisphere(_tool);
}
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.cpp
index 9d170378ba..3feb24ce5a 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.cpp
@@ -1,414 +1,426 @@
/*===================================================================
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 "QmitkUSNavigationStepCombinedModality.h"
#include "ui_QmitkUSNavigationStepCombinedModality.h"
#include "mitkUSCombinedModality.h"
#include "../Widgets/QmitkUSCombinedModalityEditWidget.h"
#include <QFileDialog>
#include <QTextStream>
#include <QSettings>
+#include "mitkBaseRenderer.h"
+
QmitkUSNavigationStepCombinedModality::QmitkUSNavigationStepCombinedModality(QWidget *parent) :
QmitkUSAbstractNavigationStep(parent), m_CalibrationLoadedNecessary(true),
m_ListenerDeviceChanged(this, &QmitkUSNavigationStepCombinedModality::OnDevicePropertyChanged),
ui(new Ui::QmitkUSNavigationStepCombinedModality),
m_LastCalibrationFilename("")
{
ui->setupUi(this);
// combined modality create widget should only be visible after button press
ui->combinedModalityCreateWidget->setVisible(false);
ui->combinedModalityEditWidget->setVisible(false);
connect(ui->combinedModalityListWidget, SIGNAL(ServiceSelectionChanged(us::ServiceReferenceU)), this, SLOT(OnDeviceSelectionChanged()));
connect(ui->combinedModalityListWidget, SIGNAL(ServiceModified(us::ServiceReferenceU)), this, SLOT(OnDeviceSelectionChanged()));
connect(ui->combinedModalityCreateWidget, SIGNAL(SignalAborted()), this, SLOT(OnCombinedModalityCreationExit()));
connect(ui->combinedModalityCreateWidget, SIGNAL(SignalCreated()), this, SLOT(OnCombinedModalityCreationExit()));
connect(ui->combinedModalityEditWidget, SIGNAL(SignalAborted()), this, SLOT(OnCombinedModalityEditExit()));
connect(ui->combinedModalityEditWidget, SIGNAL(SignalSaved()), this, SLOT(OnCombinedModalityEditExit()));
std::string filterOnlyCombinedModalities = "(&(" + us::ServiceConstants::OBJECTCLASS() + "=" + "org.mitk.services.USCombinedModality)(" + mitk::USCombinedModality::GetPropertyKeys().US_PROPKEY_CLASS + "=" + mitk::USCombinedModality::DeviceClassIdentifier + "))";
//std::string filter = "(&(" + us::ServiceConstants::OBJECTCLASS() + "=" + "org.mitk.services.UltrasoundDevice))";
ui->combinedModalityListWidget->Initialize<mitk::USCombinedModality>(mitk::USCombinedModality::US_PROPKEY_DEVICENAME);
ui->combinedModalityListWidget->SetAutomaticallySelectFirstEntry(true);
//try to load UI settings
QSettings settings;
settings.beginGroup(QString::fromStdString("QmitkUSNavigationStepCombinedModality"));
m_LastCalibrationFilename = settings.value("LastCalibrationFilename", QVariant("")).toString().toStdString();
MITK_DEBUG << "PERSISTENCE load: " << m_LastCalibrationFilename;
settings.endGroup();
}
QmitkUSNavigationStepCombinedModality::~QmitkUSNavigationStepCombinedModality()
{
ui->combinedModalityListWidget->blockSignals(true);
//save UI settings
QSettings settings;
settings.beginGroup(QString::fromStdString("QmitkUSNavigationStepCombinedModality"));
settings.setValue("LastCalibrationFilename", QVariant(m_LastCalibrationFilename.c_str()));
settings.endGroup();
MITK_DEBUG << "PERSISTENCE save: " << m_LastCalibrationFilename;
//delete UI
delete ui;
}
void QmitkUSNavigationStepCombinedModality::OnDeviceSelectionChanged()
{
mitk::USCombinedModality::Pointer combinedModality = this->GetSelectedCombinedModality();
bool combinedModalitySelected = combinedModality.IsNotNull();
ui->calibrationGroupBox->setEnabled(combinedModalitySelected);
ui->combinedModalityDeleteButton->setEnabled(combinedModalitySelected);
ui->combinedModalitEditButton->setEnabled(combinedModalitySelected);
if (!combinedModalitySelected || m_CombinedModality != combinedModality)
{
emit SignalNoLongerReadyForNextStep();
if (m_CombinedModality.IsNotNull() && m_CombinedModality->GetUltrasoundDevice().IsNotNull())
{
m_CombinedModality->GetUltrasoundDevice()->RemovePropertyChangedListener(m_ListenerDeviceChanged);
}
if (combinedModalitySelected && combinedModality->GetUltrasoundDevice().IsNotNull())
{
combinedModality->GetUltrasoundDevice()->RemovePropertyChangedListener(m_ListenerDeviceChanged);
}
}
m_CombinedModality = combinedModality;
if (combinedModalitySelected)
{
bool calibrated = this->UpdateCalibrationState();
if (!m_CalibrationLoadedNecessary) { emit SignalReadyForNextStep(); }
else
{
if (calibrated) { emit SignalReadyForNextStep(); }
else { emit SignalNoLongerReadyForNextStep(); }
}
// enable disconnect button only if combined modality is connected or active
ui->combinedModalityDistconnectButton->setEnabled(combinedModality->GetDeviceState() >= mitk::USCombinedModality::State_Connected);
ui->combinedModalityActivateButton->setEnabled(combinedModality->GetDeviceState() < mitk::USCombinedModality::State_Activated);
this->UpdateTrackingToolNames();
}
else
{
ui->combinedModalityDistconnectButton->setEnabled(false);
ui->combinedModalityActivateButton->setEnabled(false);
}
}
void QmitkUSNavigationStepCombinedModality::OnLoadCalibration()
{
QString filename = QFileDialog::getOpenFileName(QApplication::activeWindow(),
"Load Calibration",
m_LastCalibrationFilename.c_str(),
"Calibration files *.cal");
m_LastCalibrationFilename = filename.toStdString();
mitk::USCombinedModality::Pointer combinedModality = this->GetSelectedCombinedModality();
if (combinedModality.IsNull())
{
ui->calibrationLoadStateLabel->setText("Selected device is no USCombinedModality.");
emit SignalNoLongerReadyForNextStep();
return;
}
if (filename.isEmpty())
{
bool calibrated = this->UpdateCalibrationState();
if (!calibrated) { emit SignalNoLongerReadyForNextStep(); }
return;
}
QFile file(filename);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
{
MITK_WARN << "Cannot open file '" << filename.toStdString() << "' for reading.";
ui->calibrationLoadStateLabel->setText("Cannot open file '" + filename + "' for reading.");
emit SignalNoLongerReadyForNextStep();
return;
}
QTextStream inStream(&file);
m_LoadedCalibration = inStream.readAll().toStdString();
if (m_LoadedCalibration.empty())
{
MITK_WARN << "Failed to load file. Unsupported format?";
ui->calibrationLoadStateLabel->setText("Failed to load file. Unsupported format?");
emit SignalNoLongerReadyForNextStep();
return;
}
try
{
combinedModality->DeserializeCalibration(m_LoadedCalibration);
}
catch (const mitk::Exception& /*exception*/)
{
MITK_WARN << "Failed to deserialize calibration. Unsuppoerted format?";
ui->calibrationLoadStateLabel->setText("Failed to deserialize calibration. Unsuppoerted format?");
emit SignalNoLongerReadyForNextStep();
return;
}
ui->calibrationLoadStateLabel->setText("Loaded calibration : " + filename);
m_CombinedModality = combinedModality;
emit SignalReadyForNextStep();
}
void QmitkUSNavigationStepCombinedModality::OnCombinedModalityCreateNewButtonClicked()
{
this->SetCombinedModalityCreateWidgetEnabled(true);
}
void QmitkUSNavigationStepCombinedModality::OnCombinedModalityCreationExit()
{
this->SetCombinedModalityCreateWidgetEnabled(false);
+ try
+ {
+ mitk::RenderingManager::GetInstance()->InitializeViews(//Reinit
+ mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetDataStorage()//GetDataStorage
+ ->GetNamedNode("US Support Viewing Stream")->GetData()->GetTimeGeometry());//GetNode
+ }
+ catch (...)
+ {
+ MITK_DEBUG << "No reinit possible";
+ }
}
void QmitkUSNavigationStepCombinedModality::OnCombinedModalityEditExit()
{
this->SetCombinedModalityEditWidgetEnabled(false);
ui->combinedModalityEditWidget->SetCombinedModality(0);
}
void QmitkUSNavigationStepCombinedModality::OnDeleteButtonClicked()
{
mitk::USCombinedModality::Pointer combinedModality = this->GetSelectedCombinedModality();
if (combinedModality.IsNotNull())
{
combinedModality->RemoveAllObservers();
combinedModality->UnregisterOnService();
}
}
void QmitkUSNavigationStepCombinedModality::OnCombinedModalityEditButtonClicked()
{
ui->combinedModalityEditWidget->SetCombinedModality(m_CombinedModality);
this->SetCombinedModalityEditWidgetEnabled(true);
}
void QmitkUSNavigationStepCombinedModality::OnActivateButtonClicked()
{
mitk::USCombinedModality::Pointer combinedModality = this->GetSelectedCombinedModality();
if (combinedModality.IsNotNull())
{
if (!combinedModality->GetIsConnected()) { combinedModality->Connect(); }
if (!combinedModality->GetIsActive()) { combinedModality->Activate(); }
}
}
void QmitkUSNavigationStepCombinedModality::OnDisconnectButtonClicked()
{
mitk::USCombinedModality::Pointer combinedModality = this->GetSelectedCombinedModality();
if (combinedModality.IsNotNull())
{
if (combinedModality->GetIsActive()) { combinedModality->Deactivate(); }
if (combinedModality->GetIsConnected()) { combinedModality->Disconnect(); }
}
}
bool QmitkUSNavigationStepCombinedModality::OnStartStep()
{
return true;
}
bool QmitkUSNavigationStepCombinedModality::OnRestartStep()
{
return true;
}
bool QmitkUSNavigationStepCombinedModality::OnFinishStep()
{
mitk::USCombinedModality::Pointer combinedModality = this->GetSelectedCombinedModality();
if (combinedModality.IsNotNull())
{
QApplication::setOverrideCursor(Qt::WaitCursor);
// make sure that the combined modality is in connected state before using it
if (combinedModality->GetDeviceState() < mitk::USDevice::State_Connected) { combinedModality->Connect(); }
if (combinedModality->GetDeviceState() < mitk::USDevice::State_Activated) { combinedModality->Activate(); }
QApplication::restoreOverrideCursor();
}
emit SignalCombinedModalityChanged(combinedModality);
this->CreateCombinedModalityResultAndSignalIt();
return true;
}
bool QmitkUSNavigationStepCombinedModality::OnActivateStep()
{
// make sure that device selection status is up-to-date
this->OnDeviceSelectionChanged();
return true;
}
void QmitkUSNavigationStepCombinedModality::OnUpdate()
{
}
QString QmitkUSNavigationStepCombinedModality::GetTitle()
{
return "Selection of Combined Modality";
}
bool QmitkUSNavigationStepCombinedModality::GetIsRestartable()
{
return false;
}
void QmitkUSNavigationStepCombinedModality::SetCombinedModalityCreateWidgetEnabled(bool enabled)
{
ui->combinedModalityLabel->setVisible(!enabled);
ui->combinedModalityListWidget->setVisible(!enabled);
ui->combinedModalityCreateButton->setVisible(!enabled);
ui->combinedModalityDeleteButton->setVisible(!enabled);
ui->combinedModalitEditButton->setVisible(!enabled);
ui->combinedModalityActivateButton->setVisible(!enabled);
ui->combinedModalityDistconnectButton->setVisible(!enabled);
ui->helpLabel->setVisible(!enabled);
ui->calibrationGroupBox->setVisible(!enabled);
ui->combinedModalityCreateWidget->setVisible(enabled);
}
void QmitkUSNavigationStepCombinedModality::SetCombinedModalityEditWidgetEnabled(bool enabled)
{
ui->combinedModalityLabel->setVisible(!enabled);
ui->combinedModalityListWidget->setVisible(!enabled);
ui->combinedModalityCreateButton->setVisible(!enabled);
ui->combinedModalityDeleteButton->setVisible(!enabled);
ui->combinedModalitEditButton->setVisible(!enabled);
ui->combinedModalityActivateButton->setVisible(!enabled);
ui->combinedModalityDistconnectButton->setVisible(!enabled);
ui->helpLabel->setVisible(!enabled);
ui->calibrationGroupBox->setVisible(!enabled);
ui->combinedModalityEditWidget->setVisible(enabled);
}
void QmitkUSNavigationStepCombinedModality::CreateCombinedModalityResultAndSignalIt()
{
mitk::USCombinedModality::Pointer combinedModality = this->GetCombinedModality();
mitk::USDevice::Pointer usDevice = combinedModality->GetUltrasoundDevice();
// save identifiers and calibration to a result object
mitk::DataNode::Pointer combinedModalityResult = mitk::DataNode::New();
combinedModalityResult->SetName("CombinedModalityResult");
combinedModalityResult->SetStringProperty("USNavigation::CombinedModality",
std::string(combinedModality->GetDeviceManufacturer() + ": " + combinedModality->GetDeviceModel()
+ " (" + combinedModality->GetDeviceComment() + ")").c_str());
combinedModalityResult->SetStringProperty("USNavigation::UltrasoundDevice",
std::string(usDevice->GetDeviceManufacturer() + ": " + usDevice->GetDeviceModel()
+ " (" + usDevice->GetDeviceComment() + ")").c_str());
combinedModalityResult->SetStringProperty("USNavigation::TrackingDevice",
combinedModality->GetNavigationDataSource()->GetName().c_str());
combinedModalityResult->SetStringProperty("USNavigation::Calibration",
combinedModality->SerializeCalibration().c_str());
emit SignalIntermediateResult(combinedModalityResult);
}
bool QmitkUSNavigationStepCombinedModality::UpdateCalibrationState()
{
if (m_CombinedModality.IsNull()) { return false; }
bool calibrated = m_CombinedModality->GetContainsAtLeastOneCalibration();
if (calibrated) { ui->calibrationLoadStateLabel->setText("Selected device contains at least one calibration."); }
else { ui->calibrationLoadStateLabel->setText("Selected device is not calibrated."); }
return calibrated;
}
mitk::USCombinedModality::Pointer QmitkUSNavigationStepCombinedModality::GetSelectedCombinedModality()
{
// nothing more to do if no device is selected at the moment
if (!ui->combinedModalityListWidget->GetIsServiceSelected()) { return 0; }
mitk::USCombinedModality::Pointer combinedModality = ui->combinedModalityListWidget->GetSelectedService<mitk::USCombinedModality>();
if (combinedModality.IsNull())
{
MITK_WARN << "Selected device is no USCombinedModality.";
}
return combinedModality;
}
void QmitkUSNavigationStepCombinedModality::SetCalibrationLoadedNecessary(bool necessary)
{
m_CalibrationLoadedNecessary = necessary;
}
void QmitkUSNavigationStepCombinedModality::OnDevicePropertyChanged(const std::string& key, const std::string&)
{
// property changes only matter if the navigation step is currently active
// (being sensitive to them in other states may even be dangerous)
if (this->GetNavigationStepState() < QmitkUSAbstractNavigationStep::State_Active) { return; }
// calibration state could have changed if the depth was changed
if (key == mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DEPTH)
{
bool calibrated = this->UpdateCalibrationState();
if (calibrated) { emit SignalReadyForNextStep(); }
else { emit SignalNoLongerReadyForNextStep(); }
}
}
void QmitkUSNavigationStepCombinedModality::UpdateTrackingToolNames()
{
//check if everything is initialized
if (m_CombinedModality.IsNull()) { return; }
mitk::NavigationDataSource::Pointer navigationDataSource = m_CombinedModality->GetNavigationDataSource();
if (navigationDataSource.IsNull()) { return; }
if (GetDataStorage(false).IsNull()) { return; }
// get the settings node
mitk::DataNode::Pointer settingsNode = this->GetNamedDerivedNode(DATANAME_SETTINGS, DATANAME_BASENODE);
std::string needleNames;
itk::ProcessObject::DataObjectPointerArray outputs = navigationDataSource->GetOutputs();
for (itk::ProcessObject::DataObjectPointerArray::iterator it = outputs.begin(); it != outputs.end(); ++it)
{
needleNames += std::string((static_cast<mitk::NavigationData*>(it->GetPointer()))->GetName()) + ";";
}
// change the settings node only if the settings changed
std::string oldProperty;
if (!settingsNode->GetStringProperty("settings.needle-names", oldProperty)
|| oldProperty != needleNames
|| !settingsNode->GetStringProperty("settings.reference-names", oldProperty)
|| oldProperty != needleNames)
{
settingsNode->SetStringProperty("settings.needle-names", needleNames.c_str());
settingsNode->SetStringProperty("settings.reference-names", needleNames.c_str());
emit SignalSettingsNodeChanged(settingsNode);
}
}
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.cpp
index f8edc7a2fa..cd584daa9e 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.cpp
@@ -1,807 +1,862 @@
/*===================================================================
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 "USNavigationMarkerPlacement.h"
#include "ui_USNavigationMarkerPlacement.h"
#include "NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.h"
#include "NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.h"
#include "NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.h"
#include "NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.h"
#include "NavigationStepWidgets/QmitkUSNavigationStepTumourSelection.h"
#include "NavigationStepWidgets/QmitkUSNavigationStepZoneMarking.h"
#include "SettingsWidgets/QmitkUSNavigationCombinedSettingsWidget.h"
#include "mitkIRenderingManager.h"
#include "mitkNodeDisplacementFilter.h"
#include "mitkUSCombinedModality.h"
#include <mitkIOUtil.h>
#include "IO/mitkUSNavigationExperimentLogging.h"
#include "IO/mitkUSNavigationStepTimer.h"
#include <QDateTime>
#include <QDir>
#include <QInputDialog>
#include <QMessageBox>
#include <QSignalMapper>
#include <QTimer>
#include "QmitkRenderWindow.h"
#include "QmitkStdMultiWidget.h"
#include "QmitkStdMultiWidgetEditor.h"
#include "mitkLayoutAnnotationRenderer.h"
+#include "mitkCameraController.h"
// scene serialization
#include <mitkConvert2Dto3DImageFilter.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
#include <mitkSceneIO.h>
#include <mitkSurface.h>
const std::string USNavigationMarkerPlacement::VIEW_ID = "org.mitk.views.usmarkerplacement";
const char *USNavigationMarkerPlacement::DATANAME_TUMOUR = "Tumour";
const char *USNavigationMarkerPlacement::DATANAME_TARGETSURFACE = "Target Surface";
const char *USNavigationMarkerPlacement::DATANAME_ZONES = "Zones";
const char *USNavigationMarkerPlacement::DATANAME_TARGETS = "Targets";
const char *USNavigationMarkerPlacement::DATANAME_TARGETS_PATHS = "Target Paths";
const char *USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS = "Reached Targets";
USNavigationMarkerPlacement::USNavigationMarkerPlacement()
: m_UpdateTimer(new QTimer(this)),
m_ImageAndNavigationDataLoggingTimer(new QTimer(this)),
m_StdMultiWidget(0),
m_ReinitAlreadyDone(false),
m_IsExperimentRunning(false),
m_NavigationStepTimer(mitk::USNavigationStepTimer::New()),
m_ExperimentLogging(mitk::USNavigationExperimentLogging::New()),
m_AblationZonesDisplacementFilter(mitk::NodeDisplacementFilter::New()),
m_IconRunning(QPixmap(":/USNavigation/record.png")),
m_IconNotRunning(QPixmap(":/USNavigation/record-gray.png")),
m_USImageLoggingFilter(mitk::USImageLoggingFilter::New()),
m_NavigationDataRecorder(mitk::NavigationDataRecorder::New()),
m_SceneNumber(1),
m_WarnOverlay(mitk::TextAnnotation2D::New()),
m_ListenerDeviceChanged(this, &USNavigationMarkerPlacement::OnCombinedModalityPropertyChanged),
m_NeedleIndex(0),
m_MarkerIndex(1),
ui(new Ui::USNavigationMarkerPlacement)
{
connect(m_UpdateTimer, SIGNAL(timeout()), this, SLOT(OnTimeout()));
connect(
m_ImageAndNavigationDataLoggingTimer, SIGNAL(timeout()), this, SLOT(OnImageAndNavigationDataLoggingTimeout()));
// scale running (and not running) icon the specific height
m_IconRunning = m_IconRunning.scaledToHeight(20, Qt::SmoothTransformation);
m_IconNotRunning = m_IconNotRunning.scaledToHeight(20, Qt::SmoothTransformation);
// set prefix for experiment logging (only keys with this prefix are taken
// into consideration
m_ExperimentLogging->SetKeyPrefix("USNavigation::");
m_UpdateTimer->start(33); // every 33 Milliseconds = 30 Frames/Second
}
USNavigationMarkerPlacement::~USNavigationMarkerPlacement()
{
-
// remove listener for ultrasound device changes
if (m_CombinedModality.IsNotNull() && m_CombinedModality->GetUltrasoundDevice().IsNotNull())
{
m_CombinedModality->GetUltrasoundDevice()->RemovePropertyChangedListener(m_ListenerDeviceChanged);
}
-
// remove listener for ultrasound device changes
if (m_CombinedModality.IsNotNull() && m_CombinedModality->GetUltrasoundDevice().IsNotNull())
{
m_CombinedModality->GetUltrasoundDevice()->RemovePropertyChangedListener(m_ListenerDeviceChanged);
}
delete ui;
-
-
}
void USNavigationMarkerPlacement::OnChangeAblationZone(int id, int newSize)
{
if ((m_AblationZonesVector.size() < id) || (id < 0))
{
return;
}
MITK_INFO << "Ablation Zone " << id << " changed, new size: " << newSize;
// create a vtk sphere with given radius
vtkSphereSource *vtkData = vtkSphereSource::New();
vtkData->SetRadius(newSize / 2);
vtkData->SetCenter(0, 0, 0);
vtkData->SetPhiResolution(20);
vtkData->SetThetaResolution(20);
vtkData->Update();
mitk::Surface::Pointer zoneSurface = dynamic_cast<mitk::Surface *>(m_AblationZonesVector.at(id)->GetData());
zoneSurface->SetVtkPolyData(vtkData->GetOutput());
vtkData->Delete();
}
void USNavigationMarkerPlacement::OnAddAblationZone(int size)
{
m_AblationZonesDisplacementFilter->SetInitialReferencePose(
m_CombinedModality->GetNavigationDataSource()->GetOutput(m_MarkerIndex));
mitk::DataNode::Pointer NewAblationZone = mitk::DataNode::New();
mitk::Point3D origin = m_CombinedModality->GetNavigationDataSource()->GetOutput(m_NeedleIndex)->GetPosition();
MITK_INFO("USNavigationLogging") << "Ablation Zone Added, initial size: " << size << ", origin: " << origin;
mitk::Surface::Pointer zone = mitk::Surface::New();
// create a vtk sphere with given radius
vtkSphereSource *vtkData = vtkSphereSource::New();
vtkData->SetRadius(size / 2);
vtkData->SetCenter(0, 0, 0);
vtkData->SetPhiResolution(20);
vtkData->SetThetaResolution(20);
vtkData->Update();
zone->SetVtkPolyData(vtkData->GetOutput());
vtkData->Delete();
// set vtk sphere and origin to data node (origin must be set
// again, because of the new sphere set as data)
NewAblationZone->SetData(zone);
NewAblationZone->GetData()->GetGeometry()->SetOrigin(origin);
mitk::Color SphereColor = mitk::Color();
// default color
SphereColor[0] = 102;
SphereColor[1] = 0;
SphereColor[2] = 204;
NewAblationZone->SetColor(SphereColor);
NewAblationZone->SetOpacity(0.3);
// set name of zone
std::stringstream name;
name << "Ablation Zone" << m_AblationZonesVector.size();
NewAblationZone->SetName(name.str());
// add zone to filter
m_AblationZonesDisplacementFilter->AddNode(NewAblationZone);
m_AblationZonesVector.push_back(NewAblationZone);
this->GetDataStorage()->Add(NewAblationZone);
}
void USNavigationMarkerPlacement::CreateQtPartControl(QWidget *parent)
{
m_Parent = parent;
ui->setupUi(parent);
connect(ui->navigationProcessWidget,
SIGNAL(SignalCombinedModalityChanged(itk::SmartPointer<mitk::USCombinedModality>)),
this,
SLOT(OnCombinedModalityChanged(itk::SmartPointer<mitk::USCombinedModality>)));
connect(ui->navigationProcessWidget,
SIGNAL(SignalSettingsChanged(itk::SmartPointer<mitk::DataNode>)),
this,
SLOT(OnSettingsChanged(itk::SmartPointer<mitk::DataNode>)));
connect(ui->navigationProcessWidget,
SIGNAL(SignalActiveNavigationStepChanged(int)),
this,
SLOT(OnActiveNavigationStepChanged(int)));
connect(ui->navigationProcessWidget,
SIGNAL(SignalActiveNavigationStepChangeRequested(int)),
this,
SLOT(OnNextNavigationStepInitialization(int)));
connect(ui->startExperimentButton, SIGNAL(clicked()), this, SLOT(OnStartExperiment()));
connect(ui->finishExperimentButton, SIGNAL(clicked()), this, SLOT(OnFinishExperiment()));
connect(ui->m_enableNavigationLayout, SIGNAL(clicked()), this, SLOT(OnChangeLayoutClicked()));
+ connect(ui->m_RenderWindowSelection, SIGNAL(valueChanged(int)), this, SLOT(OnRenderWindowSelection()));
+ connect(ui->m_RefreshView, SIGNAL(clicked()), this, SLOT(OnRefreshView()));
connect(ui->navigationProcessWidget,
SIGNAL(SignalIntermediateResult(const itk::SmartPointer<mitk::DataNode>)),
this,
SLOT(OnIntermediateResultProduced(const itk::SmartPointer<mitk::DataNode>)));
ui->navigationProcessWidget->SetDataStorage(this->GetDataStorage());
// indicate that no experiment is running at start
ui->runningLabel->setPixmap(m_IconNotRunning);
ui->navigationProcessWidget->SetSettingsWidget(new QmitkUSNavigationCombinedSettingsWidget(m_Parent));
}
void USNavigationMarkerPlacement::OnCombinedModalityPropertyChanged(const std::string &key, const std::string &)
{
if (key == mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DEPTH)
{
m_ReinitAlreadyDone = false;
this->ReinitOnImage();
if (m_CombinedModality.IsNotNull() && !m_CombinedModality->GetIsCalibratedForCurrentStatus())
{
mitk::LayoutAnnotationRenderer::AddAnnotation(
m_WarnOverlay.GetPointer(), "stdmulti.widget1", mitk::LayoutAnnotationRenderer::TopLeft);
MITK_WARN << "No calibration available for the selected ultrasound image depth.";
}
}
}
void USNavigationMarkerPlacement::SetFocus()
{
this->ReinitOnImage();
}
void USNavigationMarkerPlacement::OnTimeout()
{
if (!m_StdMultiWidget)
{
// try to get the standard multi widget if it couldn't be got before
mitk::IRenderWindowPart *renderWindow = this->GetRenderWindowPart();
QmitkStdMultiWidgetEditor *multiWidgetEditor = dynamic_cast<QmitkStdMultiWidgetEditor *>(renderWindow);
// if there is a standard multi widget now, disable the level window and
// change the layout to 2D up and 3d down
if (multiWidgetEditor)
{
m_StdMultiWidget = multiWidgetEditor->GetStdMultiWidget();
- if (m_StdMultiWidget)
- {
- m_StdMultiWidget->DisableStandardLevelWindow();
- m_StdMultiWidget->changeLayoutTo2DUpAnd3DDown();
- }
+ SetTwoWindowView();
}
this->CreateOverlays();
}
if (m_CombinedModality.IsNotNull() &&
!this->m_CombinedModality->GetIsFreezed()) // if the combined modality is freezed: do nothing
{
ui->navigationProcessWidget->UpdateNavigationProgress();
m_AblationZonesDisplacementFilter->Update();
// update the 3D window only every fourth time to speed up the rendering (at least in 2D)
this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS);
// make sure that a reinit was performed on the image
this->ReinitOnImage();
}
}
void USNavigationMarkerPlacement::OnEnableNavigationLayout()
{
MITK_INFO << "Navigation Layout";
// try to get the standard multi widget if it couldn't be got before
mitk::IRenderWindowPart *renderWindow = this->GetRenderWindowPart();
QmitkStdMultiWidgetEditor *multiWidgetEditor = dynamic_cast<QmitkStdMultiWidgetEditor *>(renderWindow);
// if there is a standard multi widget now, disable the level window and
// change the layout to 2D up and 3d down
if (multiWidgetEditor)
{
m_StdMultiWidget = multiWidgetEditor->GetStdMultiWidget();
- if (m_StdMultiWidget)
+ SetTwoWindowView();
+ }
+}
+
+void USNavigationMarkerPlacement::OnRenderWindowSelection()
+{
+ SetTwoWindowView();
+}
+
+void USNavigationMarkerPlacement::OnRefreshView()
+{
+ if (!ui->m_enableNavigationLayout->isChecked())
+ OnResetStandardLayout();
+ else
+ {
+ //Reinit the US Image Stream (this might be broken if there was a global reinit somewhere...)
+ try
+ {
+ mitk::RenderingManager::GetInstance()->InitializeViews(//Reinit
+ this->GetDataStorage()//GetDataStorage
+ ->GetNamedNode("US Support Viewing Stream")->GetData()->GetTimeGeometry());//GetNode
+ }
+ catch (...)
{
- m_StdMultiWidget->DisableStandardLevelWindow();
- m_StdMultiWidget->changeLayoutTo2DUpAnd3DDown();
- this->GetDataStorage()->GetNamedNode("stdmulti.widget1.plane")->SetVisibility(false);
- this->GetDataStorage()->GetNamedNode("stdmulti.widget3.plane")->SetVisibility(false);
+ MITK_DEBUG << "No reinit possible";
}
+ SetTwoWindowView();
+ }
+}
+
+void USNavigationMarkerPlacement::SetTwoWindowView()
+{
+ if (m_StdMultiWidget)
+ {
+ m_StdMultiWidget->DisableStandardLevelWindow();
+ int i, j, k;
+ switch (this->ui->m_RenderWindowSelection->value())
+ {
+ case 1:
+ mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetCameraController()->SetViewToCaudal();
+ i = 2; j = 3; //other windows
+ k = 1;
+ break;
+ case 2:
+ mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetCameraController()->SetViewToSinister();
+ i = 1; j = 3;
+ k = 2;
+ break;
+ case 3:
+ mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetCameraController()->SetViewToAnterior();
+ i = 2; j = 1;
+ k = 3;
+ break;
+ default:
+ return;
+ }
+ m_StdMultiWidget->changeLayoutTo2DUpAnd3DDown(k);
+ ////Crosshair invisible in 3D view
+ this->GetDataStorage()->GetNamedNode("stdmulti.widget" + std::to_string(i) + ".plane")->
+ SetBoolProperty("visible", false, mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4")));
+ this->GetDataStorage()->GetNamedNode("stdmulti.widget" + std::to_string(j) + ".plane")->
+ SetBoolProperty("visible", false, mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4")));
+ this->GetDataStorage()->GetNamedNode("stdmulti.widget" + std::to_string(k) + ".plane")->
+ SetBoolProperty("visible", true, mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4")));
+ this->GetDataStorage()->GetNamedNode("stdmulti.widget" + std::to_string(i) + ".plane")->
+ SetIntProperty("Crosshair.Gap Size", 0);
+ this->GetDataStorage()->GetNamedNode("stdmulti.widget" + std::to_string(j) + ".plane")->
+ SetIntProperty("Crosshair.Gap Size", 0);
}
}
void USNavigationMarkerPlacement::OnResetStandardLayout()
{
//reset render windows
mitk::DataNode::Pointer widget1 = this->GetDataStorage()->GetNamedNode("stdmulti.widget1.plane");
if (widget1.IsNotNull()) { widget1->SetVisibility(true); }
+ mitk::DataNode::Pointer widget2 = this->GetDataStorage()->GetNamedNode("stdmulti.widget2.plane");
+ if (widget2.IsNotNull()) { widget2->SetVisibility(true); }
mitk::DataNode::Pointer widget3 = this->GetDataStorage()->GetNamedNode("stdmulti.widget3.plane");
if (widget3.IsNotNull()) { widget3->SetVisibility(true); }
m_StdMultiWidget->changeLayoutToDefault();
}
void USNavigationMarkerPlacement::OnChangeLayoutClicked()
{
if (ui->m_enableNavigationLayout->isChecked()) OnEnableNavigationLayout();
else OnResetStandardLayout();
}
void USNavigationMarkerPlacement::OnImageAndNavigationDataLoggingTimeout()
{
// update filter for logging navigation data and ultrasound images
if (m_CombinedModality.IsNotNull())
{
m_NavigationDataRecorder->Update();
// get last messages for logging filer and store them
std::vector<std::string> messages = m_LoggingBackend.GetNavigationMessages();
std::string composedMessage = "";
for (int i = 0; i < messages.size(); i++)
{
composedMessage += messages.at(i);
}
m_USImageLoggingFilter->AddMessageToCurrentImage(composedMessage);
m_LoggingBackend.ClearNavigationMessages();
// update logging filter
m_USImageLoggingFilter->Update();
}
}
void USNavigationMarkerPlacement::OnStartExperiment()
{
// get name for the experiment by a QInputDialog
bool ok;
if (m_ExperimentName.isEmpty())
{ // default: current date
m_ExperimentName = QString::number(QDateTime::currentDateTime().date().year()) + "_" +
QString::number(QDateTime::currentDateTime().date().month()) + "_" +
QString::number(QDateTime::currentDateTime().date().day()) + "_experiment_" +
QString::number(QDateTime::currentDateTime().time().hour()) + "." +
QString::number(QDateTime::currentDateTime().time().minute());
}
m_ExperimentName = QInputDialog::getText(
m_Parent, QString("Experiment Name"), QString("Name of the Experiment"), QLineEdit::Normal, m_ExperimentName, &ok);
MITK_INFO("USNavigationLogging") << "Experiment started: " << m_ExperimentName.toStdString();
if (ok && !m_ExperimentName.isEmpty())
{
// display error message and call the function recursivly if a directory
// with the given name already exists
QDir experimentResultsDir(m_ResultsDirectory + QDir::separator() + m_ExperimentName);
if (experimentResultsDir.exists())
{
QMessageBox::critical(
m_Parent, "Results Directory Exists", "The result directory already exists.\nPlease choose an other name.");
this->OnStartExperiment();
}
else
{
QDir(m_ResultsDirectory).mkdir(m_ExperimentName);
m_ExperimentResultsSubDirectory = m_ResultsDirectory + QDir::separator() + m_ExperimentName;
// experiment is running now
ui->runningLabel->setPixmap(m_IconRunning);
ui->navigationProcessWidget->EnableInteraction(true);
// (re)start timer for navigation step durations
m_NavigationStepTimer->Reset();
m_NavigationStepTimer->SetOutputFileName(
QString(m_ExperimentResultsSubDirectory + QDir::separator() + QString("durations.cvs")).toStdString());
m_NavigationStepTimer->SetActiveIndex(0, m_NavigationSteps.at(0)->GetTitle().toStdString());
ui->finishExperimentButton->setEnabled(true);
ui->startExperimentButton->setDisabled(true);
// initialize and register logging backend
QString loggingFilename = m_ExperimentResultsSubDirectory + QDir::separator() + "logging.txt";
m_LoggingBackend.SetOutputFileName(loggingFilename.toStdString());
mbilog::RegisterBackend(&m_LoggingBackend);
// initialize and start navigation data recorder form xml recording
m_NavigationDataRecorder->StartRecording();
m_IsExperimentRunning = true;
m_ImageAndNavigationDataLoggingTimer->start(1000);
// (re)start experiment logging and set output file name
m_ExperimentLogging->Reset();
m_ExperimentLogging->SetFileName(
QString(m_ExperimentResultsSubDirectory + QDir::separator() + "experiment-logging.xml").toStdString());
}
}
}
void USNavigationMarkerPlacement::OnFinishExperiment()
{
this->WaitCursorOn();
MITK_INFO("USNavigationLogging") << "Experiment finished!";
MITK_INFO("USNavigationLogging")
<< "Position/Orientation of needle tip: "
<< (dynamic_cast<mitk::NavigationData *>(m_CombinedModality->GetTrackingDevice()->GetOutput(0)))->GetPosition();
MITK_INFO("USNavigationLogging")
<< "Position of target: " << m_TargetNodeDisplacementFilter->GetRawDisplacementNavigationData(0)->GetPosition();
MITK_INFO("USNavigationLogging") << "Total duration: " << m_NavigationStepTimer->GetTotalDuration();
ui->navigationProcessWidget->FinishCurrentNavigationStep();
m_ImageAndNavigationDataLoggingTimer->stop();
ui->runningLabel->setPixmap(m_IconNotRunning);
ui->navigationProcessWidget->EnableInteraction(false);
m_NavigationStepTimer->Stop();
// make sure that the navigation process will be start from beginning at the
// next experiment
ui->navigationProcessWidget->ResetNavigationProcess();
ui->finishExperimentButton->setDisabled(true);
ui->startExperimentButton->setEnabled(true);
MITK_INFO("USNavigationLogging") << "Writing logging data to " << m_ExperimentResultsSubDirectory.toStdString();
// save ultrasound images to the file system
QDir(m_ExperimentResultsSubDirectory).mkdir("ImageStream");
m_USImageLoggingFilter->Update();
m_USImageLoggingFilter->SetImageFilesExtension(".jpg");
m_USImageLoggingFilter->SaveImages(
QString(m_ExperimentResultsSubDirectory + QDir::separator() + "ImageStream" + QDir::separator()).toStdString());
m_USImageLoggingFilter = mitk::USImageLoggingFilter::New();
m_NavigationDataRecorder->StopRecording();
// Write data to csv and xml file
mitk::IOUtil::SaveBaseData(
m_NavigationDataRecorder->GetNavigationDataSet(),
(QString(m_ExperimentResultsSubDirectory + QDir::separator() + "navigation-data.xml").toStdString().c_str()));
mitk::IOUtil::SaveBaseData(
m_NavigationDataRecorder->GetNavigationDataSet(),
(QString(m_ExperimentResultsSubDirectory + QDir::separator() + "navigation-data.csv").toStdString().c_str()));
// write logged navigation data messages to separate file
std::stringstream csvNavigationMessagesFilename;
csvNavigationMessagesFilename << m_ExperimentResultsSubDirectory.toStdString() << QDir::separator().toLatin1()
<< "CSVNavigationMessagesLogFile.csv";
MITK_INFO("USNavigationLogging") << "Writing logged navigation messages to separate csv file: "
<< csvNavigationMessagesFilename.str();
m_LoggingBackend.WriteCSVFileWithNavigationMessages(csvNavigationMessagesFilename.str());
mbilog::UnregisterBackend(&m_LoggingBackend);
m_IsExperimentRunning = false;
m_ImageAndNavigationDataLoggingTimer->stop();
m_CombinedModality = 0;
// reset scene number for next experiment
m_SceneNumber = 1;
this->WaitCursorOff();
MITK_INFO("USNavigationLogging") << "Finished!";
}
void USNavigationMarkerPlacement::OnCombinedModalityChanged(
itk::SmartPointer<mitk::USCombinedModality> combinedModality)
{
// remove old listener for ultrasound device changes
if (m_CombinedModality.IsNotNull() && m_CombinedModality->GetUltrasoundDevice().IsNotNull())
{
m_CombinedModality->GetUltrasoundDevice()->RemovePropertyChangedListener(m_ListenerDeviceChanged);
}
m_CombinedModality = combinedModality;
m_ReinitAlreadyDone = false;
// add a listener for ultrasound device changes
if (m_CombinedModality.IsNotNull() && m_CombinedModality->GetUltrasoundDevice().IsNotNull())
{
m_CombinedModality->GetUltrasoundDevice()->AddPropertyChangedListener(m_ListenerDeviceChanged);
}
// update navigation data recorder for using the new combined modality
mitk::NavigationDataSource::Pointer navigationDataSource = combinedModality->GetNavigationDataSource();
m_NavigationDataRecorder->ConnectTo(navigationDataSource);
m_NavigationDataRecorder->ResetRecording();
// update ultrasound image logging filter for using the new combined modality
mitk::USDevice::Pointer ultrasoundImageSource = combinedModality->GetUltrasoundDevice();
for (unsigned int n = 0; n < ultrasoundImageSource->GetNumberOfIndexedOutputs(); ++n)
{
m_USImageLoggingFilter->SetInput(n, ultrasoundImageSource->GetOutput(n));
}
// update ablation zone filter for using the new combined modality
for (unsigned int n = 0; n < navigationDataSource->GetNumberOfIndexedOutputs(); ++n)
{
m_AblationZonesDisplacementFilter->SetInput(n, navigationDataSource->GetOutput(n));
}
m_AblationZonesDisplacementFilter->SelectInput(m_MarkerIndex);
// make sure that a reinit is done for the new images
this->ReinitOnImage();
}
void USNavigationMarkerPlacement::OnSettingsChanged(itk::SmartPointer<mitk::DataNode> settings)
{
std::string applicationName;
if (!settings->GetStringProperty("settings.application", applicationName))
{
// set default application if the string property is not available
applicationName = "Marker Placement";
}
// create navigation step widgets according to the selected application
if (applicationName != m_CurrentApplicationName)
{
m_CurrentApplicationName = applicationName;
QmitkUSNavigationProcessWidget::NavigationStepVector navigationSteps;
if (applicationName == "Puncture")
{
QmitkUSNavigationStepCombinedModality* stepCombinedModality =
new QmitkUSNavigationStepCombinedModality(m_Parent);
QmitkUSNavigationStepTumourSelection* stepTumourSelection =
new QmitkUSNavigationStepTumourSelection(m_Parent);
stepTumourSelection->SetTargetSelectionOptional(true);
m_TargetNodeDisplacementFilter = stepTumourSelection->GetTumourNodeDisplacementFilter();
QmitkUSNavigationStepZoneMarking* stepZoneMarking =
new QmitkUSNavigationStepZoneMarking(m_Parent);
QmitkUSNavigationStepPunctuationIntervention* stepIntervention =
new QmitkUSNavigationStepPunctuationIntervention(m_Parent);
connect(stepIntervention, SIGNAL(AddAblationZoneClicked(int)), this, SLOT(OnAddAblationZone(int)));
connect(stepIntervention, SIGNAL(AblationZoneChanged(int, int)), this, SLOT(OnChangeAblationZone(int, int)));
m_NavigationStepNames = std::vector<QString>();
navigationSteps.push_back(stepCombinedModality);
m_NavigationStepNames.push_back("Combined Modality Initialization");
navigationSteps.push_back(stepTumourSelection);
m_NavigationStepNames.push_back("Target Selection");
navigationSteps.push_back(stepZoneMarking);
m_NavigationStepNames.push_back("Critical Structure Marking");
navigationSteps.push_back(stepIntervention);
m_NavigationStepNames.push_back("Intervention");
}
else if (applicationName == "Marker Placement")
{
QmitkUSNavigationStepCombinedModality *stepCombinedModality = new QmitkUSNavigationStepCombinedModality(m_Parent);
QmitkUSNavigationStepTumourSelection *stepTumourSelection = new QmitkUSNavigationStepTumourSelection(m_Parent);
m_TargetNodeDisplacementFilter = stepTumourSelection->GetTumourNodeDisplacementFilter();
QmitkUSNavigationStepZoneMarking *stepZoneMarking = new QmitkUSNavigationStepZoneMarking(m_Parent);
QmitkUSNavigationStepPlacementPlanning *stepPlacementPlanning =
new QmitkUSNavigationStepPlacementPlanning(m_Parent);
QmitkUSNavigationStepMarkerIntervention *stepMarkerIntervention =
new QmitkUSNavigationStepMarkerIntervention(m_Parent);
m_NavigationStepNames = std::vector<QString>();
navigationSteps.push_back(stepCombinedModality);
m_NavigationStepNames.push_back("Combined Modality Initialization");
navigationSteps.push_back(stepTumourSelection);
m_NavigationStepNames.push_back("Target Selection");
navigationSteps.push_back(stepZoneMarking);
m_NavigationStepNames.push_back("Critical Structure Marking");
navigationSteps.push_back(stepPlacementPlanning);
m_NavigationStepNames.push_back("Placement Planning");
navigationSteps.push_back(stepMarkerIntervention);
m_NavigationStepNames.push_back("Marker Intervention");
}
// set navigation step widgets to the process widget
ui->navigationProcessWidget->SetNavigationSteps(navigationSteps);
for (QmitkUSNavigationProcessWidget::NavigationStepIterator it = m_NavigationSteps.begin();
it != m_NavigationSteps.end();
++it)
{
delete *it;
}
m_NavigationSteps.clear();
m_NavigationSteps = navigationSteps;
}
// initialize gui according to the experiment mode setting
bool experimentMode = false;
settings->GetBoolProperty("settings.experiment-mode", experimentMode);
ui->startExperimentButton->setVisible(experimentMode);
ui->finishExperimentButton->setVisible(experimentMode);
ui->runningLabel->setVisible(experimentMode);
if (experimentMode && !m_IsExperimentRunning)
{
ui->navigationProcessWidget->ResetNavigationProcess();
ui->navigationProcessWidget->EnableInteraction(false);
ui->runningLabel->setPixmap(m_IconNotRunning);
}
else if (!experimentMode)
{
if (m_IsExperimentRunning)
{
this->OnFinishExperiment();
}
ui->navigationProcessWidget->EnableInteraction(true);
}
// get the results directory from the settings and use home directory if
// there is no results directory configured
std::string resultsDirectory;
if (settings->GetStringProperty("settings.experiment-results-directory", resultsDirectory))
{
m_ResultsDirectory = QString::fromStdString(resultsDirectory);
}
else
{
m_ResultsDirectory = QDir::homePath();
}
// make sure that the results directory exists
QDir resultsDirectoryQDir = QDir(m_ResultsDirectory);
if (!resultsDirectoryQDir.exists())
{
resultsDirectoryQDir.mkpath(m_ResultsDirectory);
}
MITK_INFO("USNavigation") << "Results Directory: " << m_ResultsDirectory.toStdString();
}
void USNavigationMarkerPlacement::OnActiveNavigationStepChanged(int index)
{
// update navigation step timer each time the active navigation step changes
m_NavigationStepTimer->SetActiveIndex(index, m_NavigationSteps.at(index)->GetTitle().toStdString());
if (m_NavigationStepNames.size() <= index)
{
MITK_INFO("USNavigationLogging") << "Someting went wrong: unknown navigation step!";
}
else
{
MITK_INFO("USNavigationLogging") << "Navigation step finished/changed, next step: "
<< this->m_NavigationStepNames.at(index).toStdString()
<< "; duration until now: " << m_NavigationStepTimer->GetTotalDuration();
}
+}
- }
+void USNavigationMarkerPlacement::OnNextNavigationStepInitialization(int index)
+{
+ MITK_DEBUG << "Next Step: " << m_NavigationSteps.at(index)->GetTitle().toStdString();
- void USNavigationMarkerPlacement::OnNextNavigationStepInitialization(int index)
+ if (m_NavigationSteps.at(index)->GetTitle().toStdString() == "Computer-assisted Intervention")
{
-
- MITK_DEBUG << "Next Step: " << m_NavigationSteps.at(index)->GetTitle().toStdString();
-
- if (m_NavigationSteps.at(index)->GetTitle().toStdString() == "Computer-assisted Intervention")
+ QmitkUSNavigationStepPunctuationIntervention* navigationStepPunctuationIntervention = static_cast<QmitkUSNavigationStepPunctuationIntervention*>(m_NavigationSteps.at(index));
+ if (navigationStepPunctuationIntervention != nullptr)
{
- QmitkUSNavigationStepPunctuationIntervention* navigationStepPunctuationIntervention = static_cast<QmitkUSNavigationStepPunctuationIntervention*>(m_NavigationSteps.at(index));
- if (navigationStepPunctuationIntervention != nullptr)
+ if (m_CurrentStorage.IsNull()) { this->UpdateToolStorage(); }
+ if (m_CurrentStorage.IsNull() || (m_CurrentStorage->GetTool(m_NeedleIndex).IsNull()))
+ {
+ MITK_WARN << "Found null pointer when setting the tool axis, aborting";
+ }
+ else
{
- if (m_CurrentStorage.IsNull()) { this->UpdateToolStorage(); }
- if (m_CurrentStorage.IsNull() || (m_CurrentStorage->GetTool(m_NeedleIndex).IsNull()))
- {
- MITK_WARN << "Found null pointer when setting the tool axis, aborting";
- }
- else
- {
- navigationStepPunctuationIntervention->SetNeedleMetaData(m_CurrentStorage->GetTool(m_NeedleIndex));
- MITK_DEBUG << "Needle axis vector: " << m_CurrentStorage->GetTool(m_NeedleIndex)->GetToolAxis();
- }
+ navigationStepPunctuationIntervention->SetNeedleMetaData(m_CurrentStorage->GetTool(m_NeedleIndex));
+ MITK_DEBUG << "Needle axis vector: " << m_CurrentStorage->GetTool(m_NeedleIndex)->GetToolAxis();
}
}
-
+ }
}
void USNavigationMarkerPlacement::OnIntermediateResultProduced(const itk::SmartPointer<mitk::DataNode> resultsNode)
{
// intermediate results only matter during an experiment
if (!m_IsExperimentRunning)
{
return;
}
this->WaitCursorOn();
// set results node to the experiment logging (for saving contents to the
// file system)
m_ExperimentLogging->SetResult(resultsNode);
std::string resultsName;
if (!resultsNode->GetName(resultsName))
{
MITK_WARN << "Could not get name of current results node.";
return;
}
// save the mitk scene
std::string scenefile = QString(m_ExperimentResultsSubDirectory + QDir::separator() +
QString("Scene %1 - ").arg(m_SceneNumber++, 2, 10, QChar('0')) +
QString::fromStdString(resultsName).replace(":", "_") + ".mitk")
.toStdString();
MITK_INFO << "Saving Scene File: " << scenefile;
mitk::SceneIO::Pointer sceneIO = mitk::SceneIO::New();
mitk::NodePredicateNot::Pointer isNotHelperObject =
mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(true)));
mitk::DataStorage::SetOfObjects::ConstPointer nodesToBeSaved = this->GetDataStorage()->GetSubset(isNotHelperObject);
this->Convert2DImagesTo3D(nodesToBeSaved);
sceneIO->SaveScene(nodesToBeSaved, this->GetDataStorage(), scenefile);
this->WaitCursorOff();
}
void USNavigationMarkerPlacement::ReinitOnImage()
{
if (!m_ReinitAlreadyDone && m_CombinedModality.IsNotNull())
{
// make sure that the output is already calibrated correctly
// (if the zoom level was changed recently)
m_CombinedModality->Modified();
m_CombinedModality->Update();
mitk::Image::Pointer image = m_CombinedModality->GetOutput();
if (image.IsNotNull() && image->IsInitialized())
{
// make a reinit on the ultrasound image
mitk::IRenderWindowPart *renderWindow = this->GetRenderWindowPart();
if (renderWindow != NULL && image->GetTimeGeometry()->IsValid())
{
renderWindow->GetRenderingManager()->InitializeViews(
image->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
renderWindow->GetRenderingManager()->RequestUpdateAll();
}
this->RequestRenderWindowUpdate();
m_ReinitAlreadyDone = true;
}
}
}
void USNavigationMarkerPlacement::Convert2DImagesTo3D(mitk::DataStorage::SetOfObjects::ConstPointer nodes)
{
for (mitk::DataStorage::SetOfObjects::ConstIterator it = nodes->Begin(); it != nodes->End(); ++it)
{
if (it->Value()->GetData() && strcmp(it->Value()->GetData()->GetNameOfClass(), "Image") == 0)
{
// convert image to 3d image if it is 2d at the moment
mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(it->Value()->GetData());
if (image.IsNotNull() && image->GetDimension() == 2 && !image->GetGeometry()->Is2DConvertable())
{
mitk::Convert2Dto3DImageFilter::Pointer convert2DTo3DImageFilter = mitk::Convert2Dto3DImageFilter::New();
convert2DTo3DImageFilter->SetInput(image);
convert2DTo3DImageFilter->Update();
it->Value()->SetData(convert2DTo3DImageFilter->GetOutput());
}
}
}
}
void USNavigationMarkerPlacement::CreateOverlays()
{
// initialize warning overlay (and do not display it, yet)
m_WarnOverlay->SetText("Warning: No calibration available for current depth.");
// set position and font size for the text overlay
// (nonesense postition as a layouter is used, but it ignored
// the overlay without setting a position here)
mitk::Point2D overlayPosition;
overlayPosition.SetElement(0, -50.0f);
overlayPosition.SetElement(1, -50.0f);
m_WarnOverlay->SetPosition2D(overlayPosition);
m_WarnOverlay->SetFontSize(22);
m_WarnOverlay->SetColor(1, 0, 0); // overlay should be red
}
void USNavigationMarkerPlacement::UpdateToolStorage()
{
if (m_NavigationDataSource.IsNull()) { m_NavigationDataSource = m_CombinedModality->GetNavigationDataSource(); }
if (m_NavigationDataSource.IsNull()) { MITK_WARN << "Found an invalid navigation data source object!"; }
us::ModuleContext* context = us::GetModuleContext();
std::string id = m_NavigationDataSource->US_PROPKEY_ID;
std::string filter = "(" + mitk::NavigationToolStorage::US_PROPKEY_SOURCE_ID + "=" + id + ")";
// Get Storage
std::vector<us::ServiceReference<mitk::NavigationToolStorage> > refs = context->GetServiceReferences<mitk::NavigationToolStorage>();
m_CurrentStorage = context->GetService(refs.front());
if (m_CurrentStorage.IsNull())
{
MITK_WARN << "Found an invalid storage object!";
}
else if (m_CurrentStorage->GetToolCount() != m_NavigationDataSource->GetNumberOfOutputs()) //there is something wrong with the storage
{
MITK_WARN << "Found a tool storage, but it has not the same number of tools like the NavigationDataSource. This storage won't be used because it isn't the right one.";
m_CurrentStorage = NULL;
}
-}
+}
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.h b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.h
index b95448c856..6c981fce96 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.h
@@ -1,207 +1,216 @@
/*===================================================================
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 USNAVIGATIONMARKERPLACEMENT_H
#define USNAVIGATIONMARKERPLACEMENT_H
#include <QmitkAbstractView.h>
#include "IO/mitkUSNavigationLoggingBackend.h"
#include "Widgets/QmitkUSNavigationProcessWidget.h"
#include "mitkNavigationDataRecorder.h"
#include "mitkNodeDisplacementFilter.h"
#include "mitkUSImageLoggingFilter.h"
#include <mitkMessage.h>
#include <mitkTextAnnotation2D.h>
#include <mitkUSCombinedModality.h>
#include <mitkNavigationToolStorage.h>
namespace itk
{
- template <class T>
- class SmartPointer;
+ template <class T>
+ class SmartPointer;
}
namespace mitk
{
- class USNavigationStepTimer;
- class USNavigationExperimentLogging;
+ class USNavigationStepTimer;
+ class USNavigationExperimentLogging;
}
namespace Ui
{
- class USNavigationMarkerPlacement;
+ class USNavigationMarkerPlacement;
}
class QmitkUSAbstractNavigationStep;
class QmitkUSNavigationStepPunctuationIntervention;
class QmitkStdMultiWidget;
class QTimer;
class QSignalMapper;
/**
* \brief View for navigated marker placement using the combined modality.
* This view utilizes the QmitkUSNavigationProcessWidget to do the navigation
* process. It can be switched between widgets for marker placement and widgets
* for punctuation.
*
* An experiment mode allows for logging results, durations and the ultrasound
* images.
*/
class USNavigationMarkerPlacement : public QmitkAbstractView
{
- Q_OBJECT
-
- protected slots:
- /**
- * \brief Called periodically to update the rendering.
- * The standard multi widget is changed to fit the navigation process once it
- * is available and a reinit on the ultrasound image is done for a new image
- * node.
- */
- void OnTimeout();
-
- /**
- * \brief Called periodically during an experiment for logging the ultrasound images.
- */
- void OnImageAndNavigationDataLoggingTimeout();
-
- /**
- * \brief Initializes anything neccessary for an experiment.
- * The user is asked for a directory for storing the results and the logging
- * is started.
- */
- void OnStartExperiment();
-
- /**
- * \brief Stops logging and saves everything to the file system.
- */
- void OnFinishExperiment();
-
- void OnCombinedModalityChanged(itk::SmartPointer<mitk::USCombinedModality>);
-
- /**
- * \brief Switches the navigation step widgets if the navigation application was changed.
- */
- void OnSettingsChanged(itk::SmartPointer<mitk::DataNode>);
-
- /**
- * \brief Updates the timer for the navigation steps durations every time the active navigation step changes.
- */
- void OnActiveNavigationStepChanged(int);
+ Q_OBJECT
+
+ protected slots:
+ /**
+ * \brief Called periodically to update the rendering.
+ * The standard multi widget is changed to fit the navigation process once it
+ * is available and a reinit on the ultrasound image is done for a new image
+ * node.
+ */
+ void OnTimeout();
+
+ /**
+ * \brief Called periodically during an experiment for logging the ultrasound images.
+ */
+ void OnImageAndNavigationDataLoggingTimeout();
+
+ /**
+ * \brief Initializes anything neccessary for an experiment.
+ * The user is asked for a directory for storing the results and the logging
+ * is started.
+ */
+ void OnStartExperiment();
+
+ /**
+ * \brief Stops logging and saves everything to the file system.
+ */
+ void OnFinishExperiment();
+
+ void OnCombinedModalityChanged(itk::SmartPointer<mitk::USCombinedModality>);
+
+ /**
+ * \brief Switches the navigation step widgets if the navigation application was changed.
+ */
+ void OnSettingsChanged(itk::SmartPointer<mitk::DataNode>);
+
+ /**
+ * \brief Updates the timer for the navigation steps durations every time the active navigation step changes.
+ */
+ void OnActiveNavigationStepChanged(int);
/** Initializes the next navigation step */
void OnNextNavigationStepInitialization(int);
- /**
- * \brief The data node is given to the experiment logging and scene is saved to the file system.
- */
- void OnIntermediateResultProduced(const itk::SmartPointer<mitk::DataNode>);
+ /**
+ * \brief The data node is given to the experiment logging and scene is saved to the file system.
+ */
+ void OnIntermediateResultProduced(const itk::SmartPointer<mitk::DataNode>);
- void OnAddAblationZone(int size);
+ void OnAddAblationZone(int size);
void OnEnableNavigationLayout();
void OnResetStandardLayout();
void OnChangeLayoutClicked();
- void OnChangeAblationZone(int id, int newSize);
+ void OnChangeAblationZone(int id, int newSize);
-public:
- static const char *DATANAME_TUMOUR;
- static const char *DATANAME_TARGETSURFACE;
- static const char *DATANAME_ZONES;
- static const char *DATANAME_TARGETS;
- static const char *DATANAME_TARGETS_PATHS;
- static const char *DATANAME_REACHED_TARGETS;
+ void OnRenderWindowSelection();
- explicit USNavigationMarkerPlacement();
- ~USNavigationMarkerPlacement();
+ void OnRefreshView();
- virtual void CreateQtPartControl(QWidget *parent);
+public:
+ static const char *DATANAME_TUMOUR;
+ static const char *DATANAME_TARGETSURFACE;
+ static const char *DATANAME_ZONES;
+ static const char *DATANAME_TARGETS;
+ static const char *DATANAME_TARGETS_PATHS;
+ static const char *DATANAME_REACHED_TARGETS;
- static const std::string VIEW_ID;
+ explicit USNavigationMarkerPlacement();
+ ~USNavigationMarkerPlacement();
- void OnCombinedModalityPropertyChanged(const std::string &, const std::string &);
+ virtual void CreateQtPartControl(QWidget *parent);
-protected:
- /**
- * \brief A reinit on the ultrasound image is performed every time the view gets the focus.
- */
- virtual void SetFocus();
+ static const std::string VIEW_ID;
- /**
- * \brief Helper function which performs a reinit on the ultrasound image.
- */
- void ReinitOnImage();
+ void OnCombinedModalityPropertyChanged(const std::string &, const std::string &);
- /**
- * \brief Helper function for being able to serialize the 2d ultrasound image.
- */
- void Convert2DImagesTo3D(mitk::DataStorage::SetOfObjects::ConstPointer nodes);
+protected:
+ /**
+ * \brief A reinit on the ultrasound image is performed every time the view gets the focus.
+ */
+ virtual void SetFocus();
+
+ /**
+ * \brief Sets the multiwidget to two windows, axial on top and 3D render window on the bottom.
+ */
+ virtual void SetTwoWindowView();
+
+ /**
+ * \brief Helper function which performs a reinit on the ultrasound image.
+ */
+ void ReinitOnImage();
+
+ /**
+ * \brief Helper function for being able to serialize the 2d ultrasound image.
+ */
+ void Convert2DImagesTo3D(mitk::DataStorage::SetOfObjects::ConstPointer nodes);
void UpdateToolStorage();
- void CreateOverlays();
+ void CreateOverlays();
- QWidget *m_Parent;
- QmitkUSNavigationProcessWidget::NavigationStepVector m_NavigationSteps;
- QTimer *m_UpdateTimer;
- QTimer *m_ImageAndNavigationDataLoggingTimer;
- QmitkStdMultiWidget *m_StdMultiWidget;
- itk::SmartPointer<mitk::USCombinedModality> m_CombinedModality;
- bool m_ReinitAlreadyDone;
- bool m_IsExperimentRunning;
- std::string m_CurrentApplicationName;
+ QWidget *m_Parent;
+ QmitkUSNavigationProcessWidget::NavigationStepVector m_NavigationSteps;
+ QTimer *m_UpdateTimer;
+ QTimer *m_ImageAndNavigationDataLoggingTimer;
+ QmitkStdMultiWidget *m_StdMultiWidget;
+ itk::SmartPointer<mitk::USCombinedModality> m_CombinedModality;
+ bool m_ReinitAlreadyDone;
+ bool m_IsExperimentRunning;
+ std::string m_CurrentApplicationName;
- itk::SmartPointer<mitk::USNavigationStepTimer> m_NavigationStepTimer;
- itk::SmartPointer<mitk::USNavigationExperimentLogging> m_ExperimentLogging;
+ itk::SmartPointer<mitk::USNavigationStepTimer> m_NavigationStepTimer;
+ itk::SmartPointer<mitk::USNavigationExperimentLogging> m_ExperimentLogging;
- QPixmap m_IconRunning;
- QPixmap m_IconNotRunning;
+ QPixmap m_IconRunning;
+ QPixmap m_IconNotRunning;
- QString m_ResultsDirectory;
- QString m_ExperimentName;
- QString m_ExperimentResultsSubDirectory;
- std::vector<QString>
- m_NavigationStepNames; // stores the names of the navigation steps which are currently used (for logging purposes)
+ QString m_ResultsDirectory;
+ QString m_ExperimentName;
+ QString m_ExperimentResultsSubDirectory;
+ std::vector<QString>
+ m_NavigationStepNames; // stores the names of the navigation steps which are currently used (for logging purposes)
- mitk::USNavigationLoggingBackend m_LoggingBackend;
- mitk::USImageLoggingFilter::Pointer m_USImageLoggingFilter;
- mitk::NavigationDataRecorder::Pointer m_NavigationDataRecorder; // records navigation data files
- mitk::NodeDisplacementFilter::Pointer m_TargetNodeDisplacementFilter;
- mitk::NodeDisplacementFilter::Pointer m_AblationZonesDisplacementFilter;
- std::vector<mitk::DataNode::Pointer> m_AblationZonesVector;
+ mitk::USNavigationLoggingBackend m_LoggingBackend;
+ mitk::USImageLoggingFilter::Pointer m_USImageLoggingFilter;
+ mitk::NavigationDataRecorder::Pointer m_NavigationDataRecorder; // records navigation data files
+ mitk::NodeDisplacementFilter::Pointer m_TargetNodeDisplacementFilter;
+ mitk::NodeDisplacementFilter::Pointer m_AblationZonesDisplacementFilter;
+ std::vector<mitk::DataNode::Pointer> m_AblationZonesVector;
- int m_NeedleIndex;
- int m_MarkerIndex;
+ int m_NeedleIndex;
+ int m_MarkerIndex;
- int m_SceneNumber;
+ int m_SceneNumber;
- itk::SmartPointer<mitk::TextAnnotation2D> m_WarnOverlay;
+ itk::SmartPointer<mitk::TextAnnotation2D> m_WarnOverlay;
//To get tool storage
mitk::NavigationDataSource::Pointer m_NavigationDataSource;
mitk::NavigationToolStorage::Pointer m_CurrentStorage;
private:
- mitk::MessageDelegate2<USNavigationMarkerPlacement, const std::string &, const std::string &> m_ListenerDeviceChanged;
+ mitk::MessageDelegate2<USNavigationMarkerPlacement, const std::string &, const std::string &> m_ListenerDeviceChanged;
- Ui::USNavigationMarkerPlacement *ui;
+ Ui::USNavigationMarkerPlacement *ui;
};
#endif // USNAVIGATIONMARKERPLACEMENT_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.ui b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.ui
index eb816e0225..a181fe0767 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.ui
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.ui
@@ -1,102 +1,123 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>USNavigationMarkerPlacement</class>
<widget class="QWidget" name="USNavigationMarkerPlacement">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>400</width>
<height>146</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<property name="spacing">
<number>0</number>
</property>
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QmitkUSNavigationProcessWidget" name="navigationProcessWidget" native="true"/>
</item>
<item>
<widget class="Line" name="line">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
</widget>
</item>
<item>
- <widget class="QCheckBox" name="m_enableNavigationLayout">
- <property name="text">
- <string>Enable Navigation Render Window Layout</string>
- </property>
- <property name="checked">
- <bool>true</bool>
- </property>
- </widget>
+ <layout class="QHBoxLayout" name="horizontalLayout_2">
+ <item>
+ <widget class="QCheckBox" name="m_enableNavigationLayout">
+ <property name="text">
+ <string>Enable Navigation Render Window Layout with RenderWindow</string>
+ </property>
+ <property name="checked">
+ <bool>true</bool>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QSpinBox" name="m_RenderWindowSelection">
+ <property name="minimum">
+ <number>1</number>
+ </property>
+ <property name="maximum">
+ <number>3</number>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QPushButton" name="m_RefreshView">
+ <property name="text">
+ <string>Refresh view</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<widget class="QPushButton" name="startExperimentButton">
<property name="text">
<string>Start New Experiment</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="finishExperimentButton">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>Finish Experiment</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="runningLabel">
<property name="maximumSize">
<size>
<width>20</width>
<height>20</height>
</size>
</property>
<property name="text">
<string/>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
<customwidgets>
<customwidget>
<class>QmitkUSNavigationProcessWidget</class>
<extends>QWidget</extends>
<header>src/internal/Widgets/QmitkUSNavigationProcessWidget.h</header>
<container>1</container>
</customwidget>
</customwidgets>
<resources/>
<connections/>
<slots>
<slot>OnStartExperiment()</slot>
<slot>OnFinishExperiment()</slot>
</slots>
</ui>