diff --git a/Modules/IGT/DataManagement/mitkNavigationToolStorage.cpp b/Modules/IGT/DataManagement/mitkNavigationToolStorage.cpp
index 45ea224a70..85b8e27465 100644
--- a/Modules/IGT/DataManagement/mitkNavigationToolStorage.cpp
+++ b/Modules/IGT/DataManagement/mitkNavigationToolStorage.cpp
@@ -1,239 +1,239 @@
/*===================================================================
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 "mitkNavigationToolStorage.h"
//Microservices
#include <usGetModuleContext.h>
#include <usModule.h>
#include <usModuleContext.h>
const std::string mitk::NavigationToolStorage::US_INTERFACE_NAME = "org.mitk.services.NavigationToolStorage"; // Name of the interface
const std::string mitk::NavigationToolStorage::US_PROPKEY_SOURCE_ID = US_INTERFACE_NAME + ".sourceID";
const std::string mitk::NavigationToolStorage::US_PROPKEY_STORAGE_NAME = US_INTERFACE_NAME + ".name";
mitk::NavigationToolStorage::NavigationToolStorage()
: m_ToolCollection(std::vector<mitk::NavigationTool::Pointer>()),
m_DataStorage(nullptr),
m_storageLocked(false)
{
this->SetName("ToolStorage (no name given)");
}
mitk::NavigationToolStorage::NavigationToolStorage(mitk::DataStorage::Pointer ds)
: m_storageLocked(false)
{
m_ToolCollection = std::vector<mitk::NavigationTool::Pointer>();
this->m_DataStorage = ds;
this->SetName("Tool Storage (no name given)");
}
void mitk::NavigationToolStorage::SetName(std::string n)
{
m_Name = n;
m_props[US_PROPKEY_STORAGE_NAME] = m_Name;
}
std::string mitk::NavigationToolStorage::GetName() const
{
return m_Name;
}
void mitk::NavigationToolStorage::UpdateMicroservice()
{
if (m_ServiceRegistration) { m_ServiceRegistration.SetProperties(m_props); }
}
mitk::NavigationToolStorage::~NavigationToolStorage()
{
if (m_DataStorage.IsNotNull()) //remove all nodes from the data storage
{
for (std::vector<mitk::NavigationTool::Pointer>::iterator it = m_ToolCollection.begin(); it != m_ToolCollection.end(); it++)
m_DataStorage->Remove((*it)->GetDataNode());
}
}
void mitk::NavigationToolStorage::RegisterAsMicroservice(){
// Get Context
us::ModuleContext* context = us::GetModuleContext();
// Define ServiceProps
m_ServiceRegistration = context->RegisterService(this, m_props);
//Tell all widgets, that there is a new toolStorage registered, e.g. the old one might have changed.
UpdateMicroservice();
}
void mitk::NavigationToolStorage::UnRegisterMicroservice(){
if (!m_ServiceRegistration)
{
MITK_WARN("NavigationToolStorage")
<< "Cannot unregister microservice as it wasn't registered before.";
return;
}
m_ServiceRegistration.Unregister();
m_ServiceRegistration = 0;
}
bool mitk::NavigationToolStorage::DeleteTool(int number)
{
if (m_storageLocked)
{
MITK_WARN << "Storage is locked, cannot modify it!";
return false;
}
else if ((unsigned int)number > m_ToolCollection.size())
{
MITK_WARN << "Tool no " << number << "doesn't exist, can't delete it!";
return false;
}
std::vector<mitk::NavigationTool::Pointer>::iterator it = m_ToolCollection.begin() + number;
if (m_DataStorage.IsNotNull())
m_DataStorage->Remove((*it)->GetDataNode());
m_ToolCollection.erase(it);
//This line is important so that other widgets can get a notice that the toolStorage has changed!
this->UpdateMicroservice();
return true;
}
bool mitk::NavigationToolStorage::DeleteAllTools()
{
if (m_storageLocked)
{
MITK_WARN << "Storage is locked, cannot modify it!";
return false;
}
while (m_ToolCollection.size() > 0) if (!DeleteTool(0)) return false;
return true;
}
bool mitk::NavigationToolStorage::AddTool(mitk::NavigationTool::Pointer tool)
{
if (m_storageLocked)
{
MITK_WARN << "Storage is locked, cannot modify it!";
return false;
}
else if (GetTool(tool->GetIdentifier()).IsNotNull())
{
MITK_WARN << "Tool ID already exists in storage, can't add!";
return false;
}
else
{
m_ToolCollection.push_back(tool);
if (m_DataStorage.IsNotNull())
{
if (!m_DataStorage->Exists(tool->GetDataNode()))
m_DataStorage->Add(tool->GetDataNode());
}
//This line is important so that other widgets can get a notice that the toolStorage has changed!
this->UpdateMicroservice();
return true;
}
}
mitk::NavigationTool::Pointer mitk::NavigationToolStorage::GetTool(int number)
{
return m_ToolCollection.at(number);
}
mitk::NavigationTool::Pointer mitk::NavigationToolStorage::GetTool(std::string identifier)
{
- for (int i = 0; i < GetToolCount(); i++) if ((GetTool(i)->GetIdentifier()) == identifier) return GetTool(i);
+ for (unsigned int i = 0; i < GetToolCount(); i++) if ((GetTool(i)->GetIdentifier()) == identifier) return GetTool(i);
return nullptr;
}
mitk::NavigationTool::Pointer mitk::NavigationToolStorage::GetToolByName(std::string name)
{
- for (int i = 0; i < GetToolCount(); i++) if ((GetTool(i)->GetToolName()) == name) return GetTool(i);
+ for (unsigned int i = 0; i < GetToolCount(); i++) if ((GetTool(i)->GetToolName()) == name) return GetTool(i);
return nullptr;
}
-int mitk::NavigationToolStorage::GetToolCount()
+unsigned int mitk::NavigationToolStorage::GetToolCount()
{
return m_ToolCollection.size();
}
bool mitk::NavigationToolStorage::isEmpty()
{
return m_ToolCollection.empty();
}
void mitk::NavigationToolStorage::LockStorage()
{
m_storageLocked = true;
}
void mitk::NavigationToolStorage::UnLockStorage()
{
m_storageLocked = false;
}
bool mitk::NavigationToolStorage::isLocked()
{
return m_storageLocked;
}
bool mitk::NavigationToolStorage::AssignToolNumber(std::string identifier1, int number2)
{
if (this->GetTool(identifier1).IsNull())
{
MITK_WARN << "Identifier does not exist, cannot assign new number";
return false;
}
if ((number2 >= static_cast<int>(m_ToolCollection.size())) || (number2 < 0))
{
MITK_WARN << "Invalid number, cannot assign new number";
return false;
}
mitk::NavigationTool::Pointer tool2 = m_ToolCollection.at(number2);
int number1 = -1;
for(int i = 0; i<static_cast<int>(m_ToolCollection.size()); i++)
{
if (m_ToolCollection.at(i)->GetIdentifier() == identifier1) { number1 = i; }
}
m_ToolCollection[number2] = m_ToolCollection.at(number1);
m_ToolCollection[number1] = tool2;
MITK_DEBUG << "Swapped tool " << number2 << " with tool " << number1;
//This line is important so that other widgets can get a notice that the toolStorage has changed!
this->UpdateMicroservice();
return true;
}
void mitk::NavigationToolStorage::SetSourceID(std::string _id)
{
m_SourceID = _id;
m_props[US_PROPKEY_SOURCE_ID] = m_SourceID;
}
/** @return Returns the name of this storage. */
std::string mitk::NavigationToolStorage::GetSourceID() const
{
return m_SourceID;
-}
\ No newline at end of file
+}
diff --git a/Modules/IGT/DataManagement/mitkNavigationToolStorage.h b/Modules/IGT/DataManagement/mitkNavigationToolStorage.h
index e31e804a3f..74fcbef42b 100644
--- a/Modules/IGT/DataManagement/mitkNavigationToolStorage.h
+++ b/Modules/IGT/DataManagement/mitkNavigationToolStorage.h
@@ -1,201 +1,201 @@
/*===================================================================
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 NAVIGATIONTOOLSTORAGE_H_INCLUDED
#define NAVIGATIONTOOLSTORAGE_H_INCLUDED
//itk headers
#include <itkObjectFactory.h>
//mitk headers
#include <mitkCommon.h>
#include <MitkIGTExports.h>
#include "mitkNavigationTool.h"
#include <mitkDataStorage.h>
// Microservices
#include <mitkServiceInterface.h>
#include <usServiceRegistration.h>
#include <usServiceProperties.h>
namespace mitk {
/**Documentation
* \brief An object of this class represents a collection of navigation tools.
* You may add/delete navigation tools or store/load the whole collection
* to/from the harddisc by using the class NavigationToolStorageSerializer
* and NavigationToolStorageDeserializer.
*
* \ingroup IGT
*/
class MITKIGT_EXPORT NavigationToolStorage : public itk::Object
{
public:
mitkClassMacroItkParent(NavigationToolStorage,itk::Object);
/** @brief Constructs a NavigationToolStorage without reference to a DataStorage. The Data Nodes of tools have to be added and removed to a data storage outside this class.
* Normaly the other constructor should be used.
*/
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
/** @brief Constructs a NavigationToolStorage with reference to a DataStorage. The Data Nodes of tools are added and removed automatically to this data storage. */
mitkNewMacro1Param(Self,mitk::DataStorage::Pointer);
/**
*\brief Registers this object as a Microservice, making it available to every module and/or plugin.
* To unregister, call UnregisterMicroservice(). Make sure to pass the id of the Device that this tool is connected to.
*/
virtual void RegisterAsMicroservice();
/**
*\brief Registers this object as a Microservice, making it available to every module and/or plugin.
*/
virtual void UnRegisterMicroservice();
/**
*\brief Returns the id that this device is registered with. The id will only be valid, if the
* NavigationDataSource has been registered using RegisterAsMicroservice().
*/
std::string GetMicroserviceID();
/**
*\brief These constants are used in conjunction with Microservices
*/
// Name of the interface
static const std::string US_INTERFACE_NAME;
// ID of the NavigationDataSource this ToolStorage is associated with. Can be empty ("") and changed with SetSourceID().
static const std::string US_PROPKEY_SOURCE_ID;
// name of the storage
static const std::string US_PROPKEY_STORAGE_NAME;
/**
* @brief Adds a tool to the storage. Be sure that the tool has a unique
* identifier which is not already part of this storage.
* @return Returns true if the tool was added to the storage, false if not
* (false can be returned if the identifier already exists in this storage
* for example).
*/
bool AddTool(mitk::NavigationTool::Pointer tool);
/**
* @return Returns the tracking tool at the position "number"
* in the storage. Returns nullptr if there is no
* tracking tool at this position.
*/
mitk::NavigationTool::Pointer GetTool(int number);
/**
* @return Returns the tracking tool with the given identifier.
* Returns nullptr if there is no
* tracking tool with this identifier in the storage.
*/
mitk::NavigationTool::Pointer GetTool(std::string identifier);
/**
* @return Returns the tracking tool with the given name.
* Returns nullptr if there is no
* tracking tool with this name in the storage.
*/
mitk::NavigationTool::Pointer GetToolByName(std::string name);
/** Assigns the given number to the tool with the given identifier. This means the tool is swapped with another tool in the internal tool vector.
* @return Returns true if the assignment was successfull. Returns false if assignment is not possible, e.g. because the identifier does not exist or if the given number is not available.
**/
bool AssignToolNumber(std::string identifier1, int number2);
/**
* @brief Deletes a tool from the collection.
* Warning, this method operates on the data storage and is not thread save. Calling it from outside the main thread may cause crashes.
*/
bool DeleteTool(int number);
/**
* @brief Deletes all tools from the collection.
* Warning, this method operates on the data storage and is not thread save. Calling it from outside the main thread may cause crashes.
*/
bool DeleteAllTools();
/**
* @return Returns the number of tools stored in the storage.
*/
- int GetToolCount();
+ unsigned int GetToolCount();
/**
* @return Returns true if the storage is empty, false if not.
*/
bool isEmpty();
/**
* @return Returns the corresponding data storage if one is set to this NavigationToolStorage.
* Returns nullptr if none is set.
*/
itkGetMacro(DataStorage,mitk::DataStorage::Pointer);
/** Sets the name of this storage. The name should be understandable for the user.
* Something like "NDI Aurora Tool Storage". If a storage is loaded from the harddisk
* the name might be the filename.
*/
void SetName(std::string);
/** @return Returns the name of this storage. */
std::string GetName() const;
/** Sets the name of this storage. The name should be understandable for the user.
* Something like "NDI Aurora Tool Storage". If a storage is loaded from the harddisk
* the name might be the filename.
* @warning: if your microservice is already registered, you need to call UpdateMicroservice after changing the ID.
* This can't be done inside this functions, as we might use different threads.
*/
void SetSourceID(std::string);
/** @return Returns the name of this storage. */
std::string GetSourceID() const;
/** Locks the storage. A logged storage may not be modified.
* If a method tries to modify the storage anyway a waring message is given.
* The storage is unlocked by default. A Storage might be locked when a
* tracking device is active and needs the storage to stay consistent.
*/
void LockStorage();
/** Unlocks the storage again. */
void UnLockStorage();
/** @return Returns true if the storage is locked at the moment, false if not. */
bool isLocked();
/** Sets the properties which causes the microservice to emit an update signal. */
void UpdateMicroservice();
protected:
NavigationToolStorage();
NavigationToolStorage(mitk::DataStorage::Pointer);
~NavigationToolStorage();
std::vector<mitk::NavigationTool::Pointer> m_ToolCollection;
mitk::DataStorage::Pointer m_DataStorage;
std::string m_Name;
std::string m_SourceID;
bool m_storageLocked;
private:
us::ServiceRegistration<Self> m_ServiceRegistration;
us::ServiceProperties m_props;
};
} // namespace mitk
MITK_DECLARE_SERVICE_INTERFACE(mitk::NavigationToolStorage, "org.mitk.services.NavigationToolStorage")
#endif //NAVIGATIONTOOLSTORAGE
diff --git a/Modules/IGT/DataManagement/mitkTrackingDeviceSourceConfigurator.cpp b/Modules/IGT/DataManagement/mitkTrackingDeviceSourceConfigurator.cpp
index dec53c3505..43d5eb3dd2 100644
--- a/Modules/IGT/DataManagement/mitkTrackingDeviceSourceConfigurator.cpp
+++ b/Modules/IGT/DataManagement/mitkTrackingDeviceSourceConfigurator.cpp
@@ -1,175 +1,175 @@
/*===================================================================
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 "mitkTrackingDeviceSourceConfigurator.h"
#include "mitkNDITrackingDevice.h"
#include "mitkClaronTrackingDevice.h"
#include "mitkOptitrackTrackingDevice.h"
#include "mitkOpenIGTLinkTrackingDevice.h"
#include "mitkVirtualTrackingDevice.h"
#include <mitkIGTException.h>
#include <mitkIGTHardwareException.h>
#include <usGetModuleContext.h>
#include <usModule.h>
#include <usServiceProperties.h>
#include <usModuleContext.h>
#include <mitkTrackingDeviceTypeCollection.h>
mitk::TrackingDeviceSourceConfigurator::TrackingDeviceSourceConfigurator(mitk::NavigationToolStorage::Pointer NavigationTools, mitk::TrackingDevice::Pointer TrackingDevice)
{
//make a copy of the navigation tool storage because we will modify the storage
if (NavigationTools.IsNotNull())
{
m_NavigationTools = mitk::NavigationToolStorage::New();
- for (int i=0; i<NavigationTools->GetToolCount(); i++)
+ for (unsigned int i=0; i<NavigationTools->GetToolCount(); i++)
{
m_NavigationTools->AddTool(NavigationTools->GetTool(i));
}
}
m_TrackingDevice = TrackingDevice;
m_ToolCorrespondencesInToolStorage = std::vector<int>();
m_ErrorMessage = "";
}
mitk::NavigationToolStorage::Pointer mitk::TrackingDeviceSourceConfigurator::GetUpdatedNavigationToolStorage()
{
return m_NavigationTools;
}
mitk::TrackingDeviceSourceConfigurator::~TrackingDeviceSourceConfigurator()
{
}
bool mitk::TrackingDeviceSourceConfigurator::IsCreateTrackingDeviceSourcePossible()
{
if (m_NavigationTools.IsNull())
{
m_ErrorMessage = "NavigationToolStorage is nullptr!";
return false;
}
else if (m_TrackingDevice.IsNull())
{
m_ErrorMessage = "TrackingDevice is nullptr!";
return false;
}
else
{
- for (int i=0; i<m_NavigationTools->GetToolCount(); i++)
+ for (unsigned int i=0; i<m_NavigationTools->GetToolCount(); i++)
{
if (m_NavigationTools->GetTool(i)->GetTrackingDeviceType() != m_TrackingDevice->GetType())
{
m_ErrorMessage = "At least one tool is not of the same type like the tracking device.";
return false;
}
}
//TODO in case of Aurora: check if the tools are automatically detected by comparing the serial number
return true;
}
}
mitk::TrackingDeviceSource::Pointer mitk::TrackingDeviceSourceConfigurator::CreateTrackingDeviceSource()
{
mitk::NavigationDataObjectVisualizationFilter::Pointer dummy; //this dummy is lost directly after creating the device
return this->CreateTrackingDeviceSource(dummy);
}
mitk::TrackingDeviceSource::Pointer mitk::TrackingDeviceSourceConfigurator::CreateTrackingDeviceSource(mitk::NavigationDataObjectVisualizationFilter::Pointer &visualizationFilter)
{
if (!this->IsCreateTrackingDeviceSourcePossible()) {MITK_WARN << "Cannot create tracking decive: " << m_ErrorMessage; return nullptr;}
mitk::TrackingDeviceSource::Pointer returnValue;
us::ModuleContext* context = us::GetModuleContext();
std::vector<us::ServiceReference<mitk::TrackingDeviceTypeCollection> > refs = context->GetServiceReferences<mitk::TrackingDeviceTypeCollection>();
if (refs.empty())
{
MITK_ERROR << "No tracking device service found!";
}
mitk::TrackingDeviceTypeCollection* deviceTypeCollection = context->GetService<mitk::TrackingDeviceTypeCollection>(refs.front());
//create tracking device source
returnValue = deviceTypeCollection->GetTrackingDeviceTypeInformation(m_TrackingDevice->GetType())->
CreateTrackingDeviceSource(m_TrackingDevice,m_NavigationTools, &m_ErrorMessage, &m_ToolCorrespondencesInToolStorage);
//TODO: insert other tracking systems?
if (returnValue.IsNull()) {MITK_WARN << "Cannot create tracking decive: " << m_ErrorMessage; return nullptr;}
//create visualization filter
visualizationFilter = CreateNavigationDataObjectVisualizationFilter(returnValue,m_NavigationTools);
if (visualizationFilter.IsNull()) {MITK_WARN << "Cannot create tracking decive: " << m_ErrorMessage; return nullptr;}
return returnValue;
}
std::string mitk::TrackingDeviceSourceConfigurator::GetErrorMessage()
{
return this->m_ErrorMessage;
}
//############################ internal help methods ########################################
mitk::NavigationDataObjectVisualizationFilter::Pointer mitk::TrackingDeviceSourceConfigurator::CreateNavigationDataObjectVisualizationFilter(mitk::TrackingDeviceSource::Pointer trackingDeviceSource, mitk::NavigationToolStorage::Pointer navigationTools)
{
mitk::NavigationDataObjectVisualizationFilter::Pointer returnValue = mitk::NavigationDataObjectVisualizationFilter::New();
for (unsigned int i=0; i<trackingDeviceSource->GetNumberOfIndexedOutputs(); i++)
{
// Note: If all tools have the same name only the first tool will always be returned and
// the others won't be updated during rendering.This could potentially lead to inconstencies
mitk::NavigationTool::Pointer currentTool = navigationTools->GetToolByName(trackingDeviceSource->GetOutput(i)->GetName());
if (currentTool.IsNull())
{
this->m_ErrorMessage = "Error: did not find corresponding tool in tracking device after initialization.";
return nullptr;
}
returnValue->SetInput(i,trackingDeviceSource->GetOutput(i));
returnValue->SetRepresentationObject(i,currentTool->GetDataNode()->GetData());
}
return returnValue;
}
int mitk::TrackingDeviceSourceConfigurator::GetToolNumberInToolStorage(unsigned int outputID)
{
if (outputID < m_ToolCorrespondencesInToolStorage.size()) return m_ToolCorrespondencesInToolStorage.at(outputID);
else return -1;
}
std::string mitk::TrackingDeviceSourceConfigurator::GetToolIdentifierInToolStorage(unsigned int outputID)
{
if (outputID < m_ToolCorrespondencesInToolStorage.size()) return m_NavigationTools->GetTool(m_ToolCorrespondencesInToolStorage.at(outputID))->GetIdentifier();
else return "";
}
std::vector<int> mitk::TrackingDeviceSourceConfigurator::GetToolNumbersInToolStorage()
{
return m_ToolCorrespondencesInToolStorage;
}
std::vector<std::string> mitk::TrackingDeviceSourceConfigurator::GetToolIdentifiersInToolStorage()
{
std::vector<std::string> returnValue = std::vector<std::string>();
for (unsigned int i=0; i<m_ToolCorrespondencesInToolStorage.size(); i++)
{returnValue.push_back(m_NavigationTools->GetTool(m_ToolCorrespondencesInToolStorage.at(i))->GetIdentifier());}
return returnValue;
}
diff --git a/Modules/IGT/IO/mitkNavigationToolStorageSerializer.cpp b/Modules/IGT/IO/mitkNavigationToolStorageSerializer.cpp
index 1d4b2cf7d3..236db1c301 100644
--- a/Modules/IGT/IO/mitkNavigationToolStorageSerializer.cpp
+++ b/Modules/IGT/IO/mitkNavigationToolStorageSerializer.cpp
@@ -1,99 +1,99 @@
/*===================================================================
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.
===================================================================*/
//Poco headers
#include <Poco/Zip/Compress.h>
#include <Poco/Path.h>
#include <Poco/File.h>
#include "mitkNavigationToolStorageSerializer.h"
#include "mitkNavigationToolWriter.h"
#include "mitkIGTException.h"
#include "mitkIGTIOException.h"
#include <mitkStandaloneDataStorage.h>
#include <mitkSceneIO.h>
#include <mitkIOUtil.h>
#include <sstream>
mitk::NavigationToolStorageSerializer::NavigationToolStorageSerializer()
{
//create temp directory
m_tempDirectory = mitk::IOUtil::CreateTemporaryDirectory("NavigationToolStorageSerializerTmp_XXXXXX",mitk::IOUtil::GetProgramPath());
}
mitk::NavigationToolStorageSerializer::~NavigationToolStorageSerializer()
{
//remove temp directory
Poco::File myFile(m_tempDirectory);
try
{
if (myFile.exists()) myFile.remove(true);
}
catch(...)
{
MITK_ERROR << "Can't remove temp directory " << m_tempDirectory << "!";
}
}
bool mitk::NavigationToolStorageSerializer::Serialize(std::string filename, mitk::NavigationToolStorage::Pointer storage)
{
//save every tool to temp directory
mitk::NavigationToolWriter::Pointer myToolWriter = mitk::NavigationToolWriter::New();
- for(int i=0; i<storage->GetToolCount();i++)
+ for(unsigned int i=0; i<storage->GetToolCount();i++)
{
std::string tempFileName = m_tempDirectory + Poco::Path::separator() + "NavigationTool" + convertIntToString(i) + ".tool";
if (!myToolWriter->DoWrite(tempFileName,storage->GetTool(i)))
{
mitkThrowException(mitk::IGTIOException) << "Could not write tool to tempory directory: " << tempFileName;
}
}
//add all files to zip archive
std::ofstream file( filename.c_str(), std::ios::binary | std::ios::out);
if (!file.good()) //test if the zip archive is ready for writing
{
//first: clean up
- for (int i=0; i<storage->GetToolCount();i++)
+ for (unsigned int i=0; i<storage->GetToolCount();i++)
{
std::string tempFileName = m_tempDirectory + Poco::Path::separator() + "NavigationTool" + convertIntToString(i) + ".tool";
std::remove(tempFileName.c_str());
}
//then: throw an exception
mitkThrowException(mitk::IGTIOException) << "Could not open a file for writing: " << filename;
}
Poco::Zip::Compress zipper( file, true );
- for (int i=0; i<storage->GetToolCount();i++)
+ for (unsigned int i=0; i<storage->GetToolCount();i++)
{
std::string fileName = m_tempDirectory + Poco::Path::separator() + "NavigationTool" + convertIntToString(i) + ".tool";
zipper.addFile(fileName,myToolWriter->GetFileWithoutPath(fileName));
std::remove(fileName.c_str()); //delete file
}
zipper.close();
file.close();
return true;
}
std::string mitk::NavigationToolStorageSerializer::convertIntToString(int i)
{
std::string s;
std::stringstream out;
out << i;
s = out.str();
return s;
}
diff --git a/Modules/IGT/TrackingDevices/mitkMicronTrackerTypeInformation.cpp b/Modules/IGT/TrackingDevices/mitkMicronTrackerTypeInformation.cpp
index eb75123bf4..3edfdf7dcd 100644
--- a/Modules/IGT/TrackingDevices/mitkMicronTrackerTypeInformation.cpp
+++ b/Modules/IGT/TrackingDevices/mitkMicronTrackerTypeInformation.cpp
@@ -1,70 +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 "mitkMicronTrackerTypeInformation.h"
#include "mitkClaronTrackingDevice.h"
namespace mitk
{
std::string MicronTrackerTypeInformation::GetTrackingDeviceName()
{
return "Claron Micron";
}
TrackingDeviceData MicronTrackerTypeInformation::GetDeviceDataMicronTrackerH40()
{
TrackingDeviceData data = { MicronTrackerTypeInformation::GetTrackingDeviceName(), "Micron Tracker H40", "ClaronMicron.stl", "X" };
return data;
}
MicronTrackerTypeInformation::MicronTrackerTypeInformation()
{
m_DeviceName = MicronTrackerTypeInformation::GetTrackingDeviceName();
m_TrackingDeviceData.push_back(GetDeviceDataMicronTrackerH40());
}
MicronTrackerTypeInformation::~MicronTrackerTypeInformation()
{
}
mitk::TrackingDeviceSource::Pointer MicronTrackerTypeInformation::CreateTrackingDeviceSource(
mitk::TrackingDevice::Pointer trackingDevice,
mitk::NavigationToolStorage::Pointer navigationTools,
std::string* errorMessage,
std::vector<int>* toolCorrespondencesInToolStorage)
{
mitk::TrackingDeviceSource::Pointer returnValue = mitk::TrackingDeviceSource::New();
mitk::ClaronTrackingDevice::Pointer thisDevice = dynamic_cast<mitk::ClaronTrackingDevice*>(trackingDevice.GetPointer());
*toolCorrespondencesInToolStorage = std::vector<int>();
//add the tools to the tracking device
- for (int i = 0; i < navigationTools->GetToolCount(); i++)
+ for (unsigned int i = 0; i < navigationTools->GetToolCount(); i++)
{
mitk::NavigationTool::Pointer thisNavigationTool = navigationTools->GetTool(i);
toolCorrespondencesInToolStorage->push_back(i);
bool toolAddSuccess = thisDevice->AddTool(thisNavigationTool->GetToolName().c_str(), thisNavigationTool->GetCalibrationFile().c_str());
if (!toolAddSuccess)
{
//todo error handling
errorMessage->append("Can't add tool, is the toolfile valid?");
return nullptr;
}
thisDevice->GetTool(i)->SetToolTip(thisNavigationTool->GetToolTipPosition(), thisNavigationTool->GetToolTipOrientation());
}
returnValue->SetTrackingDevice(thisDevice);
return returnValue;
}
}
diff --git a/Modules/IGT/TrackingDevices/mitkNDIAuroraTypeInformation.cpp b/Modules/IGT/TrackingDevices/mitkNDIAuroraTypeInformation.cpp
index 63cccd6365..77b0e70b23 100644
--- a/Modules/IGT/TrackingDevices/mitkNDIAuroraTypeInformation.cpp
+++ b/Modules/IGT/TrackingDevices/mitkNDIAuroraTypeInformation.cpp
@@ -1,147 +1,153 @@
/*===================================================================
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 "mitkNDIAuroraTypeInformation.h"
#include "mitkIGTHardwareException.h"
#include "mitkNDITrackingDevice.h"
namespace mitk
{
std::string NDIAuroraTypeInformation::GetTrackingDeviceName()
{
return "NDI Aurora";
}
TrackingDeviceData NDIAuroraTypeInformation::GetDeviceDataAuroraCompact()
{
TrackingDeviceData data = { NDIAuroraTypeInformation::GetTrackingDeviceName(), "Aurora Compact", "NDIAuroraCompactFG_Dome.stl", "A" };
return data;
}
TrackingDeviceData NDIAuroraTypeInformation::GetDeviceDataAuroraPlanarCube()
{
TrackingDeviceData data = { NDIAuroraTypeInformation::GetTrackingDeviceName(), "Aurora Planar (Cube)", "NDIAurora.stl", "9" };
return data;
}
TrackingDeviceData NDIAuroraTypeInformation::GetDeviceDataAuroraPlanarDome()
{
TrackingDeviceData data = { NDIAuroraTypeInformation::GetTrackingDeviceName(), "Aurora Planar (Dome)", "NDIAuroraPlanarFG_Dome.stl", "A" };
return data;
}
TrackingDeviceData NDIAuroraTypeInformation::GetDeviceDataAuroraTabletop()
{
TrackingDeviceData data = { NDIAuroraTypeInformation::GetTrackingDeviceName(), "Aurora Tabletop", "NDIAuroraTabletopFG_Dome.stl", "A" };
return data;
}
NDIAuroraTypeInformation::NDIAuroraTypeInformation()
{
m_DeviceName = NDIAuroraTypeInformation::GetTrackingDeviceName();
m_TrackingDeviceData.push_back(GetDeviceDataAuroraCompact());
m_TrackingDeviceData.push_back(GetDeviceDataAuroraPlanarCube());
m_TrackingDeviceData.push_back(GetDeviceDataAuroraPlanarDome());
m_TrackingDeviceData.push_back(GetDeviceDataAuroraTabletop());
}
NDIAuroraTypeInformation::~NDIAuroraTypeInformation()
{
}
mitk::TrackingDeviceSource::Pointer NDIAuroraTypeInformation::CreateTrackingDeviceSource(
mitk::TrackingDevice::Pointer trackingDevice,
mitk::NavigationToolStorage::Pointer navigationTools,
std::string* errorMessage,
std::vector<int>* toolCorrespondencesInToolStorage)
{
MITK_DEBUG << "Creating Aurora tracking device.";
mitk::TrackingDeviceSource::Pointer returnValue = mitk::TrackingDeviceSource::New();
mitk::NDITrackingDevice::Pointer thisDevice = dynamic_cast<mitk::NDITrackingDevice*>(trackingDevice.GetPointer());
try
{
//connect to aurora to dectect tools automatically
thisDevice->OpenConnection();
}
catch (mitk::IGTHardwareException& e)
{
errorMessage->append("Hardware error on opening the connection (");
errorMessage->append(e.GetDescription());
errorMessage->append(")");
return nullptr;
}
catch (mitk::IGTException& e)
{
errorMessage->append("Error on opening the connection (");
errorMessage->append(e.GetDescription());
errorMessage->append(")");
return nullptr;
}
//now search for automatically detected tools in the tool storage and save them
mitk::NavigationToolStorage::Pointer newToolStorageInRightOrder = mitk::NavigationToolStorage::New();
- std::vector<int> alreadyFoundTools = std::vector<int>();
+ std::vector<unsigned int> alreadyFoundTools = std::vector<unsigned int>();
*toolCorrespondencesInToolStorage = std::vector<int>();
for (unsigned int i = 0; i < thisDevice->GetToolCount(); i++)
{
bool toolFound = false;
- for (int j = 0; j < navigationTools->GetToolCount(); j++)
+ for (unsigned int j = 0; j < navigationTools->GetToolCount(); j++)
{
//check if the serial number is the same to identify the tool
if ((dynamic_cast<mitk::NDIPassiveTool*>(thisDevice->GetTool(i)))->GetSerialNumber() == navigationTools->GetTool(j)->GetSerialNumber())
{
//check if this tool was already added to make sure that every tool is only added once (in case of same serial numbers)
bool toolAlreadyAdded = false;
- for (unsigned int k = 0; k < alreadyFoundTools.size(); k++) if (alreadyFoundTools.at(k) == j) toolAlreadyAdded = true;
+ for (unsigned int k = 0; k < alreadyFoundTools.size(); k++)
+ {
+ if (alreadyFoundTools.at(k) == j)
+ {
+ toolAlreadyAdded = true;
+ }
+ }
if (!toolAlreadyAdded)
{
//add tool in right order
newToolStorageInRightOrder->AddTool(navigationTools->GetTool(j));
toolCorrespondencesInToolStorage->push_back(j);
//adapt name of tool
dynamic_cast<mitk::NDIPassiveTool*>(thisDevice->GetTool(i))->SetToolName(navigationTools->GetTool(j)->GetToolName());
//set tip of tool
dynamic_cast<mitk::NDIPassiveTool*>(thisDevice->GetTool(i))->SetToolTip(navigationTools->GetTool(j)->GetToolTipPosition(), navigationTools->GetTool(j)->GetToolTipOrientation());
//rember that this tool was already found
alreadyFoundTools.push_back(j);
toolFound = true;
break;
}
}
}
if (!toolFound)
{
errorMessage->append("Error: did not find every automatically detected tool in the loaded tool storage: aborting initialization.");
return nullptr;
}
}
//And resort them (this was done in TrackingToolBoxWorker before).
- for (int i = 0; i < newToolStorageInRightOrder->GetToolCount(); i++)
+ for (unsigned int i = 0; i < newToolStorageInRightOrder->GetToolCount(); i++)
{
navigationTools->AssignToolNumber(newToolStorageInRightOrder->GetTool(i)->GetIdentifier(), i);
}
returnValue->SetTrackingDevice(thisDevice);
MITK_DEBUG << "Number of tools of created tracking device: " << thisDevice->GetToolCount();
MITK_DEBUG << "Number of outputs of created source: " << returnValue->GetNumberOfOutputs();
return returnValue;
}
}
diff --git a/Modules/IGT/TrackingDevices/mitkNDIPolarisTypeInformation.cpp b/Modules/IGT/TrackingDevices/mitkNDIPolarisTypeInformation.cpp
index 2fd22e6bd0..025f26d535 100644
--- a/Modules/IGT/TrackingDevices/mitkNDIPolarisTypeInformation.cpp
+++ b/Modules/IGT/TrackingDevices/mitkNDIPolarisTypeInformation.cpp
@@ -1,90 +1,90 @@
/*===================================================================
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 "mitkNDIPolarisTypeInformation.h"
#include "mitkNDITrackingDevice.h"
namespace mitk
{
std::string NDIPolarisTypeInformation::GetTrackingDeviceName()
{
return "NDI Polaris"; ///< Polaris: optical Tracker from NDI;
}
TrackingDeviceData NDIPolarisTypeInformation::GetDeviceDataPolarisOldModel()
{
TrackingDeviceData data = { NDIPolarisTypeInformation::GetTrackingDeviceName(), "Polaris (Old Model)", "NDIPolarisOldModel.stl", "0" };
return data;
}
TrackingDeviceData NDIPolarisTypeInformation::GetDeviceDataPolarisSpectra()
{
//full hardware code of polaris spectra: 5-240000-153200-095000+057200+039800+056946+024303+029773+999999+99999924
TrackingDeviceData data = { NDIPolarisTypeInformation::GetTrackingDeviceName(), "Polaris Spectra", "NDIPolarisSpectra.stl", "5-2" };
return data;
}
TrackingDeviceData NDIPolarisTypeInformation::GetDeviceDataSpectraExtendedPyramid()
{
//full hardware code of polaris spectra (extended pyramid): 5-300000-153200-095000+057200+039800+056946+024303+029773+999999+07350024
TrackingDeviceData data = { NDIPolarisTypeInformation::GetTrackingDeviceName(), "Polaris Spectra (Extended Pyramid)", "NDIPolarisSpectraExtendedPyramid.stl", "5-3" };
return data;
}
TrackingDeviceData NDIPolarisTypeInformation::GetDeviceDataPolarisVicra()
{
TrackingDeviceData data = { NDIPolarisTypeInformation::GetTrackingDeviceName(), "Polaris Vicra", "NDIPolarisVicra.stl", "7" };
return data;
}
NDIPolarisTypeInformation::NDIPolarisTypeInformation()
{
m_DeviceName = NDIPolarisTypeInformation::GetTrackingDeviceName();
m_TrackingDeviceData.push_back(GetDeviceDataPolarisOldModel());
m_TrackingDeviceData.push_back(GetDeviceDataSpectraExtendedPyramid());
m_TrackingDeviceData.push_back(GetDeviceDataPolarisSpectra());
m_TrackingDeviceData.push_back(GetDeviceDataPolarisVicra());
}
NDIPolarisTypeInformation::~NDIPolarisTypeInformation()
{
}
mitk::TrackingDeviceSource::Pointer NDIPolarisTypeInformation::CreateTrackingDeviceSource(
mitk::TrackingDevice::Pointer trackingDevice,
mitk::NavigationToolStorage::Pointer navigationTools,
std::string* errorMessage,
std::vector<int>* toolCorrespondencesInToolStorage)
{
mitk::TrackingDeviceSource::Pointer returnValue = mitk::TrackingDeviceSource::New();
mitk::NDITrackingDevice::Pointer thisDevice = dynamic_cast<mitk::NDITrackingDevice*>(trackingDevice.GetPointer());
*toolCorrespondencesInToolStorage = std::vector<int>();
//add the tools to the tracking device
- for (int i = 0; i < navigationTools->GetToolCount(); i++)
+ for (unsigned int i = 0; i < navigationTools->GetToolCount(); i++)
{
mitk::NavigationTool::Pointer thisNavigationTool = navigationTools->GetTool(i);
toolCorrespondencesInToolStorage->push_back(i);
bool toolAddSuccess = thisDevice->AddTool(thisNavigationTool->GetToolName().c_str(), thisNavigationTool->GetCalibrationFile().c_str());
if (!toolAddSuccess)
{
//todo: error handling
errorMessage->append("Can't add tool, is the SROM-file valid?");
return nullptr;
}
thisDevice->GetTool(i)->SetToolTip(thisNavigationTool->GetToolTipPosition(), thisNavigationTool->GetToolTipOrientation());
}
returnValue->SetTrackingDevice(thisDevice);
return returnValue;
}
}
diff --git a/Modules/IGT/TrackingDevices/mitkNPOptitrackTrackingTypeInformation.cpp b/Modules/IGT/TrackingDevices/mitkNPOptitrackTrackingTypeInformation.cpp
index e16418f2ed..7b56482453 100644
--- a/Modules/IGT/TrackingDevices/mitkNPOptitrackTrackingTypeInformation.cpp
+++ b/Modules/IGT/TrackingDevices/mitkNPOptitrackTrackingTypeInformation.cpp
@@ -1,75 +1,75 @@
/*===================================================================
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 "mitkNPOptitrackTrackingTypeInformation.h"
#include "mitkOptitrackTrackingDevice.h"
namespace mitk
{
std::string NPOptitrackTrackingTypeInformation::GetTrackingDeviceName()
{
return "NP Optitrack";
}
TrackingDeviceData NPOptitrackTrackingTypeInformation::GetDeviceDataNPOptitrack()
{
TrackingDeviceData data = { NPOptitrackTrackingTypeInformation::GetTrackingDeviceName(), "Optitrack", "cube", "X" };
return data;
}
NPOptitrackTrackingTypeInformation::NPOptitrackTrackingTypeInformation()
{
m_DeviceName = NPOptitrackTrackingTypeInformation::GetTrackingDeviceName();
m_TrackingDeviceData.push_back(GetDeviceDataNPOptitrack());
}
NPOptitrackTrackingTypeInformation::~NPOptitrackTrackingTypeInformation()
{
}
TrackingDeviceSource::Pointer NPOptitrackTrackingTypeInformation::CreateTrackingDeviceSource(
TrackingDevice::Pointer trackingDevice,
NavigationToolStorage::Pointer navigationTools,
std::string* errorMessage,
std::vector<int>* toolCorrespondencesInToolStorage)
{
mitk::TrackingDeviceSource::Pointer returnValue = mitk::TrackingDeviceSource::New();
mitk::OptitrackTrackingDevice::Pointer thisDevice = dynamic_cast<mitk::OptitrackTrackingDevice*>(trackingDevice.GetPointer());
*toolCorrespondencesInToolStorage = std::vector<int>();
//OpenConnection with Optitrack
thisDevice->OpenConnection();
//add the tools to the tracking device
- for (int i = 0; i < navigationTools->GetToolCount(); i++)
+ for (unsigned int i = 0; i < navigationTools->GetToolCount(); i++)
{
mitk::NavigationTool::Pointer thisNavigationTool = navigationTools->GetTool(i);
toolCorrespondencesInToolStorage->push_back(i);
bool toolAddSuccess = thisDevice->AddToolByDefinitionFile(thisNavigationTool->GetCalibrationFile());
thisDevice->GetOptitrackTool(i)->SetToolName(thisNavigationTool->GetToolName().c_str());
if (!toolAddSuccess)
{
//todo error handling
errorMessage->append("Can't add tool, is the toolfile valid?");
return nullptr;
}
//thisDevice->GetTool(i)->SetToolTip(thisNavigationTool->GetToolTipPosition(),thisNavigationTool->GetToolTipOrientation());
}
returnValue->SetTrackingDevice(thisDevice);
return returnValue;
}
}
diff --git a/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.cpp b/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.cpp
index fc5dffae3d..0ea2bd84e4 100644
--- a/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.cpp
+++ b/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.cpp
@@ -1,508 +1,508 @@
/*===================================================================
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 "mitkOpenIGTLinkTrackingDevice.h"
#include "mitkOpenIGTLinkTrackingTool.h"
#include "mitkIGTConfig.h"
#include "mitkIGTTimeStamp.h"
#include "mitkIGTHardwareException.h"
#include "mitkTrackingTypes.h"
#include <itksys/SystemTools.hxx>
#include <iostream>
#include <itkMutexLockHolder.h>
#include <itkCommand.h>
#include <mitkOpenIGTLinkTypeInformation.h>
#include <vtkConeSource.h>
//sleep headers
#include <chrono>
#include <thread>
typedef itk::MutexLockHolder<itk::FastMutexLock> MutexLockHolder;
mitk::OpenIGTLinkTrackingDevice::OpenIGTLinkTrackingDevice() : mitk::TrackingDevice(), m_UpdateRate(60)
{
//set the type of this tracking device
this->m_Data = mitk::OpenIGTLinkTypeInformation::GetDeviceDataOpenIGTLinkTrackingDeviceConnection();
m_OpenIGTLinkClient = mitk::IGTLClient::New(true);
m_OpenIGTLinkClient->SetName("OpenIGTLink Tracking Device");
m_OpenIGTLinkClient->EnableNoBufferingMode(false);
m_IGTLDeviceSource = mitk::IGTLTrackingDataDeviceSource::New();
m_IGTLDeviceSource->SetIGTLDevice(m_OpenIGTLinkClient);
}
mitk::OpenIGTLinkTrackingDevice::~OpenIGTLinkTrackingDevice()
{
}
int mitk::OpenIGTLinkTrackingDevice::GetPortNumber()
{
return m_OpenIGTLinkClient->GetPortNumber();
}
bool mitk::OpenIGTLinkTrackingDevice::AutoDetectToolsAvailable()
{
return true;
}
mitk::NavigationToolStorage::Pointer mitk::OpenIGTLinkTrackingDevice::AutoDetectTools()
{
mitk::NavigationToolStorage::Pointer returnValue = mitk::NavigationToolStorage::New();
if (m_OpenIGTLinkClient->GetPortNumber() == -1)
{
MITK_WARN << "Connection not initialized, aborting (invalid port number).";
return mitk::NavigationToolStorage::New();
}
//open connection
try
{
m_IGTLDeviceSource->Connect();
m_IGTLDeviceSource->StartCommunication();
}
catch (std::runtime_error &e)
{
MITK_WARN << "AutoDetection: Open IGT Link device retruned an error while trying to connect: " << e.what();
return mitk::NavigationToolStorage::New();
}
//get a message to find out type
m_IGTLDeviceSource->SettrackingDataType(mitk::IGTLTrackingDataDeviceSource::UNKNOWN);
mitk::IGTLMessage::Pointer receivedMessage = ReceiveMessage(100);
const char* msgType = receivedMessage->GetIGTLMessageType();
if (std::string(msgType).empty())
{
MITK_INFO << "Did not receive a message. Do you have to start the stream manually at the server?";
MITK_INFO << "Waiting for 10 seconds ...";
receivedMessage = ReceiveMessage(10000);
msgType = receivedMessage->GetIGTLMessageType();
}
MITK_INFO << "################# got message type: " << msgType;
mitk::OpenIGTLinkTrackingDevice::TrackingMessageType type = GetMessageTypeFromString(msgType);
switch (type)
{
case UNKNOWN:
m_IGTLDeviceSource->SettrackingDataType(mitk::IGTLTrackingDataDeviceSource::UNKNOWN);
break;
case TDATA:
m_IGTLDeviceSource->SettrackingDataType(mitk::IGTLTrackingDataDeviceSource::TDATA);
break;
case QTDATA:
m_IGTLDeviceSource->SettrackingDataType(mitk::IGTLTrackingDataDeviceSource::QTDATA);
break;
case TRANSFORM:
m_IGTLDeviceSource->SettrackingDataType(mitk::IGTLTrackingDataDeviceSource::TRANSFORM);
break;
}
returnValue = DiscoverToolsAndConvertToNavigationTools(type);
//close connection
try
{
m_IGTLDeviceSource->StopCommunication();
m_IGTLDeviceSource->Disconnect();
}
catch (std::runtime_error &e)
{
MITK_WARN << "AutoDetection: Open IGT Link device retruned an error while trying to disconnect: " << e.what();
return mitk::NavigationToolStorage::New();
}
return returnValue;
}
mitk::NavigationToolStorage::Pointer mitk::OpenIGTLinkTrackingDevice::DiscoverToolsAndConvertToNavigationTools(mitk::OpenIGTLinkTrackingDevice::TrackingMessageType type, int NumberOfMessagesToWait)
{
MITK_INFO << "Start discovering tools by " << type << " messages";
mitk::NavigationToolStorage::Pointer returnValue = mitk::NavigationToolStorage::New();
std::map<std::string, int> toolNameMap;
for (int j = 0; j<NumberOfMessagesToWait; j++)
{
std::this_thread::sleep_for(std::chrono::milliseconds(20));
m_IGTLDeviceSource->Update();
switch (type)
{
case TRANSFORM:
{
igtl::TransformMessage::Pointer msg = dynamic_cast<igtl::TransformMessage*>(m_IGTLDeviceSource->GetOutput()->GetMessage().GetPointer());
if (msg == nullptr || msg.IsNull()) { MITK_INFO << "Received message is invalid / null. Skipping.."; continue; }
int count = toolNameMap[msg->GetDeviceName()];
if (count == 0) { toolNameMap[msg->GetDeviceName()] = 1; }
else { toolNameMap[msg->GetDeviceName()]++; }
}
break;
case TDATA:
{
igtl::TrackingDataMessage::Pointer msg = dynamic_cast<igtl::TrackingDataMessage*>(m_IGTLDeviceSource->GetOutput()->GetMessage().GetPointer());
if (msg == nullptr || msg.IsNull()) { MITK_INFO << "Received message is invalid / null. Skipping.."; continue; }
for (int k = 0; k < msg->GetNumberOfTrackingDataElements(); k++)
{
igtl::TrackingDataElement::Pointer tde;
msg->GetTrackingDataElement(k, tde);
if (tde.IsNotNull())
{
int count = toolNameMap[tde->GetName()];
if (count == 0) { toolNameMap[tde->GetName()] = 1; }
else { toolNameMap[tde->GetName()]++; }
}
}
}
break;
default:
MITK_WARN << "Only TRANSFORM and TDATA is currently supported, skipping!";
break;
}
}
int i = 0;
for (std::map<std::string, int>::iterator it = toolNameMap.begin(); it != toolNameMap.end(); ++it)
{
MITK_INFO << "Found tool: " << it->first;
std::stringstream name;
name << it->first;
std::stringstream identifier;
identifier << "AutoDetectedTool-" << i;
i++;
mitk::NavigationTool::Pointer newTool = ConstructDefaultOpenIGTLinkTool(name.str(), identifier.str());
returnValue->AddTool(newTool);
}
return returnValue;
}
std::string mitk::OpenIGTLinkTrackingDevice::GetHostname()
{
return m_OpenIGTLinkClient->GetHostname();
}
void mitk::OpenIGTLinkTrackingDevice::SetPortNumber(int portNumber)
{
m_OpenIGTLinkClient->SetPortNumber(portNumber);
}
void mitk::OpenIGTLinkTrackingDevice::SetHostname(std::string hostname)
{
m_OpenIGTLinkClient->SetHostname(hostname);
}
bool mitk::OpenIGTLinkTrackingDevice::IsDeviceInstalled()
{
return true;
}
mitk::TrackingTool* mitk::OpenIGTLinkTrackingDevice::AddTool(const char*, const char*)
{
mitk::OpenIGTLinkTrackingTool::Pointer t;// = mitk::OpenIGTLinkTrackingTool::New();
//TODO: Implement
if (this->InternalAddTool(t) == false)
return nullptr;
return t.GetPointer();
}
bool mitk::OpenIGTLinkTrackingDevice::InternalAddTool(OpenIGTLinkTrackingTool::Pointer tool)
{
m_AllTools.push_back(tool);
return true;
}
bool mitk::OpenIGTLinkTrackingDevice::DiscoverTools(int waitingTime)
{
if (m_OpenIGTLinkClient->GetPortNumber() == -1)
{
MITK_WARN << "Connection not initialized, aborting (invalid port number).";
return false;
}
try
{
m_IGTLDeviceSource->Connect();
m_IGTLDeviceSource->StartCommunication();
}
catch (std::runtime_error &e)
{
MITK_WARN << "Open IGT Link device retruned an error while trying to connect: " << e.what();
return false;
}
mitk::IGTLMessage::Pointer receivedMessage = ReceiveMessage(waitingTime);
//check the tracking stream for the number and type of tools
//igtl::MessageBase::Pointer receivedMessage = m_OpenIGTLinkClient->GetNextMessage();
if (receivedMessage.IsNull())
{
MITK_WARN << "No message was received. Is there really a server?";
return false;
}
else if (!receivedMessage->IsDataValid())
{
MITK_WARN << "Received invalid message.";
return false;
}
const char* msgType = receivedMessage->GetIGTLMessageType();
mitk::OpenIGTLinkTrackingDevice::TrackingMessageType type = GetMessageTypeFromString(msgType);
mitk::NavigationToolStorage::Pointer foundTools = this->DiscoverToolsAndConvertToNavigationTools(type);
if (foundTools.IsNull() || (foundTools->GetToolCount() == 0)) { return false; }
- for (int i = 0; i < foundTools->GetToolCount(); i++) { AddNewToolForName(foundTools->GetTool(i)->GetToolName(), i); }
+ for (unsigned int i = 0; i < foundTools->GetToolCount(); i++) { AddNewToolForName(foundTools->GetTool(i)->GetToolName(), i); }
MITK_INFO << "Found tools: " << foundTools->GetToolCount();
return true;
}
mitk::IGTLMessage::Pointer mitk::OpenIGTLinkTrackingDevice::ReceiveMessage(int waitingTime)
{
mitk::IGTLMessage::Pointer receivedMessage;
//send a message to the server: start tracking stream
mitk::IGTLMessageFactory::Pointer msgFactory = m_OpenIGTLinkClient->GetMessageFactory();
std::string message[2] = {"STT_QTDATA","STT_TDATA"};
for (int i = 0; i < 2; i++)
{
igtl::MessageBase::Pointer sttMsg = msgFactory->CreateInstance(message[i]);
//TODO: Fix this to dynamically get this from GUI
((igtl::StartTrackingDataMessage*)sttMsg.GetPointer())->SetResolution(m_UpdateRate);
m_OpenIGTLinkClient->SendMessage(mitk::IGTLMessage::New(sttMsg));
}
std::chrono::high_resolution_clock::time_point time = std::chrono::high_resolution_clock::now();
std::chrono::milliseconds d = std::chrono::milliseconds(waitingTime);
while (!(receivedMessage.IsNotNull() && receivedMessage->IsDataValid()))
{
m_IGTLDeviceSource->Update();
receivedMessage = m_IGTLDeviceSource->GetOutput();
if ((time + d) < std::chrono::high_resolution_clock::now())
break;
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
return receivedMessage;
}
void mitk::OpenIGTLinkTrackingDevice::AddNewToolForName(std::string name, int i)
{
mitk::OpenIGTLinkTrackingTool::Pointer newTool = mitk::OpenIGTLinkTrackingTool::New();
if (name == "") //if no name was given create a default name
{
std::stringstream defaultName;
defaultName << "OpenIGTLinkTool#" << i;
name = defaultName.str();
}
MITK_INFO << "Added tool " << name << " to tracking device.";
newTool->SetToolName(name);
InternalAddTool(newTool);
}
mitk::NavigationTool::Pointer mitk::OpenIGTLinkTrackingDevice::ConstructDefaultOpenIGTLinkTool(std::string name, std::string identifier)
{
mitk::NavigationTool::Pointer newTool = mitk::NavigationTool::New();
newTool->GetDataNode()->SetName(name);
newTool->SetIdentifier(identifier);
newTool->SetTrackingDeviceType(mitk::OpenIGTLinkTypeInformation::GetDeviceDataOpenIGTLinkTrackingDeviceConnection().Line);
return newTool;
}
void mitk::OpenIGTLinkTrackingDevice::UpdateTools()
{
if (this->GetState() != Tracking)
{
MITK_ERROR << "Method was called in the wrong state, something went wrong!";
return;
}
m_IGTLMsgToNavDataFilter->Update();
for (std::size_t j = 0; j < m_IGTLMsgToNavDataFilter->GetNumberOfIndexedOutputs(); ++j)
{
mitk::NavigationData::Pointer currentNavData = m_IGTLMsgToNavDataFilter->GetOutput(j);
const char* name = currentNavData->GetName();
for (std::size_t i = 0; i < m_AllTools.size(); i++)
{
if (strcmp(m_AllTools.at(i)->GetToolName(), name) == 0)
{
m_AllTools.at(i)->SetDataValid(currentNavData->IsDataValid());
m_AllTools.at(i)->SetPosition(currentNavData->GetPosition());
m_AllTools.at(i)->SetOrientation(currentNavData->GetOrientation());
m_AllTools.at(i)->SetIGTTimeStamp(currentNavData->GetIGTTimeStamp());
}
}
}
}
bool mitk::OpenIGTLinkTrackingDevice::StartTracking()
{
//check tracking state
if (this->GetState() != Ready)
{
MITK_WARN << "Cannot start tracking, device is not ready!";
return false;
}
try
{
m_IGTLDeviceSource->StartCommunication();
//send a message to the server: start tracking stream
mitk::IGTLMessageFactory::Pointer msgFactory = m_OpenIGTLinkClient->GetMessageFactory();
std::string message = "STT_TDATA";
//m_OpenIGTLinkClient->SendMessage(msgFactory->CreateInstance(message));
}
catch (std::runtime_error &e)
{
MITK_WARN << "Open IGT Link device retruned an error while starting communication: " << e.what();
return false;
}
//create internal igtl pipeline
m_IGTLMsgToNavDataFilter = mitk::IGTLMessageToNavigationDataFilter::New();
m_IGTLMsgToNavDataFilter->SetNumberOfExpectedOutputs(this->GetToolCount());
m_IGTLMsgToNavDataFilter->ConnectTo(m_IGTLDeviceSource);
//connect itk events
typedef itk::SimpleMemberCommand< mitk::OpenIGTLinkTrackingDevice > CurCommandType;
CurCommandType::Pointer messageReceivedCommand = CurCommandType::New();
messageReceivedCommand->SetCallbackFunction(this, &mitk::OpenIGTLinkTrackingDevice::UpdateTools);
m_MessageReceivedObserverTag = m_OpenIGTLinkClient->AddObserver(mitk::MessageReceivedEvent(), messageReceivedCommand);
m_OpenIGTLinkClient->EnableNoBufferingMode(true);
this->SetState(Tracking);
return true;
}
bool mitk::OpenIGTLinkTrackingDevice::StopTracking()
{
//check tracking state
if (this->GetState() != Tracking)
{
MITK_WARN << "Cannot open connection, device is already connected!";
return false;
}
m_OpenIGTLinkClient->RemoveObserver(m_MessageReceivedObserverTag); //disconnect itk events
try
{
m_IGTLDeviceSource->StopCommunication();
}
catch (std::runtime_error &e)
{
MITK_WARN << "Open IGT Link device retruned an error while stopping communication: " << e.what();
return false;
}
m_OpenIGTLinkClient->EnableNoBufferingMode(false);
this->SetState(Ready);
return true;
}
unsigned int mitk::OpenIGTLinkTrackingDevice::GetToolCount() const
{
return (unsigned int)this->m_AllTools.size();
}
mitk::TrackingTool* mitk::OpenIGTLinkTrackingDevice::GetTool(unsigned int toolNumber) const
{
if (toolNumber >= this->GetToolCount())
return nullptr;
else
return this->m_AllTools[toolNumber];
}
bool mitk::OpenIGTLinkTrackingDevice::OpenConnection()
{
//check tracking state
if (this->GetState() != Setup)
{
MITK_WARN << "Cannot open connection, device is already connected!";
return false;
}
try
{
m_IGTLDeviceSource->Connect();
}
catch (std::runtime_error &e)
{
MITK_WARN << "Open IGT Link device retruned an error while trying to connect: " << e.what();
return false;
}
this->SetState(Ready);
return true;
}
bool mitk::OpenIGTLinkTrackingDevice::CloseConnection()
{
//check tracking state
if (this->GetState() != Ready)
{
MITK_WARN << "Cannot close connection, device is in the wrong state!";
return false;
}
try
{
m_IGTLDeviceSource->Disconnect();
}
catch (std::runtime_error &e)
{
MITK_WARN << "Open IGT Link device retruned an error while trying to disconnect: " << e.what();
return false;
}
this->SetState(Setup);
return true;
}
std::vector<mitk::OpenIGTLinkTrackingTool::Pointer> mitk::OpenIGTLinkTrackingDevice::GetAllTools()
{
return this->m_AllTools;
}
mitk::OpenIGTLinkTrackingDevice::TrackingMessageType mitk::OpenIGTLinkTrackingDevice::GetMessageTypeFromString(const char* messageTypeString)
{
if (strcmp(messageTypeString, "TDATA") == 0)
{
return mitk::OpenIGTLinkTrackingDevice::TrackingMessageType::TDATA;
}
else if (strcmp(messageTypeString, "QTDATA") == 0)
{
return mitk::OpenIGTLinkTrackingDevice::TrackingMessageType::QTDATA;
}
else if (strcmp(messageTypeString, "TRANSFORM") == 0)
{
return mitk::OpenIGTLinkTrackingDevice::TrackingMessageType::TRANSFORM;
}
else
{
return mitk::OpenIGTLinkTrackingDevice::TrackingMessageType::UNKNOWN;
}
}
diff --git a/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTypeInformation.cpp b/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTypeInformation.cpp
index 428e1e043c..aacdeea343 100644
--- a/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTypeInformation.cpp
+++ b/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTypeInformation.cpp
@@ -1,60 +1,60 @@
/*===================================================================
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 "mitkOpenIGTLinkTypeInformation.h"
#include "mitkOpenIGTLinkTrackingDevice.h"
namespace mitk
{
std::string OpenIGTLinkTypeInformation::GetTrackingDeviceName()
{
return "Open IGT Link Connection";
}
TrackingDeviceData OpenIGTLinkTypeInformation::GetDeviceDataOpenIGTLinkTrackingDeviceConnection(){
TrackingDeviceData data = { OpenIGTLinkTypeInformation::GetTrackingDeviceName(), "OpenIGTLink Tracking Device", "cube", "X" };
return data;
}
OpenIGTLinkTypeInformation::OpenIGTLinkTypeInformation()
{
m_DeviceName = OpenIGTLinkTypeInformation::GetTrackingDeviceName();
m_TrackingDeviceData.push_back(GetDeviceDataOpenIGTLinkTrackingDeviceConnection());
}
OpenIGTLinkTypeInformation::~OpenIGTLinkTypeInformation()
{
}
mitk::TrackingDeviceSource::Pointer OpenIGTLinkTypeInformation::CreateTrackingDeviceSource(
mitk::TrackingDevice::Pointer trackingDevice,
mitk::NavigationToolStorage::Pointer navigationTools,
std::string* errorMessage,
std::vector<int>* /*toolCorrespondencesInToolStorage*/)
{
mitk::TrackingDeviceSource::Pointer returnValue = mitk::TrackingDeviceSource::New();
mitk::OpenIGTLinkTrackingDevice::Pointer thisDevice = dynamic_cast<mitk::OpenIGTLinkTrackingDevice*>(trackingDevice.GetPointer());
thisDevice->DiscoverTools();
- if (static_cast<int>(thisDevice->GetToolCount()) != navigationTools->GetToolCount())
+ if (thisDevice->GetToolCount() != navigationTools->GetToolCount())
{
errorMessage->append("The number of tools in the connected device differs from the tool storage, cannot add tools.");
return nullptr;
}
returnValue->SetTrackingDevice(thisDevice);
return returnValue;
}
}
diff --git a/Modules/IGT/TrackingDevices/mitkVirtualTrackerTypeInformation.cpp b/Modules/IGT/TrackingDevices/mitkVirtualTrackerTypeInformation.cpp
index 2bcc5fa600..eae7f126b7 100644
--- a/Modules/IGT/TrackingDevices/mitkVirtualTrackerTypeInformation.cpp
+++ b/Modules/IGT/TrackingDevices/mitkVirtualTrackerTypeInformation.cpp
@@ -1,70 +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 "mitkVirtualTrackerTypeInformation.h"
#include "mitkVirtualTrackingDevice.h"
namespace mitk
{
std::string VirtualTrackerTypeInformation::GetTrackingDeviceName()
{
return "Virtual Tracker";
}
TrackingDeviceData VirtualTrackerTypeInformation::GetDeviceDataVirtualTracker()
{
TrackingDeviceData data = { VirtualTrackerTypeInformation::GetTrackingDeviceName(), "Virtual Tracker", "cube", "X" };
return data;
}
VirtualTrackerTypeInformation::VirtualTrackerTypeInformation()
{
m_DeviceName = VirtualTrackerTypeInformation::GetTrackingDeviceName();
m_TrackingDeviceData.push_back(GetDeviceDataVirtualTracker());
}
VirtualTrackerTypeInformation::~VirtualTrackerTypeInformation()
{
}
mitk::TrackingDeviceSource::Pointer VirtualTrackerTypeInformation::CreateTrackingDeviceSource(
mitk::TrackingDevice::Pointer trackingDevice,
mitk::NavigationToolStorage::Pointer navigationTools,
std::string* errorMessage,
std::vector<int>* toolCorrespondencesInToolStorage)
{
mitk::TrackingDeviceSource::Pointer returnValue = mitk::TrackingDeviceSource::New();
mitk::VirtualTrackingDevice::Pointer thisDevice = dynamic_cast<mitk::VirtualTrackingDevice*>(trackingDevice.GetPointer());
*toolCorrespondencesInToolStorage = std::vector<int>();
//add the tools to the tracking device
- for (int i = 0; i < navigationTools->GetToolCount(); i++)
+ for (unsigned int i = 0; i < navigationTools->GetToolCount(); i++)
{
mitk::NavigationTool::Pointer thisNavigationTool = navigationTools->GetTool(i);
toolCorrespondencesInToolStorage->push_back(i);
bool toolAddSuccess = thisDevice->AddTool(thisNavigationTool->GetToolName().c_str());
if (!toolAddSuccess)
{
//todo error handling
errorMessage->append("Can't add tool, is the toolfile valid?");
return nullptr;
}
}
returnValue->SetTrackingDevice(thisDevice);
return returnValue;
}
}
diff --git a/Modules/IGTUI/Qmitk/QmitkIGTConnectionWidget.cpp b/Modules/IGTUI/Qmitk/QmitkIGTConnectionWidget.cpp
index d86c9516d2..099873b754 100644
--- a/Modules/IGTUI/Qmitk/QmitkIGTConnectionWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkIGTConnectionWidget.cpp
@@ -1,215 +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 = nullptr;
CreateQtPartControl(this);
CreateConnections();
m_TrackingDevice = nullptr;
m_TrackingDeviceSource = nullptr;
m_NavigationToolStorage = nullptr;
m_DataStorage = nullptr;
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(nullptr,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(nullptr,"Warning",error);
// reset button to unchecked
m_Controls->connectButton->setChecked(false);
// remove tool nodes from DataStorage
this->RemoveToolNodes();
// reset NavigationToolStorage
m_NavigationToolStorage = nullptr;
}
}
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 = nullptr;
m_TrackingDevice = nullptr;
m_TrackingDeviceSource = nullptr;
// 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++)
+ for (unsigned 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++)
+ for (unsigned 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/QmitkNavigationDataSourceSelectionWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNavigationDataSourceSelectionWidget.cpp
index 131bf68838..0419e4ca9e 100644
--- a/Modules/IGTUI/Qmitk/QmitkNavigationDataSourceSelectionWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNavigationDataSourceSelectionWidget.cpp
@@ -1,137 +1,137 @@
/*===================================================================
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 "QmitkNavigationDataSourceSelectionWidget.h"
//mitk headers
#include <mitkNavigationDataSource.h>
#include <usGetModuleContext.h>
#include <usServiceReference.h>
QmitkNavigationDataSourceSelectionWidget::QmitkNavigationDataSourceSelectionWidget(QWidget* parent, Qt::WindowFlags f)
: QWidget(parent, f)
{
m_Controls = nullptr;
CreateQtPartControl(this);
CreateConnections();
}
QmitkNavigationDataSourceSelectionWidget::~QmitkNavigationDataSourceSelectionWidget()
{
}
void QmitkNavigationDataSourceSelectionWidget::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkNavigationDataSourceSelectionWidgetControls;
m_Controls->setupUi(parent);
std::string empty = "";
m_Controls->m_NavigationDataSourceWidget->Initialize<mitk::NavigationDataSource>(mitk::NavigationDataSource::US_PROPKEY_DEVICENAME,empty);
}
}
void QmitkNavigationDataSourceSelectionWidget::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_Controls->m_NavigationDataSourceWidget), SIGNAL(ServiceSelectionChanged(us::ServiceReferenceU)), this, SLOT(NavigationDataSourceSelected(us::ServiceReferenceU)) );
connect((QObject*)(m_Controls->m_ToolView), SIGNAL(currentRowChanged(int)), this, SLOT(NavigationToolSelected(int)));
}
}
void QmitkNavigationDataSourceSelectionWidget::NavigationToolSelected(int selection)
{
emit NavigationToolSelected(this->m_CurrentStorage->GetTool(selection));
}
void QmitkNavigationDataSourceSelectionWidget::NavigationDataSourceSelected(us::ServiceReferenceU s)
{
if (!s) //no device selected
{
//reset everything
m_CurrentSource = nullptr;
m_CurrentStorage = nullptr;
emit NavigationDataSourceSelected(m_CurrentSource);
return;
}
// Get Source
us::ModuleContext* context = us::GetModuleContext();
m_CurrentSource = context->GetService<mitk::NavigationDataSource>(s);
// clear tool list before filling it
m_Controls->m_ToolView->clear();
//Fill tool list
MITK_INFO<<"no outputs: "<<m_CurrentSource->GetNumberOfOutputs();
for(std::size_t i = 0; i < m_CurrentSource->GetNumberOfOutputs(); i++)
{
new QListWidgetItem(tr(m_CurrentSource->GetOutput(i)->GetName()), m_Controls->m_ToolView);
}
// Get Storage
std::string filter = "(" + mitk::NavigationToolStorage::US_PROPKEY_SOURCE_ID + "=" + m_CurrentSource->GetMicroserviceID() + ")";
std::vector<us::ServiceReference<mitk::NavigationToolStorage> > refs = context->GetServiceReferences<mitk::NavigationToolStorage>(filter);
if (refs.empty()) return; //no storage was found
m_CurrentStorage = context->GetService(refs.front());
if (m_CurrentStorage.IsNull())
{
MITK_WARN << "Found an invalid storage object!";
return;
}
- if (m_CurrentStorage->GetToolCount() != static_cast<int>(m_CurrentSource->GetNumberOfOutputs())) //there is something wrong with the storage
+ if (m_CurrentStorage->GetToolCount() != m_CurrentSource->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 = nullptr;
}
emit NavigationDataSourceSelected(m_CurrentSource);
}
mitk::NavigationDataSource::Pointer QmitkNavigationDataSourceSelectionWidget::GetSelectedNavigationDataSource()
{
return this->m_CurrentSource;
}
int QmitkNavigationDataSourceSelectionWidget::GetSelectedToolID()
{
return this->m_Controls->m_ToolView->currentIndex().row();
}
mitk::NavigationTool::Pointer QmitkNavigationDataSourceSelectionWidget::GetSelectedNavigationTool()
{
if (this->m_CurrentStorage.IsNull()) return nullptr;
- if (m_Controls->m_ToolView->currentIndex().row() >= m_CurrentStorage->GetToolCount()) return nullptr;
+ if ((m_Controls->m_ToolView->currentIndex().row() < 0) || (static_cast<unsigned int>(m_Controls->m_ToolView->currentIndex().row()) >= m_CurrentStorage->GetToolCount())) return nullptr;
return this->m_CurrentStorage->GetTool(m_Controls->m_ToolView->currentIndex().row());
}
mitk::NavigationToolStorage::Pointer QmitkNavigationDataSourceSelectionWidget::GetNavigationToolStorageOfSource()
{
return this->m_CurrentStorage;
}
diff --git a/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.cpp
index d8d423865e..7de0a427ca 100644
--- a/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.cpp
@@ -1,442 +1,442 @@
/*===================================================================
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 = nullptr;
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(nullptr,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();
}
}
void QmitkNavigationToolManagementWidget::OnSaveTool()
{
//if no item is selected, show error message:
if (m_Controls->m_ToolList->currentItem() == nullptr) { MessageBox("Error: Please select tool first!"); return; }
mitk::NavigationToolWriter::Pointer myWriter = mitk::NavigationToolWriter::New();
std::string filename = QFileDialog::getSaveFileName(nullptr,tr("Save Navigation Tool"), QmitkIGTCommonHelper::GetLastFileSavePath(), "*.IGTTool").toLatin1().data();
QmitkIGTCommonHelper::SetLastFileSavePathByFileName(QString::fromStdString(filename));
if (filename == "") return;
std::string fileExt = Poco::Path(filename).getExtension();
if (fileExt == "") { filename.append(".IGTTool"); }
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()));
connect((QObject*)(m_Controls->m_ToolList), SIGNAL(itemClicked(QListWidgetItem *)), this, SLOT(OnToolSelected()));
//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 = nullptr;
DisableStorageControls();
}
UpdateToolTable();
}
//##################################################################################
//############################## slots: main widget ################################
//##################################################################################
void QmitkNavigationToolManagementWidget::OnMoveToolUp()
{
if (m_NavigationToolStorage.IsNotNull())
{
//Proof, if the NavigationToolStorage is locked. If it is locked, show MessageBox to user.
if( m_NavigationToolStorage->isLocked() )
{
MessageBox("The storage is locked and it cannot be modified. Maybe the tracking device which " \
"uses this storage is connected. If you want to modify the storage please " \
"disconnect the device first.");
return;
}
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();
}
}
}
}
void QmitkNavigationToolManagementWidget::OnMoveToolDown()
{
if (m_NavigationToolStorage.IsNotNull())
{
//Proof, if the NavigationToolStorage is locked. If it is locked, show MessageBox to user.
if( m_NavigationToolStorage->isLocked() )
{
MessageBox("The storage is locked and it cannot be modified. Maybe the tracking device which " \
"uses this storage is connected. If you want to modify the storage please " \
"disconnect the device first.");
return;
}
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;
+ unsigned 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();
}
}
}
}
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_Controls->m_ToolCreationWidget->ShowToolPreview("Tool preview");
m_edit = false;
m_Controls->m_MainWidgets->setCurrentIndex(1);
}
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() == nullptr) //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();
}
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() == nullptr) //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->Initialize(m_DataStorage, "", ""); //Initialize once again, might be called here for the first time after autodetection
m_Controls->m_ToolCreationWidget->SetDefaultData(selectedTool);
m_Controls->m_ToolCreationWidget->ShowToolPreview("Tool preview");
m_edit = true;
m_Controls->m_MainWidgets->setCurrentIndex(1);
}
void QmitkNavigationToolManagementWidget::OnCreateStorage()
{
QString storageName = QInputDialog::getText(nullptr, "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(nullptr, tr("Open Navigation Tool Storage"), QmitkIGTCommonHelper::GetLastFileLoadPath(), tr("IGT Tool Storage (*.IGTToolStorage)")).toStdString();
if (filename == "") return;
QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(QString::fromStdString(filename));
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());
}
}
catch (const mitk::Exception& exception)
{
MessageBox(exception.GetDescription());
}
}
void QmitkNavigationToolManagementWidget::OnSaveStorage()
{
QFileDialog *fileDialog = new QFileDialog;
fileDialog->setDefaultSuffix("IGTToolStorage");
QString suffix = "IGT Tool Storage (*.IGTToolStorage)";
QString filename = fileDialog->getSaveFileName(nullptr, tr("Save Navigation Tool Storage"), QmitkIGTCommonHelper::GetLastFileSavePath(), suffix, &suffix);
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()
{
//Proof, if the NavigationToolStorage is locked. If it is locked, show MessageBox to user.
if( m_NavigationToolStorage->isLocked() )
{
MessageBox( "The storage is locked and it cannot be modified. Maybe the tracking device which " \
"uses this storage is connected. If you want to modify the storage please " \
"disconnect the device first.");
return;
}
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);
//Keep this line, 'cause otherwise, the NavigationToolStorage wouldn't notice, that the toolStorage changed.
m_NavigationToolStorage->UpdateMicroservice();
}
else //here we create a new tool
{
m_NavigationToolStorage->AddTool(newTool);
}
//Remove tool preview
m_DataStorage->Remove(m_DataStorage->GetNamedNode("Tool preview"));
UpdateToolTable();
m_Controls->m_MainWidgets->setCurrentIndex(0);
m_Controls->m_ToolInformation->setText("");
}
void QmitkNavigationToolManagementWidget::OnAddToolCancel()
{
m_Controls->m_MainWidgets->setCurrentIndex(0);
//Remove tool preview
m_DataStorage->Remove(m_DataStorage->GetNamedNode("Tool preview"));
}
void QmitkNavigationToolManagementWidget::OnToolSelected()
{
QString _label = "Information for tool " + m_Controls->m_ToolList->currentItem()->text() + "\n";
_label.append(QString(m_NavigationToolStorage->GetTool(m_Controls->m_ToolList->currentIndex().row())->GetStringWithAllToolInformation().c_str()));
m_Controls->m_ToolInformation->setText(_label);
}
//##################################################################################
//############################## 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++)
+ for (unsigned int i = 0; i < m_NavigationToolStorage->GetToolCount(); i++)
{
QString currentTool = "Tool" + QString::number(i) + ": " + QString(m_NavigationToolStorage->GetTool(i)->GetToolName().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);
}
diff --git a/Modules/IGTUI/Qmitk/QmitkToolTrackingStatusWidget.cpp b/Modules/IGTUI/Qmitk/QmitkToolTrackingStatusWidget.cpp
index f75837b771..a46f603f9c 100644
--- a/Modules/IGTUI/Qmitk/QmitkToolTrackingStatusWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkToolTrackingStatusWidget.cpp
@@ -1,273 +1,273 @@
/*===================================================================
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 "QmitkToolTrackingStatusWidget.h"
#include <usGetModuleContext.h>
QmitkToolTrackingStatusWidget::QmitkToolTrackingStatusWidget(QWidget* parent)
: QWidget(parent), m_Controls(nullptr), m_StatusLabels(nullptr), m_NavigationDatas(nullptr), m_NavDatasNewFlag(false)
{
m_ShowPositions = false;
m_ShowQuaternions = false;
m_Alignment = Qt::AlignHCenter;
m_Style = QmitkToolTrackingStatusWidget::VerticalUpperStyle;
CreateQtPartControl( this );
}
void QmitkToolTrackingStatusWidget::SetStyle(QmitkToolTrackingStatusWidget::Style newStyle)
{
//set new style
m_Style = newStyle;
//update current labels to show them in the new style
Refresh();
}
void QmitkToolTrackingStatusWidget::SetShowPositions(bool enable)
{
m_ShowPositions = enable;
//update current labels
Refresh();
}
void QmitkToolTrackingStatusWidget::SetShowQuaternions(bool enable)
{
m_ShowQuaternions = enable;
//update current labels
Refresh();
}
void QmitkToolTrackingStatusWidget::SetTextAlignment(Qt::AlignmentFlag alignment)
{
m_Alignment = alignment;
//update current labels
Refresh();
}
QmitkToolTrackingStatusWidget::~QmitkToolTrackingStatusWidget()
{
//m_Controls = nullptr;
if (m_StatusLabels!=nullptr) {delete m_StatusLabels;}
if (m_NavigationDatas != nullptr)
{
m_NavigationDatas->clear();
if (m_NavDatasNewFlag)
{
delete m_NavigationDatas;
}
}
}
void QmitkToolTrackingStatusWidget::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkToolTrackingStatusWidgetControls;
m_Controls->setupUi(parent);
this->CreateConnections();
//add empty label
AddEmptyLabel();
}
m_Context = us::GetModuleContext();
std::string m_Filter = "(" + us::ServiceConstants::OBJECTCLASS() + "=" + "org.mitk.services.NavigationToolStorage" + ")";
m_Context->AddServiceListener(this, &QmitkToolTrackingStatusWidget::OnServiceEvent, m_Filter);
}
void QmitkToolTrackingStatusWidget::OnServiceEvent(const us::ServiceEvent event)
{
if ((event.GetType() == us::ServiceEvent::MODIFIED) && (m_previewToolStorage.IsNotNull())) {this->PreShowTools(m_previewToolStorage);}
}
void QmitkToolTrackingStatusWidget::CreateConnections()
{
}
void QmitkToolTrackingStatusWidget::SetNavigationDatas(std::vector<mitk::NavigationData::Pointer>* navDatas)
{
m_NavigationDatas = navDatas;
m_previewToolStorage = nullptr;
}
void QmitkToolTrackingStatusWidget::AddNavigationData(mitk::NavigationData::Pointer nd)
{
if(m_NavigationDatas == nullptr)
{
m_NavigationDatas = new std::vector<mitk::NavigationData::Pointer>();
m_NavDatasNewFlag = true;
m_previewToolStorage = nullptr;
}
m_NavigationDatas->push_back(nd);
}
void QmitkToolTrackingStatusWidget::Refresh(int posPrecision, int quatPrecision)
{
if(m_NavigationDatas == nullptr || m_NavigationDatas->size() <= 0)
{
RemoveGuiLabels();
AddEmptyLabel();
return;
}
mitk::NavigationData* navData;
for(unsigned int i = 0; i < m_NavigationDatas->size(); i++)
{
navData = m_NavigationDatas->at(i).GetPointer();
QString name(navData->GetName());
QString pos = "";
QString quat = "";
if (m_ShowPositions)
{
mitk::Point3D position = navData->GetPosition();
pos = " [" + QString::number(position[0],'f',posPrecision) + ";" + QString::number(position[1],'f',posPrecision) + ";" + QString::number(position[2],'f',posPrecision) + "]";
}
if (m_ShowQuaternions)
{
mitk::Quaternion quaternion = navData->GetOrientation();
quat = " / [qx:" + QString::number(quaternion.x(),'f',quatPrecision) + ";qy:" + QString::number(quaternion.y(),'f',quatPrecision) + ";qz:" + QString::number(quaternion.z(),'f',quatPrecision) + ";qr:" + QString::number(quaternion.r()) + "]";
}
if(!(m_StatusLabels->at(i)->text() == name+pos+quat))
m_StatusLabels->at(i)->setText(name+pos+quat);
if(navData->IsDataValid())
m_StatusLabels->at(i)->setStyleSheet("QLabel{background-color: #8bff8b }");
else
m_StatusLabels->at(i)->setStyleSheet("QLabel{background-color: #ff7878 }");
}
}
void QmitkToolTrackingStatusWidget::ShowStatusLabels()
{
RemoveGuiLabels();
if(m_NavigationDatas == nullptr || m_NavigationDatas->size() <= 0)
{
RemoveGuiLabels();
AddEmptyLabel();
return;
}
m_StatusLabels = new QVector<QLabel*>();
mitk::NavigationData* navData;
QLabel* label;
for(unsigned int i = 0; i < m_NavigationDatas->size(); i++)
{
navData = m_NavigationDatas->at(i).GetPointer();
QString name(navData->GetName());
label = new QLabel(name, this);
label->setObjectName(name);
label->setAlignment(m_Alignment | Qt::AlignVCenter);
label->setFrameStyle(QFrame::Panel | QFrame::Sunken);
m_StatusLabels->append(label);
if (m_Style == QmitkToolTrackingStatusWidget::VerticalUpperStyle)
m_Controls->m_VerticalLayout->addWidget(m_StatusLabels->at(i));
else m_Controls->m_GridLayout->addWidget(m_StatusLabels->at(i),i,0);
}
}
void QmitkToolTrackingStatusWidget::PreShowTools(mitk::NavigationToolStorage::Pointer toolStorage)
{
RemoveGuiLabels();
QLabel* label;
- for(int i = 0; i < toolStorage->GetToolCount(); i++)
+ for(unsigned int i = 0; i < toolStorage->GetToolCount(); i++)
{
QString name(toolStorage->GetTool(i)->GetToolName().c_str());
label = new QLabel(name, this);
label->setObjectName(name);
label->setAlignment(m_Alignment | Qt::AlignVCenter);
label->setFrameStyle(QFrame::Panel | QFrame::Sunken);
label->setStyleSheet("QLabel{background-color: #dddddd }");
if (m_Style == QmitkToolTrackingStatusWidget::VerticalUpperStyle) m_Controls->m_VerticalLayout->addWidget(label);
else m_Controls->m_GridLayout->addWidget(label);
}
m_previewToolStorage = toolStorage;
}
void QmitkToolTrackingStatusWidget::RemoveStatusLabels()
{
//remove GUI elements
RemoveGuiLabels();
//clear members
if(m_StatusLabels != nullptr && m_StatusLabels->size() > 0)
{
delete m_StatusLabels;
m_StatusLabels = new QVector< QLabel* >();
}
if(m_NavigationDatas != nullptr && m_NavigationDatas->size() > 0)
{
if (m_NavDatasNewFlag)
{
delete m_NavigationDatas;
m_NavDatasNewFlag = false;
}
m_NavigationDatas = new std::vector<mitk::NavigationData::Pointer>();
m_NavDatasNewFlag = true;
}
//add empty label
AddEmptyLabel();
}
void QmitkToolTrackingStatusWidget::RemoveGuiLabels()
{
while(m_Controls->m_GridLayout->count() > 0 || m_Controls->m_VerticalLayout->count() > 0)
{
if (m_Controls->m_GridLayout->count() > 0)
{
QWidget* actWidget = m_Controls->m_GridLayout->itemAt(0)->widget();
m_Controls->m_GridLayout->removeWidget(actWidget);
delete actWidget;
}
else if (m_Controls->m_VerticalLayout->count() > 0)
{
QWidget* actWidget = m_Controls->m_VerticalLayout->itemAt(0)->widget();
m_Controls->m_VerticalLayout->removeWidget(actWidget);
delete actWidget;
}
}
}
void QmitkToolTrackingStatusWidget::AddEmptyLabel()
{
//add a label which tells that no tools are loaded yet
QLabel* label = new QLabel("No tools loaded yet.", this);
label->setObjectName("No tools loaded yet.");
label->setAlignment(m_Alignment | Qt::AlignVCenter);
label->setFrameStyle(QFrame::Panel | QFrame::Sunken);
label->setStyleSheet("QLabel{background-color: #dddddd }");
if (m_Style == QmitkToolTrackingStatusWidget::VerticalUpperStyle) m_Controls->m_VerticalLayout->addWidget(label);
else m_Controls->m_GridLayout->addWidget(label);
}
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.cpp
index 4b2babb767..61c7b2e42d 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.cpp
@@ -1,1076 +1,1017 @@
/*===================================================================
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 "QmitkUSNavigationStepMarkerIntervention.h"
#include "ui_QmitkUSNavigationStepMarkerIntervention.h"
#include "mitkBaseRenderer.h"
#include "mitkContourModel.h"
#include "mitkNeedleProjectionFilter.h"
#include "mitkNodeDisplacementFilter.h"
#include "mitkSurface.h"
#include "mitkTextAnnotation2D.h"
#include <mitkBaseGeometry.h>
#include <mitkManualPlacementAnnotationRenderer.h>
#include "../Filter/mitkUSNavigationTargetIntersectionFilter.h"
#include "../Filter/mitkUSNavigationTargetOcclusionFilter.h"
#include "../Filter/mitkUSNavigationTargetUpdateFilter.h"
#include "../USNavigationMarkerPlacement.h"
#include "../Widgets/QmitkZoneProgressBar.h"
#include "../mitkUSTargetPlacementQualityCalculator.h"
#include "../Interactors/mitkUSPointMarkInteractor.h"
#include "usModuleRegistry.h"
#include "mitkLookupTable.h"
#include "mitkLookupTableProperty.h"
#include "mitkSurface.h"
// VTK
#include "vtkCellLocator.h"
#include "vtkDataSet.h"
#include "vtkDoubleArray.h"
#include "vtkFloatArray.h"
#include "vtkIdList.h"
#include "vtkLinearTransform.h"
#include "vtkLookupTable.h"
#include "vtkMath.h"
#include "vtkOBBTree.h"
#include "vtkPointData.h"
#include "vtkPointData.h"
#include "vtkPolyData.h"
#include "vtkSelectEnclosedPoints.h"
#include "vtkSmartPointer.h"
#include "vtkSphereSource.h"
#include "vtkTransformPolyDataFilter.h"
#include "vtkWarpScalar.h"
QmitkUSNavigationStepMarkerIntervention::QmitkUSNavigationStepMarkerIntervention(QWidget *parent)
: QmitkUSAbstractNavigationStep(parent),
m_NumberOfTargets(0),
- m_TargetProgressBar(0),
- m_PlannedTargetProgressBar(0),
+ m_PlannedTargetsNodes(),
+ m_ReachedTargetsNodes(),
+ m_TargetProgressBar(new QmitkZoneProgressBar(QString::fromStdString("Target: %1 mm"), 200, 0, this)),
+ m_PlannedTargetProgressBar(nullptr),
m_CurrentTargetIndex(0),
m_CurrentTargetReached(false),
m_ShowPlanningColors(false),
+ m_PointMarkInteractor(mitk::USPointMarkInteractor::New()),
+ m_TargetNode(nullptr),
+ m_TargetColorLookupTableProperty(nullptr),
+ m_TargetSurface(nullptr),
m_NeedleProjectionFilter(mitk::NeedleProjectionFilter::New()),
m_NodeDisplacementFilter(mitk::NodeDisplacementFilter::New()),
m_TargetUpdateFilter(mitk::USNavigationTargetUpdateFilter::New()),
m_TargetOcclusionFilter(mitk::USNavigationTargetOcclusionFilter::New()),
m_TargetIntersectionFilter(mitk::USNavigationTargetIntersectionFilter::New()),
m_PlacementQualityCalculator(mitk::USTargetPlacementQualityCalculator::New()),
m_TargetStructureWarnOverlay(mitk::TextAnnotation2D::New()),
+ m_ReferenceSensorName(),
+ m_NeedleSensorName(),
m_ReferenceSensorIndex(1),
m_NeedleSensorIndex(0),
m_ListenerTargetCoordinatesChanged(this, &QmitkUSNavigationStepMarkerIntervention::UpdateTargetCoordinates),
ui(new Ui::QmitkUSNavigationStepMarkerIntervention)
{
m_ActiveTargetColor[0] = 1;
m_ActiveTargetColor[1] = 1;
m_ActiveTargetColor[2] = 0;
m_InactiveTargetColor[0] = 1;
m_InactiveTargetColor[1] = 1;
m_InactiveTargetColor[2] = 0.5;
m_ReachedTargetColor[0] = 0.6;
m_ReachedTargetColor[1] = 1;
m_ReachedTargetColor[2] = 0.6;
ui->setupUi(this);
connect(ui->freezeImageButton, SIGNAL(SignalFreezed(bool)), this, SLOT(OnFreeze(bool)));
connect(ui->backToLastTargetButton, SIGNAL(clicked()), this, SLOT(OnBackToLastTargetClicked()));
connect(ui->targetReachedButton, SIGNAL(clicked()), this, SLOT(OnTargetLeft()));
connect(this, SIGNAL(TargetReached(int)), this, SLOT(OnTargetReached()));
connect(this, SIGNAL(TargetLeft(int)), this, SLOT(OnTargetLeft()));
connect(ui->riskStructuresRangeWidget,
SIGNAL(SignalZoneViolated(const mitk::DataNode *, mitk::Point3D)),
this,
SLOT(OnRiskZoneViolated(const mitk::DataNode *, mitk::Point3D)));
- m_PointMarkInteractor = mitk::USPointMarkInteractor::New();
m_PointMarkInteractor->CoordinatesChangedEvent.AddListener(m_ListenerTargetCoordinatesChanged);
this->GenerateTargetColorLookupTable();
- m_TargetProgressBar = new QmitkZoneProgressBar(QString::fromStdString("Target: %1 mm"), 200, 0, this);
- m_TargetProgressBar->SetTextFormatInvalid("Target is not on Needle Path");
- ui->targetStructuresRangeLayout->addWidget(m_TargetProgressBar);
-
- m_TargetUpdateFilter->SetScalarArrayIdentifier("USNavigation::ReachedTargetScores");
-}
-
-QmitkUSNavigationStepMarkerIntervention::QmitkUSNavigationStepMarkerIntervention(mitk::Point3D toolAxis, QWidget *parent)
- : QmitkUSAbstractNavigationStep(parent),
- m_NumberOfTargets(0),
- m_TargetProgressBar(0),
- m_PlannedTargetProgressBar(0),
- m_CurrentTargetIndex(0),
- m_CurrentTargetReached(false),
- m_ShowPlanningColors(false),
- m_NeedleProjectionFilter(mitk::NeedleProjectionFilter::New()),
- m_NodeDisplacementFilter(mitk::NodeDisplacementFilter::New()),
- m_TargetUpdateFilter(mitk::USNavigationTargetUpdateFilter::New()),
- m_TargetOcclusionFilter(mitk::USNavigationTargetOcclusionFilter::New()),
- m_TargetIntersectionFilter(mitk::USNavigationTargetIntersectionFilter::New()),
- m_PlacementQualityCalculator(mitk::USTargetPlacementQualityCalculator::New()),
- m_ListenerTargetCoordinatesChanged(this, &QmitkUSNavigationStepMarkerIntervention::UpdateTargetCoordinates),
- m_TargetStructureWarnOverlay(mitk::TextAnnotation2D::New()),
- m_ReferenceSensorIndex(1),
- m_NeedleSensorIndex(0),
- ui(new Ui::QmitkUSNavigationStepMarkerIntervention)
-{
- m_ActiveTargetColor[0] = 1;
- m_ActiveTargetColor[1] = 1;
- m_ActiveTargetColor[2] = 0;
- m_InactiveTargetColor[0] = 1;
- m_InactiveTargetColor[1] = 1;
- m_InactiveTargetColor[2] = 0.5;
- m_ReachedTargetColor[0] = 0.6;
- m_ReachedTargetColor[1] = 1;
- m_ReachedTargetColor[2] = 0.6;
-
- ui->setupUi(this);
-
- m_NeedleProjectionFilter->SetToolAxisForFilter(toolAxis);
-
- connect(ui->freezeImageButton, SIGNAL(SignalFreezed(bool)), this, SLOT(OnFreeze(bool)));
- connect(ui->backToLastTargetButton, SIGNAL(clicked()), this, SLOT(OnBackToLastTargetClicked()));
- connect(ui->targetReachedButton, SIGNAL(clicked()), this, SLOT(OnTargetLeft()));
- connect(this, SIGNAL(TargetReached(int)), this, SLOT(OnTargetReached()));
- connect(this, SIGNAL(TargetLeft(int)), this, SLOT(OnTargetLeft()));
- connect(ui->riskStructuresRangeWidget,
- SIGNAL(SignalZoneViolated(const mitk::DataNode *, mitk::Point3D)),
- this,
- SLOT(OnRiskZoneViolated(const mitk::DataNode *, mitk::Point3D)));
-
- m_PointMarkInteractor = mitk::USPointMarkInteractor::New();
- m_PointMarkInteractor->CoordinatesChangedEvent.AddListener(m_ListenerTargetCoordinatesChanged);
-
- this->GenerateTargetColorLookupTable();
-
- m_TargetProgressBar = new QmitkZoneProgressBar(QString::fromStdString("Target: %1 mm"), 200, 0, this);
m_TargetProgressBar->SetTextFormatInvalid("Target is not on Needle Path");
ui->targetStructuresRangeLayout->addWidget(m_TargetProgressBar);
m_TargetUpdateFilter->SetScalarArrayIdentifier("USNavigation::ReachedTargetScores");
}
QmitkUSNavigationStepMarkerIntervention::~QmitkUSNavigationStepMarkerIntervention()
{
mitk::DataStorage::Pointer dataStorage = this->GetDataStorage(false);
if (dataStorage.IsNotNull())
{
// remove the node for the needle path
mitk::DataNode::Pointer node =
this->GetNamedDerivedNode("Needle Path", QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
if (node.IsNotNull())
{
dataStorage->Remove(node);
}
}
- if (m_SegmentationNode.IsNotNull())
- {
- this->GetDataStorage()->Remove(m_SegmentationNode);
- }
- if (m_ForegroundModelPointsNode.IsNotNull())
- {
- this->GetDataStorage()->Remove(m_ForegroundModelPointsNode);
- }
-
delete ui;
m_PointMarkInteractor->CoordinatesChangedEvent.RemoveListener(m_ListenerTargetCoordinatesChanged);
}
bool QmitkUSNavigationStepMarkerIntervention::OnStartStep()
{
m_NeedleProjectionFilter->SelectInput(m_NeedleSensorIndex);
// create node for Needle Projection
mitk::DataNode::Pointer node =
this->GetNamedDerivedNodeAndCreate("Needle Path", QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
node->SetData(m_NeedleProjectionFilter->GetProjection());
node->SetBoolProperty("show contour", true);
// initialize warning overlay (and do not display it, yet)
m_TargetStructureWarnOverlay->SetText("Warning: Needle is Inside the Target Structure.");
m_TargetStructureWarnOverlay->SetVisibility(false);
// set position and font size for the text overlay
mitk::Point2D overlayPosition;
overlayPosition.SetElement(0, 10.0f);
overlayPosition.SetElement(1, 10.0f);
m_TargetStructureWarnOverlay->SetPosition2D(overlayPosition);
m_TargetStructureWarnOverlay->SetFontSize(18);
// overlay should be red
mitk::Color color;
color[0] = 1;
color[1] = 0;
color[2] = 0;
m_TargetStructureWarnOverlay->SetColor(color);
mitk::ManualPlacementAnnotationRenderer::AddAnnotation(m_TargetStructureWarnOverlay.GetPointer(), "stdmulti.widget4");
return true;
}
bool QmitkUSNavigationStepMarkerIntervention::OnStopStep()
{
mitk::DataStorage::Pointer dataStorage = this->GetDataStorage();
// remove all reached nodes from the data storage
for (QVector<itk::SmartPointer<mitk::DataNode>>::iterator it = m_ReachedTargetsNodes.begin();
it != m_ReachedTargetsNodes.end();
++it)
{
dataStorage->Remove(*it);
}
m_ReachedTargetsNodes.clear();
m_CurrentTargetIndex = 0;
// reset button states
ui->freezeImageButton->setEnabled(false);
ui->backToLastTargetButton->setEnabled(false);
ui->targetReachedButton->setEnabled(true);
// make sure that it is unfreezed after stopping the step
ui->freezeImageButton->Unfreeze();
// remove base node for reached targets from the data storage
mitk::DataNode::Pointer reachedTargetsNode = this->GetNamedDerivedNode(
QmitkUSAbstractNavigationStep::DATANAME_BASENODE, USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS);
if (reachedTargetsNode.IsNotNull())
{
dataStorage->Remove(reachedTargetsNode);
}
return true;
}
bool QmitkUSNavigationStepMarkerIntervention::OnFinishStep()
{
return true;
}
bool QmitkUSNavigationStepMarkerIntervention::OnActivateStep()
{
this->ClearZones(); // clear risk zones before adding new ones
// get target node from data storage and make sure that it contains data
m_TargetNode = this->GetNamedDerivedNode(USNavigationMarkerPlacement::DATANAME_TARGETSURFACE,
USNavigationMarkerPlacement::DATANAME_TUMOUR);
if (m_TargetNode.IsNull() || m_TargetNode->GetData() == 0)
{
mitkThrow() << "Target node (" << USNavigationMarkerPlacement::DATANAME_TARGETSURFACE << ") must not be null.";
}
// get target data and make sure that it is a surface
m_TargetSurface = dynamic_cast<mitk::Surface *>(m_TargetNode->GetData());
if (m_TargetSurface.IsNull())
{
mitkThrow() << "Target node (" << USNavigationMarkerPlacement::DATANAME_TARGETSURFACE
<< ") data must be of type mitk::Surface";
}
// delete progress bars for reinitializing them again afterwards
if (m_PlannedTargetProgressBar)
{
ui->targetStructuresRangeLayout->removeWidget(m_PlannedTargetProgressBar);
delete m_PlannedTargetProgressBar;
m_PlannedTargetProgressBar = 0;
}
m_NodeDisplacementFilter->SelectInput(m_ReferenceSensorIndex);
this->UpdateTargetProgressDisplay();
mitk::DataNode::Pointer tumourNode = this->GetNamedDerivedNode(USNavigationMarkerPlacement::DATANAME_TUMOUR,
QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
if (tumourNode.IsNotNull())
{
// do not show tumour node during intervention (target surface is shown)
tumourNode->SetBoolProperty("visible", false);
// add tumour as a risk structure
ui->riskStructuresRangeWidget->AddZone(tumourNode);
}
// set target structure for target update filter
m_TargetUpdateFilter->SetTargetStructure(m_TargetNode);
m_TargetOcclusionFilter->SetTargetStructure(m_TargetNode);
// set lookup table of tumour node
m_TargetNode->SetProperty("LookupTable", m_TargetColorLookupTableProperty);
//
mitk::DataNode::Pointer targetsBaseNode = this->GetNamedDerivedNode(USNavigationMarkerPlacement::DATANAME_TARGETS,
QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
mitk::DataStorage::SetOfObjects::ConstPointer plannedTargetNodes;
if (targetsBaseNode.IsNotNull())
{
plannedTargetNodes = this->GetDataStorage()->GetDerivations(targetsBaseNode);
}
if (plannedTargetNodes.IsNotNull() && plannedTargetNodes->Size() > 0)
{
for (mitk::DataStorage::SetOfObjects::ConstIterator it = plannedTargetNodes->Begin();
it != plannedTargetNodes->End();
++it)
{
m_PlannedTargetsNodes.push_back(it->Value());
}
m_PlannedTargetProgressBar = new QmitkZoneProgressBar(QString::fromStdString("Planned Target"), 200, 0);
ui->targetStructuresRangeLayout->addWidget(m_PlannedTargetProgressBar);
}
// add progress bars for risk zone nodes
mitk::DataNode::Pointer zonesBaseNode = this->GetNamedDerivedNode(USNavigationMarkerPlacement::DATANAME_ZONES,
QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
// only add progress bars if the base node for zones was created
if (zonesBaseNode.IsNotNull())
{
mitk::DataStorage::SetOfObjects::ConstPointer zoneNodes = this->GetDataStorage()->GetDerivations(zonesBaseNode);
for (mitk::DataStorage::SetOfObjects::ConstIterator it = zoneNodes->Begin(); it != zoneNodes->End(); ++it)
{
ui->riskStructuresRangeWidget->AddZone(it->Value());
}
m_TargetOcclusionFilter->SelectStartPositionInput(m_NeedleSensorIndex);
m_TargetOcclusionFilter->SetObstacleStructures(zoneNodes);
}
return true;
}
bool QmitkUSNavigationStepMarkerIntervention::OnDeactivateStep()
{
ui->freezeImageButton->Unfreeze();
return true;
}
void QmitkUSNavigationStepMarkerIntervention::OnUpdate()
{
// get navigation data source and make sure that it is not null
mitk::NavigationDataSource::Pointer navigationDataSource = this->GetCombinedModality()->GetNavigationDataSource();
if (navigationDataSource.IsNull())
{
MITK_ERROR("QmitkUSAbstractNavigationStep")
("QmitkUSNavigationStepMarkerIntervention") << "Navigation Data Source of Combined Modality must not be null.";
mitkThrow() << "Navigation Data Source of Combined Modality must not be null.";
}
ui->riskStructuresRangeWidget->UpdateDistancesToNeedlePosition(navigationDataSource->GetOutput(m_NeedleSensorIndex));
this->UpdateBodyMarkerStatus(navigationDataSource->GetOutput(m_ReferenceSensorIndex));
this->UpdateTargetColors();
this->UpdateTargetScore();
this->UpdateTargetViolationStatus();
}
void QmitkUSNavigationStepMarkerIntervention::OnSettingsChanged(const itk::SmartPointer<mitk::DataNode> settingsNode)
{
if (settingsNode.IsNull())
{
return;
}
int numberOfTargets;
if (settingsNode->GetIntProperty("settings.number-of-targets", numberOfTargets))
{
m_NumberOfTargets = numberOfTargets;
m_TargetUpdateFilter->SetNumberOfTargets(numberOfTargets);
m_PlacementQualityCalculator->SetOptimalAngle(m_TargetUpdateFilter->GetOptimalAngle());
}
std::string referenceSensorName;
if (settingsNode->GetStringProperty("settings.reference-name-selected", referenceSensorName))
{
m_ReferenceSensorName = referenceSensorName;
}
std::string needleSensorName;
if (settingsNode->GetStringProperty("settings.needle-name-selected", needleSensorName))
{
m_NeedleSensorName = needleSensorName;
}
this->UpdateSensorsNames();
}
QString QmitkUSNavigationStepMarkerIntervention::GetTitle()
{
return "Computer-assisted Intervention";
}
bool QmitkUSNavigationStepMarkerIntervention::GetIsRestartable()
{
return true;
}
QmitkUSAbstractNavigationStep::FilterVector QmitkUSNavigationStepMarkerIntervention::GetFilter()
{
FilterVector filter;
filter.push_back(m_NeedleProjectionFilter.GetPointer());
filter.push_back(m_NodeDisplacementFilter.GetPointer());
filter.push_back(m_TargetOcclusionFilter.GetPointer());
return filter;
}
void QmitkUSNavigationStepMarkerIntervention::OnSetCombinedModality()
{
mitk::USCombinedModality::Pointer combinedModality = this->GetCombinedModality(false);
if (combinedModality.IsNotNull())
{
mitk::AffineTransform3D::Pointer calibration = combinedModality->GetCalibration();
if (calibration.IsNotNull())
{
m_NeedleProjectionFilter->SetTargetPlane(calibration);
}
}
ui->freezeImageButton->SetCombinedModality(combinedModality, m_ReferenceSensorIndex);
this->UpdateSensorsNames();
}
void QmitkUSNavigationStepMarkerIntervention::OnTargetReached()
{
m_CurrentTargetReached = true;
}
void QmitkUSNavigationStepMarkerIntervention::OnTargetLeft()
{
m_CurrentTargetReached = false;
m_CurrentTargetIndex++;
if (m_CurrentTargetIndex >= 0 && static_cast<unsigned int>(m_CurrentTargetIndex) >= m_NumberOfTargets)
{
ui->targetReachedButton->setDisabled(true);
}
ui->backToLastTargetButton->setEnabled(true);
ui->freezeImageButton->setEnabled(true);
this->UpdateTargetProgressDisplay();
if (m_ReachedTargetsNodes.size() < m_CurrentTargetIndex)
{
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetName(
(QString("Target ") + QString("%1").arg(m_CurrentTargetIndex, 2, 10, QLatin1Char('0'))).toStdString());
this->GetDataStorage()->Add(
node,
this->GetNamedDerivedNodeAndCreate(USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS,
QmitkUSAbstractNavigationStep::DATANAME_BASENODE));
m_ReachedTargetsNodes.push_back(node);
}
mitk::DataNode::Pointer node = m_ReachedTargetsNodes.at(m_CurrentTargetIndex - 1);
mitk::Surface::Pointer zone = mitk::Surface::New();
// create a vtk sphere with given radius
vtkSphereSource *vtkData = vtkSphereSource::New();
vtkData->SetRadius(5);
vtkData->SetCenter(0, 0, 0);
vtkData->Update();
zone->SetVtkPolyData(vtkData->GetOutput());
vtkData->Delete();
// set vtk sphere and origin to data node
node->SetData(zone);
node->GetData()->GetGeometry()->SetOrigin(
this->GetCombinedModality()->GetNavigationDataSource()->GetOutput(m_NeedleSensorIndex)->GetPosition());
node->SetColor(0.2, 0.9, 0.2);
this->UpdateTargetCoordinates(node);
}
void QmitkUSNavigationStepMarkerIntervention::OnBackToLastTargetClicked()
{
if (m_CurrentTargetIndex < 1)
{
MITK_WARN << "Cannot go back to last target as there is no last target.";
return;
}
m_CurrentTargetIndex--;
if (m_ReachedTargetsNodes.size() > m_CurrentTargetIndex)
{
this->GetDataStorage()->Remove(m_ReachedTargetsNodes.last());
MITK_INFO("QmitkUSAbstractNavigationStep")
("QmitkUSNavigationStepMarkerIntervention") << "Removed Target " << m_ReachedTargetsNodes.size();
m_ReachedTargetsNodes.pop_back();
}
if (m_CurrentTargetIndex == 0)
{
ui->backToLastTargetButton->setDisabled(true);
}
if (m_CurrentTargetIndex >= 0 && static_cast<unsigned int>(m_CurrentTargetIndex) < m_NumberOfTargets)
{
ui->targetReachedButton->setEnabled(true);
}
ui->freezeImageButton->setEnabled(false);
ui->freezeImageButton->Unfreeze();
this->UpdateTargetProgressDisplay();
m_TargetUpdateFilter->RemovePositionOfTarget(m_CurrentTargetIndex);
}
void QmitkUSNavigationStepMarkerIntervention::OnFreeze(bool freezed)
{
if (freezed)
{
this->GetCombinedModality()->SetIsFreezed(true);
// load state machine and event config for data interactor
m_PointMarkInteractor->LoadStateMachine("USPointMarkInteractions.xml", us::ModuleRegistry::GetModule("MitkUS"));
m_PointMarkInteractor->SetEventConfig("globalConfig.xml");
if (m_CurrentTargetIndex < 1)
{
mitkThrow() << "Current target index has to be greater zero when freeze button is clicked.";
}
if (m_ReachedTargetsNodes.size() < m_CurrentTargetIndex)
{
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetName(
(QString("Target ") + QString("%1").arg(m_CurrentTargetIndex, 2, 10, QLatin1Char('0'))).toStdString());
this->GetDataStorage()->Add(
node,
this->GetNamedDerivedNodeAndCreate(USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS,
QmitkUSAbstractNavigationStep::DATANAME_BASENODE));
m_ReachedTargetsNodes.push_back(node);
}
m_PointMarkInteractor->SetDataNode(m_ReachedTargetsNodes.last());
}
else
{
m_PointMarkInteractor->SetDataNode(0);
this->GetCombinedModality()->SetIsFreezed(false);
}
}
void QmitkUSNavigationStepMarkerIntervention::OnShowPlanningView(bool show)
{
m_ShowPlanningColors = show;
}
void QmitkUSNavigationStepMarkerIntervention::OnRiskZoneViolated(const mitk::DataNode *node, mitk::Point3D position)
{
MITK_INFO << "Risk zone (" << node->GetName() << ") violated at position " << position << ".";
}
void QmitkUSNavigationStepMarkerIntervention::ClearZones()
{
ui->riskStructuresRangeWidget->ClearZones();
// remove all reached target nodes from the data storage and clear the list
mitk::DataStorage::Pointer dataStorage = this->GetDataStorage();
for (QVector<mitk::DataNode::Pointer>::iterator it = m_ReachedTargetsNodes.begin(); it != m_ReachedTargetsNodes.end();
++it)
{
if (it->IsNotNull())
{
dataStorage->Remove(*it);
}
}
m_ReachedTargetsNodes.clear();
}
void QmitkUSNavigationStepMarkerIntervention::UpdateTargetCoordinates(mitk::DataNode *dataNode)
{
m_NodeDisplacementFilter->ResetNodes();
for (QVector<itk::SmartPointer<mitk::DataNode>>::iterator it = m_ReachedTargetsNodes.begin();
it != m_ReachedTargetsNodes.end();
++it)
{
if (it->IsNotNull() && (*it)->GetData() != 0)
{
m_NodeDisplacementFilter->AddNode(*it);
}
}
mitk::BaseData *baseData = dataNode->GetData();
if (!baseData)
{
mitkThrow() << "Data of the data node must not be null.";
}
mitk::BaseGeometry::Pointer geometry = baseData->GetGeometry();
if (geometry.IsNull())
{
mitkThrow() << "Geometry of the data node must not be null.";
}
m_TargetUpdateFilter->SetControlNode(m_CurrentTargetIndex - 1, dataNode);
if (m_PlannedTargetsNodes.size() > m_CurrentTargetIndex - 1)
{
m_PlannedTargetsNodes.at(m_CurrentTargetIndex - 1)->SetVisibility(false);
}
MITK_INFO("QmitkUSAbstractNavigationStep")
("QmitkUSNavigationStepMarkerIntervention") << "Target " << m_CurrentTargetIndex << " reached at position "
<< geometry->GetOrigin();
this->CalculateTargetPlacementQuality();
}
void QmitkUSNavigationStepMarkerIntervention::UpdateBodyMarkerStatus(mitk::NavigationData::Pointer bodyMarker)
{
if (bodyMarker.IsNull())
{
MITK_ERROR("QmitkUSAbstractNavigationStep")
("QmitkUSNavigationStepMarkerIntervention")
<< "Current Navigation Data for body marker of Combined Modality must not be null.";
mitkThrow() << "Current Navigation Data for body marker of Combined Modality must not be null.";
}
bool valid = bodyMarker->IsDataValid();
// update body marker status label
if (valid)
{
ui->bodyMarkerTrackingStatusLabel->setStyleSheet(
"background-color: #8bff8b; margin-right: 1em; margin-left: 1em; border: 1px solid grey");
ui->bodyMarkerTrackingStatusLabel->setText("Body marker is inside the tracking volume.");
}
else
{
ui->bodyMarkerTrackingStatusLabel->setStyleSheet(
"background-color: #ff7878; margin-right: 1em; margin-left: 1em; border: 1px solid grey");
ui->bodyMarkerTrackingStatusLabel->setText("Body marker is not inside the tracking volume.");
}
ui->targetStructuresRangeGroupBox->setEnabled(valid);
ui->riskStructuresRangeGroupBox->setEnabled(valid);
}
void QmitkUSNavigationStepMarkerIntervention::GenerateTargetColorLookupTable()
{
vtkSmartPointer<vtkLookupTable> lookupTable = vtkSmartPointer<vtkLookupTable>::New();
lookupTable->SetHueRange(0.0, 0.33);
lookupTable->SetSaturationRange(1.0, 1.0);
lookupTable->SetValueRange(1.0, 1.0);
lookupTable->SetTableRange(0.0, 1.0);
lookupTable->Build();
mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
lut->SetVtkLookupTable(lookupTable);
m_TargetColorLookupTableProperty = mitk::LookupTableProperty::New(lut);
}
void QmitkUSNavigationStepMarkerIntervention::UpdateTargetColors()
{
if (m_TargetNode.IsNull())
{
return;
}
m_TargetNode->SetColor(1, 1, 1);
mitk::BaseData *targetNodeData = m_TargetNode->GetData();
if (targetNodeData == 0)
{
return;
}
mitk::Surface::Pointer targetNodeSurface = dynamic_cast<mitk::Surface *>(targetNodeData);
vtkSmartPointer<vtkPolyData> targetNodeSurfaceVtk = targetNodeSurface->GetVtkPolyData();
vtkPointData *targetPointData = targetNodeSurface->GetVtkPolyData()->GetPointData();
vtkFloatArray *scalars = dynamic_cast<vtkFloatArray *>(targetPointData->GetScalars("USNavigation::Occlusion"));
vtkFloatArray *targetScoreScalars;
if (m_ShowPlanningColors)
{
targetScoreScalars = dynamic_cast<vtkFloatArray *>(targetPointData->GetScalars("USNavigation::PlanningScalars"));
}
else
{
targetScoreScalars =
dynamic_cast<vtkFloatArray *>(targetPointData->GetScalars("USNavigation::ReachedTargetScores"));
}
if (!scalars || !targetScoreScalars)
{
return;
}
unsigned int numberOfTupels = scalars->GetNumberOfTuples();
vtkSmartPointer<vtkFloatArray> colors = vtkSmartPointer<vtkFloatArray>::New();
colors->SetNumberOfComponents(1);
colors->SetNumberOfTuples(numberOfTupels);
colors->SetName("Colors");
double color, intersection, markerScore;
for (unsigned int n = 0; n < numberOfTupels; n++)
{
scalars->GetTuple(n, &intersection);
targetScoreScalars->GetTuple(n, &markerScore);
if (intersection > 0)
{
color = 0;
}
else
{
color = markerScore;
}
colors->SetTuple(n, &color);
}
if (numberOfTupels > 0)
{
targetNodeSurfaceVtk->GetPointData()->SetScalars(colors);
targetNodeSurfaceVtk->GetPointData()->Update();
}
}
void QmitkUSNavigationStepMarkerIntervention::UpdateTargetScore()
{
if (m_NeedleProjectionFilter->GetProjection()->GetSize() != 2)
{
return;
}
vtkSmartPointer<vtkPolyData> targetSurfaceVtk = m_TargetSurface->GetVtkPolyData();
m_TargetIntersectionFilter->SetTargetSurface(m_TargetSurface);
m_TargetIntersectionFilter->SetLine(m_NeedleProjectionFilter->GetProjection());
m_TargetIntersectionFilter->CalculateIntersection();
if (m_TargetIntersectionFilter->GetIsIntersecting())
{
vtkFloatArray *scalars =
dynamic_cast<vtkFloatArray *>(targetSurfaceVtk->GetPointData()->GetScalars("USNavigation::ReachedTargetScores"));
double score;
scalars->GetTuple(m_TargetIntersectionFilter->GetIntersectionNearestSurfacePointId(), &score);
double color[3];
m_TargetColorLookupTableProperty->GetLookupTable()->GetVtkLookupTable()->GetColor(score, color);
float colorF[3];
colorF[0] = color[0];
colorF[1] = color[1];
colorF[2] = color[2];
m_TargetProgressBar->SetColor(colorF);
m_TargetProgressBar->SetBorderColor(colorF);
m_TargetProgressBar->setValue(m_TargetIntersectionFilter->GetDistanceToIntersection());
if (m_PlannedTargetProgressBar)
{
vtkFloatArray *scalars =
dynamic_cast<vtkFloatArray *>(targetSurfaceVtk->GetPointData()->GetScalars("USNavigation::PlanningScalars"));
if (scalars)
{
double score;
scalars->GetTuple(m_TargetIntersectionFilter->GetIntersectionNearestSurfacePointId(), &score);
double color[3];
m_TargetColorLookupTableProperty->GetLookupTable()->GetVtkLookupTable()->GetColor(score, color);
float colorF[3];
colorF[0] = color[0];
colorF[1] = color[1];
colorF[2] = color[2];
m_PlannedTargetProgressBar->SetColor(colorF);
m_PlannedTargetProgressBar->SetBorderColor(colorF);
m_PlannedTargetProgressBar->SetTextFormatValid("Planned Target: %1 mm");
mitk::Point3D intersectionPoint = m_TargetIntersectionFilter->GetIntersectionPoint();
mitk::ScalarType minDistance = -1;
for (QVector<itk::SmartPointer<mitk::DataNode>>::iterator it = m_PlannedTargetsNodes.begin();
it != m_PlannedTargetsNodes.end();
++it)
{
mitk::ScalarType distance =
intersectionPoint.EuclideanDistanceTo((*it)->GetData()->GetGeometry()->GetOrigin());
if (minDistance < 0 || distance < minDistance)
{
minDistance = distance;
}
}
m_PlannedTargetProgressBar->setValue(minDistance);
}
}
}
else
{
m_TargetProgressBar->setValueInvalid();
}
}
void QmitkUSNavigationStepMarkerIntervention::UpdateTargetProgressDisplay()
{
QString description;
if (m_CurrentTargetIndex >= static_cast<int>(m_NumberOfTargets))
{
description = "All Targets Reached";
if (m_TargetProgressBar)
{
m_TargetProgressBar->hide();
}
}
else
{
description = QString("Distance to Target ") + QString::number(m_CurrentTargetIndex + 1) + QString(" of ") +
QString::number(m_NumberOfTargets);
if (m_TargetProgressBar)
{
m_TargetProgressBar->show();
}
}
ui->targetStructuresRangeGroupBox->setTitle(description);
}
void QmitkUSNavigationStepMarkerIntervention::UpdatePlannedTargetProgressDisplay()
{
// make sure that the needle projection consists of two points
if (m_NeedleProjectionFilter->GetProjection()->GetSize() != 2)
{
return;
}
vtkSmartPointer<vtkPolyData> targetSurfaceVtk = m_TargetSurface->GetVtkPolyData();
m_TargetIntersectionFilter->SetTargetSurface(m_TargetSurface);
m_TargetIntersectionFilter->SetLine(m_NeedleProjectionFilter->GetProjection());
m_TargetIntersectionFilter->CalculateIntersection();
// update target progress bar according to the color of the intersection
// point on the target surface and the distance to the intersection
if (m_TargetIntersectionFilter->GetIsIntersecting())
{
vtkFloatArray *scalars = dynamic_cast<vtkFloatArray *>(targetSurfaceVtk->GetPointData()->GetScalars("Colors"));
double score;
scalars->GetTuple(m_TargetIntersectionFilter->GetIntersectionNearestSurfacePointId(), &score);
double color[3];
m_TargetColorLookupTableProperty->GetLookupTable()->GetVtkLookupTable()->GetColor(score, color);
float colorF[3];
colorF[0] = color[0];
colorF[1] = color[1];
colorF[2] = color[2];
m_TargetProgressBar->SetColor(colorF);
m_TargetProgressBar->SetBorderColor(colorF);
m_TargetProgressBar->setValue(m_TargetIntersectionFilter->GetDistanceToIntersection());
}
else
{
float red[3] = {0.6f, 0.0f, 0.0f};
m_TargetProgressBar->SetBorderColor(red);
m_TargetProgressBar->setValueInvalid();
}
}
void QmitkUSNavigationStepMarkerIntervention::UpdateTargetViolationStatus()
{
// transform vtk polydata according to mitk geometry
vtkSmartPointer<vtkTransformPolyDataFilter> transformFilter = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
transformFilter->SetInputData(0, m_TargetSurface->GetVtkPolyData());
transformFilter->SetTransform(m_TargetSurface->GetGeometry()->GetVtkTransform());
transformFilter->Update();
vtkSmartPointer<vtkSelectEnclosedPoints> enclosedPoints = vtkSmartPointer<vtkSelectEnclosedPoints>::New();
enclosedPoints->Initialize(transformFilter->GetOutput());
mitk::Point3D needleTip = m_NeedleProjectionFilter->GetProjection()->GetPoint(0);
// show warning if the needle tip is inside the target surface
if (enclosedPoints->IsInsideSurface(needleTip[0], needleTip[1], needleTip[2]))
{
if (!m_TargetStructureWarnOverlay->IsVisible(NULL))
{
m_TargetStructureWarnOverlay->SetVisibility(true);
mitk::DataNode::Pointer targetViolationResult = mitk::DataNode::New();
targetViolationResult->SetName("TargetViolation");
targetViolationResult->SetProperty("USNavigation::TargetViolationPoint", mitk::Point3dProperty::New(needleTip));
emit SignalIntermediateResult(targetViolationResult);
}
MITK_INFO("QmitkUSAbstractNavigationStep")
("QmitkUSNavigationStepMarkerIntervention") << "Target surface violated at " << needleTip << ".";
}
else
{
m_TargetStructureWarnOverlay->SetVisibility(false);
}
}
void QmitkUSNavigationStepMarkerIntervention::CalculateTargetPlacementQuality()
{
// clear quality display if there aren't all targets reached
if (m_ReachedTargetsNodes.size() != static_cast<int>(m_NumberOfTargets))
{
ui->placementQualityGroupBox->setEnabled(false);
ui->angleDifferenceValue->setText("");
ui->centersOfMassValue->setText("");
return;
}
ui->placementQualityGroupBox->setEnabled(true);
mitk::Surface::Pointer targetSurface = dynamic_cast<mitk::Surface *>(m_TargetNode->GetData());
if (targetSurface.IsNull())
{
mitkThrow() << "Target surface must not be null.";
}
m_PlacementQualityCalculator->SetTargetSurface(targetSurface);
mitk::PointSet::Pointer targetPointSet = mitk::PointSet::New();
// copy the origins of all reached target nodes into a point set
// for the quality calculator
mitk::PointSet::PointIdentifier n = 0;
for (QVector<itk::SmartPointer<mitk::DataNode>>::iterator it = m_ReachedTargetsNodes.begin();
it != m_ReachedTargetsNodes.end();
++it)
{
targetPointSet->InsertPoint(n++, (*it)->GetData()->GetGeometry()->GetOrigin());
}
m_PlacementQualityCalculator->SetTargetPoints(targetPointSet);
m_PlacementQualityCalculator->Update();
double centersOfMassDistance = m_PlacementQualityCalculator->GetCentersOfMassDistance();
ui->centersOfMassValue->setText(QString::number(centersOfMassDistance, 103, 2) + " mm");
double meanAnglesDifference = m_PlacementQualityCalculator->GetMeanAngleDifference();
- ui->angleDifferenceValue->setText(QString::number(meanAnglesDifference, 103, 2) + QString::fromLatin1(" �"));
+ ui->angleDifferenceValue->setText(QString::number(meanAnglesDifference, 103, 2) + QString::fromLatin1(" °"));
// create an intermediate result of the placement quality
mitk::DataNode::Pointer placementQualityResult = mitk::DataNode::New();
placementQualityResult->SetName("PlacementQuality");
placementQualityResult->SetFloatProperty("USNavigation::CentersOfMassDistance", centersOfMassDistance);
placementQualityResult->SetFloatProperty("USNavigation::MeanAngleDifference", meanAnglesDifference);
placementQualityResult->SetProperty(
"USNavigation::AngleDifferences",
mitk::GenericProperty<mitk::VnlVector>::New(m_PlacementQualityCalculator->GetAngleDifferences()));
if (m_PlannedTargetsNodes.size() == static_cast<int>(m_NumberOfTargets))
{
mitk::VnlVector reachedPlannedDifferences;
double reachedPlannedDifferencesSum = 0;
double reachedPlannedDifferencesMax = 0;
reachedPlannedDifferences.set_size(m_NumberOfTargets);
// get sum and maximum of the planning / reality differences
for (unsigned int n = 0; n < m_NumberOfTargets; ++n)
{
mitk::ScalarType distance =
m_PlannedTargetsNodes.at(n)->GetData()->GetGeometry()->GetOrigin().EuclideanDistanceTo(
m_ReachedTargetsNodes.at(n)->GetData()->GetGeometry()->GetOrigin());
reachedPlannedDifferences.put(n, distance);
reachedPlannedDifferencesSum += distance;
if (distance > reachedPlannedDifferencesMax)
{
reachedPlannedDifferencesMax = distance;
}
}
// add distances between planning and reality to the quality intermediate result
placementQualityResult->SetProperty("USNavigation::PlanningRealityDistances",
mitk::GenericProperty<mitk::VnlVector>::New(reachedPlannedDifferences));
placementQualityResult->SetProperty(
"USNavigation::MeanPlanningRealityDistance",
mitk::DoubleProperty::New(reachedPlannedDifferencesSum / static_cast<double>(m_NumberOfTargets)));
placementQualityResult->SetProperty("USNavigation::MaximumPlanningRealityDistance",
mitk::DoubleProperty::New(reachedPlannedDifferencesMax));
}
emit SignalIntermediateResult(placementQualityResult);
}
void QmitkUSNavigationStepMarkerIntervention::UpdateSensorsNames()
{
mitk::USCombinedModality::Pointer combinedModality = this->GetCombinedModality(false);
if (combinedModality.IsNull())
{
return;
}
mitk::NavigationDataSource::Pointer navigationDataSource = combinedModality->GetNavigationDataSource();
if (navigationDataSource.IsNull())
{
return;
}
if (!m_NeedleSensorName.empty())
{
try
{
m_NeedleSensorIndex = navigationDataSource->GetOutputIndex(m_NeedleSensorName);
}
catch (const std::exception &e)
{
MITK_WARN("QmitkUSAbstractNavigationStep")
("QmitkUSNavigationStepPlacementPlanning") << "Cannot get index for needle sensor name: " << e.what();
}
}
if (this->GetNavigationStepState() >= QmitkUSAbstractNavigationStep::State_Active)
{
m_NeedleProjectionFilter->SelectInput(m_NeedleSensorIndex);
}
if (!m_ReferenceSensorName.empty())
{
try
{
m_ReferenceSensorIndex = navigationDataSource->GetOutputIndex(m_ReferenceSensorName);
}
catch (const std::exception &e)
{
MITK_WARN("QmitkUSAbstractNavigationStep")
("QmitkUSNavigationStepPlacementPlanning") << "Cannot get index for reference sensor name: " << e.what();
}
}
if (this->GetNavigationStepState() >= QmitkUSAbstractNavigationStep::State_Active)
{
m_NodeDisplacementFilter->SelectInput(m_ReferenceSensorIndex);
}
ui->freezeImageButton->SetCombinedModality(combinedModality, m_ReferenceSensorIndex);
}
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.h b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.h
index 82dba14545..dc94ab612c 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.h
@@ -1,172 +1,167 @@
/*===================================================================
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 QMITKUSNAVIGATIONSTEPMARKERINTERVENTION_H
#define QMITKUSNAVIGATIONSTEPMARKERINTERVENTION_H
#include "QmitkUSAbstractNavigationStep.h"
namespace mitk
{
class DataNode;
class NeedleProjectionFilter;
class NodeDisplacementFilter;
class USNavigationGrabCutSegmentationUpdateFilter;
class USNavigationTargetUpdateFilter;
class USNavigationTargetOcclusionFilter;
class USNavigationTargetIntersectionFilter;
class USPointMarkInteractor;
class LookupTableProperty;
class Surface;
class TextAnnotation2D;
class USTargetPlacementQualityCalculator;
}
namespace Ui
{
class QmitkUSNavigationStepMarkerIntervention;
}
class QmitkZoneProgressBar;
/**
* \brief Navigation step for the actual marker placement.
*/
class QmitkUSNavigationStepMarkerIntervention : public QmitkUSAbstractNavigationStep
{
Q_OBJECT
signals:
void TargetReached(int);
void TargetLeft(int);
protected slots:
void OnTargetReached();
void OnTargetLeft();
void OnBackToLastTargetClicked();
void OnFreeze(bool);
void OnShowPlanningView(bool);
void OnRiskZoneViolated(const mitk::DataNode *, mitk::Point3D);
public:
explicit QmitkUSNavigationStepMarkerIntervention(QWidget *parent = 0);
- QmitkUSNavigationStepMarkerIntervention(mitk::Point3D toolAxis, QWidget *parent = 0);
~QmitkUSNavigationStepMarkerIntervention();
virtual bool OnStartStep();
virtual bool OnStopStep();
virtual bool OnFinishStep();
virtual bool OnActivateStep();
virtual bool OnDeactivateStep();
virtual void OnUpdate();
virtual void OnSettingsChanged(const itk::SmartPointer<mitk::DataNode> settingsNode);
virtual QString GetTitle();
virtual bool GetIsRestartable();
virtual FilterVector GetFilter();
protected:
virtual void OnSetCombinedModality();
void ClearZones();
void UpdateTargetCoordinates(mitk::DataNode *);
void UpdateBodyMarkerStatus(mitk::NavigationData::Pointer bodyMarker);
void GenerateTargetColorLookupTable();
void UpdateTargetColors();
/**
* \brief
*/
void UpdateTargetScore();
/**
* \brief Updates display showing the number of the currently active target.
*/
void UpdateTargetProgressDisplay();
/**
* \brief Updates color and distance of the progress bar for the planned target.
* The intersection between needle path and target surface is calculated and
* the color is got from the intersection point.
*/
void UpdatePlannedTargetProgressDisplay();
/**
* \brief Tests for target violation and updates the display accordingly.
* This method tests if the needle tip is inside the target surface.
*/
void UpdateTargetViolationStatus();
/**
* \brief Calculates and display quality metrics if all three markers are placed.
*/
void CalculateTargetPlacementQuality();
void UpdateSensorsNames();
unsigned int m_NumberOfTargets;
- QVector<itk::SmartPointer<mitk::DataNode>> m_ZoneNodes;
QVector<itk::SmartPointer<mitk::DataNode>> m_PlannedTargetsNodes;
QVector<itk::SmartPointer<mitk::DataNode>> m_ReachedTargetsNodes;
- itk::SmartPointer<mitk::DataNode> m_SegmentationNode;
- itk::SmartPointer<mitk::DataNode> m_ForegroundModelPointsNode;
-
QmitkZoneProgressBar *m_TargetProgressBar;
QmitkZoneProgressBar *m_PlannedTargetProgressBar;
int m_CurrentTargetIndex;
bool m_CurrentTargetReached;
mitk::ScalarType m_ActiveTargetColor[3];
mitk::ScalarType m_InactiveTargetColor[3];
mitk::ScalarType m_ReachedTargetColor[3];
bool m_ShowPlanningColors;
itk::SmartPointer<mitk::USPointMarkInteractor> m_PointMarkInteractor;
itk::SmartPointer<mitk::DataNode> m_TargetNode;
itk::SmartPointer<mitk::LookupTableProperty> m_TargetColorLookupTableProperty;
itk::SmartPointer<mitk::Surface> m_TargetSurface;
itk::SmartPointer<mitk::NeedleProjectionFilter> m_NeedleProjectionFilter;
itk::SmartPointer<mitk::NodeDisplacementFilter> m_NodeDisplacementFilter;
itk::SmartPointer<mitk::USNavigationTargetUpdateFilter> m_TargetUpdateFilter;
itk::SmartPointer<mitk::USNavigationTargetOcclusionFilter> m_TargetOcclusionFilter;
itk::SmartPointer<mitk::USNavigationTargetIntersectionFilter> m_TargetIntersectionFilter;
itk::SmartPointer<mitk::USTargetPlacementQualityCalculator> m_PlacementQualityCalculator;
itk::SmartPointer<mitk::TextAnnotation2D> m_TargetStructureWarnOverlay;
std::string m_ReferenceSensorName;
std::string m_NeedleSensorName;
unsigned int m_ReferenceSensorIndex;
unsigned int m_NeedleSensorIndex;
private:
mitk::MessageDelegate1<QmitkUSNavigationStepMarkerIntervention, mitk::DataNode *> m_ListenerTargetCoordinatesChanged;
Ui::QmitkUSNavigationStepMarkerIntervention *ui;
};
#endif // QMITKUSNAVIGATIONSTEPMARKERINTERVENTION_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.cpp
index eabdb9d147..1e0fcbba77 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.cpp
@@ -1,281 +1,283 @@
/*===================================================================
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 "QmitkUSNavigationStepPunctuationIntervention.h"
#include "ui_QmitkUSNavigationStepPunctuationIntervention.h"
#include "mitkNeedleProjectionFilter.h"
#include "../Widgets/QmitkZoneProgressBar.h"
#include "../USNavigationMarkerPlacement.h"
#include "usModuleRegistry.h"
#include <mitkTrackingTypes.h>
QmitkUSNavigationStepPunctuationIntervention::QmitkUSNavigationStepPunctuationIntervention(QWidget *parent) :
QmitkUSAbstractNavigationStep(parent),
m_Ui(new Ui::QmitkUSNavigationStepPunctuationIntervention),
+ m_ZoneNodes(nullptr),
m_NeedleProjectionFilter(mitk::NeedleProjectionFilter::New()),
+ m_NeedleNavigationTool(mitk::NavigationTool::New()),
+ m_OldColors(),
m_SphereSource(vtkSmartPointer<vtkSphereSource>::New()),
m_OBBTree(vtkSmartPointer<vtkOBBTree>::New()),
- m_IntersectPoints(vtkSmartPointer<vtkPoints>::New()),
- m_NeedleNavigationTool(mitk::NavigationTool::New())
+ m_IntersectPoints(vtkSmartPointer<vtkPoints>::New())
{
m_Ui->setupUi(this);
connect(m_Ui->m_AddNewAblationZone, SIGNAL(clicked()), this, SLOT(OnAddAblationZoneClicked()));
connect(m_Ui->m_ShowToolAxisN, SIGNAL(stateChanged(int)), this, SLOT(OnShowToolAxisEnabled(int)));
connect(m_Ui->m_EnableAblationMarking, SIGNAL(clicked()), this, SLOT(OnEnableAblationZoneMarkingClicked()));
connect(m_Ui->m_AblationZoneSizeSlider, SIGNAL(valueChanged(int)), this, SLOT(OnAblationZoneSizeSliderChanged(int)));
m_Ui->m_AblationZonesBox->setVisible(false);
}
void QmitkUSNavigationStepPunctuationIntervention::SetNeedleMetaData(mitk::NavigationTool::Pointer needleNavigationTool)
{
this->m_NeedleNavigationTool = needleNavigationTool;
}
void QmitkUSNavigationStepPunctuationIntervention::OnEnableAblationZoneMarkingClicked()
{
if(m_Ui->m_EnableAblationMarking->isChecked())
m_Ui->m_AblationZonesBox->setVisible(true);
else
m_Ui->m_AblationZonesBox->setVisible(false);
}
void QmitkUSNavigationStepPunctuationIntervention::OnAblationZoneSizeSliderChanged(int size)
{
int id = m_Ui->m_AblationZonesList->currentRow();
if (id!=-1) {emit AblationZoneChanged(id,size);}
}//
void QmitkUSNavigationStepPunctuationIntervention::OnAddAblationZoneClicked()
{
QListWidgetItem* newItem = new QListWidgetItem("Ablation Zone (initial size: " + QString::number(m_Ui->m_AblationZoneSizeSlider->value()) + " mm)", m_Ui->m_AblationZonesList);
newItem->setSelected(true);
emit AddAblationZoneClicked(m_Ui->m_AblationZoneSizeSlider->value());
}
QmitkUSNavigationStepPunctuationIntervention::~QmitkUSNavigationStepPunctuationIntervention()
{
mitk::DataStorage::Pointer dataStorage = this->GetDataStorage(false);
if ( dataStorage.IsNotNull() )
{
// remove needle path from data storage if it is there
mitk::DataNode::Pointer node = this->GetNamedDerivedNode
("Needle Path", QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
if ( node.IsNotNull() ) { dataStorage->Remove(node); }
}
delete m_Ui;
}
bool QmitkUSNavigationStepPunctuationIntervention::OnStartStep()
{
// create node for Needle Projection
mitk::DataNode::Pointer node = this->GetNamedDerivedNodeAndCreate
("Needle Path", QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
node->SetData(m_NeedleProjectionFilter->GetProjection());
node->SetBoolProperty("show contour", true);
m_NeedleProjectionFilter->SetToolAxisForFilter(m_NeedleNavigationTool->GetToolAxis());
return true;
}
bool QmitkUSNavigationStepPunctuationIntervention::OnRestartStep()
{
return this->OnActivateStep();
}
bool QmitkUSNavigationStepPunctuationIntervention::OnFinishStep()
{
mitk::DataNode::Pointer finishPunctionResult = mitk::DataNode::New();
finishPunctionResult->SetName("PunctionResult");
mitk::Point3D needlePos = m_NeedleProjectionFilter->GetOutput(0)->GetPosition();
mitk::Quaternion needleRot = m_NeedleProjectionFilter->GetOutput(0)->GetOrientation();
finishPunctionResult->SetProperty("USNavigation::TipPositionEnd", mitk::Point3dProperty::New(needlePos));
MITK_INFO("USNavigationLogging") << "Instrument tip at end: " <<needlePos<< " / " << needleRot;
emit SignalIntermediateResult(finishPunctionResult);
return true;
}
bool QmitkUSNavigationStepPunctuationIntervention::OnActivateStep()
{
this->ClearZones();
mitk::DataStorage::Pointer dataStorage = this->GetDataStorage();
// add progress bars for risk zone nodes
m_ZoneNodes = dataStorage->GetDerivations(dataStorage->GetNamedNode(USNavigationMarkerPlacement::DATANAME_ZONES));
// add zones to the widgets for risk structures
for (mitk::DataStorage::SetOfObjects::ConstIterator it = m_ZoneNodes->Begin();
it != m_ZoneNodes->End(); ++it)
{
m_Ui->riskStructuresRangeWidget->AddZone(it->Value());
float rgb[3];
it->Value()->GetColor(rgb);
mitk::Color color;
color.SetRed(rgb[0]);
color.SetGreen(rgb[1]);
color.SetBlue(rgb[2]);
m_OldColors[it->Value()] = color;
}
m_NeedleProjectionFilter->SelectInput(0);
return true;
}
void QmitkUSNavigationStepPunctuationIntervention::OnShowToolAxisEnabled(int enabled)
{
if (enabled == 0) { m_NeedleProjectionFilter->ShowToolAxis(false); }
else { m_NeedleProjectionFilter->ShowToolAxis(true); }
}
void QmitkUSNavigationStepPunctuationIntervention::OnUpdate()
{
// get navigation data source and make sure that it is not null
mitk::NavigationDataSource::Pointer navigationDataSource =
this->GetCombinedModality()->GetNavigationDataSource();
if ( navigationDataSource.IsNull() )
{
MITK_ERROR("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPunctuationIntervention")
<< "Navigation Data Source of Combined Modality must not be null.";
mitkThrow() << "Navigation Data Source of Combined Modality must not be null.";
}
// update body marker
this->UpdateBodyMarkerStatus(navigationDataSource->GetOutput(1));
// update critical structures
this->UpdateCriticalStructures(navigationDataSource->GetOutput(0),m_NeedleProjectionFilter->GetProjection());
//Update Distance to US image
mitk::Point3D point1 = m_NeedleProjectionFilter->GetProjection()->GetPoint(0);
mitk::Point3D point2 = m_NeedleProjectionFilter->GetProjection()->GetPoint(1);
double distance = point1.EuclideanDistanceTo(point2);
m_Ui->m_DistanceToUSPlane->setText(QString::number(distance) + " mm");
}
void QmitkUSNavigationStepPunctuationIntervention::OnSettingsChanged(const itk::SmartPointer<mitk::DataNode> settingsNode)
{
if ( settingsNode.IsNull() ) { return; }
}
QString QmitkUSNavigationStepPunctuationIntervention::GetTitle()
{
return "Computer-assisted Intervention";
}
bool QmitkUSNavigationStepPunctuationIntervention::GetIsRestartable()
{
return false;
}
QmitkUSNavigationStepPunctuationIntervention::FilterVector QmitkUSNavigationStepPunctuationIntervention::GetFilter()
{
return FilterVector(1, m_NeedleProjectionFilter.GetPointer());
}
void QmitkUSNavigationStepPunctuationIntervention::OnSetCombinedModality()
{
mitk::USCombinedModality::Pointer combinedModality = this->GetCombinedModality(false);
if ( combinedModality.IsNotNull() )
{
// set calibration of the combined modality to the needle projection filter
mitk::AffineTransform3D::Pointer calibration = combinedModality->GetCalibration();
if ( calibration.IsNotNull() )
{
m_NeedleProjectionFilter->SetTargetPlane(calibration);
}
}
}
void QmitkUSNavigationStepPunctuationIntervention::ClearZones()
{
m_Ui->riskStructuresRangeWidget->ClearZones();
}
void QmitkUSNavigationStepPunctuationIntervention::UpdateBodyMarkerStatus(mitk::NavigationData::Pointer bodyMarker)
{
if ( bodyMarker.IsNull() )
{
MITK_ERROR("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPunctuationIntervention")
<< "Current Navigation Data for body marker of Combined Modality must not be null.";
mitkThrow() << "Current Navigation Data for body marker of Combined Modality must not be null.";
}
bool valid = bodyMarker->IsDataValid();
// update body marker status label
if (valid)
{
m_Ui->bodyMarkerTrackingStatusLabel->setStyleSheet(
"background-color: #8bff8b; margin-right: 1em; margin-left: 1em; border: 1px solid grey");
m_Ui->bodyMarkerTrackingStatusLabel->setText("Body marker is inside the tracking volume.");
}
else
{
m_Ui->bodyMarkerTrackingStatusLabel->setStyleSheet(
"background-color: #ff7878; margin-right: 1em; margin-left: 1em; border: 1px solid grey");
m_Ui->bodyMarkerTrackingStatusLabel->setText("Body marker is not inside the tracking volume.");
}
m_Ui->riskStructuresRangeGroupBox->setEnabled(valid);
}
void QmitkUSNavigationStepPunctuationIntervention::UpdateCriticalStructures(mitk::NavigationData::Pointer needle, mitk::PointSet::Pointer path)
{
// update the distances for the risk structures widget
m_Ui->riskStructuresRangeWidget->UpdateDistancesToNeedlePosition(needle);
//iterate through all zones
for (mitk::DataStorage::SetOfObjects::ConstIterator it = m_ZoneNodes->Begin();
it != m_ZoneNodes->End(); ++it)
{
mitk::DataNode::Pointer currentNode = it->Value();
//get center point and radius
float radius = -1;
mitk::Point3D center;
currentNode->GetFloatProperty("zone.size", radius);
center = currentNode->GetData()->GetGeometry()->GetIndexToWorldTransform()->GetTranslation();
mitk::Point3D point0 = path->GetPoint(0);
mitk::Point3D point1 = path->GetPoint(1);
if (CheckSphereLineIntersection(center,radius,point0,point1))
{currentNode->SetColor(mitk::IGTColor_WARNING);}
else
{currentNode->SetColor(m_OldColors[currentNode]);}
}
}
bool QmitkUSNavigationStepPunctuationIntervention::CheckSphereLineIntersection(mitk::Point3D& sphereOrigin, float& sphereRadius, mitk::Point3D& lineStart, mitk::Point3D& lineEnd)
{
double center[3] = {sphereOrigin[0],sphereOrigin[1],sphereOrigin[2]};
m_SphereSource->SetCenter(center);
m_SphereSource->SetRadius(sphereRadius);
m_SphereSource->Update();
m_OBBTree->SetDataSet(m_SphereSource->GetOutput());
m_OBBTree->BuildLocator();
double lineP0[3] = {lineStart[0], lineStart[1], lineStart[2]};
double lineP1[3] = {lineEnd[0], lineEnd[1], lineEnd[2]};
m_OBBTree->IntersectWithLine(lineP0, lineP1, m_IntersectPoints, nullptr);
if (m_IntersectPoints->GetNumberOfPoints() > 0) {return true;}
else {return false;}
}
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 80c1c2231a..61500be8af 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,863 +1,875 @@
/*===================================================================
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_Parent(nullptr),
+ m_NavigationSteps(),
m_UpdateTimer(new QTimer(this)),
m_ImageAndNavigationDataLoggingTimer(new QTimer(this)),
m_StdMultiWidget(nullptr),
+ m_CombinedModality(nullptr),
m_ReinitAlreadyDone(false),
m_IsExperimentRunning(false),
+ m_CurrentApplicationName(),
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_ResultsDirectory(),
+ m_ExperimentName(),
+ m_ExperimentResultsSubDirectory(),
+ m_NavigationStepNames(),
+ m_LoggingBackend(),
m_USImageLoggingFilter(mitk::USImageLoggingFilter::New()),
m_NavigationDataRecorder(mitk::NavigationDataRecorder::New()),
- m_SceneNumber(1),
- m_WarnOverlay(mitk::TextAnnotation2D::New()),
+ m_TargetNodeDisplacementFilter(nullptr),
+ m_AblationZonesDisplacementFilter(mitk::NodeDisplacementFilter::New()),
+ m_AblationZonesVector(),
m_NeedleIndex(0),
m_MarkerIndex(1),
+ m_SceneNumber(1),
+ m_WarnOverlay(mitk::TextAnnotation2D::New()),
+ m_NavigationDataSource(nullptr),
+ m_CurrentStorage(nullptr),
m_ListenerDeviceChanged(this, &USNavigationMarkerPlacement::OnCombinedModalityPropertyChanged),
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 ((static_cast<int>(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();
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();
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 (...)
{
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 (std::size_t 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::Save(
m_NavigationDataRecorder->GetNavigationDataSet(),
(QString(m_ExperimentResultsSubDirectory + QDir::separator() + "navigation-data.xml").toStdString().c_str()));
mitk::IOUtil::Save(
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;
+ m_CombinedModality = nullptr;
// 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 (static_cast<int>(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();
if (m_NavigationSteps.at(index)->GetTitle().toStdString() == "Computer-assisted Intervention")
{
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
{
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 c638743171..6dd2b585ea 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,238 +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;
}
namespace mitk
{
class USNavigationStepTimer;
class USNavigationExperimentLogging;
}
namespace Ui
{
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);
/** 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>);
void OnAddAblationZone(int size);
void OnEnableNavigationLayout();
void OnResetStandardLayout();
void OnChangeLayoutClicked();
void OnChangeAblationZone(int id, int newSize);
void OnRenderWindowSelection();
void OnRefreshView();
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;
explicit USNavigationMarkerPlacement();
~USNavigationMarkerPlacement();
virtual void CreateQtPartControl(QWidget *parent);
static const std::string VIEW_ID;
void OnCombinedModalityPropertyChanged(const std::string &, const std::string &);
protected:
/**
* \brief A reinit on the ultrasound image is performed every time the view gets the focus.
*/
virtual void SetFocus();
/**
* \brief Helper function which performs a reinit on the ultrasound image.
*/
void ReinitOnImage();
+
/**
* \brief Sets the multiwidget to two windows, axial on top and 3D render window on the bottom.
*/
virtual void SetTwoWindowView();
/**
* \brief Helper function for being able to serialize the 2d ultrasound image.
*/
void Convert2DImagesTo3D(mitk::DataStorage::SetOfObjects::ConstPointer nodes);
- /**
- * \brief Helper function for being able to serialize the 2d ultrasound image.
- */
- void Convert2DImagesTo3D(mitk::DataStorage::SetOfObjects::ConstPointer nodes);
-
void UpdateToolStorage();
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;
itk::SmartPointer<mitk::USNavigationStepTimer> m_NavigationStepTimer;
itk::SmartPointer<mitk::USNavigationExperimentLogging> m_ExperimentLogging;
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)
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_SceneNumber;
itk::SmartPointer<mitk::TextAnnotation2D> m_WarnOverlay;
//To get tool storage
mitk::NavigationDataSource::Pointer m_NavigationDataSource;
mitk::NavigationToolStorage::Pointer m_CurrentStorage;
- QWidget *m_Parent;
- QTimer *m_UpdateTimer;
- QTimer *m_ImageAndNavigationDataLoggingTimer;
- QmitkStdMultiWidget *m_StdMultiWidget;
- bool m_ReinitAlreadyDone;
- bool m_IsExperimentRunning;
- itk::SmartPointer<mitk::USNavigationStepTimer> m_NavigationStepTimer;
- itk::SmartPointer<mitk::USNavigationExperimentLogging> m_ExperimentLogging;
- mitk::NodeDisplacementFilter::Pointer m_AblationZonesDisplacementFilter;
- QPixmap m_IconRunning;
- QPixmap m_IconNotRunning;
- mitk::USImageLoggingFilter::Pointer m_USImageLoggingFilter;
- mitk::NavigationDataRecorder::Pointer m_NavigationDataRecorder; // records navigation data files
- int m_SceneNumber;
- itk::SmartPointer<mitk::TextAnnotation2D> m_WarnOverlay;
- int m_NeedleIndex;
- int m_MarkerIndex;
-
private:
mitk::MessageDelegate2<USNavigationMarkerPlacement, const std::string &, const std::string &> m_ListenerDeviceChanged;
Ui::USNavigationMarkerPlacement *ui;
};
#endif // USNAVIGATIONMARKERPLACEMENT_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/org_mbi_gui_qt_usnavigation_Activator.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/org_mbi_gui_qt_usnavigation_Activator.cpp
index f8a17098f1..fb1eaf8361 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/org_mbi_gui_qt_usnavigation_Activator.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/org_mbi_gui_qt_usnavigation_Activator.cpp
@@ -1,67 +1,67 @@
/*===================================================================
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 "org_mbi_gui_qt_usnavigation_Activator.h"
#include <usModuleInitialization.h>
#include <QtPlugin>
//#include "USNavigation.h"
#include "UltrasoundCalibration.h"
#include "USNavigationMarkerPlacement.h"
#include "QmitkUSNavigationPerspective.h"
#include "mitkVirtualTrackingDevice.h"
namespace mitk {
ctkPluginContext* org_mbi_gui_qt_usnavigation_Activator::m_Context = 0;
void org_mbi_gui_qt_usnavigation_Activator::start(ctkPluginContext* context)
{
m_Context = context;
//BERRY_REGISTER_EXTENSION_CLASS(USNavigation, context)
BERRY_REGISTER_EXTENSION_CLASS(UltrasoundCalibration, context)
BERRY_REGISTER_EXTENSION_CLASS(USNavigationMarkerPlacement, context)
BERRY_REGISTER_EXTENSION_CLASS(QmitkUSNavigationPerspective, context)
- // create a combined modality persitence object for loading and storing
+ // create a combined modality persistence object for loading and storing
// combined modality objects persistently
m_USCombinedModalityPersistence = mitk::USNavigationCombinedModalityPersistence::New();
}
void org_mbi_gui_qt_usnavigation_Activator::stop(ctkPluginContext* context)
{
m_USCombinedModalityPersistence = 0;
m_Context = 0;
Q_UNUSED(context)
}
ctkPluginContext *org_mbi_gui_qt_usnavigation_Activator::GetContext()
{
return m_Context;
}
}
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
Q_EXPORT_PLUGIN2(org_mitk_gui_qt_igt_app_echotrack, mitk::org_mbi_gui_qt_usnavigation_Activator)
#endif
// necessary for us::GetModuleContext() in USNavigationCombinedModalityPersistence
// (see: https://www.mail-archive.com/mitk-users@lists.sourceforge.net/msg04421.html)
US_INITIALIZE_MODULE
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
index 2e50875e29..ad176e1cf9 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
@@ -1,1349 +1,1349 @@
/*===================================================================
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.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkMITKIGTTrackingToolboxView.h"
// Qt
#include <QMessageBox>
#include <QSettings>
#include <qfiledialog.h>
// MITK
#include <mitkNavigationToolStorageDeserializer.h>
#include <mitkTrackingVolumeGenerator.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
#include <mitkNavigationToolStorageSerializer.h>
#include <mitkIOUtil.h>
#include <mitkLog.h>
#include <mitkTrackingDeviceTypeCollection.h>
#include <mitkUnspecifiedTrackingTypeInformation.h>
#include <mitkNeedleProjectionFilter.h>
//for exceptions
#include <mitkIGTException.h>
#include <mitkIGTIOException.h>
#include "mitkPluginActivator.h"
const std::string QmitkMITKIGTTrackingToolboxView::VIEW_ID = "org.mitk.views.mitkigttrackingtoolbox";
QmitkMITKIGTTrackingToolboxView::QmitkMITKIGTTrackingToolboxView()
: QmitkAbstractView()
, m_Controls(nullptr)
, m_DeviceTypeCollection(nullptr)
{
m_TrackingLoggingTimer = new QTimer(this);
m_TrackingRenderTimer = new QTimer(this);
m_TimeoutTimer = new QTimer(this);
m_tracking = false;
m_connected = false;
m_logging = false;
m_ShowHideToolProjection = false;
m_ShowHideToolAxis = false;
m_loggedFrames = 0;
m_SimpleModeEnabled = false;
m_NeedleProjectionFilter = mitk::NeedleProjectionFilter::New();
//create filename for autosaving of tool storage
QString loggingPathWithoutFilename = QString(mitk::LoggingBackend::GetLogFile().c_str());
if (!loggingPathWithoutFilename.isEmpty()) //if there already is a path for the MITK logging file use this one
{
//extract path from path+filename (if someone knows a better way to do this feel free to change it)
int lengthOfFilename = QFileInfo(QString::fromStdString(mitk::LoggingBackend::GetLogFile())).fileName().size();
loggingPathWithoutFilename.resize(loggingPathWithoutFilename.size() - lengthOfFilename);
m_AutoSaveFilename = loggingPathWithoutFilename + "TrackingToolboxAutoSave.IGTToolStorage";
}
else //if not: use a temporary path from IOUtil
{
m_AutoSaveFilename = QString(mitk::IOUtil::GetTempPath().c_str()) + "TrackingToolboxAutoSave.IGTToolStorage";
}
MITK_INFO("IGT Tracking Toolbox") << "Filename for auto saving of IGT ToolStorages: " << m_AutoSaveFilename.toStdString();
//! [Thread 1]
//initialize worker thread
m_WorkerThread = new QThread();
m_Worker = new QmitkMITKIGTTrackingToolboxViewWorker();
//! [Thread 1]
ctkPluginContext* pluginContext = mitk::PluginActivator::GetContext();
if (pluginContext)
{
QString interfaceName = QString::fromStdString(us_service_interface_iid<mitk::TrackingDeviceTypeCollection>());
QList<ctkServiceReference> serviceReference = pluginContext->getServiceReferences(interfaceName);
if (serviceReference.size() > 0)
{
m_DeviceTypeServiceReference = serviceReference.at(0);
const ctkServiceReference& r = serviceReference.at(0);
m_DeviceTypeCollection = pluginContext->getService<mitk::TrackingDeviceTypeCollection>(r);
}
else
{
MITK_INFO << "No Tracking Device Collection!";
}
}
}
QmitkMITKIGTTrackingToolboxView::~QmitkMITKIGTTrackingToolboxView()
{
this->StoreUISettings();
m_TrackingLoggingTimer->stop();
m_TrackingRenderTimer->stop();
m_TimeoutTimer->stop();
delete m_TrackingLoggingTimer;
delete m_TrackingRenderTimer;
delete m_TimeoutTimer;
try
{
//! [Thread 2]
// wait for thread to finish
m_WorkerThread->terminate();
m_WorkerThread->wait();
//clean up worker thread
if (m_WorkerThread) { delete m_WorkerThread; }
if (m_Worker) { delete m_Worker; }
//! [Thread 2]
//remove the tracking volume
this->GetDataStorage()->Remove(m_TrackingVolumeNode);
//unregister microservices
if (m_toolStorage) { m_toolStorage->UnRegisterMicroservice(); }
if (m_IGTLMessageProvider.IsNotNull()){ m_IGTLMessageProvider->UnRegisterMicroservice(); }
}
catch (std::exception& e) { MITK_WARN << "Unexpected exception during clean up of tracking toolbox view: " << e.what(); }
catch (...) { MITK_WARN << "Unexpected unknown error during clean up of tracking toolbox view!"; }
//store tool storage and UI settings for persistence
this->AutoSaveToolStorage();
this->StoreUISettings();
m_DeviceTypeCollection = nullptr;
mitk::PluginActivator::GetContext()->ungetService(m_DeviceTypeServiceReference);
}
void QmitkMITKIGTTrackingToolboxView::CreateQtPartControl(QWidget *parent)
{
// build up qt view, unless already done
if (!m_Controls)
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkMITKIGTTrackingToolboxViewControls;
m_Controls->setupUi(parent);
//create connections
connect(m_Controls->m_LoadTools, SIGNAL(clicked()), this, SLOT(OnLoadTools()));
connect(m_Controls->m_ConnectDisconnectButton, SIGNAL(clicked()), this, SLOT(OnConnectDisconnect()));
connect(m_Controls->m_StartStopTrackingButton, SIGNAL(clicked()), this, SLOT(OnStartStopTracking()));
connect(m_Controls->m_ConnectSimpleMode, SIGNAL(clicked()), this, SLOT(OnConnectDisconnect()));
connect(m_Controls->m_StartTrackingSimpleMode, SIGNAL(clicked()), this, SLOT(OnStartStopTracking()));
connect(m_Controls->m_FreezeUnfreezeTrackingButton, SIGNAL(clicked()), this, SLOT(OnFreezeUnfreezeTracking()));
connect(m_TrackingLoggingTimer, SIGNAL(timeout()), this, SLOT(UpdateLoggingTrackingTimer()));
connect(m_TrackingRenderTimer, SIGNAL(timeout()), this, SLOT(UpdateRenderTrackingTimer()));
connect(m_TimeoutTimer, SIGNAL(timeout()), this, SLOT(OnTimeOut()));
connect(m_Controls->m_ChooseFile, SIGNAL(clicked()), this, SLOT(OnChooseFileClicked()));
connect(m_Controls->m_StartLogging, SIGNAL(clicked()), this, SLOT(StartLogging()));
connect(m_Controls->m_StopLogging, SIGNAL(clicked()), this, SLOT(StopLogging()));
connect(m_Controls->m_VolumeSelectionBox, SIGNAL(currentIndexChanged(QString)), this, SLOT(OnTrackingVolumeChanged(QString)));
connect(m_Controls->m_ShowTrackingVolume, SIGNAL(clicked()), this, SLOT(OnShowTrackingVolumeChanged()));
connect(m_Controls->m_AutoDetectTools, SIGNAL(clicked()), this, SLOT(OnAutoDetectTools()));
connect(m_Controls->m_ResetTools, SIGNAL(clicked()), this, SLOT(OnResetTools()));
connect(m_Controls->m_AddSingleTool, SIGNAL(clicked()), this, SLOT(OnAddSingleTool()));
connect(m_Controls->m_NavigationToolCreationWidget, SIGNAL(NavigationToolFinished()), this, SLOT(OnAddSingleToolFinished()));
connect(m_Controls->m_NavigationToolCreationWidget, SIGNAL(Canceled()), this, SLOT(OnAddSingleToolCanceled()));
connect(m_Controls->m_CsvFormat, SIGNAL(clicked()), this, SLOT(OnToggleFileExtension()));
connect(m_Controls->m_XmlFormat, SIGNAL(clicked()), this, SLOT(OnToggleFileExtension()));
connect(m_Controls->m_UseDifferentUpdateRates, SIGNAL(clicked()), this, SLOT(OnToggleDifferentUpdateRates()));
connect(m_Controls->m_RenderUpdateRate, SIGNAL(valueChanged(int)), this, SLOT(OnChangeRenderUpdateRate()));
connect(m_Controls->m_DisableAllTimers, SIGNAL(stateChanged(int)), this, SLOT(EnableDisableTimerButtons(int)));
connect(m_Controls->m_advancedUI, SIGNAL(clicked()), this, SLOT(OnToggleAdvancedSimpleMode()));
connect(m_Controls->m_SimpleUI, SIGNAL(clicked()), this, SLOT(OnToggleAdvancedSimpleMode()));
connect(m_Controls->showHideToolProjectionCheckBox, SIGNAL(clicked()), this, SLOT(OnShowHideToolProjectionClicked()));
connect(m_Controls->showHideToolAxisCheckBox, SIGNAL(clicked()), this, SLOT(OnShowHideToolAxisClicked()));
//connections for the tracking device configuration widget
connect(m_Controls->m_ConfigurationWidget, SIGNAL(TrackingDeviceSelectionChanged()), this, SLOT(OnTrackingDeviceChanged()));
//! [Thread 3]
//connect worker thread
connect(m_Worker, SIGNAL(AutoDetectToolsFinished(bool, QString)), this, SLOT(OnAutoDetectToolsFinished(bool, QString)));
connect(m_Worker, SIGNAL(ConnectDeviceFinished(bool, QString)), this, SLOT(OnConnectFinished(bool, QString)));
connect(m_Worker, SIGNAL(StartTrackingFinished(bool, QString)), this, SLOT(OnStartTrackingFinished(bool, QString)));
connect(m_Worker, SIGNAL(StopTrackingFinished(bool, QString)), this, SLOT(OnStopTrackingFinished(bool, QString)));
connect(m_Worker, SIGNAL(DisconnectDeviceFinished(bool, QString)), this, SLOT(OnDisconnectFinished(bool, QString)));
connect(m_WorkerThread, SIGNAL(started()), m_Worker, SLOT(ThreadFunc()));
connect(m_Worker, SIGNAL(ConnectDeviceFinished(bool, QString)), m_Controls->m_ConfigurationWidget, SLOT(OnConnected(bool)));
connect(m_Worker, SIGNAL(DisconnectDeviceFinished(bool, QString)), m_Controls->m_ConfigurationWidget, SLOT(OnDisconnected(bool)));
connect(m_Worker, SIGNAL(StartTrackingFinished(bool, QString)), m_Controls->m_ConfigurationWidget, SLOT(OnStartTracking(bool)));
connect(m_Worker, SIGNAL(StopTrackingFinished(bool, QString)), m_Controls->m_ConfigurationWidget, SLOT(OnStopTracking(bool)));
//Add Listener, so that we know when the toolStorage changed.
std::string m_Filter = "(" + us::ServiceConstants::OBJECTCLASS() + "=" + "org.mitk.services.NavigationToolStorage" + ")";
mitk::PluginActivator::GetContext()->connectServiceListener(this, "OnToolStorageChanged", QString(m_Filter.c_str()));
//move the worker to the thread
m_Worker->moveToThread(m_WorkerThread);
//! [Thread 3]
//initialize widgets
m_Controls->m_TrackingToolsStatusWidget->SetShowPositions(true);
m_Controls->m_TrackingToolsStatusWidget->SetTextAlignment(Qt::AlignLeft);
m_Controls->m_simpleWidget->setVisible(false);
//initialize tracking volume node
m_TrackingVolumeNode = mitk::DataNode::New();
m_TrackingVolumeNode->SetName("TrackingVolume");
m_TrackingVolumeNode->SetBoolProperty("Backface Culling", true);
mitk::Color red;
red.SetRed(1);
m_TrackingVolumeNode->SetColor(red);
//initialize buttons
m_Controls->m_AutoDetectTools->setVisible(false); //only visible if supported by tracking device
m_Controls->m_StartStopTrackingButton->setEnabled(false);
m_Controls->m_StartTrackingSimpleMode->setEnabled(false);
m_Controls->m_FreezeUnfreezeTrackingButton->setEnabled(false);
//initialize warning labels
m_Controls->m_RenderWarningLabel->setVisible(false);
m_Controls->m_TrackingFrozenLabel->setVisible(false);
//Update List of available models for selected tool.
std::vector<mitk::TrackingDeviceData> Compatibles;
if ((m_Controls == nullptr) || //check all these stuff for NULL, latterly this causes crashes from time to time
(m_Controls->m_ConfigurationWidget == nullptr) ||
(m_Controls->m_ConfigurationWidget->GetTrackingDevice().IsNull()))
{
MITK_ERROR << "Couldn't get current tracking device or an object is nullptr, something went wrong!";
return;
}
else
{
Compatibles = m_DeviceTypeCollection->GetDeviceDataForLine(m_Controls->m_ConfigurationWidget->GetTrackingDevice()->GetType());
}
m_Controls->m_VolumeSelectionBox->clear();
for (std::size_t i = 0; i < Compatibles.size(); i++)
{
m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
}
//initialize tool storage
m_toolStorage = mitk::NavigationToolStorage::New(GetDataStorage());
m_toolStorage->SetName("TrackingToolbox Default Storage");
m_toolStorage->RegisterAsMicroservice();
//set home directory as default path for logfile
m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(QDir::homePath()) + QDir::separator() + "logfile.csv");
//tracking device may be changed already by the persistence of the
//QmitkTrackingDeciveConfigurationWidget
this->OnTrackingDeviceChanged();
this->LoadUISettings();
//add tracking volume node only to data storage
this->GetDataStorage()->Add(m_TrackingVolumeNode);
if (!m_Controls->m_ShowTrackingVolume->isChecked()) m_TrackingVolumeNode->SetOpacity(0.0);
else m_TrackingVolumeNode->SetOpacity(0.25);
//Update List of available models for selected tool.
m_Controls->m_VolumeSelectionBox->clear();
for (std::size_t i = 0; i < Compatibles.size(); i++)
{
m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
}
}
}
void QmitkMITKIGTTrackingToolboxView::OnLoadTools()
{
//read in filename
QString filename = QFileDialog::getOpenFileName(nullptr, tr("Open Tool Storage"), "/", tr("Tool Storage Files (*.IGTToolStorage)"));
if (filename.isNull()) return;
//read tool storage from disk
std::string errorMessage = "";
mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(GetDataStorage());
// try-catch block for exceptions
try
{
this->ReplaceCurrentToolStorage(myDeserializer->Deserialize(filename.toStdString()), filename.toStdString());
}
catch (mitk::IGTException)
{
std::string errormessage = "Error during loading the tool storage file. Please only load tool storage files created with the NavigationToolManager view.";
QMessageBox::warning(nullptr, "Tool Storage Loading Error", errormessage.c_str());
return;
}
if (m_toolStorage->isEmpty())
{
errorMessage = myDeserializer->GetErrorMessage();
MessageBox(errorMessage);
return;
}
//update label
UpdateToolStorageLabel(filename);
//update tool preview
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
//save filename for persistent storage
m_ToolStorageFilename = filename;
}
void QmitkMITKIGTTrackingToolboxView::OnResetTools()
{
//remove data nodes of surfaces from data storage to clean up
- for (int i = 0; i < m_toolStorage->GetToolCount(); i++)
+ for (unsigned int i = 0; i < m_toolStorage->GetToolCount(); i++)
{
this->GetDataStorage()->Remove(m_toolStorage->GetTool(i)->GetDataNode());
}
this->ReplaceCurrentToolStorage(mitk::NavigationToolStorage::New(GetDataStorage()), "TrackingToolbox Default Storage");
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
QString toolLabel = QString("<none>");
m_Controls->m_ToolLabel->setText(toolLabel);
m_ToolStorageFilename = "";
}
void QmitkMITKIGTTrackingToolboxView::OnStartStopTracking()
{
if (!m_connected)
{
MITK_WARN << "Can't start tracking if no device is connected. Aborting";
return;
}
if (m_tracking) { OnStopTracking(); }
else { OnStartTracking(); }
}
void QmitkMITKIGTTrackingToolboxView::OnFreezeUnfreezeTracking()
{
if (m_Controls->m_FreezeUnfreezeTrackingButton->text() == "Freeze Tracking")
{
m_Worker->GetTrackingDeviceSource()->Freeze();
m_Controls->m_FreezeUnfreezeTrackingButton->setText("Unfreeze Tracking");
m_Controls->m_TrackingFrozenLabel->setVisible(true);
}
else if (m_Controls->m_FreezeUnfreezeTrackingButton->text() == "Unfreeze Tracking")
{
m_Worker->GetTrackingDeviceSource()->UnFreeze();
m_Controls->m_FreezeUnfreezeTrackingButton->setText("Freeze Tracking");
m_Controls->m_TrackingFrozenLabel->setVisible(false);
}
}
void QmitkMITKIGTTrackingToolboxView::OnShowHideToolProjectionClicked()
{
if( !m_ShowHideToolProjection )
{
//Activate and show the tool projection
mitk::DataNode::Pointer node = this->GetDataStorage()->GetNamedNode("Tool Projection");
//If node does not exist, create the node for the Pointset
if( node.IsNull() )
{
node = mitk::DataNode::New();
node->SetName("Tool Projection");
node->SetData(m_NeedleProjectionFilter->GetProjection());
node->SetBoolProperty("show contour", true);
this->GetDataStorage()->Add(node);
}
else
{
node->SetBoolProperty("show contour", true);
}
//Enable the checkbox for displaying the (standard) tool axis
m_Controls->showHideToolAxisCheckBox->setEnabled(true);
m_ShowHideToolProjection = true;
}
else
{
//Deactivate and hide the tool projection
mitk::DataNode::Pointer node = this->GetDataStorage()->GetNamedNode("Tool Projection");
if( !node.IsNull() )
{
this->GetDataStorage()->Remove(node);
}
m_Controls->showHideToolAxisCheckBox->setEnabled(false);
m_ShowHideToolProjection = false;
}
if( m_NeedleProjectionFilter.IsNotNull() )
{
m_NeedleProjectionFilter->Update();
}
//Refresh the view and the status widget
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
m_Controls->m_TrackingToolsStatusWidget->Refresh();
}
void QmitkMITKIGTTrackingToolboxView::OnShowHideToolAxisClicked()
{
if( !m_ShowHideToolAxis )
{
//Activate and show the tool axis
m_NeedleProjectionFilter->ShowToolAxis(true);
m_ShowHideToolAxis = true;
}
else
{
//Deactivate and hide the tool axis
m_NeedleProjectionFilter->ShowToolAxis(false);
m_NeedleProjectionFilter->GetProjection()->RemovePointIfExists(2);
m_ShowHideToolAxis = false;
}
//Update the filter
if( m_NeedleProjectionFilter.IsNotNull() )
{
m_NeedleProjectionFilter->Update();
}
//Refresh the view and the status widget
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
m_Controls->m_TrackingToolsStatusWidget->Refresh();
}
void QmitkMITKIGTTrackingToolboxView::OnConnectDisconnect()
{
if (m_connected) { OnDisconnect(); }
else { OnConnect(); }
}
void QmitkMITKIGTTrackingToolboxView::OnConnect()
{
MITK_DEBUG << "Connect Clicked";
//check if everything is ready to start tracking
if (this->m_toolStorage.IsNull())
{
MessageBox("Error: No Tools Loaded Yet!");
return;
}
else if (this->m_toolStorage->GetToolCount() == 0)
{
MessageBox("Error: No Way To Track Without Tools!");
return;
}
//parse tracking device data
mitk::TrackingDeviceData data = mitk::UnspecifiedTrackingTypeInformation::GetDeviceDataUnspecified();
QString qstr = m_Controls->m_VolumeSelectionBox->currentText();
if ((!qstr.isNull()) || (!qstr.isEmpty())) {
std::string str = qstr.toStdString();
data = m_DeviceTypeCollection->GetDeviceDataByName(str); //Data will be set later, after device generation
}
//! [Thread 4]
//initialize worker thread
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eConnectDevice);
m_Worker->SetTrackingDevice(this->m_Controls->m_ConfigurationWidget->GetTrackingDevice());
m_Worker->SetInverseMode(m_Controls->m_InverseMode->isChecked());
m_Worker->SetNavigationToolStorage(this->m_toolStorage);
m_Worker->SetTrackingDeviceData(data);
//start worker thread
m_WorkerThread->start();
//! [Thread 4]
//disable buttons
this->m_Controls->m_MainWidget->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::EnableDisableTimerButtons(int enable)
{
bool enableBool = enable;
m_Controls->m_UpdateRateOptionsGroupBox->setEnabled(!enableBool);
m_Controls->m_RenderWarningLabel->setVisible(enableBool);
}
void QmitkMITKIGTTrackingToolboxView::OnConnectFinished(bool success, QString errorMessage)
{
m_WorkerThread->quit();
m_WorkerThread->wait();
//enable buttons
this->m_Controls->m_MainWidget->setEnabled(true);
if (!success)
{
MITK_WARN << errorMessage.toStdString();
MessageBox(errorMessage.toStdString());
return;
}
//! [Thread 6]
//get data from worker thread
m_TrackingDeviceData = m_Worker->GetTrackingDeviceData();
m_ToolVisualizationFilter = m_Worker->GetToolVisualizationFilter();
if( m_ToolVisualizationFilter.IsNotNull() )
{
//Connect the NeedleProjectionFilter to the ToolVisualizationFilter as third filter of the IGT pipeline
m_NeedleProjectionFilter->ConnectTo(m_ToolVisualizationFilter);
m_NeedleProjectionFilter->SelectInput(0);
}
//! [Thread 6]
//enable/disable Buttons
DisableOptionsButtons();
DisableTrackingConfigurationButtons();
m_Controls->m_TrackingControlLabel->setText("Status: connected");
m_Controls->m_ConnectDisconnectButton->setText("Disconnect");
m_Controls->m_ConnectSimpleMode->setText("Disconnect");
m_Controls->m_StartStopTrackingButton->setEnabled(true);
m_Controls->m_StartTrackingSimpleMode->setEnabled(true);
m_connected = true;
//During connection, thi sourceID of the tool storage changed. However, Microservice can't be updated on a different thread.
//UpdateMicroservice is necessary to use filter to get the right storage belonging to a source.
//Don't do it before m_connected is true, as we don't want to call content of OnToolStorageChanged.
m_toolStorage->UpdateMicroservice();
}
void QmitkMITKIGTTrackingToolboxView::OnDisconnect()
{
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eDisconnectDevice);
m_WorkerThread->start();
m_Controls->m_MainWidget->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::OnDisconnectFinished(bool success, QString errorMessage)
{
m_WorkerThread->quit();
m_WorkerThread->wait();
m_Controls->m_MainWidget->setEnabled(true);
if (!success)
{
MITK_WARN << errorMessage.toStdString();
MessageBox(errorMessage.toStdString());
return;
}
//enable/disable Buttons
m_Controls->m_StartStopTrackingButton->setEnabled(false);
m_Controls->m_StartTrackingSimpleMode->setEnabled(false);
EnableOptionsButtons();
EnableTrackingConfigurationButtons();
m_Controls->m_TrackingControlLabel->setText("Status: disconnected");
m_Controls->m_ConnectDisconnectButton->setText("Connect");
m_Controls->m_ConnectSimpleMode->setText("Connect");
m_Controls->m_FreezeUnfreezeTrackingButton->setText("Freeze Tracking");
m_Controls->m_TrackingFrozenLabel->setVisible(false);
m_connected = false;
}
void QmitkMITKIGTTrackingToolboxView::OnStartTracking()
{
//show tracking volume
this->OnTrackingVolumeChanged(m_Controls->m_VolumeSelectionBox->currentText());
//Reset the view to a defined start. Do it here and not in OnStartTrackingFinished, to give other tracking devices the chance to reset the view to a different direction.
this->GlobalReinit();
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eStartTracking);
m_WorkerThread->start();
this->m_Controls->m_MainWidget->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::OnStartTrackingFinished(bool success, QString errorMessage)
{
//! [Thread 5]
m_WorkerThread->quit();
m_WorkerThread->wait();
//! [Thread 5]
this->m_Controls->m_MainWidget->setEnabled(true);
if (!success)
{
MessageBox(errorMessage.toStdString());
MITK_WARN << errorMessage.toStdString();
return;
}
if (!(m_Controls->m_DisableAllTimers->isChecked()))
{
if (m_Controls->m_UseDifferentUpdateRates->isChecked())
{
if (m_Controls->m_RenderUpdateRate->value() != 0)
m_TrackingRenderTimer->start(1000 / (m_Controls->m_RenderUpdateRate->value()));
m_TrackingLoggingTimer->start(1000 / (m_Controls->m_LogUpdateRate->value()));
}
else
{
m_TrackingRenderTimer->start(1000 / (m_Controls->m_UpdateRate->value()));
m_TrackingLoggingTimer->start(1000 / (m_Controls->m_UpdateRate->value()));
}
}
m_Controls->m_TrackingControlLabel->setText("Status: tracking");
//connect the tool visualization widget
for (std::size_t i = 0; i < m_Worker->GetTrackingDeviceSource()->GetNumberOfOutputs(); i++)
{
m_Controls->m_TrackingToolsStatusWidget->AddNavigationData(m_Worker->GetTrackingDeviceSource()->GetOutput(i));
}
m_Controls->m_TrackingToolsStatusWidget->ShowStatusLabels();
if (m_Controls->m_ShowToolQuaternions->isChecked()) { m_Controls->m_TrackingToolsStatusWidget->SetShowQuaternions(true); }
else { m_Controls->m_TrackingToolsStatusWidget->SetShowQuaternions(false); }
//if activated enable open IGT link microservice
if (m_Controls->m_EnableOpenIGTLinkMicroService->isChecked())
{
//create convertion filter
m_IGTLConversionFilter = mitk::NavigationDataToIGTLMessageFilter::New();
m_IGTLConversionFilter->SetName("IGT Tracking Toolbox");
QString dataModeSelection = this->m_Controls->m_OpenIGTLinkDataFormat->currentText();
if (dataModeSelection == "TDATA")
{
m_IGTLConversionFilter->SetOperationMode(mitk::NavigationDataToIGTLMessageFilter::ModeSendTDataMsg);
}
else if (dataModeSelection == "TRANSFORM")
{
m_IGTLConversionFilter->SetOperationMode(mitk::NavigationDataToIGTLMessageFilter::ModeSendTransMsg);
}
else if (dataModeSelection == "QTDATA")
{
m_IGTLConversionFilter->SetOperationMode(mitk::NavigationDataToIGTLMessageFilter::ModeSendQTDataMsg);
}
else if (dataModeSelection == "POSITION")
{
m_IGTLConversionFilter->SetOperationMode(mitk::NavigationDataToIGTLMessageFilter::ModeSendQTransMsg);
}
m_IGTLConversionFilter->ConnectTo(m_ToolVisualizationFilter);
m_IGTLConversionFilter->RegisterAsMicroservice();
//create server and message provider
m_IGTLServer = mitk::IGTLServer::New(false);
m_IGTLServer->SetName("Tracking Toolbox IGTL Server");
m_IGTLMessageProvider = mitk::IGTLMessageProvider::New();
m_IGTLMessageProvider->SetIGTLDevice(m_IGTLServer);
m_IGTLMessageProvider->RegisterAsMicroservice();
}
m_tracking = true;
m_Controls->m_ConnectDisconnectButton->setEnabled(false);
m_Controls->m_StartStopTrackingButton->setText("Stop Tracking");
m_Controls->m_StartTrackingSimpleMode->setText("Stop\nTracking");
m_Controls->m_FreezeUnfreezeTrackingButton->setEnabled(true);
}
void QmitkMITKIGTTrackingToolboxView::OnStopTracking()
{
if (!m_tracking) return;
m_TrackingRenderTimer->stop();
m_TrackingLoggingTimer->stop();
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eStopTracking);
m_WorkerThread->start();
m_Controls->m_MainWidget->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::OnStopTrackingFinished(bool success, QString errorMessage)
{
m_WorkerThread->quit();
m_WorkerThread->wait();
m_Controls->m_MainWidget->setEnabled(true);
if (!success)
{
MessageBox(errorMessage.toStdString());
MITK_WARN << errorMessage.toStdString();
return;
}
m_Controls->m_TrackingControlLabel->setText("Status: connected");
if (m_logging) StopLogging();
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
m_tracking = false;
m_Controls->m_StartStopTrackingButton->setText("Start Tracking");
m_Controls->m_StartTrackingSimpleMode->setText("Start\nTracking");
m_Controls->m_ConnectDisconnectButton->setEnabled(true);
m_Controls->m_FreezeUnfreezeTrackingButton->setEnabled(false);
//unregister open IGT link micro service
if (m_Controls->m_EnableOpenIGTLinkMicroService->isChecked())
{
m_IGTLConversionFilter->UnRegisterMicroservice();
m_IGTLMessageProvider->UnRegisterMicroservice();
}
}
void QmitkMITKIGTTrackingToolboxView::OnTrackingDeviceChanged()
{
mitk::TrackingDeviceType Type;
if (m_Controls->m_ConfigurationWidget->GetTrackingDevice().IsNotNull())
{
Type = m_Controls->m_ConfigurationWidget->GetTrackingDevice()->GetType();
//enable controls because device is valid
m_Controls->m_TrackingToolsGoupBox->setEnabled(true);
m_Controls->m_TrackingControlsGroupBox->setEnabled(true);
}
else
{
Type = mitk::UnspecifiedTrackingTypeInformation::GetTrackingDeviceName();
MessageBox("Error: This tracking device is not included in this project. Please make sure that the device is installed and activated in your MITK build.");
m_Controls->m_TrackingToolsGoupBox->setEnabled(false);
m_Controls->m_TrackingControlsGroupBox->setEnabled(false);
return;
}
// Code to enable/disable device specific buttons
if (m_Controls->m_ConfigurationWidget->GetTrackingDevice()->AutoDetectToolsAvailable())
{
m_Controls->m_AutoDetectTools->setVisible(true);
}
else
{
m_Controls->m_AutoDetectTools->setVisible(false);
}
m_Controls->m_AddSingleTool->setEnabled(this->m_Controls->m_ConfigurationWidget->GetTrackingDevice()->AddSingleToolIsAvailable());
// Code to select appropriate tracking volume for current type
std::vector<mitk::TrackingDeviceData> Compatibles = m_DeviceTypeCollection->GetDeviceDataForLine(Type);
m_Controls->m_VolumeSelectionBox->clear();
for (std::size_t i = 0; i < Compatibles.size(); i++)
{
m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
}
}
void QmitkMITKIGTTrackingToolboxView::OnTrackingVolumeChanged(QString qstr)
{
if (qstr.isNull()) return;
if (qstr.isEmpty()) return;
mitk::TrackingVolumeGenerator::Pointer volumeGenerator = mitk::TrackingVolumeGenerator::New();
std::string str = qstr.toStdString();
mitk::TrackingDeviceData data = m_DeviceTypeCollection->GetDeviceDataByName(str);
m_TrackingDeviceData = data;
volumeGenerator->SetTrackingDeviceData(data);
volumeGenerator->Update();
mitk::Surface::Pointer volumeSurface = volumeGenerator->GetOutput();
m_TrackingVolumeNode->SetData(volumeSurface);
if (!m_Controls->m_ShowTrackingVolume->isChecked()) m_TrackingVolumeNode->SetOpacity(0.0);
else m_TrackingVolumeNode->SetOpacity(0.25);
GlobalReinit();
}
void QmitkMITKIGTTrackingToolboxView::OnShowTrackingVolumeChanged()
{
if (m_Controls->m_ShowTrackingVolume->isChecked())
{
OnTrackingVolumeChanged(m_Controls->m_VolumeSelectionBox->currentText());
m_TrackingVolumeNode->SetOpacity(0.25);
}
else
{
m_TrackingVolumeNode->SetOpacity(0.0);
}
}
void QmitkMITKIGTTrackingToolboxView::OnAutoDetectTools()
{
if (m_Controls->m_ConfigurationWidget->GetTrackingDevice()->AutoDetectToolsAvailable())
{
DisableTrackingConfigurationButtons();
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eAutoDetectTools);
m_Worker->SetTrackingDevice(m_Controls->m_ConfigurationWidget->GetTrackingDevice().GetPointer());
m_Worker->SetDataStorage(this->GetDataStorage());
m_WorkerThread->start();
m_TimeoutTimer->start(7000);
//disable controls until worker thread is finished
this->m_Controls->m_MainWidget->setEnabled(false);
}
}
void QmitkMITKIGTTrackingToolboxView::OnAutoDetectToolsFinished(bool success, QString errorMessage)
{
//Check, if the thread is running. There might have been a timeOut inbetween and this causes crashes...
if (m_WorkerThread->isRunning())
{
m_TimeoutTimer->stop();
m_WorkerThread->quit();
m_WorkerThread->wait();
}
//enable controls again
this->m_Controls->m_MainWidget->setEnabled(true);
EnableTrackingConfigurationButtons();
if (!success)
{
MITK_WARN << errorMessage.toStdString();
MessageBox(errorMessage.toStdString());
EnableTrackingConfigurationButtons();
return;
}
mitk::NavigationToolStorage::Pointer autoDetectedStorage = m_Worker->GetNavigationToolStorage();
//save detected tools
std::string _autoDetectText;
_autoDetectText = "Autodetected ";
_autoDetectText.append(this->m_TrackingDeviceData.Line); //This is the device name as string of the current TrackingDevice.
_autoDetectText.append(" Storage");
this->ReplaceCurrentToolStorage(autoDetectedStorage, _autoDetectText);
//auto save the new storage to hard disc (for persistence)
AutoSaveToolStorage();
//update label
QString toolLabel = QString("Loaded Tools: ") + QString::number(m_toolStorage->GetToolCount()) + " Tools (Auto Detected)";
m_Controls->m_ToolLabel->setText(toolLabel);
//update tool preview
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
EnableTrackingConfigurationButtons();
//print a logging message about the detected tools
switch (m_toolStorage->GetToolCount())
{
case 0:
MITK_INFO("IGT Tracking Toolbox") << "Found no tools. Empty ToolStorage was autosaved to " << m_ToolStorageFilename.toStdString();
break;
case 1:
MITK_INFO("IGT Tracking Toolbox") << "Found one tool. ToolStorage was autosaved to " << m_ToolStorageFilename.toStdString();
break;
default:
MITK_INFO("IGT Tracking Toolbox") << "Found " << m_toolStorage->GetToolCount() << " tools. ToolStorage was autosaved to " << m_ToolStorageFilename.toStdString();
}
}
void QmitkMITKIGTTrackingToolboxView::MessageBox(std::string s)
{
QMessageBox msgBox;
msgBox.setText(s.c_str());
msgBox.exec();
}
void QmitkMITKIGTTrackingToolboxView::UpdateRenderTrackingTimer()
{
//update filter
m_ToolVisualizationFilter->Update();
MITK_DEBUG << "Number of outputs ToolVisualizationFilter: " << m_ToolVisualizationFilter->GetNumberOfIndexedOutputs();
MITK_DEBUG << "Number of inputs ToolVisualizationFilter: " << m_ToolVisualizationFilter->GetNumberOfIndexedInputs();
//update tool colors to show tool status
for (unsigned int i = 0; i < m_ToolVisualizationFilter->GetNumberOfIndexedOutputs(); i++)
{
mitk::NavigationData::Pointer currentTool = m_ToolVisualizationFilter->GetOutput(i);
if (currentTool->IsDataValid())
{
this->m_toolStorage->GetTool(i)->GetDataNode()->SetColor(mitk::IGTColor_VALID);
}
else
{
this->m_toolStorage->GetTool(i)->GetDataNode()->SetColor(mitk::IGTColor_WARNING);
}
}
//Update the NeedleProjectionFilter
if( m_NeedleProjectionFilter.IsNotNull() )
{
m_NeedleProjectionFilter->Update();
}
//refresh view and status widget
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
m_Controls->m_TrackingToolsStatusWidget->Refresh();
}
void QmitkMITKIGTTrackingToolboxView::UpdateLoggingTrackingTimer()
{
//update logging
if (m_logging)
{
this->m_loggingFilter->Update();
m_loggedFrames = this->m_loggingFilter->GetNumberOfRecordedSteps();
this->m_Controls->m_LoggedFramesLabel->setText("Logged Frames: " + QString::number(m_loggedFrames));
//check if logging stopped automatically
if ((m_loggedFrames > 1) && (!m_loggingFilter->GetRecording())){ StopLogging(); }
}
//refresh status widget
m_Controls->m_TrackingToolsStatusWidget->Refresh();
}
void QmitkMITKIGTTrackingToolboxView::OnChooseFileClicked()
{
QDir currentPath = QFileInfo(m_Controls->m_LoggingFileName->text()).dir();
// if no path was selected (QDir would select current working dir then) or the
// selected path does not exist -> use home directory
if (currentPath == QDir() || !currentPath.exists())
{
currentPath = QDir(QDir::homePath());
}
QString filename = QFileDialog::getSaveFileName(nullptr, tr("Choose Logging File"), currentPath.absolutePath(), "*.*");
if (filename == "") return;
this->m_Controls->m_LoggingFileName->setText(filename);
this->OnToggleFileExtension();
}
// bug-16470: toggle file extension after clicking on radio button
void QmitkMITKIGTTrackingToolboxView::OnToggleFileExtension()
{
QString currentInputText = this->m_Controls->m_LoggingFileName->text();
QString currentFile = QFileInfo(currentInputText).baseName();
QDir currentPath = QFileInfo(currentInputText).dir();
if (currentFile.isEmpty())
{
currentFile = "logfile";
}
// Setting currentPath to default home path when currentPath is empty or it does not exist
if (currentPath == QDir() || !currentPath.exists())
{
currentPath = QDir::homePath();
}
// check if csv radio button is clicked
if (this->m_Controls->m_CsvFormat->isChecked())
{
// you needn't add a seperator to the input text when currentpath is the rootpath
if (currentPath.isRoot())
{
this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + currentFile + ".csv");
}
else
{
this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + QDir::separator() + currentFile + ".csv");
}
}
// check if xml radio button is clicked
else if (this->m_Controls->m_XmlFormat->isChecked())
{
// you needn't add a seperator to the input text when currentpath is the rootpath
if (currentPath.isRoot())
{
this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + currentFile + ".xml");
}
else
{
this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + QDir::separator() + currentFile + ".xml");
}
}
}
void QmitkMITKIGTTrackingToolboxView::OnToggleAdvancedSimpleMode()
{
if (m_SimpleModeEnabled)
{
m_Controls->m_simpleWidget->setVisible(false);
m_Controls->m_MainWidget->setVisible(true);
m_Controls->m_SimpleUI->setChecked(false);
m_SimpleModeEnabled = false;
}
else
{
m_Controls->m_simpleWidget->setVisible(true);
m_Controls->m_MainWidget->setVisible(false);
m_SimpleModeEnabled = true;
}
}
void QmitkMITKIGTTrackingToolboxView::OnToggleDifferentUpdateRates()
{
if (m_Controls->m_UseDifferentUpdateRates->isChecked())
{
if (m_Controls->m_RenderUpdateRate->value() == 0)
m_Controls->m_RenderWarningLabel->setVisible(true);
else
m_Controls->m_RenderWarningLabel->setVisible(false);
m_Controls->m_UpdateRate->setEnabled(false);
m_Controls->m_OptionsUpdateRateLabel->setEnabled(false);
m_Controls->m_RenderUpdateRate->setEnabled(true);
m_Controls->m_OptionsRenderUpdateRateLabel->setEnabled(true);
m_Controls->m_LogUpdateRate->setEnabled(true);
m_Controls->m_OptionsLogUpdateRateLabel->setEnabled(true);
}
else
{
m_Controls->m_RenderWarningLabel->setVisible(false);
m_Controls->m_UpdateRate->setEnabled(true);
m_Controls->m_OptionsUpdateRateLabel->setEnabled(true);
m_Controls->m_RenderUpdateRate->setEnabled(false);
m_Controls->m_OptionsRenderUpdateRateLabel->setEnabled(false);
m_Controls->m_LogUpdateRate->setEnabled(false);
m_Controls->m_OptionsLogUpdateRateLabel->setEnabled(false);
}
}
void QmitkMITKIGTTrackingToolboxView::OnChangeRenderUpdateRate()
{
if (m_Controls->m_RenderUpdateRate->value() == 0)
m_Controls->m_RenderWarningLabel->setVisible(true);
else
m_Controls->m_RenderWarningLabel->setVisible(false);
}
void QmitkMITKIGTTrackingToolboxView::StartLogging()
{
if (m_ToolVisualizationFilter.IsNull())
{
MessageBox("Cannot activate logging without a connected device. Configure and connect a tracking device first.");
return;
}
if (!m_logging)
{
//initialize logging filter
m_loggingFilter = mitk::NavigationDataRecorder::New();
m_loggingFilter->SetRecordOnlyValidData(m_Controls->m_SkipInvalidData->isChecked());
m_loggingFilter->ConnectTo(m_ToolVisualizationFilter);
if (m_Controls->m_LoggingLimit->isChecked()){ m_loggingFilter->SetRecordCountLimit(m_Controls->m_LoggedFramesLimit->value()); }
//start filter with try-catch block for exceptions
try
{
m_loggingFilter->StartRecording();
}
catch (mitk::IGTException)
{
std::string errormessage = "Error during start recording. Recorder already started recording?";
QMessageBox::warning(nullptr, "IGTPlayer: Error", errormessage.c_str());
m_loggingFilter->StopRecording();
return;
}
//update labels / logging variables
this->m_Controls->m_LoggingLabel->setText("Logging ON");
this->m_Controls->m_LoggedFramesLabel->setText("Logged Frames: 0");
m_loggedFrames = 0;
m_logging = true;
DisableLoggingButtons();
}
}
void QmitkMITKIGTTrackingToolboxView::StopLogging()
{
if (m_logging)
{
//stop logging
m_loggingFilter->StopRecording();
m_logging = false;
//update GUI
this->m_Controls->m_LoggingLabel->setText("Logging OFF");
EnableLoggingButtons();
//write the results to a file
if (m_Controls->m_CsvFormat->isChecked())
{
mitk::IOUtil::Save(m_loggingFilter->GetNavigationDataSet(), this->m_Controls->m_LoggingFileName->text().toStdString());
}
else if (m_Controls->m_XmlFormat->isChecked())
{
mitk::IOUtil::Save(m_loggingFilter->GetNavigationDataSet(), this->m_Controls->m_LoggingFileName->text().toStdString());
}
}
}
void QmitkMITKIGTTrackingToolboxView::SetFocus()
{
}
void QmitkMITKIGTTrackingToolboxView::OnAddSingleTool()
{
QString Identifier = "Tool#";
QString Name = "NewTool";
if (m_toolStorage.IsNotNull()) {
Identifier += QString::number(m_toolStorage->GetToolCount());
Name += QString::number(m_toolStorage->GetToolCount());
}
else {
Identifier += "0";
Name += "0";
}
m_Controls->m_NavigationToolCreationWidget->Initialize(GetDataStorage(), Identifier.toStdString(), Name.toStdString());
m_Controls->m_NavigationToolCreationWidget->SetTrackingDeviceType(m_Controls->m_ConfigurationWidget->GetTrackingDevice()->GetType(), false);
m_Controls->m_TrackingToolsWidget->setCurrentIndex(1);
//disable tracking volume during tool editing
lastTrackingVolumeState = m_Controls->m_ShowTrackingVolume->isChecked();
if (lastTrackingVolumeState) m_Controls->m_ShowTrackingVolume->click();
GlobalReinit();
}
void QmitkMITKIGTTrackingToolboxView::OnAddSingleToolFinished()
{
m_Controls->m_TrackingToolsWidget->setCurrentIndex(0);
if (this->m_toolStorage.IsNull())
{
//this shouldn't happen!
MITK_WARN << "No ToolStorage available, cannot add tool, aborting!";
return;
}
m_toolStorage->AddTool(m_Controls->m_NavigationToolCreationWidget->GetCreatedTool());
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
m_Controls->m_ToolLabel->setText("<manually added>");
//auto save current storage for persistence
MITK_INFO << "Auto saving manually added tools for persistence.";
AutoSaveToolStorage();
//enable tracking volume again
if (lastTrackingVolumeState) m_Controls->m_ShowTrackingVolume->click();
GlobalReinit();
}
void QmitkMITKIGTTrackingToolboxView::OnAddSingleToolCanceled()
{
m_Controls->m_TrackingToolsWidget->setCurrentIndex(0);
//enable tracking volume again
if (lastTrackingVolumeState) m_Controls->m_ShowTrackingVolume->click();
GlobalReinit();
}
void QmitkMITKIGTTrackingToolboxView::GlobalReinit()
{
// get all nodes that have not set "includeInBoundingBox" to false
mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false)));
mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
// calculate bounding geometry of these nodes
mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
// initialize the views to the bounding geometry
mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
}
void QmitkMITKIGTTrackingToolboxView::DisableLoggingButtons()
{
m_Controls->m_StartLogging->setEnabled(false);
m_Controls->m_LoggingFileName->setEnabled(false);
m_Controls->m_ChooseFile->setEnabled(false);
m_Controls->m_LoggingLimit->setEnabled(false);
m_Controls->m_LoggedFramesLimit->setEnabled(false);
m_Controls->m_CsvFormat->setEnabled(false);
m_Controls->m_XmlFormat->setEnabled(false);
m_Controls->m_SkipInvalidData->setEnabled(false);
m_Controls->m_StopLogging->setEnabled(true);
}
void QmitkMITKIGTTrackingToolboxView::EnableLoggingButtons()
{
m_Controls->m_StartLogging->setEnabled(true);
m_Controls->m_LoggingFileName->setEnabled(true);
m_Controls->m_ChooseFile->setEnabled(true);
m_Controls->m_LoggingLimit->setEnabled(true);
m_Controls->m_LoggedFramesLimit->setEnabled(true);
m_Controls->m_CsvFormat->setEnabled(true);
m_Controls->m_XmlFormat->setEnabled(true);
m_Controls->m_SkipInvalidData->setEnabled(true);
m_Controls->m_StopLogging->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::DisableOptionsButtons()
{
m_Controls->m_ShowTrackingVolume->setEnabled(false);
m_Controls->m_UseDifferentUpdateRates->setEnabled(false);
m_Controls->m_UpdateRate->setEnabled(false);
m_Controls->m_OptionsUpdateRateLabel->setEnabled(false);
m_Controls->m_RenderUpdateRate->setEnabled(false);
m_Controls->m_OptionsRenderUpdateRateLabel->setEnabled(false);
m_Controls->m_LogUpdateRate->setEnabled(false);
m_Controls->m_OptionsLogUpdateRateLabel->setEnabled(false);
m_Controls->m_DisableAllTimers->setEnabled(false);
m_Controls->m_OtherOptionsGroupBox->setEnabled(false);
m_Controls->m_EnableOpenIGTLinkMicroService->setEnabled(false);
m_Controls->m_OpenIGTLinkDataFormat->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::EnableOptionsButtons()
{
m_Controls->m_ShowTrackingVolume->setEnabled(true);
m_Controls->m_UseDifferentUpdateRates->setEnabled(true);
m_Controls->m_DisableAllTimers->setEnabled(true);
m_Controls->m_OtherOptionsGroupBox->setEnabled(true);
m_Controls->m_EnableOpenIGTLinkMicroService->setEnabled(true);
m_Controls->m_OpenIGTLinkDataFormat->setEnabled(true);
OnToggleDifferentUpdateRates();
}
void QmitkMITKIGTTrackingToolboxView::EnableTrackingControls()
{
m_Controls->m_TrackingControlsGroupBox->setEnabled(true);
}
void QmitkMITKIGTTrackingToolboxView::DisableTrackingControls()
{
m_Controls->m_TrackingControlsGroupBox->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::EnableTrackingConfigurationButtons()
{
m_Controls->m_AutoDetectTools->setEnabled(true);
m_Controls->m_AddSingleTool->setEnabled(this->m_Controls->m_ConfigurationWidget->GetTrackingDevice()->AddSingleToolIsAvailable());
m_Controls->m_LoadTools->setEnabled(true);
m_Controls->m_ResetTools->setEnabled(true);
}
void QmitkMITKIGTTrackingToolboxView::DisableTrackingConfigurationButtons()
{
m_Controls->m_AutoDetectTools->setEnabled(false);
m_Controls->m_AddSingleTool->setEnabled(false);
m_Controls->m_LoadTools->setEnabled(false);
m_Controls->m_ResetTools->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::ReplaceCurrentToolStorage(mitk::NavigationToolStorage::Pointer newStorage, std::string newStorageName)
{
//first: get rid of the old one
//don't reset if there is no tool storage. BugFix #17793
if (m_toolStorage.IsNotNull()){
m_toolStorage->UnLockStorage(); //only to be sure...
m_toolStorage->UnRegisterMicroservice();
m_toolStorage = nullptr;
}
//now: replace by the new one
m_toolStorage = newStorage;
m_toolStorage->SetName(newStorageName);
m_toolStorage->RegisterAsMicroservice();
}
void QmitkMITKIGTTrackingToolboxView::OnTimeOut()
{
MITK_WARN << "TimeOut. Quitting the thread...";
m_WorkerThread->quit();
//only if we can't quit use terminate.
if (!m_WorkerThread->wait(1000))
{
MITK_ERROR << "Can't quit the thread. Terminating... Might cause further problems, be careful!";
m_WorkerThread->terminate();
m_WorkerThread->wait();
}
m_TimeoutTimer->stop();
}
void QmitkMITKIGTTrackingToolboxView::OnToolStorageChanged(const ctkServiceEvent event)
{
//don't listen to any changes during connection, toolStorage is locked anyway, so this are only changes of e.g. sourceID which are not relevant for the widget.
if (!m_connected && (event.getType() == ctkServiceEvent::MODIFIED))
{
m_Controls->m_ConfigurationWidget->OnToolStorageChanged();
}
}
//! [StoreUISettings]
void QmitkMITKIGTTrackingToolboxView::StoreUISettings()
{
// persistence service does not directly work in plugins for now
// -> using QSettings
QSettings settings;
settings.beginGroup(QString::fromStdString(VIEW_ID));
MITK_DEBUG << "Store UI settings";
// set the values of some widgets and attrbutes to the QSettings
settings.setValue("ShowTrackingVolume", QVariant(m_Controls->m_ShowTrackingVolume->isChecked()));
settings.setValue("toolStorageFilename", QVariant(m_ToolStorageFilename));
settings.setValue("VolumeSelectionBox", QVariant(m_Controls->m_VolumeSelectionBox->currentIndex()));
settings.setValue("SimpleModeEnabled", QVariant(m_SimpleModeEnabled));
settings.setValue("OpenIGTLinkDataFormat", QVariant(m_Controls->m_OpenIGTLinkDataFormat->currentIndex()));
settings.setValue("EnableOpenIGTLinkMicroService", QVariant(m_Controls->m_EnableOpenIGTLinkMicroService->isChecked()));
settings.endGroup();
}
//! [StoreUISettings]
//! [LoadUISettings]
void QmitkMITKIGTTrackingToolboxView::LoadUISettings()
{
// persistence service does not directly work in plugins for now -> using QSettings
QSettings settings;
settings.beginGroup(QString::fromStdString(VIEW_ID));
// set some widgets and attributes by the values from the QSettings
m_Controls->m_ShowTrackingVolume->setChecked(settings.value("ShowTrackingVolume", true).toBool());
m_Controls->m_EnableOpenIGTLinkMicroService->setChecked(settings.value("EnableOpenIGTLinkMicroService", true).toBool());
m_Controls->m_VolumeSelectionBox->setCurrentIndex(settings.value("VolumeSelectionBox", 0).toInt());
m_Controls->m_OpenIGTLinkDataFormat->setCurrentIndex(settings.value("OpenIGTLinkDataFormat", 0).toInt());
m_ToolStorageFilename = settings.value("toolStorageFilename", QVariant("")).toString();
if (settings.value("SimpleModeEnabled", false).toBool()) { this->OnToggleAdvancedSimpleMode(); }
settings.endGroup();
//! [LoadUISettings]
//! [LoadToolStorage]
// try to deserialize the tool storage from the given tool storage file name
if (!m_ToolStorageFilename.isEmpty())
{
// try-catch block for exceptions
try
{
mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(GetDataStorage());
m_toolStorage->UnRegisterMicroservice();
m_toolStorage = myDeserializer->Deserialize(m_ToolStorageFilename.toStdString());
m_toolStorage->RegisterAsMicroservice();
//update label
UpdateToolStorageLabel(m_ToolStorageFilename);
//update tool preview
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
}
catch (mitk::IGTException)
{
MITK_WARN("QmitkMITKIGTTrackingToolBoxView") << "Error during restoring tools. Problems with file (" << m_ToolStorageFilename.toStdString() << "), please check the file?";
this->OnResetTools(); //if there where errors reset the tool storage to avoid problems later on
}
}
//! [LoadToolStorage]
}
void QmitkMITKIGTTrackingToolboxView::UpdateToolStorageLabel(QString pathOfLoadedStorage)
{
QFileInfo myPath(pathOfLoadedStorage); //use this to seperate filename from path
QString toolLabel = myPath.fileName();
if (toolLabel.size() > 45) //if the tool storage name is to long trimm the string
{
toolLabel.resize(40);
toolLabel += "[...]";
}
m_Controls->m_ToolLabel->setText(toolLabel);
}
void QmitkMITKIGTTrackingToolboxView::AutoSaveToolStorage()
{
m_ToolStorageFilename = m_AutoSaveFilename;
mitk::NavigationToolStorageSerializer::Pointer mySerializer = mitk::NavigationToolStorageSerializer::New();
mySerializer->Serialize(m_ToolStorageFilename.toStdString(), m_toolStorage);
-}
\ No newline at end of file
+}
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewWorker.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewWorker.cpp
index 0d1b858a06..5064dd4ef2 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewWorker.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewWorker.cpp
@@ -1,250 +1,250 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
// Qmitk
#include "QmitkMITKIGTTrackingToolboxViewWorker.h"
#include <mitkTrackingDeviceSourceConfigurator.h>
QmitkMITKIGTTrackingToolboxViewWorker::QmitkMITKIGTTrackingToolboxViewWorker()
{
}
QmitkMITKIGTTrackingToolboxViewWorker::~QmitkMITKIGTTrackingToolboxViewWorker()
{
}
void QmitkMITKIGTTrackingToolboxViewWorker::SetWorkerMethod(WorkerMethod w)
{
m_WorkerMethod = w;
}
void QmitkMITKIGTTrackingToolboxViewWorker::SetTrackingDevice(mitk::TrackingDevice::Pointer t)
{
m_TrackingDevice = t;
}
void QmitkMITKIGTTrackingToolboxViewWorker::SetDataStorage(mitk::DataStorage::Pointer d)
{
m_DataStorage = d;
}
void QmitkMITKIGTTrackingToolboxViewWorker::SetInverseMode(bool mode)
{
m_InverseMode = mode;
}
void QmitkMITKIGTTrackingToolboxViewWorker::SetTrackingDeviceData(mitk::TrackingDeviceData d)
{
m_TrackingDeviceData = d;
}
void QmitkMITKIGTTrackingToolboxViewWorker::SetNavigationToolStorage(mitk::NavigationToolStorage::Pointer n)
{
m_NavigationToolStorage = n;
}
//! [Thread 7]
void QmitkMITKIGTTrackingToolboxViewWorker::ThreadFunc()
{
switch (m_WorkerMethod)
{
case eAutoDetectTools:
this->AutoDetectTools();
break;
case eConnectDevice:
this->ConnectDevice();
break;
case eStartTracking:
this->StartTracking();
break;
case eStopTracking:
this->StopTracking();
break;
case eDisconnectDevice:
this->DisconnectDevice();
break;
default:
MITK_WARN << "Undefined worker method was set ... something went wrong!";
break;
}
}
//! [Thread 7]
void QmitkMITKIGTTrackingToolboxViewWorker::AutoDetectTools()
{
mitk::NavigationToolStorage::Pointer autoDetectedStorage = mitk::NavigationToolStorage::New(m_DataStorage);
try
{
mitk::NavigationToolStorage::Pointer tempStorage = m_TrackingDevice->AutoDetectTools();
- for (int i = 0; i < tempStorage->GetToolCount(); i++) { autoDetectedStorage->AddTool(tempStorage->GetTool(i)); }
+ for (unsigned int i = 0; i < tempStorage->GetToolCount(); i++) { autoDetectedStorage->AddTool(tempStorage->GetTool(i)); }
}
catch (mitk::Exception& e)
{
MITK_WARN << e.GetDescription();
emit AutoDetectToolsFinished(false, e.GetDescription());
return;
}
m_NavigationToolStorage = nullptr;
m_NavigationToolStorage = autoDetectedStorage;
emit AutoDetectToolsFinished(true, "");
MITK_INFO << "AutoDetect Tools Finished.";
}
void QmitkMITKIGTTrackingToolboxViewWorker::ConnectDevice()
{
std::string message = "";
//build the IGT pipeline
mitk::TrackingDevice::Pointer trackingDevice = m_TrackingDevice;
trackingDevice->SetData(m_TrackingDeviceData);
//set device to rotation mode transposed becaus we are working with VNL style quaternions
if (m_InverseMode)
{
trackingDevice->SetRotationMode(mitk::TrackingDevice::RotationTransposed);
}
//Get Tracking Volume Data
mitk::TrackingDeviceData data = m_TrackingDeviceData;
//Create Navigation Data Source with the factory class
mitk::TrackingDeviceSourceConfigurator::Pointer myTrackingDeviceSourceFactory = mitk::TrackingDeviceSourceConfigurator::New(m_NavigationToolStorage, trackingDevice);
m_TrackingDeviceSource = myTrackingDeviceSourceFactory->CreateTrackingDeviceSource(m_ToolVisualizationFilter);
if (m_TrackingDeviceSource.IsNull())
{
message = std::string("Cannot connect to device: ") + myTrackingDeviceSourceFactory->GetErrorMessage();
emit ConnectDeviceFinished(false, QString(message.c_str()));
return;
}
//set filter to rotation mode transposed becaus we are working with VNL style quaternions
if (m_InverseMode)
m_ToolVisualizationFilter->SetRotationMode(mitk::NavigationDataObjectVisualizationFilter::RotationTransposed);
//First check if the created object is valid
if (m_TrackingDeviceSource.IsNull())
{
message = myTrackingDeviceSourceFactory->GetErrorMessage();
emit ConnectDeviceFinished(false, QString(message.c_str()));
return;
}
MITK_INFO << "Connected device with " << m_TrackingDeviceSource->GetNumberOfOutputs() << " tools.";
//connect to device
try
{
m_TrackingDeviceSource->Connect();
//Microservice registration:
m_TrackingDeviceSource->RegisterAsMicroservice();
m_NavigationToolStorage->SetSourceID(m_TrackingDeviceSource->GetMicroserviceID());
m_NavigationToolStorage->LockStorage();
}
catch (...) //todo: change to mitk::IGTException
{
message = "Error on connecting the tracking device.";
emit ConnectDeviceFinished(false, QString(message.c_str()));
return;
}
emit ConnectDeviceFinished(true, QString(message.c_str()));
}
mitk::TrackingDeviceSource::Pointer QmitkMITKIGTTrackingToolboxViewWorker::GetTrackingDeviceSource()
{
return this->m_TrackingDeviceSource;
}
void QmitkMITKIGTTrackingToolboxViewWorker::StartTracking()
{
QString errorMessage = "";
try
{
m_TrackingDeviceSource->StartTracking();
}
catch (...) //todo: change to mitk::IGTException
{
errorMessage += "Error while starting the tracking device!";
emit StartTrackingFinished(false, errorMessage);
return;
}
//remember the original colors of the tools
m_OriginalColors = std::map<mitk::DataNode::Pointer, mitk::Color>();
- for (int i = 0; i < this->m_NavigationToolStorage->GetToolCount(); i++)
+ for (unsigned int i = 0; i < this->m_NavigationToolStorage->GetToolCount(); i++)
{
mitk::DataNode::Pointer currentToolNode = m_NavigationToolStorage->GetTool(i)->GetDataNode();
float c[3];
currentToolNode->GetColor(c);
mitk::Color color;
color.SetRed(c[0]);
color.SetGreen(c[1]);
color.SetBlue(c[2]);
m_OriginalColors[currentToolNode] = color;
}
emit StartTrackingFinished(true, errorMessage);
}
void QmitkMITKIGTTrackingToolboxViewWorker::StopTracking()
{
//stop tracking
try
{
m_TrackingDeviceSource->StopTracking();
}
catch (mitk::Exception& e)
{
emit StopTrackingFinished(false, e.GetDescription());
}
//restore the original colors of the tools
- for (int i = 0; i < this->m_NavigationToolStorage->GetToolCount(); i++)
+ for (unsigned int i = 0; i < this->m_NavigationToolStorage->GetToolCount(); i++)
{
mitk::DataNode::Pointer currentToolNode = m_NavigationToolStorage->GetTool(i)->GetDataNode();
if (m_OriginalColors.find(currentToolNode) == m_OriginalColors.end())
{
MITK_WARN << "Cannot restore original color of tool " << m_NavigationToolStorage->GetTool(i)->GetToolName();
}
else
{
currentToolNode->SetColor(m_OriginalColors[currentToolNode]);
}
}
//emit signal
emit StopTrackingFinished(true, "");
}
void QmitkMITKIGTTrackingToolboxViewWorker::DisconnectDevice()
{
try
{
if (m_TrackingDeviceSource->IsTracking()) { m_TrackingDeviceSource->StopTracking(); }
m_TrackingDeviceSource->Disconnect();
m_TrackingDeviceSource->UnRegisterMicroservice();
m_NavigationToolStorage->UnLockStorage();
m_TrackingDeviceSource = nullptr;
}
catch (mitk::Exception& e)
{
emit DisconnectDeviceFinished(false, e.GetDescription());
}
emit DisconnectDeviceFinished(true, "");
-}
\ No newline at end of file
+}