diff --git a/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.cpp b/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.cpp
index 19e989ad48..f467d89616 100644
--- a/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.cpp
+++ b/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.cpp
@@ -1,474 +1,463 @@
/*===================================================================
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 "mitkAbstractUltrasoundTrackerDevice.h"
#include "mitkImageReadAccessor.h"
-#include "mitkNavigationDataSmoothingFilter.h"
#include "mitkNavigationDataDelayFilter.h"
#include "mitkNavigationDataDisplacementFilter.h"
+#include "mitkNavigationDataSmoothingFilter.h"
#include "mitkTrackingDeviceSource.h"
// US Control Interfaces
-#include "mitkUSControlInterfaceProbes.h"
#include "mitkUSControlInterfaceBMode.h"
#include "mitkUSControlInterfaceDoppler.h"
+#include "mitkUSControlInterfaceProbes.h"
-//Microservices
+// Microservices
#include <usGetModuleContext.h>
#include <usModule.h>
-#include <usServiceProperties.h>
#include <usModuleContext.h>
+#include <usServiceProperties.h>
#include <algorithm>
-//TempIncludes
+// TempIncludes
#include <tinyxml.h>
-const std::string mitk::AbstractUltrasoundTrackerDevice::DeviceClassIdentifier = "org.mitk.modules.us.AbstractUltrasoundTrackerDevice";
-const char* mitk::AbstractUltrasoundTrackerDevice::DefaultProbeIdentifier = "default";
-const char* mitk::AbstractUltrasoundTrackerDevice::ProbeAndDepthSeperator = "_";
+const std::string mitk::AbstractUltrasoundTrackerDevice::DeviceClassIdentifier =
+ "org.mitk.modules.us.AbstractUltrasoundTrackerDevice";
+const char *mitk::AbstractUltrasoundTrackerDevice::DefaultProbeIdentifier = "default";
+const char *mitk::AbstractUltrasoundTrackerDevice::ProbeAndDepthSeperator = "_";
-const std::string mitk::AbstractUltrasoundTrackerDevice::US_INTERFACE_NAME = "org.mitk.services.AbstractUltrasoundTrackerDevice";
+const std::string mitk::AbstractUltrasoundTrackerDevice::US_INTERFACE_NAME =
+ "org.mitk.services.AbstractUltrasoundTrackerDevice";
const std::string mitk::AbstractUltrasoundTrackerDevice::US_PROPKEY_DEVICENAME = US_INTERFACE_NAME + ".devicename";
const std::string mitk::AbstractUltrasoundTrackerDevice::US_PROPKEY_CLASS = US_INTERFACE_NAME + ".class";
const std::string mitk::AbstractUltrasoundTrackerDevice::US_PROPKEY_ID = US_INTERFACE_NAME + ".id";
//____
-
-mitk::AbstractUltrasoundTrackerDevice::AbstractUltrasoundTrackerDevice(
- USDevice::Pointer usDevice, NavigationDataSource::Pointer trackingDevice,
- bool trackedUltrasoundActive ) :
- m_UltrasoundDevice(usDevice), m_TrackingDeviceDataSource(trackingDevice),
+mitk::AbstractUltrasoundTrackerDevice::AbstractUltrasoundTrackerDevice(USDevice::Pointer usDevice,
+ NavigationDataSource::Pointer trackingDevice,
+ bool trackedUltrasoundActive)
+ : m_UltrasoundDevice(usDevice),
+ m_TrackingDeviceDataSource(trackingDevice),
m_SmoothingFilter(mitk::NavigationDataSmoothingFilter::New()),
m_DelayFilter(mitk::NavigationDataDelayFilter::New(0)),
m_DisplacementFilter(mitk::NavigationDataDisplacementFilter::New()),
m_LastFilterOfIGTPipeline(nullptr),
- m_NumberOfSmoothingValues(0), m_DelayCount(0),
- m_IsTrackedUltrasoundActive( trackedUltrasoundActive )
+ m_NumberOfSmoothingValues(0),
+ m_DelayCount(0),
+ m_IsTrackedUltrasoundActive(trackedUltrasoundActive)
{
m_DisplacementFilter->SetTransform6DOF(true);
this->RebuildFilterPipeline();
- //create a new output (for the image data)
+ // create a new output (for the image data)
//___ mitk::Image::Pointer newOutput = mitk::Image::New();
//___ this->SetNthOutput(0, newOutput);
// Combined Modality should not spawn an own acquire thread, because
// image acquiring is done by the included us device
//___ m_UltrasoundDevice->SetSpawnAcquireThread(false);
}
+mitk::AffineTransform3D::Pointer mitk::AbstractUltrasoundTrackerDevice::GetUSPlaneTransform()
+{
+ return mitk::AffineTransform3D::New();
+}
mitk::AbstractUltrasoundTrackerDevice::~AbstractUltrasoundTrackerDevice()
{
if (m_ServiceRegistration != nullptr)
{
m_ServiceRegistration.Unregister();
}
m_ServiceRegistration = 0;
}
-mitk::AffineTransform3D::Pointer
- mitk::AbstractUltrasoundTrackerDevice::GetCalibration()
+mitk::AffineTransform3D::Pointer mitk::AbstractUltrasoundTrackerDevice::GetCalibration()
{
- return this->GetCalibration( this->GetCurrentDepthValue(),
- this->GetIdentifierForCurrentProbe() );
+ return this->GetCalibration(this->GetCurrentDepthValue(), this->GetIdentifierForCurrentProbe());
}
-mitk::AffineTransform3D::Pointer
- mitk::AbstractUltrasoundTrackerDevice::GetCalibration(std::string depth)
+mitk::AffineTransform3D::Pointer mitk::AbstractUltrasoundTrackerDevice::GetCalibration(std::string depth)
{
return this->GetCalibration(depth, this->GetIdentifierForCurrentProbe());
}
-mitk::AffineTransform3D::Pointer
- mitk::AbstractUltrasoundTrackerDevice::GetCalibration( std::string depth,
- std::string probe )
+mitk::AffineTransform3D::Pointer mitk::AbstractUltrasoundTrackerDevice::GetCalibration(std::string depth,
+ std::string probe)
{
// make sure that there is no '/' which would cause problems for TinyXML
std::replace(probe.begin(), probe.end(), '/', '-');
// create identifier for calibration from probe and depth
- std::string calibrationKey =
- probe +
- mitk::AbstractUltrasoundTrackerDevice::ProbeAndDepthSeperator +
- depth;
+ std::string calibrationKey = probe + mitk::AbstractUltrasoundTrackerDevice::ProbeAndDepthSeperator + depth;
// find calibration for combination of probe identifier and depth
- std::map<std::string, mitk::AffineTransform3D::Pointer>::iterator calibrationIterator
- = m_Calibrations.find(calibrationKey);
+ std::map<std::string, mitk::AffineTransform3D::Pointer>::iterator calibrationIterator =
+ m_Calibrations.find(calibrationKey);
- if (calibrationIterator == m_Calibrations.end()) { return 0; }
+ if (calibrationIterator == m_Calibrations.end())
+ {
+ return 0;
+ }
return calibrationIterator->second;
}
-void mitk::AbstractUltrasoundTrackerDevice::SetCalibration(
- mitk::AffineTransform3D::Pointer calibration )
+void mitk::AbstractUltrasoundTrackerDevice::SetCalibration(mitk::AffineTransform3D::Pointer calibration)
{
- if( calibration.IsNull() )
+ if (calibration.IsNull())
{
MITK_WARN << "Null pointer passed to SetCalibration of mitk::USDevice. Ignoring call.";
return;
}
std::string calibrationKey = this->GetIdentifierForCurrentCalibration();
- if( calibrationKey.empty() )
+ if (calibrationKey.empty())
{
MITK_WARN << "Could not get a key for the calibration -> Calibration cannot be set.";
return;
}
m_Calibrations[calibrationKey] = calibration;
}
bool mitk::AbstractUltrasoundTrackerDevice::RemoveCalibration()
{
- return this->RemoveCalibration( this->GetCurrentDepthValue(),
- this->GetIdentifierForCurrentProbe() );
+ return this->RemoveCalibration(this->GetCurrentDepthValue(), this->GetIdentifierForCurrentProbe());
}
bool mitk::AbstractUltrasoundTrackerDevice::RemoveCalibration(std::string depth)
{
- return this->RemoveCalibration( depth,
- this->GetIdentifierForCurrentProbe() );
+ return this->RemoveCalibration(depth, this->GetIdentifierForCurrentProbe());
}
-bool mitk::AbstractUltrasoundTrackerDevice::RemoveCalibration( std::string depth,
- std::string probe )
+bool mitk::AbstractUltrasoundTrackerDevice::RemoveCalibration(std::string depth, std::string probe)
{
// make sure that there is no '/' which would cause problems for TinyXML
std::replace(probe.begin(), probe.end(), '/', '-');
// create identifier for calibration from probe and depth
- std::string calibrationKey =
- probe +
- mitk::AbstractUltrasoundTrackerDevice::ProbeAndDepthSeperator +
- depth;
+ std::string calibrationKey = probe + mitk::AbstractUltrasoundTrackerDevice::ProbeAndDepthSeperator + depth;
return m_Calibrations.erase(calibrationKey) > 0;
}
std::string mitk::AbstractUltrasoundTrackerDevice::GetDeviceClass()
{
return DeviceClassIdentifier;
}
mitk::USImageSource::Pointer mitk::AbstractUltrasoundTrackerDevice::GetUSImageSource()
{
if (m_UltrasoundDevice.IsNull())
{
MITK_ERROR("AbstractUltrasoundTrackerDevice")("USDevice") << "UltrasoundDevice must not be null.";
mitkThrow() << "UltrasoundDevice must not be null.";
}
return m_UltrasoundDevice->GetUSImageSource();
}
mitk::NavigationDataSource::Pointer mitk::AbstractUltrasoundTrackerDevice::GetNavigationDataSource()
{
- if( m_LastFilterOfIGTPipeline.IsNull() )
+ if (m_LastFilterOfIGTPipeline.IsNull())
{
this->RebuildFilterPipeline();
}
m_LastFilterOfIGTPipeline->SetToolMetaDataCollection(this->m_TrackingDeviceDataSource->GetToolMetaDataCollection());
return m_LastFilterOfIGTPipeline;
}
bool mitk::AbstractUltrasoundTrackerDevice::GetIsCalibratedForCurrentStatus()
{
return m_Calibrations.find(this->GetIdentifierForCurrentCalibration()) != m_Calibrations.end();
}
bool mitk::AbstractUltrasoundTrackerDevice::GetContainsAtLeastOneCalibration()
{
return !m_Calibrations.empty();
}
std::string mitk::AbstractUltrasoundTrackerDevice::SerializeCalibration()
{
std::stringstream result;
result << "<calibrations>" << std::endl;
// For each calibration in the set
- for( std::map<std::string,
- mitk::AffineTransform3D::Pointer>::iterator it = m_Calibrations.begin();
- it != m_Calibrations.end(); it++ )
+ for (std::map<std::string, mitk::AffineTransform3D::Pointer>::iterator it = m_Calibrations.begin();
+ it != m_Calibrations.end();
+ it++)
{
mitk::AffineTransform3D::MatrixType matrix = it->second->GetMatrix();
mitk::AffineTransform3D::TranslationType translation = it->second->GetTranslation();
TiXmlElement elem(it->first);
// Serialize Matrix
elem.SetDoubleAttribute("M00", matrix[0][0]);
elem.SetDoubleAttribute("M01", matrix[0][1]);
elem.SetDoubleAttribute("M02", matrix[0][2]);
elem.SetDoubleAttribute("M10", matrix[1][0]);
elem.SetDoubleAttribute("M11", matrix[1][1]);
elem.SetDoubleAttribute("M12", matrix[1][2]);
elem.SetDoubleAttribute("M20", matrix[2][0]);
elem.SetDoubleAttribute("M21", matrix[2][1]);
elem.SetDoubleAttribute("M22", matrix[2][2]);
// Serialize Offset
elem.SetDoubleAttribute("T0", translation[0]);
elem.SetDoubleAttribute("T1", translation[1]);
elem.SetDoubleAttribute("T2", translation[2]);
result << elem << std::endl;
}
result << "</calibrations>" << std::endl;
return result.str();
}
-void mitk::AbstractUltrasoundTrackerDevice::DeserializeCalibration(
- const std::string& xmlString,
- bool clearPreviousCalibrations )
+void mitk::AbstractUltrasoundTrackerDevice::DeserializeCalibration(const std::string &xmlString,
+ bool clearPreviousCalibrations)
{
// Sanitize Input
if (xmlString == "")
{
MITK_ERROR << "Empty string passed to Deserialize() method of CombinedModality. Aborting...";
mitkThrow() << "Empty string passed to Deserialize() method of CombinedModality. Aborting...";
return;
}
// Clear previous calibrations if necessary
- if (clearPreviousCalibrations) m_Calibrations.clear();
+ if (clearPreviousCalibrations)
+ m_Calibrations.clear();
// Parse Input
TiXmlDocument doc;
if (!doc.Parse(xmlString.c_str()))
{
MITK_ERROR << "Unable to deserialize calibrations in CombinedModality. Error was: " << doc.ErrorDesc();
mitkThrow() << "Unable to deserialize calibrations in CombinedModality. Error was: " << doc.ErrorDesc();
return;
}
- TiXmlElement* root = doc.FirstChildElement();
+ TiXmlElement *root = doc.FirstChildElement();
if (root == nullptr)
{
MITK_ERROR << "Unable to deserialize calibrations in CombinedModality. String contained no root element.";
mitkThrow() << "Unable to deserialize calibrations in CombinedModality. String contained no root element.";
return;
}
// Read Calibrations
- for (TiXmlElement* elem = root->FirstChildElement(); elem != nullptr; elem = elem->NextSiblingElement())
+ for (TiXmlElement *elem = root->FirstChildElement(); elem != nullptr; elem = elem->NextSiblingElement())
{
mitk::AffineTransform3D::MatrixType matrix;
mitk::AffineTransform3D::OffsetType translation;
std::string calibName = elem->Value();
// Deserialize Matrix
elem->QueryDoubleAttribute("M00", &matrix[0][0]);
elem->QueryDoubleAttribute("M01", &matrix[0][1]);
elem->QueryDoubleAttribute("M02", &matrix[0][2]);
elem->QueryDoubleAttribute("M10", &matrix[1][0]);
elem->QueryDoubleAttribute("M11", &matrix[1][1]);
elem->QueryDoubleAttribute("M12", &matrix[1][2]);
elem->QueryDoubleAttribute("M20", &matrix[2][0]);
elem->QueryDoubleAttribute("M21", &matrix[2][1]);
elem->QueryDoubleAttribute("M22", &matrix[2][2]);
// Deserialize Offset
elem->QueryDoubleAttribute("T0", &translation[0]);
elem->QueryDoubleAttribute("T1", &translation[1]);
elem->QueryDoubleAttribute("T2", &translation[2]);
mitk::AffineTransform3D::Pointer calibration = mitk::AffineTransform3D::New();
calibration->SetMatrix(matrix);
calibration->SetTranslation(translation);
m_Calibrations[calibName] = calibration;
}
}
-void mitk::AbstractUltrasoundTrackerDevice::SetNumberOfSmoothingValues(
- unsigned int numberOfSmoothingValues )
+void mitk::AbstractUltrasoundTrackerDevice::SetNumberOfSmoothingValues(unsigned int numberOfSmoothingValues)
{
unsigned int oldNumber = m_NumberOfSmoothingValues;
m_NumberOfSmoothingValues = numberOfSmoothingValues;
// if filter should be activated or deactivated
- if ((oldNumber == 0 && numberOfSmoothingValues != 0) ||
- (oldNumber != 0 && numberOfSmoothingValues == 0))
+ if ((oldNumber == 0 && numberOfSmoothingValues != 0) || (oldNumber != 0 && numberOfSmoothingValues == 0))
{
this->RebuildFilterPipeline();
}
m_SmoothingFilter->SetNumerOfValues(numberOfSmoothingValues);
}
-void mitk::AbstractUltrasoundTrackerDevice::SetDelayCount( unsigned int delayCount )
+void mitk::AbstractUltrasoundTrackerDevice::SetDelayCount(unsigned int delayCount)
{
unsigned int oldCount = m_DelayCount;
m_DelayCount = delayCount;
// if filter should be activated or deactivated
- if ((oldCount == 0 && delayCount != 0) ||
- (oldCount != 0 && delayCount == 0))
+ if ((oldCount == 0 && delayCount != 0) || (oldCount != 0 && delayCount == 0))
{
this->RebuildFilterPipeline();
}
m_DelayFilter->SetDelay(delayCount);
}
-void mitk::AbstractUltrasoundTrackerDevice::GenerateData()
-{
-}
+void mitk::AbstractUltrasoundTrackerDevice::GenerateData() {}
std::string mitk::AbstractUltrasoundTrackerDevice::GetIdentifierForCurrentCalibration()
{
- return this->GetIdentifierForCurrentProbe()
- + mitk::AbstractUltrasoundTrackerDevice::ProbeAndDepthSeperator
- + this->GetCurrentDepthValue();
+ return this->GetIdentifierForCurrentProbe() + mitk::AbstractUltrasoundTrackerDevice::ProbeAndDepthSeperator +
+ this->GetCurrentDepthValue();
}
std::string mitk::AbstractUltrasoundTrackerDevice::GetIdentifierForCurrentProbe()
{
us::ServiceProperties usdeviceProperties = m_UltrasoundDevice->GetServiceProperties();
- us::ServiceProperties::const_iterator probeIt = usdeviceProperties.find(
- mitk::USDevice::GetPropertyKeys().US_PROPKEY_PROBES_SELECTED);
+ us::ServiceProperties::const_iterator probeIt =
+ usdeviceProperties.find(mitk::USDevice::GetPropertyKeys().US_PROPKEY_PROBES_SELECTED);
// get probe identifier from control interface for probes
std::string probeName = mitk::AbstractUltrasoundTrackerDevice::DefaultProbeIdentifier;
if (probeIt != usdeviceProperties.end())
{
probeName = (probeIt->second).ToString();
}
// make sure that there is no '/' which would cause problems for TinyXML
std::replace(probeName.begin(), probeName.end(), '/', '-');
return probeName;
}
std::string mitk::AbstractUltrasoundTrackerDevice::GetCurrentDepthValue()
{
us::ServiceProperties usdeviceProperties = m_UltrasoundDevice->GetServiceProperties();
// get string for depth value from the micro service properties
std::string depth;
- us::ServiceProperties::iterator depthIterator = usdeviceProperties.find(
- mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DEPTH);
+ us::ServiceProperties::iterator depthIterator =
+ usdeviceProperties.find(mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DEPTH);
if (depthIterator != usdeviceProperties.end())
{
depth = depthIterator->second.ToString();
}
else
{
depth = "0";
}
return depth;
}
void mitk::AbstractUltrasoundTrackerDevice::RebuildFilterPipeline()
{
m_LastFilterOfIGTPipeline = m_TrackingDeviceDataSource;
- if( m_NumberOfSmoothingValues > 0 )
+ if (m_NumberOfSmoothingValues > 0)
{
m_SmoothingFilter->ConnectTo(m_LastFilterOfIGTPipeline.GetPointer());
m_LastFilterOfIGTPipeline = m_SmoothingFilter;
}
- if( m_DelayCount > 0 )
+ if (m_DelayCount > 0)
{
m_DelayFilter->ConnectTo(m_LastFilterOfIGTPipeline.GetPointer());
m_LastFilterOfIGTPipeline = m_DelayFilter;
}
- if( m_IsTrackedUltrasoundActive )
+ if (m_IsTrackedUltrasoundActive)
{
m_DisplacementFilter->ConnectTo(m_LastFilterOfIGTPipeline.GetPointer());
m_LastFilterOfIGTPipeline = m_DisplacementFilter;
}
}
void mitk::AbstractUltrasoundTrackerDevice::UnregisterOnService()
{
if (m_UltrasoundDevice->GetDeviceState() == USDevice::State_Activated)
{
m_UltrasoundDevice->Deactivate();
}
if (m_UltrasoundDevice->GetDeviceState() == USDevice::State_Connected)
{
m_UltrasoundDevice->Disconnect();
}
if (m_ServiceRegistration != nullptr)
m_ServiceRegistration.Unregister();
m_ServiceRegistration = 0;
}
void mitk::AbstractUltrasoundTrackerDevice::RegisterAsMicroservice()
{
- //Get Context
- us::ModuleContext* context = us::GetModuleContext();
+ // Get Context
+ us::ModuleContext *context = us::GetModuleContext();
- //Define ServiceProps
- //us::ServiceProperties props;
- mitk::UIDGenerator uidGen =
- mitk::UIDGenerator("org.mitk.services.AbstractUltrasoundTrackerDevice", 16);
+ // Define ServiceProps
+ // us::ServiceProperties props;
+ mitk::UIDGenerator uidGen = mitk::UIDGenerator("org.mitk.services.AbstractUltrasoundTrackerDevice", 16);
m_ServiceProperties[US_PROPKEY_ID] = uidGen.GetUID();
m_ServiceProperties[US_PROPKEY_DEVICENAME] = m_UltrasoundDevice->GetName();
m_ServiceProperties[US_PROPKEY_CLASS] = mitk::AbstractUltrasoundTrackerDevice::DeviceClassIdentifier;
m_ServiceRegistration = context->RegisterService(this, m_ServiceProperties);
}
mitk::USAbstractControlInterface::Pointer mitk::AbstractUltrasoundTrackerDevice::GetControlInterfaceCustom()
{
if (m_UltrasoundDevice.IsNull())
{
MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
mitkThrow() << "UltrasoundDevice must not be null.";
}
return m_UltrasoundDevice->GetControlInterfaceCustom();
}
mitk::USControlInterfaceBMode::Pointer mitk::AbstractUltrasoundTrackerDevice::GetControlInterfaceBMode()
{
if (m_UltrasoundDevice.IsNull())
{
MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
mitkThrow() << "UltrasoundDevice must not be null.";
}
return m_UltrasoundDevice->GetControlInterfaceBMode();
}
mitk::USControlInterfaceProbes::Pointer mitk::AbstractUltrasoundTrackerDevice::GetControlInterfaceProbes()
{
if (m_UltrasoundDevice.IsNull())
{
MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
mitkThrow() << "UltrasoundDevice must not be null.";
}
return m_UltrasoundDevice->GetControlInterfaceProbes();
}
mitk::USControlInterfaceDoppler::Pointer mitk::AbstractUltrasoundTrackerDevice::GetControlInterfaceDoppler()
{
if (m_UltrasoundDevice.IsNull())
{
MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
mitkThrow() << "UltrasoundDevice must not be null.";
}
return m_UltrasoundDevice->GetControlInterfaceDoppler();
}
diff --git a/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.h b/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.h
index 8e0f8bf705..03eb9b8728 100644
--- a/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.h
+++ b/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.h
@@ -1,257 +1,260 @@
/*===================================================================
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 __mitkAbstractUltrasoundTrackerDevice_h
#define __mitkAbstractUltrasoundTrackerDevice_h
#include <MitkUSNavigationExports.h>
#include "mitkUSDevice.h"
#include "mitkImageSource.h"
#include "mitkNavigationDataSource.h"
// Microservices
#include <mitkServiceInterface.h>
#include <usServiceRegistration.h>
#include <usGetModuleContext.h>
#include <usModule.h>
#include <usServiceProperties.h>
#include <usModuleContext.h>
namespace itk {
template<class T> class SmartPointer;
}
namespace mitk {
class NavigationDataSmoothingFilter;
class NavigationDataDelayFilter;
class NavigationDataDisplacementFilter;
/**
* \brief Abstract class for an easy handling of a combination of an USDevice and
* a NavigationDataSource.
* This class can be used as an ImageSource subclass. Additionally tracking data be
* retrieved from the NavigationDataSource returned by GetTrackingDevice().
*
* A calibration of the ultrasound image stream to the navigation datas can be set
* for the currently active zoom level (of the ultrasound device) by SetCalibration()
* The ultrasound images are transformed according to this calibration in the
* GenerateData() method.
*/
class MITKUSNAVIGATION_EXPORT AbstractUltrasoundTrackerDevice : public mitk::ImageSource
{
public:
static const std::string DeviceClassIdentifier;
static const char* DefaultProbeIdentifier;
static const char* ProbeAndDepthSeperator;
static const std::string US_INTERFACE_NAME;
static const std::string US_PROPKEY_DEVICENAME;
static const std::string US_PROPKEY_CLASS;
static const std::string US_PROPKEY_ID;
mitkClassMacro(AbstractUltrasoundTrackerDevice, mitk::ImageSource);
mitkNewMacro3Param(AbstractUltrasoundTrackerDevice, USDevice::Pointer, itk::SmartPointer<NavigationDataSource>, bool);
itkGetMacro(UltrasoundDevice, itk::SmartPointer<USDevice>);
itkSetMacro(UltrasoundDevice, itk::SmartPointer<USDevice>);
itkGetMacro(TrackingDeviceDataSource, itk::SmartPointer<NavigationDataSource>);
itkSetMacro(TrackingDeviceDataSource, itk::SmartPointer<NavigationDataSource>);
itkGetMacro(IsTrackedUltrasoundActive, bool);
/**
* \brief Getter for calibration data of the currently active depth and probe.
*
* \return Transformation for calibration or null if no calibration is available.
*/
AffineTransform3D::Pointer GetCalibration();
/**
* \brief Getter for calibration data of the given depth and the currently active probe.
*
* \param depth depth of the b mode ultrasound image for which the calibration should be returned
* \return Transformation for calibration or null if no calibration is available.
*/
AffineTransform3D::Pointer GetCalibration(std::string depth);
/**
* \brief Getter for calibration data of the given depth and probe.
*
* \param depth depth of the b mode ultrasound image for which the calibration should be returned
* \param probe probe of the ultrasound device for which the calibration should be returned
* \return Transformation for calibration or null if no calibration is available.
*/
AffineTransform3D::Pointer GetCalibration(std::string depth, std::string probe);
+ /** Returns the index to world transform of the US plane. */
+ virtual AffineTransform3D::Pointer GetUSPlaneTransform();
+
/**
* \brief Sets a transformation as calibration data.
* Calibration data is set for the currently activated probe and their current
* zoom factor. It also marks the device as calibrated.
*/
void SetCalibration(AffineTransform3D::Pointer calibration);
/**
* \brief Removes the calibration data of the currently active depth and probe.
* \return true on success, false if there was no calibration
*/
bool RemoveCalibration();
/**
* \brief Removes the calibration data of the given depth and the currently active probe.
*
* \param depth depth of the b mode ultrasound image for which the calibration should be removed
* \return true on success, false if there was no calibration
*/
bool RemoveCalibration(std::string depth);
/**
* \brief Removes the calibration data of the given depth and probe.
*
* \param depth depth of the b mode ultrasound image for which the calibration should be removed
* \param probe probe of the ultrasound device for which the calibration should be removed
* \return true on success, false if there was no calibration
*/
bool RemoveCalibration(std::string depth, std::string probe);
/**
* \brief Returns the Class of the Device.
*/
std::string GetDeviceClass();
/**
* \brief Wrapper for returning USImageSource of the UltrasoundDevice.
*/
USImageSource::Pointer GetUSImageSource();
itk::SmartPointer<mitk::NavigationDataSource> GetNavigationDataSource();
/**
* \return true if the device is calibrated for the currently selected probe with the current zoom level
*/
bool GetIsCalibratedForCurrentStatus();
/**
* \return true if a calibration was loaded for at least one probe and depth
*/
bool GetContainsAtLeastOneCalibration();
/**
* \brief Serializes all contained calibrations into an xml fragment.
*
* The returned string contains one parent node named "calibrations" and several
* subnodes, one for each calibration that is present.
*/
std::string SerializeCalibration();
/**
* \brief Deserializes a string provided by a prior call to Serialize().
* If the bool flag is true, all prior calibrations will be deleted.
* If the flag is set to false, prior calibrations will be retained, but overwritten
* if one of equal name is present.
*
* \throws mitk::Exception if the given string could not be parsed correctly.
*/
void DeserializeCalibration(const std::string &xmlString, bool clearPreviousCalibrations = true);
void SetNumberOfSmoothingValues(unsigned int numberOfSmoothingValues);
void SetDelayCount(unsigned int delayCount);
/**
* \brief Remove this device from the micro service.
* This method is public for mitk::USCombinedModality, because this devices
* can be completly removed. This is not possible for API devices, which
* should be available while their sub module is loaded.
*/
void UnregisterOnService();
virtual void RegisterAsMicroservice();
/**
* \brief Wrapper for returning custom control interface of the UltrasoundDevice.
*/
virtual itk::SmartPointer<USAbstractControlInterface> GetControlInterfaceCustom();
/**
* \brief Wrapper for returning B mode control interface of the UltrasoundDevice.
*/
virtual itk::SmartPointer<USControlInterfaceBMode> GetControlInterfaceBMode();
/**
* \brief Wrapper for returning probes control interface of the UltrasoundDevice.
*/
virtual itk::SmartPointer<USControlInterfaceProbes> GetControlInterfaceProbes();
/**
* \brief Wrapper for returning doppler control interface of the UltrasoundDevice.
*/
virtual itk::SmartPointer<USControlInterfaceDoppler> GetControlInterfaceDoppler();
protected:
AbstractUltrasoundTrackerDevice( USDevice::Pointer usDevice,
itk::SmartPointer<NavigationDataSource> trackingDevice,
bool trackedUltrasoundActive );
virtual ~AbstractUltrasoundTrackerDevice();
/**
* \brief Grabs the next frame from the input.
* Must be implemented by the derived class.
* This method is called internally, whenever Update() is invoked by an Output.
*/
virtual void GenerateData() override;
std::string GetIdentifierForCurrentCalibration();
std::string GetIdentifierForCurrentProbe();
std::string GetCurrentDepthValue();
void RebuildFilterPipeline();
USDevice::Pointer m_UltrasoundDevice;
itk::SmartPointer<NavigationDataSource> m_TrackingDeviceDataSource;
std::map<std::string, AffineTransform3D::Pointer> m_Calibrations;
itk::SmartPointer<mitk::NavigationDataSmoothingFilter> m_SmoothingFilter;
itk::SmartPointer<mitk::NavigationDataDelayFilter> m_DelayFilter;
itk::SmartPointer<mitk::NavigationDataDisplacementFilter> m_DisplacementFilter;
itk::SmartPointer<mitk::NavigationDataSource> m_LastFilterOfIGTPipeline;
unsigned int m_NumberOfSmoothingValues;
unsigned int m_DelayCount;
/**
* \brief The device's ServiceRegistration object that allows to modify it's Microservice registraton details.
*/
us::ServiceRegistration<Self> m_ServiceRegistration;
/**
* \brief Properties of the device's Microservice.
*/
us::ServiceProperties m_ServiceProperties;
private:
bool m_IsTrackedUltrasoundActive;
};
} // namespace mitk
MITK_DECLARE_SERVICE_INTERFACE(mitk::AbstractUltrasoundTrackerDevice, "org.mitk.services.AbstractUltrasoundTrackerDevice")
#endif
diff --git a/Modules/US/USNavigation/mitkTrackedUltrasound.cpp b/Modules/US/USNavigation/mitkTrackedUltrasound.cpp
index 774b3d9150..d8abef4d52 100644
--- a/Modules/US/USNavigation/mitkTrackedUltrasound.cpp
+++ b/Modules/US/USNavigation/mitkTrackedUltrasound.cpp
@@ -1,79 +1,84 @@
/*===================================================================
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 "mitkTrackedUltrasound.h"
#include "mitkImageReadAccessor.h"
#include <mitkNavigationDataSmoothingFilter.h>
#include <mitkNavigationDataDelayFilter.h>
#include "mitkNavigationDataDisplacementFilter.h"
#include "mitkTrackingDeviceSource.h"
mitk::TrackedUltrasound::TrackedUltrasound( USDevice::Pointer usDevice,
NavigationDataSource::Pointer trackingDevice,
bool trackedUltrasoundActive )
: AbstractUltrasoundTrackerDevice( usDevice, trackingDevice, trackedUltrasoundActive )
{
}
mitk::TrackedUltrasound::~TrackedUltrasound()
{
}
+mitk::AffineTransform3D::Pointer mitk::TrackedUltrasound::GetUSPlaneTransform()
+{
+ return m_UltrasoundDevice->GetOutput(0)->GetGeometry()->GetIndexToWorldTransform();
+}
+
void mitk::TrackedUltrasound::GenerateData()
{
//Call Update auf US-Device + evtl. auf Tracker (???)
if (m_UltrasoundDevice->GetIsFreezed()) { return; } //if the image is freezed: do nothing
//get next image from ultrasound image source
//FOR LATER: Be aware if the for loop behaves correct, if the UltrasoundDevice has more than 1 output.
int i = 0;
m_UltrasoundDevice->Update();
mitk::Image::Pointer image = m_UltrasoundDevice->GetOutput(i);
if (image.IsNull() || !image->IsInitialized()) //check the image
{
MITK_WARN << "Invalid image in TrackedUltrasound, aborting!";
return;
}
//___MITK_INFO << "GetSpacing: " << image->GetGeometry()->GetSpacing();
//get output and initialize it if it wasn't initialized before
mitk::Image::Pointer output = this->GetOutput(i);
if (!output->IsInitialized()) { output->Initialize(image); }
//now update image data
mitk::ImageReadAccessor inputReadAccessor(image, image->GetSliceData(0, 0, 0));
output->SetSlice(inputReadAccessor.GetData()); //copy image data
output->GetGeometry()->SetSpacing(image->GetGeometry()->GetSpacing()); //copy spacing because this might also change
//and update calibration (= transformation of the image)
std::string calibrationKey = this->GetIdentifierForCurrentCalibration();
if (!calibrationKey.empty())
{
std::map<std::string, mitk::AffineTransform3D::Pointer>::iterator calibrationIterator
= m_Calibrations.find(calibrationKey);
if (calibrationIterator != m_Calibrations.end())
{
// transform image according to callibration if one is set
// for current configuration of probe and depth
m_DisplacementFilter->SetTransformation(calibrationIterator->second);
//Setze Update auf Displacementfilter ????
}
}
}
diff --git a/Modules/US/USNavigation/mitkTrackedUltrasound.h b/Modules/US/USNavigation/mitkTrackedUltrasound.h
index e05f650bd5..6395e63cb0 100644
--- a/Modules/US/USNavigation/mitkTrackedUltrasound.h
+++ b/Modules/US/USNavigation/mitkTrackedUltrasound.h
@@ -1,66 +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.
===================================================================*/
#ifndef __mitkTrackedUltrasound_h
#define __mitkTrackedUltrasound_h
#include <MitkUSNavigationExports.h>
#include "mitkUSDevice.h"
#include "mitkImageSource.h"
#include "mitkAbstractUltrasoundTrackerDevice.h"
#include "mitkNavigationDataSource.h"
namespace itk {
template<class T> class SmartPointer;
}
namespace mitk {
/**
* \brief Combination of USDevice and NavigationDataSource.
* This class can be used as an ImageSource subclass. Additionally tracking data be
* retrieved from the NavigationDataSource returned by GetTrackingDevice().
*
* A calibration of the ultrasound image stream to the navigation datas can be set
* for the currently active zoom level (of the ultrasound device) by SetCalibration().
* The ultrasound images are transformed according to this calibration in the
* GenerateData() method.
*/
class MITKUSNAVIGATION_EXPORT TrackedUltrasound : public mitk::AbstractUltrasoundTrackerDevice
{
public:
mitkClassMacro(TrackedUltrasound, mitk::AbstractUltrasoundTrackerDevice);
mitkNewMacro3Param(TrackedUltrasound, USDevice::Pointer, itk::SmartPointer<NavigationDataSource>, bool);
+ virtual AffineTransform3D::Pointer GetUSPlaneTransform();
protected:
TrackedUltrasound( USDevice::Pointer usDevice,
itk::SmartPointer<NavigationDataSource> trackingDevice,
bool trackedUltrasoundActive = true );
virtual ~TrackedUltrasound();
/**
* \brief Grabs the next frame from the input.
* This method is called internally, whenever Update() is invoked by an Output.
*/
void GenerateData() override;
};
} // namespace mitk
#endif // __mitkTrackedUltrasound_h
diff --git a/Modules/US/USNavigation/mitkUSCombinedModality.cpp b/Modules/US/USNavigation/mitkUSCombinedModality.cpp
index b7c23d1470..4c9a33053c 100644
--- a/Modules/US/USNavigation/mitkUSCombinedModality.cpp
+++ b/Modules/US/USNavigation/mitkUSCombinedModality.cpp
@@ -1,77 +1,84 @@
/*===================================================================
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 "mitkUSCombinedModality.h"
#include "mitkImageReadAccessor.h"
-#include <mitkNavigationDataSmoothingFilter.h>
-#include <mitkNavigationDataDelayFilter.h>
#include "mitkTrackingDeviceSource.h"
+#include "mitkUSCombinedModality.h"
+#include <mitkNavigationDataDelayFilter.h>
+#include <mitkNavigationDataSmoothingFilter.h>
// US Control Interfaces
-#include "mitkUSControlInterfaceProbes.h"
#include "mitkUSControlInterfaceBMode.h"
#include "mitkUSControlInterfaceDoppler.h"
+#include "mitkUSControlInterfaceProbes.h"
-mitk::USCombinedModality::USCombinedModality( USDevice::Pointer usDevice,
- NavigationDataSource::Pointer trackingDevice,
- bool trackedUltrasoundActive )
- : AbstractUltrasoundTrackerDevice( usDevice, trackingDevice, trackedUltrasoundActive )
+mitk::USCombinedModality::USCombinedModality(USDevice::Pointer usDevice,
+ NavigationDataSource::Pointer trackingDevice,
+ bool trackedUltrasoundActive)
+ : AbstractUltrasoundTrackerDevice(usDevice, trackingDevice, trackedUltrasoundActive)
{
}
-
-mitk::USCombinedModality::~USCombinedModality()
+mitk::AffineTransform3D::Pointer mitk::USCombinedModality::GetUSPlaneTransform()
{
+ return this->GetCalibration();
}
+mitk::USCombinedModality::~USCombinedModality() {}
void mitk::USCombinedModality::GenerateData()
{
- if (m_UltrasoundDevice->GetIsFreezed()) { return; } //if the image is freezed: do nothing
-
- //get next image from ultrasound image source
- //FOR LATER: Be aware if the for loop behaves correct, if the UltrasoundDevice has more than 1 output.
+ if (m_UltrasoundDevice->GetIsFreezed())
+ {
+ return;
+ } // if the image is freezed: do nothing
+
+ // get next image from ultrasound image source
+ // FOR LATER: Be aware if the for loop behaves correct, if the UltrasoundDevice has more than 1 output.
int i = 0;
m_UltrasoundDevice->Update();
mitk::Image::Pointer image = m_UltrasoundDevice->GetOutput(0);
- if (image.IsNull() || !image->IsInitialized()) //check the image
+ if (image.IsNull() || !image->IsInitialized()) // check the image
{
MITK_WARN << "Invalid image in USCombinedModality, aborting!";
return;
}
- //get output and initialize it if it wasn't initialized before
+ // get output and initialize it if it wasn't initialized before
mitk::Image::Pointer output = this->GetOutput();
- if (!output->IsInitialized()) { output->Initialize(image); }
+ if (!output->IsInitialized())
+ {
+ output->Initialize(image);
+ }
- //now update image data
+ // now update image data
mitk::ImageReadAccessor inputReadAccessor(image, image->GetSliceData(0, 0, 0));
- output->SetSlice(inputReadAccessor.GetData()); //copy image data
- output->GetGeometry()->SetSpacing(image->GetGeometry()->GetSpacing()); //copy spacing because this might also change
+ output->SetSlice(inputReadAccessor.GetData()); // copy image data
+ output->GetGeometry()->SetSpacing(image->GetGeometry()->GetSpacing()); // copy spacing because this might also change
- //and update calibration (= transformation of the image)
+ // and update calibration (= transformation of the image)
std::string calibrationKey = this->GetIdentifierForCurrentCalibration();
if (!calibrationKey.empty())
{
- std::map<std::string, mitk::AffineTransform3D::Pointer>::iterator calibrationIterator
- = m_Calibrations.find(calibrationKey);
+ std::map<std::string, mitk::AffineTransform3D::Pointer>::iterator calibrationIterator =
+ m_Calibrations.find(calibrationKey);
if (calibrationIterator != m_Calibrations.end())
{
// transform image according to callibration if one is set
// for current configuration of probe and depth
this->GetOutput()->GetGeometry()->SetIndexToWorldTransform(calibrationIterator->second);
}
}
}
diff --git a/Modules/US/USNavigation/mitkUSCombinedModality.h b/Modules/US/USNavigation/mitkUSCombinedModality.h
index d9f5c3ae62..60963adcaf 100644
--- a/Modules/US/USNavigation/mitkUSCombinedModality.h
+++ b/Modules/US/USNavigation/mitkUSCombinedModality.h
@@ -1,71 +1,72 @@
/*===================================================================
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 MITKUSCombinedModality_H_HEADER_INCLUDED_
#define MITKUSCombinedModality_H_HEADER_INCLUDED_
#include <MitkUSNavigationExports.h>
#include "mitkUSDevice.h"
#include "mitkImageSource.h"
#include "mitkAbstractUltrasoundTrackerDevice.h"
#include "mitkNavigationDataSource.h"
// Microservices
#include <mitkServiceInterface.h>
#include <usServiceRegistration.h>
namespace itk {
template<class T> class SmartPointer;
}
namespace mitk {
class USControlInterfaceBMode;
class USControlInterfaceProbes;
class USControlInterfaceDoppler;
/**
* \brief Combination of USDevice and NavigationDataSource.
* This class can be used as an ImageSource subclass. Additionally tracking data be
* retrieved from the NavigationDataSource returned by GetTrackingDevice().
*
* A calibration of the ultrasound image stream to the navigation datas can be set
* for the currently active zoom level (of the ultrasound device) by SetCalibration().
* The ultrasound images are transformed according to this calibration in the
* GenerateData() method.
*/
class MITKUSNAVIGATION_EXPORT USCombinedModality : public mitk::AbstractUltrasoundTrackerDevice
{
public:
mitkClassMacro(USCombinedModality, mitk::AbstractUltrasoundTrackerDevice);
mitkNewMacro3Param(USCombinedModality, USDevice::Pointer, itk::SmartPointer<NavigationDataSource>, bool);
+ virtual AffineTransform3D::Pointer GetUSPlaneTransform();
protected:
USCombinedModality( USDevice::Pointer usDevice,
itk::SmartPointer<NavigationDataSource> trackingDevice,
bool trackedUltrasoundActive = false );
virtual ~USCombinedModality();
/**
* \brief Grabs the next frame from the input.
* This method is called internally, whenever Update() is invoked by an Output.
*/
void GenerateData() override;
};
} // namespace mitk
#endif // MITKUSCombinedModality_H_HEADER_INCLUDED_
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 4cc5291594..86635094b7 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,294 +1,294 @@
/*===================================================================
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 "../QmitkUSNavigationMarkerPlacement.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_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());
+ //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(QmitkUSNavigationMarkerPlacement::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()
{
if (this->GetCombinedModality(false).IsNull()) return;
// 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());
m_NeedleProjectionFilter->Update();
//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::AbstractUltrasoundTrackerDevice::Pointer combinedModality = this->GetCombinedModality(false);
if ( combinedModality.IsNotNull() )
{
m_NeedleProjectionFilter->ConnectTo(combinedModality->GetNavigationDataSource());
// set calibration of the combined modality to the needle projection filter
- mitk::AffineTransform3D::Pointer calibration = combinedModality->GetCalibration();
- if ( calibration.IsNotNull() )
+ mitk::AffineTransform3D::Pointer usPlaneTransform = combinedModality->GetUSPlaneTransform();
+ if (usPlaneTransform.IsNotNull())
{
- m_NeedleProjectionFilter->SetTargetPlane(calibration);
+ m_NeedleProjectionFilter->SetTargetPlane(usPlaneTransform);
}
}
else
{
MITK_WARN << "CombinedModality is null!";
}
}
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;}
}