diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/Filter/mitkFloatingImageToUltrasoundRegistrationFilter.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/Filter/mitkFloatingImageToUltrasoundRegistrationFilter.cpp
index ff6c61e7fb..2f199dec32 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/Filter/mitkFloatingImageToUltrasoundRegistrationFilter.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/Filter/mitkFloatingImageToUltrasoundRegistrationFilter.cpp
@@ -1,196 +1,205 @@
/*===================================================================
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 "mitkFloatingImageToUltrasoundRegistrationFilter.h"
#include <itkScalableAffineTransform.h>
#include <itkScalableAffineTransform.hxx>
mitk::FloatingImageToUltrasoundRegistrationFilter::FloatingImageToUltrasoundRegistrationFilter()
: mitk::NavigationDataPassThroughFilter(),
m_Segmentation(nullptr),
m_TransformMarkerCSToSensorCS(mitk::AffineTransform3D::New()),
m_TransformMarkerCSToFloatingImageCS(mitk::AffineTransform3D::New()),
m_TransformUSimageCSToTrackingCS(mitk::AffineTransform3D::New()),
m_TransformCTimageIndexToWorld(mitk::AffineTransform3D::New()),
m_TrackedUltrasoundActive(false)
{
m_SurfaceGeometry = mitk::Geometry3D::New();
m_PointSet = nullptr;
m_CTimage = mitk::Image::New();
}
mitk::FloatingImageToUltrasoundRegistrationFilter::~FloatingImageToUltrasoundRegistrationFilter()
{
}
void mitk::FloatingImageToUltrasoundRegistrationFilter::InitializeTransformationMarkerCSToSensorCS( bool useNdiTracker)
{
//The following calculations are related to the 3mm | 15mm fiducial configuration
m_TransformMarkerCSToSensorCS = mitk::AffineTransform3D::New();
if (useNdiTracker) // Use the NDI disc tracker for performing the CT-to-US registration:
{
MITK_INFO << "Use NDI disc tracker for performing the CT-to-US-registration";
mitk::Vector3D translationNDI;
translationNDI[0] = 15.000;
translationNDI[1] = 8.000;
translationNDI[2] = -2.500; // use -2.500 instead of 0.000 for the z translation if working with v2 of the
// sensor adapter.
m_TransformMarkerCSToSensorCS->SetOffset(translationNDI);
// Quaternion (x, y, z, r) --> n = (0,0,1) --> q(0,0,sin(90�),cos(90�))
mitk::Quaternion qNDI(0, 0, 1, 0); // corresponding to a rotation of 180� around the normal z-axis.
// .transpose() is needed for changing the rows and the columns of the returned rotation_matrix_transpose
vnl_matrix_fixed<double, 3, 3> vnl_rotation = qNDI.rotation_matrix_transpose().transpose(); // :-)
mitk::Matrix3D rotationMatrix;
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
rotationMatrix[i][j] = vnl_rotation[i][j];
}
}
m_TransformMarkerCSToSensorCS->SetMatrix(rotationMatrix);
}
else // Use the polhemus RX2 tracker for performing the CT-to-US registration:
{
MITK_INFO << "Use Polhemus RX2 tracker for performing the CT-to-US-registration";
mitk::Vector3D translationPolhemus;
translationPolhemus[0] = -18.175;
translationPolhemus[1] = 15.000;
translationPolhemus[2] = 10.501; // considering a distance from the base plate of 0.315 inch and not 0.313 inch
// use 10.501 instead of 8.001 for the z translation if working with v2 of the
// sensor adapter.
m_TransformMarkerCSToSensorCS->SetOffset(translationPolhemus);
// Quaternion (x, y, z, r) --> n = (1,0,0) --> q(sin(90�),0,0,cos(90�))
mitk::Quaternion q1(1, 0, 0, 0); // corresponding to a rotation of 180� around the normal x-axis.
// .transpose() is needed for changing the rows and the columns of the returned rotation_matrix_transpose
vnl_matrix_fixed<double, 3, 3> vnl_rotation = q1.rotation_matrix_transpose().transpose(); // :-)
mitk::Matrix3D rotationMatrix;
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
rotationMatrix[i][j] = vnl_rotation[i][j];
}
}
m_TransformMarkerCSToSensorCS->SetMatrix(rotationMatrix);
}
//The transformation from the sensor-CS to the marker-CS is calculated now.
}
void mitk::FloatingImageToUltrasoundRegistrationFilter::SetSegmentation(mitk::DataNode::Pointer segmentationNode, mitk::Image::Pointer ctimage)
{
m_Segmentation = segmentationNode;
m_TransformCTimageIndexToWorld = m_Segmentation->GetData()->GetGeometry()->GetIndexToWorldTransform();
m_CTimage = ctimage;
}
void mitk::FloatingImageToUltrasoundRegistrationFilter::SetSurface(mitk::DataNode::Pointer surfaceNode)
{
m_Surface = surfaceNode;
m_SurfaceGeometry = m_Surface->GetData()->GetGeometry();
}
void mitk::FloatingImageToUltrasoundRegistrationFilter::SetPointSet(mitk::DataNode::Pointer pointSetNode)
{
m_PointSet = pointSetNode;
}
void mitk::FloatingImageToUltrasoundRegistrationFilter::SetTransformMarkerCSToFloatingImageCS(mitk::AffineTransform3D::Pointer transform)
{
m_TransformMarkerCSToFloatingImageCS = transform;
}
void mitk::FloatingImageToUltrasoundRegistrationFilter::SetTransformUSimageCSToTrackingCS(mitk::AffineTransform3D::Pointer transform)
{
m_TransformUSimageCSToTrackingCS = transform;
}
void mitk::FloatingImageToUltrasoundRegistrationFilter::GenerateData()
{
Superclass::GenerateData();
if (m_TrackedUltrasoundActive)
{
MITK_WARN << "The CT-to-US-registration is not supported by tracked ultrasound, yet.";
return;
}
//IMPORTANT --- Hard coded --- First device = EM-Sensor | eventually second device = needle
mitk::NavigationData::Pointer transformSensorCSToTracking = this->GetOutput(0);
// cancel, if the EM-sensor is currently not being tracked
if (!transformSensorCSToTracking->IsDataValid())
{
return;
}
//We start the transformation with a new transform:
mitk::AffineTransform3D::Pointer totalTransformation = mitk::AffineTransform3D::New();
totalTransformation->SetIdentity();
//Compose it with the inverse transform of marker-CS to floating image-CS:
MITK_INFO << "Marker-to-CT Transform:" << m_TransformMarkerCSToFloatingImageCS;
totalTransformation->Compose(this->GetInverseTransform(m_TransformMarkerCSToFloatingImageCS)); //CT->Marker
MITK_INFO << "CT-to-Marker Transform:" << totalTransformation;
MITK_INFO << "Marker-to-Sensor Transform:" << m_TransformMarkerCSToSensorCS;
//Compose this with the inverse transform of EM-sensor-CS to marker-CS:
totalTransformation->Compose(m_TransformMarkerCSToSensorCS); //CT->Marker(Marker->Sensor) => CT->Sensor
MITK_INFO << "CT-to-Sensor Transform:" << totalTransformation;
//Compose this with the transform of the sensor-CS to Tracking-CS:
totalTransformation->Compose(transformSensorCSToTracking->GetAffineTransform3D());
//Compose this with the inverse transform of USimage-CS to tracking-CS:
totalTransformation->Modified();
//Finally, set the total transformation (from floatingImage-CS to US-image-CS
// to the selected floatingImageSurface:
//m_Segmentation->GetData()->GetGeometry()->SetIndexToWorldTransform(totalTransformation);
//m_Segmentation->Modified();
//m_CTimage->GetGeometry()->SetIndexToWorldTransform(totalTransformation);
//m_CTimage->Modified();
m_Surface->GetData()->GetGeometry()->SetIndexToWorldTransform(totalTransformation);
m_Surface->Modified();
m_PointSet->GetData()->GetGeometry()->SetIndexToWorldTransform(totalTransformation);
m_PointSet->Modified();
+
+ for (mitk::DataNode::Pointer node : m_additionalSurfaces) {
+ node->GetData()->GetGeometry()->SetIndexToWorldTransform(totalTransformation);
+ node->Modified();
+ }
+}
+
+void mitk::FloatingImageToUltrasoundRegistrationFilter::AddAdditionalSurface(mitk::DataNode::Pointer newSurfaceNode) {
+ m_additionalSurfaces.push_back(newSurfaceNode);
}
mitk::AffineTransform3D::Pointer mitk::FloatingImageToUltrasoundRegistrationFilter::GetInverseTransform(mitk::AffineTransform3D::Pointer transform)
{
mitk::AffineTransform3D::Pointer inverseTransform = mitk::AffineTransform3D::New();
mitk::AffineTransform3D::Pointer inverse = dynamic_cast<mitk::AffineTransform3D*>(transform->GetInverseTransform().GetPointer());
//itk::SmartPointer<itk::ScalableAffineTransform<mitk::ScalarType, 3U>> inverse = dynamic_cast<itk::ScalableAffineTransform<mitk::ScalarType, 3U>*> (transform->GetInverseTransform().GetPointer()); //itkScalableAffineTransform_hxx
if (inverse.IsNull())
{
MITK_WARN << "Could not get inverse transform of mitk::AffineTransform3D. Returning nullptr";
return nullptr;
}
inverseTransform->SetOffset(inverse->GetOffset());
inverseTransform->SetMatrix(inverse->GetMatrix());
return inverseTransform;
}
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/Filter/mitkFloatingImageToUltrasoundRegistrationFilter.h b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/Filter/mitkFloatingImageToUltrasoundRegistrationFilter.h
index e2cc461cc1..9a4f38b046 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/Filter/mitkFloatingImageToUltrasoundRegistrationFilter.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/Filter/mitkFloatingImageToUltrasoundRegistrationFilter.h
@@ -1,74 +1,76 @@
/*===================================================================
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 MITKFLOATINGIMAGETOULTRASOUNDREGISTRATIONFILTER_H_HEADER_INCLUDED_
#define MITKFLOATINGIMAGETOULTRASOUNDREGISTRATIONFILTER_H_HEADER_INCLUDED_
#include <mitkNavigationDataPassThroughFilter.h>
#include <mitkImage.h>
namespace mitk
{
/**Documentation
* \brief This filter transforms a given floating image into the ultrasound coordinate system.
*
*
* \ingroup US
*/
class FloatingImageToUltrasoundRegistrationFilter : public NavigationDataPassThroughFilter
{
public:
mitkClassMacro(FloatingImageToUltrasoundRegistrationFilter, NavigationDataPassThroughFilter);
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
void InitializeTransformationMarkerCSToSensorCS( bool useNdiTracker = false );
void SetSegmentation(mitk::DataNode::Pointer segmentationNode, mitk::Image::Pointer ctimage);
void SetSurface(mitk::DataNode::Pointer surfaceNode);
void SetPointSet(mitk::DataNode::Pointer pointSetNode);
void SetTransformMarkerCSToFloatingImageCS( mitk::AffineTransform3D::Pointer transform );
void SetTransformUSimageCSToTrackingCS(mitk::AffineTransform3D::Pointer transform);
+ void AddAdditionalSurface(mitk::DataNode::Pointer newSurfaceNode);
protected:
FloatingImageToUltrasoundRegistrationFilter();
~FloatingImageToUltrasoundRegistrationFilter() override;
/**Documentation
* \brief filter execute method
*
*
*/
void GenerateData() override;
mitk::AffineTransform3D::Pointer GetInverseTransform(mitk::AffineTransform3D::Pointer transform);
private:
mitk::DataNode::Pointer m_Segmentation;
mitk::DataNode::Pointer m_Surface;
+ std::vector <mitk::DataNode::Pointer> m_additionalSurfaces;
mitk::DataNode::Pointer m_PointSet;
mitk::Image::Pointer m_CTimage;
mitk::AffineTransform3D::Pointer m_TransformMarkerCSToSensorCS;
mitk::AffineTransform3D::Pointer m_TransformMarkerCSToFloatingImageCS;
mitk::AffineTransform3D::Pointer m_TransformUSimageCSToTrackingCS;
mitk::AffineTransform3D::Pointer m_TransformCTimageIndexToWorld;
mitk::BaseGeometry::Pointer m_SurfaceGeometry;
bool m_TrackedUltrasoundActive;
};
} // namespace mitk
#endif // MITKFLOATINGIMAGETOULTRASOUNDREGISTRATIONFILTER_H_HEADER_INCLUDED_
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCtUsRegistration.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCtUsRegistration.cpp
index 63768bee3e..987d610bdf 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCtUsRegistration.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCtUsRegistration.cpp
@@ -1,2020 +1,2064 @@
/*===================================================================
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 "QmitkUSNavigationStepCtUsRegistration.h"
#include "ui_QmitkUSNavigationStepCtUsRegistration.h"
#include <QMessageBox>
-#include "mitkNodeDisplacementFilter.h"
#include "../Filter/mitkFloatingImageToUltrasoundRegistrationFilter.h"
#include "../QmitkUSNavigationMarkerPlacement.h"
+#include "mitkNodeDisplacementFilter.h"
-
-
-#include <mitkNodePredicateNot.h>
-#include <mitkNodePredicateProperty.h>
-#include <mitkLabelSetImage.h>
#include "mitkProperties.h"
#include <mitkImage.h>
#include <mitkImageCast.h>
+#include <mitkLabelSetImage.h>
+#include <mitkNodePredicateNot.h>
+#include <mitkNodePredicateProperty.h>
#include <mitkRenderingManager.h>
#include <mitkStaticIGTHelperFunctions.h>
#include <vtkLandmarkTransform.h>
#include <vtkPoints.h>
-#include <itkImageRegionIterator.h>
#include <itkGeometryUtilities.h>
+#include <itkImageRegionIterator.h>
#include <mitkImagePixelReadAccessor.h>
-#include <itkZeroCrossingImageFilter.h>
-#include <itkSimpleContourExtractorImageFilter.h>
#include <itkCannyEdgeDetectionImageFilter.h>
+#include <itkSimpleContourExtractorImageFilter.h>
+#include <itkZeroCrossingImageFilter.h>
-static const int NUMBER_FIDUCIALS_NEEDED = 8;
+static const int NUMBER_FIDUCIALS_NEEDED = 8;
-QmitkUSNavigationStepCtUsRegistration::QmitkUSNavigationStepCtUsRegistration(QWidget *parent) :
- QmitkUSAbstractNavigationStep(parent),
- ui(new Ui::QmitkUSNavigationStepCtUsRegistration),
- m_PerformingGroundTruthProtocolEvaluation(false),
- m_FloatingImageToUltrasoundRegistrationFilter(nullptr),
- m_FreezeCombinedModality(false)
+QmitkUSNavigationStepCtUsRegistration::QmitkUSNavigationStepCtUsRegistration(QWidget *parent)
+ : QmitkUSAbstractNavigationStep(parent),
+ ui(new Ui::QmitkUSNavigationStepCtUsRegistration),
+ m_PerformingGroundTruthProtocolEvaluation(false),
+ m_FloatingImageToUltrasoundRegistrationFilter(nullptr),
+ m_FreezeCombinedModality(false),
+ m_UpdateRunning(false)
{
this->UnsetFloatingImageGeometry();
this->DefineDataStorageImageFilter();
this->CreateQtPartControl(this);
}
-
QmitkUSNavigationStepCtUsRegistration::~QmitkUSNavigationStepCtUsRegistration()
{
delete ui;
}
bool QmitkUSNavigationStepCtUsRegistration::OnStartStep()
{
MITK_INFO << "OnStartStep()";
return true;
}
bool QmitkUSNavigationStepCtUsRegistration::OnStopStep()
{
MITK_INFO << "OnStopStep()";
return true;
}
bool QmitkUSNavigationStepCtUsRegistration::OnFinishStep()
{
MITK_INFO << "OnFinishStep()";
return true;
}
bool QmitkUSNavigationStepCtUsRegistration::OnActivateStep()
{
MITK_INFO << "OnActivateStep()";
ui->floatingImageComboBox->SetDataStorage(this->GetDataStorage());
ui->ctImagesToChooseComboBox->SetDataStorage(this->GetDataStorage());
ui->segmentationComboBox->SetDataStorage(this->GetDataStorage());
ui->selectedSurfaceComboBox->SetDataStorage(this->GetDataStorage());
ui->pointSetComboBox->SetDataStorage(this->GetDataStorage());
- m_FloatingImageToUltrasoundRegistrationFilter =
- mitk::FloatingImageToUltrasoundRegistrationFilter::New();
+ m_FloatingImageToUltrasoundRegistrationFilter = mitk::FloatingImageToUltrasoundRegistrationFilter::New();
return true;
}
bool QmitkUSNavigationStepCtUsRegistration::OnDeactivateStep()
{
MITK_INFO << "OnDeactivateStep()";
return true;
}
void QmitkUSNavigationStepCtUsRegistration::OnUpdate()
{
- if (m_NavigationDataSource.IsNull()) { return; }
-
- m_NavigationDataSource->Update();
- m_FloatingImageToUltrasoundRegistrationFilter->Update();
+ if (m_NavigationDataSource.IsNull() || !m_UpdateRunning)
+ {
+ return;
+ }
+ else
+ {
+ m_NavigationDataSource->Update();
+ m_FloatingImageToUltrasoundRegistrationFilter->Update();
+ }
}
-void QmitkUSNavigationStepCtUsRegistration::OnSettingsChanged(const itk::SmartPointer<mitk::DataNode> settingsNode)
-{
-
-}
+void QmitkUSNavigationStepCtUsRegistration::OnSettingsChanged(const itk::SmartPointer<mitk::DataNode> settingsNode) {}
QString QmitkUSNavigationStepCtUsRegistration::GetTitle()
{
return "CT-to-US registration";
}
QmitkUSAbstractNavigationStep::FilterVector QmitkUSNavigationStepCtUsRegistration::GetFilter()
{
return FilterVector();
}
void QmitkUSNavigationStepCtUsRegistration::OnSetCombinedModality()
{
mitk::AbstractUltrasoundTrackerDevice::Pointer combinedModality = this->GetCombinedModality(false);
if (combinedModality.IsNotNull())
{
m_NavigationDataSource = combinedModality->GetNavigationDataSource();
}
-
}
void QmitkUSNavigationStepCtUsRegistration::UnsetFloatingImageGeometry()
{
m_ImageDimension[0] = 0;
m_ImageDimension[1] = 0;
m_ImageDimension[2] = 0;
m_ImageSpacing[0] = 1;
m_ImageSpacing[1] = 1;
m_ImageSpacing[2] = 1;
}
-void QmitkUSNavigationStepCtUsRegistration::SetFloatingImageGeometryInformation(mitk::Image * image)
+void QmitkUSNavigationStepCtUsRegistration::SetFloatingImageGeometryInformation(mitk::Image *image)
{
m_ImageDimension[0] = image->GetDimension(0);
m_ImageDimension[1] = image->GetDimension(1);
m_ImageDimension[2] = image->GetDimension(2);
m_ImageSpacing[0] = image->GetGeometry()->GetSpacing()[0];
m_ImageSpacing[1] = image->GetGeometry()->GetSpacing()[1];
m_ImageSpacing[2] = image->GetGeometry()->GetSpacing()[2];
}
double QmitkUSNavigationStepCtUsRegistration::GetVoxelVolume()
{
if (m_FloatingImage.IsNull())
{
return 0.0;
}
MITK_INFO << "ImageSpacing = " << m_ImageSpacing;
return m_ImageSpacing[0] * m_ImageSpacing[1] * m_ImageSpacing[2];
}
double QmitkUSNavigationStepCtUsRegistration::GetFiducialVolume(double radius)
{
return 1.333333333 * 3.141592 * (radius * radius * radius);
}
bool QmitkUSNavigationStepCtUsRegistration::FilterFloatingImage()
{
if (m_FloatingImage.IsNull())
{
return false;
}
ImageType::Pointer itkImage1 = ImageType::New();
mitk::CastToItkImage(m_FloatingImage, itkImage1);
this->InitializeImageFilters();
m_ThresholdFilter->SetInput(itkImage1);
m_LaplacianFilter1->SetInput(m_ThresholdFilter->GetOutput());
m_LaplacianFilter2->SetInput(m_LaplacianFilter1->GetOutput());
m_BinaryThresholdFilter->SetInput(m_LaplacianFilter2->GetOutput());
m_HoleFillingFilter->SetInput(m_BinaryThresholdFilter->GetOutput());
m_BinaryImageToShapeLabelMapFilter->SetInput(m_HoleFillingFilter->GetOutput());
m_BinaryImageToShapeLabelMapFilter->Update();
ImageType::Pointer binaryImage = ImageType::New();
binaryImage = m_HoleFillingFilter->GetOutput();
this->EliminateTooSmallLabeledObjects(binaryImage);
- //mitk::CastToMitkImage(binaryImage, m_FloatingImage);
+ // mitk::CastToMitkImage(binaryImage, m_FloatingImage);
return true;
}
void QmitkUSNavigationStepCtUsRegistration::InitializeImageFilters()
{
- //Initialize threshold filters
+ // Initialize threshold filters
m_ThresholdFilter = itk::ThresholdImageFilter<ImageType>::New();
m_ThresholdFilter->SetOutsideValue(0);
m_ThresholdFilter->SetLower(500);
m_ThresholdFilter->SetUpper(3200);
- //Initialize binary threshold filter 1
+ // Initialize binary threshold filter 1
m_BinaryThresholdFilter = BinaryThresholdImageFilterType::New();
m_BinaryThresholdFilter->SetOutsideValue(0);
m_BinaryThresholdFilter->SetInsideValue(1);
m_BinaryThresholdFilter->SetLowerThreshold(350);
m_BinaryThresholdFilter->SetUpperThreshold(10000);
- //Initialize laplacian recursive gaussian image filter
+ // Initialize laplacian recursive gaussian image filter
m_LaplacianFilter1 = LaplacianRecursiveGaussianImageFilterType::New();
m_LaplacianFilter2 = LaplacianRecursiveGaussianImageFilterType::New();
- //Initialize binary hole filling filter
+ // Initialize binary hole filling filter
m_HoleFillingFilter = VotingBinaryIterativeHoleFillingImageFilterType::New();
VotingBinaryIterativeHoleFillingImageFilterType::InputSizeType radius;
radius.Fill(1);
m_HoleFillingFilter->SetRadius(radius);
m_HoleFillingFilter->SetBackgroundValue(0);
m_HoleFillingFilter->SetForegroundValue(1);
m_HoleFillingFilter->SetMaximumNumberOfIterations(5);
- //Initialize binary image to shape label map filter
+ // Initialize binary image to shape label map filter
m_BinaryImageToShapeLabelMapFilter = BinaryImageToShapeLabelMapFilterType::New();
m_BinaryImageToShapeLabelMapFilter->SetInputForegroundValue(1);
}
double QmitkUSNavigationStepCtUsRegistration::GetCharacteristicDistanceAWithUpperMargin()
{
switch (ui->fiducialMarkerConfigurationComboBox->currentIndex())
{
// case 0 is equal to fiducial marker configuration A (10mm distance)
case 0:
return 12.07;
// case 1 is equal to fiducial marker configuration B (15mm distance)
case 1:
return 18.105;
// case 2 is equal to fiducial marker configuration C (20mm distance)
case 2:
return 24.14;
}
return 0.0;
}
double QmitkUSNavigationStepCtUsRegistration::GetCharacteristicDistanceBWithLowerMargin()
{
switch (ui->fiducialMarkerConfigurationComboBox->currentIndex())
{
- // case 0 is equal to fiducial marker configuration A (10mm distance)
- case 0:
- return 12.07;
+ // case 0 is equal to fiducial marker configuration A (10mm distance)
+ case 0:
+ return 12.07;
- // case 1 is equal to fiducial marker configuration B (15mm distance)
- case 1:
- return 18.105;
+ // case 1 is equal to fiducial marker configuration B (15mm distance)
+ case 1:
+ return 18.105;
- // case 2 is equal to fiducial marker configuration C (20mm distance)
- case 2:
- return 24.14;
+ // case 2 is equal to fiducial marker configuration C (20mm distance)
+ case 2:
+ return 24.14;
}
return 0.0;
}
double QmitkUSNavigationStepCtUsRegistration::GetCharacteristicDistanceBWithUpperMargin()
{
switch (ui->fiducialMarkerConfigurationComboBox->currentIndex())
{
- // case 0 is equal to fiducial marker configuration A (10mm distance)
- case 0:
- return 15.73;
+ // case 0 is equal to fiducial marker configuration A (10mm distance)
+ case 0:
+ return 15.73;
- // case 1 is equal to fiducial marker configuration B (15mm distance)
- case 1:
- return 23.595;
+ // case 1 is equal to fiducial marker configuration B (15mm distance)
+ case 1:
+ return 23.595;
- // case 2 is equal to fiducial marker configuration C (20mm distance)
- case 2:
- return 31.46;
+ // case 2 is equal to fiducial marker configuration C (20mm distance)
+ case 2:
+ return 31.46;
}
return 0.0;
}
double QmitkUSNavigationStepCtUsRegistration::GetMinimalFiducialConfigurationDistance()
{
switch (ui->fiducialMarkerConfigurationComboBox->currentIndex())
{
- // case 0 is equal to fiducial marker configuration A (10mm distance)
- case 0:
- return 10.0;
+ // case 0 is equal to fiducial marker configuration A (10mm distance)
+ case 0:
+ return 10.0;
- // case 1 is equal to fiducial marker configuration B (15mm distance)
- case 1:
- return 15.0;
+ // case 1 is equal to fiducial marker configuration B (15mm distance)
+ case 1:
+ return 15.0;
- // case 2 is equal to fiducial marker configuration C (20mm distance)
- case 2:
- return 20.0;
+ // case 2 is equal to fiducial marker configuration C (20mm distance)
+ case 2:
+ return 20.0;
}
return 0.0;
}
void QmitkUSNavigationStepCtUsRegistration::CreateMarkerModelCoordinateSystemPointSet()
{
if (m_MarkerModelCoordinateSystemPointSet.IsNull())
{
m_MarkerModelCoordinateSystemPointSet = mitk::PointSet::New();
}
else
{
m_MarkerModelCoordinateSystemPointSet->Clear();
}
mitk::Point3D fiducial1;
mitk::Point3D fiducial2;
mitk::Point3D fiducial3;
mitk::Point3D fiducial4;
mitk::Point3D fiducial5;
mitk::Point3D fiducial6;
mitk::Point3D fiducial7;
mitk::Point3D fiducial8;
-
-
switch (ui->fiducialMarkerConfigurationComboBox->currentIndex())
{
- // case 0 is equal to fiducial marker configuration A (10mm distance)
- case 0:
- fiducial1[0] = 0;
- fiducial1[1] = 0;
- fiducial1[2] = 0;
-
- fiducial2[0] = 0;
- fiducial2[1] = 10;
- fiducial2[2] = 0;
-
- fiducial3[0] = 10;
- fiducial3[1] = 0;
- fiducial3[2] = 0;
-
- fiducial4[0] = 20;
- fiducial4[1] = 20;
- fiducial4[2] = 0;
-
- fiducial5[0] = 0;
- fiducial5[1] = 20;
- fiducial5[2] = 10;
-
- fiducial6[0] = 10;
- fiducial6[1] = 20;
- fiducial6[2] = 10;
-
- fiducial7[0] = 20;
- fiducial7[1] = 10;
- fiducial7[2] = 10;
-
- fiducial8[0] = 20;
- fiducial8[1] = 0;
- fiducial8[2] = 10;
- break;
- // case 1 is equal to fiducial marker configuration B (15mm distance)
- case 1:
- fiducial1[0] = 0;
- fiducial1[1] = 0;
- fiducial1[2] = 0;
-
- fiducial2[0] = 0;
- fiducial2[1] = 15;
- fiducial2[2] = 0;
-
- fiducial3[0] = 15;
- fiducial3[1] = 0;
- fiducial3[2] = 0;
-
- fiducial4[0] = 30;
- fiducial4[1] = 30;
- fiducial4[2] = 0;
-
- fiducial5[0] = 0;
- fiducial5[1] = 30;
- fiducial5[2] = 15;
-
- fiducial6[0] = 15;
- fiducial6[1] = 30;
- fiducial6[2] = 15;
-
- fiducial7[0] = 30;
- fiducial7[1] = 15;
- fiducial7[2] = 15;
-
- fiducial8[0] = 30;
- fiducial8[1] = 0;
- fiducial8[2] = 15;
- break;
- // case 2 is equal to fiducial marker configuration C (20mm distance)
- case 2:
- fiducial1[0] = 0;
- fiducial1[1] = 0;
- fiducial1[2] = 0;
+ // case 0 is equal to fiducial marker configuration A (10mm distance)
+ case 0:
+ fiducial1[0] = 0;
+ fiducial1[1] = 0;
+ fiducial1[2] = 0;
+
+ fiducial2[0] = 0;
+ fiducial2[1] = 10;
+ fiducial2[2] = 0;
+
+ fiducial3[0] = 10;
+ fiducial3[1] = 0;
+ fiducial3[2] = 0;
- fiducial2[0] = 0;
- fiducial2[1] = 20;
- fiducial2[2] = 0;
+ fiducial4[0] = 20;
+ fiducial4[1] = 20;
+ fiducial4[2] = 0;
- fiducial3[0] = 20;
- fiducial3[1] = 0;
- fiducial3[2] = 0;
+ fiducial5[0] = 0;
+ fiducial5[1] = 20;
+ fiducial5[2] = 10;
- fiducial4[0] = 40;
- fiducial4[1] = 40;
- fiducial4[2] = 0;
+ fiducial6[0] = 10;
+ fiducial6[1] = 20;
+ fiducial6[2] = 10;
- fiducial5[0] = 0;
- fiducial5[1] = 40;
- fiducial5[2] = 20;
+ fiducial7[0] = 20;
+ fiducial7[1] = 10;
+ fiducial7[2] = 10;
+
+ fiducial8[0] = 20;
+ fiducial8[1] = 0;
+ fiducial8[2] = 10;
+ break;
+ // case 1 is equal to fiducial marker configuration B (15mm distance)
+ case 1:
+ fiducial1[0] = 0;
+ fiducial1[1] = 0;
+ fiducial1[2] = 0;
- fiducial6[0] = 20;
- fiducial6[1] = 40;
- fiducial6[2] = 20;
+ fiducial2[0] = 0;
+ fiducial2[1] = 15;
+ fiducial2[2] = 0;
- fiducial7[0] = 40;
- fiducial7[1] = 20;
- fiducial7[2] = 20;
+ fiducial3[0] = 15;
+ fiducial3[1] = 0;
+ fiducial3[2] = 0;
- fiducial8[0] = 40;
- fiducial8[1] = 0;
- fiducial8[2] = 20;
- break;
+ fiducial4[0] = 30;
+ fiducial4[1] = 30;
+ fiducial4[2] = 0;
+
+ fiducial5[0] = 0;
+ fiducial5[1] = 30;
+ fiducial5[2] = 15;
+
+ fiducial6[0] = 15;
+ fiducial6[1] = 30;
+ fiducial6[2] = 15;
+
+ fiducial7[0] = 30;
+ fiducial7[1] = 15;
+ fiducial7[2] = 15;
+
+ fiducial8[0] = 30;
+ fiducial8[1] = 0;
+ fiducial8[2] = 15;
+ break;
+ // case 2 is equal to fiducial marker configuration C (20mm distance)
+ case 2:
+ fiducial1[0] = 0;
+ fiducial1[1] = 0;
+ fiducial1[2] = 0;
+
+ fiducial2[0] = 0;
+ fiducial2[1] = 20;
+ fiducial2[2] = 0;
+
+ fiducial3[0] = 20;
+ fiducial3[1] = 0;
+ fiducial3[2] = 0;
+
+ fiducial4[0] = 40;
+ fiducial4[1] = 40;
+ fiducial4[2] = 0;
+
+ fiducial5[0] = 0;
+ fiducial5[1] = 40;
+ fiducial5[2] = 20;
+
+ fiducial6[0] = 20;
+ fiducial6[1] = 40;
+ fiducial6[2] = 20;
+
+ fiducial7[0] = 40;
+ fiducial7[1] = 20;
+ fiducial7[2] = 20;
+
+ fiducial8[0] = 40;
+ fiducial8[1] = 0;
+ fiducial8[2] = 20;
+ break;
}
m_MarkerModelCoordinateSystemPointSet->InsertPoint(0, fiducial1);
m_MarkerModelCoordinateSystemPointSet->InsertPoint(1, fiducial2);
m_MarkerModelCoordinateSystemPointSet->InsertPoint(2, fiducial3);
m_MarkerModelCoordinateSystemPointSet->InsertPoint(3, fiducial4);
m_MarkerModelCoordinateSystemPointSet->InsertPoint(4, fiducial5);
m_MarkerModelCoordinateSystemPointSet->InsertPoint(5, fiducial6);
m_MarkerModelCoordinateSystemPointSet->InsertPoint(6, fiducial7);
m_MarkerModelCoordinateSystemPointSet->InsertPoint(7, fiducial8);
/*mitk::DataNode::Pointer node = this->GetDataStorage()->GetNamedNode("Marker Model Coordinate System Point Set");
if (node == nullptr)
{
node = mitk::DataNode::New();
node->SetName("Marker Model Coordinate System Point Set");
node->SetData(m_MarkerModelCoordinateSystemPointSet);
this->GetDataStorage()->Add(node);
}
else
{
node->SetData(m_MarkerModelCoordinateSystemPointSet);
this->GetDataStorage()->Modified();
}*/
}
void QmitkUSNavigationStepCtUsRegistration::InitializePointsToTransformForGroundTruthProtocol()
{
-
m_PointsToTransformGroundTruthProtocol.clear();
mitk::Point3D point0mm;
mitk::Point3D point20mm;
mitk::Point3D point40mm;
mitk::Point3D point60mm;
mitk::Point3D point80mm;
mitk::Point3D point100mm;
point0mm[0] = 0.0;
point0mm[1] = 0.0;
point0mm[2] = 0.0;
point20mm[0] = 0.0;
point20mm[1] = 0.0;
point20mm[2] = 0.0;
point40mm[0] = 0.0;
point40mm[1] = 0.0;
point40mm[2] = 0.0;
point60mm[0] = 0.0;
point60mm[1] = 0.0;
point60mm[2] = 0.0;
point80mm[0] = 0.0;
point80mm[1] = 0.0;
point80mm[2] = 0.0;
point100mm[0] = 0.0;
point100mm[1] = 0.0;
point100mm[2] = 0.0;
m_PointsToTransformGroundTruthProtocol.insert(std::pair<int, mitk::Point3D>(0, point0mm));
m_PointsToTransformGroundTruthProtocol.insert(std::pair<int, mitk::Point3D>(20, point20mm));
m_PointsToTransformGroundTruthProtocol.insert(std::pair<int, mitk::Point3D>(40, point40mm));
m_PointsToTransformGroundTruthProtocol.insert(std::pair<int, mitk::Point3D>(60, point60mm));
m_PointsToTransformGroundTruthProtocol.insert(std::pair<int, mitk::Point3D>(80, point80mm));
m_PointsToTransformGroundTruthProtocol.insert(std::pair<int, mitk::Point3D>(100, point100mm));
}
void QmitkUSNavigationStepCtUsRegistration::CreatePointsToTransformForGroundTruthProtocol()
{
this->InitializePointsToTransformForGroundTruthProtocol();
switch (ui->fiducialMarkerConfigurationComboBox->currentIndex())
{
- // case 0 is equal to fiducial marker configuration A (10mm distance)
- case 0:
- MITK_WARN << "For this marker configuration (10mm) there does not exist a point to transform.";
- break;
- // case 1 is equal to fiducial marker configuration B (15mm distance)
- case 1:
- m_PointsToTransformGroundTruthProtocol.at(0)[0] = 130; // = 30mm to end of clipping plate + 100 mm to middle axis of measurement plate
- m_PointsToTransformGroundTruthProtocol.at(0)[1] = 15;
- m_PointsToTransformGroundTruthProtocol.at(0)[2] = -7; // = 5mm distance to clipping plate + 2mm to base
-
- m_PointsToTransformGroundTruthProtocol.at(20)[0] = 130;
- m_PointsToTransformGroundTruthProtocol.at(20)[1] = 15;
- m_PointsToTransformGroundTruthProtocol.at(20)[2] = -27; // = 5mm distance to clipping plate + 2mm to base + 20mm depth
-
- m_PointsToTransformGroundTruthProtocol.at(40)[0] = 130;
- m_PointsToTransformGroundTruthProtocol.at(40)[1] = 15;
- m_PointsToTransformGroundTruthProtocol.at(40)[2] = -47; // = 5mm distance to clipping plate + 2mm to base + 40mm depth
-
- m_PointsToTransformGroundTruthProtocol.at(60)[0] = 130;
- m_PointsToTransformGroundTruthProtocol.at(60)[1] = 15;
- m_PointsToTransformGroundTruthProtocol.at(60)[2] = -67; // = 5mm distance to clipping plate + 2mm to base + 60mm depth
-
- m_PointsToTransformGroundTruthProtocol.at(80)[0] = 130;
- m_PointsToTransformGroundTruthProtocol.at(80)[1] = 15;
- m_PointsToTransformGroundTruthProtocol.at(80)[2] = -87; // = 5mm distance to clipping plate + 2mm to base + 80mm depth
-
- m_PointsToTransformGroundTruthProtocol.at(100)[0] = 130;
- m_PointsToTransformGroundTruthProtocol.at(100)[1] = 15;
- m_PointsToTransformGroundTruthProtocol.at(100)[2] = -107; // = 5mm distance to clipping plate + 2mm to base + 100mm depth
-
- break;
- // case 2 is equal to fiducial marker configuration C (20mm distance)
- case 2:
- m_PointsToTransformGroundTruthProtocol.at(0)[0] = 135; // = 20 + 15mm to end of clipping plate + 100 mm to middle axis of measurement plate
- m_PointsToTransformGroundTruthProtocol.at(0)[1] = 20;
- m_PointsToTransformGroundTruthProtocol.at(0)[2] = -9; // = 7mm distance to clipping plate + 2mm to base
-
- m_PointsToTransformGroundTruthProtocol.at(20)[0] = 135;
- m_PointsToTransformGroundTruthProtocol.at(20)[1] = 20;
- m_PointsToTransformGroundTruthProtocol.at(20)[2] = -29; // = 7mm distance to clipping plate + 2mm to base + 20mm depth
-
- m_PointsToTransformGroundTruthProtocol.at(40)[0] = 135;
- m_PointsToTransformGroundTruthProtocol.at(40)[1] = 20;
- m_PointsToTransformGroundTruthProtocol.at(40)[2] = -49; // = 7mm distance to clipping plate + 2mm to base + 40mm depth
-
- m_PointsToTransformGroundTruthProtocol.at(60)[0] = 135;
- m_PointsToTransformGroundTruthProtocol.at(60)[1] = 20;
- m_PointsToTransformGroundTruthProtocol.at(60)[2] = -69; // = 7mm distance to clipping plate + 2mm to base + 60mm depth
-
- m_PointsToTransformGroundTruthProtocol.at(80)[0] = 135;
- m_PointsToTransformGroundTruthProtocol.at(80)[1] = 20;
- m_PointsToTransformGroundTruthProtocol.at(80)[2] = -89; // = 7mm distance to clipping plate + 2mm to base + 80mm depth
+ // case 0 is equal to fiducial marker configuration A (10mm distance)
+ case 0:
+ MITK_WARN << "For this marker configuration (10mm) there does not exist a point to transform.";
+ break;
+ // case 1 is equal to fiducial marker configuration B (15mm distance)
+ case 1:
+ m_PointsToTransformGroundTruthProtocol.at(0)[0] =
+ 130; // = 30mm to end of clipping plate + 100 mm to middle axis of measurement plate
+ m_PointsToTransformGroundTruthProtocol.at(0)[1] = 15;
+ m_PointsToTransformGroundTruthProtocol.at(0)[2] = -7; // = 5mm distance to clipping plate + 2mm to base
+
+ m_PointsToTransformGroundTruthProtocol.at(20)[0] = 130;
+ m_PointsToTransformGroundTruthProtocol.at(20)[1] = 15;
+ m_PointsToTransformGroundTruthProtocol.at(20)[2] =
+ -27; // = 5mm distance to clipping plate + 2mm to base + 20mm depth
+
+ m_PointsToTransformGroundTruthProtocol.at(40)[0] = 130;
+ m_PointsToTransformGroundTruthProtocol.at(40)[1] = 15;
+ m_PointsToTransformGroundTruthProtocol.at(40)[2] =
+ -47; // = 5mm distance to clipping plate + 2mm to base + 40mm depth
+
+ m_PointsToTransformGroundTruthProtocol.at(60)[0] = 130;
+ m_PointsToTransformGroundTruthProtocol.at(60)[1] = 15;
+ m_PointsToTransformGroundTruthProtocol.at(60)[2] =
+ -67; // = 5mm distance to clipping plate + 2mm to base + 60mm depth
+
+ m_PointsToTransformGroundTruthProtocol.at(80)[0] = 130;
+ m_PointsToTransformGroundTruthProtocol.at(80)[1] = 15;
+ m_PointsToTransformGroundTruthProtocol.at(80)[2] =
+ -87; // = 5mm distance to clipping plate + 2mm to base + 80mm depth
+
+ m_PointsToTransformGroundTruthProtocol.at(100)[0] = 130;
+ m_PointsToTransformGroundTruthProtocol.at(100)[1] = 15;
+ m_PointsToTransformGroundTruthProtocol.at(100)[2] =
+ -107; // = 5mm distance to clipping plate + 2mm to base + 100mm depth
- m_PointsToTransformGroundTruthProtocol.at(100)[0] = 135;
- m_PointsToTransformGroundTruthProtocol.at(100)[1] = 20;
- m_PointsToTransformGroundTruthProtocol.at(100)[2] = -109; // = 7mm distance to clipping plate + 2mm to base + 100mm depth
- break;
+ break;
+ // case 2 is equal to fiducial marker configuration C (20mm distance)
+ case 2:
+ m_PointsToTransformGroundTruthProtocol.at(0)[0] =
+ 135; // = 20 + 15mm to end of clipping plate + 100 mm to middle axis of measurement plate
+ m_PointsToTransformGroundTruthProtocol.at(0)[1] = 20;
+ m_PointsToTransformGroundTruthProtocol.at(0)[2] = -9; // = 7mm distance to clipping plate + 2mm to base
+
+ m_PointsToTransformGroundTruthProtocol.at(20)[0] = 135;
+ m_PointsToTransformGroundTruthProtocol.at(20)[1] = 20;
+ m_PointsToTransformGroundTruthProtocol.at(20)[2] =
+ -29; // = 7mm distance to clipping plate + 2mm to base + 20mm depth
+
+ m_PointsToTransformGroundTruthProtocol.at(40)[0] = 135;
+ m_PointsToTransformGroundTruthProtocol.at(40)[1] = 20;
+ m_PointsToTransformGroundTruthProtocol.at(40)[2] =
+ -49; // = 7mm distance to clipping plate + 2mm to base + 40mm depth
+
+ m_PointsToTransformGroundTruthProtocol.at(60)[0] = 135;
+ m_PointsToTransformGroundTruthProtocol.at(60)[1] = 20;
+ m_PointsToTransformGroundTruthProtocol.at(60)[2] =
+ -69; // = 7mm distance to clipping plate + 2mm to base + 60mm depth
+
+ m_PointsToTransformGroundTruthProtocol.at(80)[0] = 135;
+ m_PointsToTransformGroundTruthProtocol.at(80)[1] = 20;
+ m_PointsToTransformGroundTruthProtocol.at(80)[2] =
+ -89; // = 7mm distance to clipping plate + 2mm to base + 80mm depth
+
+ m_PointsToTransformGroundTruthProtocol.at(100)[0] = 135;
+ m_PointsToTransformGroundTruthProtocol.at(100)[1] = 20;
+ m_PointsToTransformGroundTruthProtocol.at(100)[2] =
+ -109; // = 7mm distance to clipping plate + 2mm to base + 100mm depth
+ break;
}
}
void QmitkUSNavigationStepCtUsRegistration::TransformPointsGroundTruthProtocol()
{
if (m_GroundTruthProtocolTransformedPoints.find(0) == m_GroundTruthProtocolTransformedPoints.end())
{
mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
- pointSet->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(0)));
+ pointSet->InsertPoint(
+ m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(0)));
m_GroundTruthProtocolTransformedPoints.insert(std::pair<int, mitk::PointSet::Pointer>(0, pointSet));
}
else
{
- m_GroundTruthProtocolTransformedPoints.at(0)->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(0)));
+ m_GroundTruthProtocolTransformedPoints.at(0)->InsertPoint(
+ m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(0)));
}
if (m_GroundTruthProtocolTransformedPoints.find(20) == m_GroundTruthProtocolTransformedPoints.end())
{
mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
- pointSet->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(20)));
+ pointSet->InsertPoint(
+ m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(20)));
m_GroundTruthProtocolTransformedPoints.insert(std::pair<int, mitk::PointSet::Pointer>(20, pointSet));
}
else
{
- m_GroundTruthProtocolTransformedPoints.at(20)->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(20)));
+ m_GroundTruthProtocolTransformedPoints.at(20)->InsertPoint(
+ m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(20)));
}
if (m_GroundTruthProtocolTransformedPoints.find(40) == m_GroundTruthProtocolTransformedPoints.end())
{
mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
- pointSet->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(40)));
+ pointSet->InsertPoint(
+ m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(40)));
m_GroundTruthProtocolTransformedPoints.insert(std::pair<int, mitk::PointSet::Pointer>(40, pointSet));
}
else
{
- m_GroundTruthProtocolTransformedPoints.at(40)->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(40)));
+ m_GroundTruthProtocolTransformedPoints.at(40)->InsertPoint(
+ m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(40)));
}
if (m_GroundTruthProtocolTransformedPoints.find(60) == m_GroundTruthProtocolTransformedPoints.end())
{
mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
- pointSet->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(60)));
+ pointSet->InsertPoint(
+ m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(60)));
m_GroundTruthProtocolTransformedPoints.insert(std::pair<int, mitk::PointSet::Pointer>(60, pointSet));
}
else
{
- m_GroundTruthProtocolTransformedPoints.at(60)->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(60)));
+ m_GroundTruthProtocolTransformedPoints.at(60)->InsertPoint(
+ m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(60)));
}
if (m_GroundTruthProtocolTransformedPoints.find(80) == m_GroundTruthProtocolTransformedPoints.end())
{
mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
- pointSet->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(80)));
+ pointSet->InsertPoint(
+ m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(80)));
m_GroundTruthProtocolTransformedPoints.insert(std::pair<int, mitk::PointSet::Pointer>(80, pointSet));
}
else
{
- m_GroundTruthProtocolTransformedPoints.at(80)->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(80)));
+ m_GroundTruthProtocolTransformedPoints.at(80)->InsertPoint(
+ m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(80)));
}
if (m_GroundTruthProtocolTransformedPoints.find(100) == m_GroundTruthProtocolTransformedPoints.end())
{
mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
- pointSet->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(100)));
+ pointSet->InsertPoint(
+ m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(100)));
m_GroundTruthProtocolTransformedPoints.insert(std::pair<int, mitk::PointSet::Pointer>(100, pointSet));
}
else
{
- m_GroundTruthProtocolTransformedPoints.at(100)->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(100)));
+ m_GroundTruthProtocolTransformedPoints.at(100)->InsertPoint(
+ m_TransformMarkerCSToFloatingImageCS->TransformPoint(m_PointsToTransformGroundTruthProtocol.at(100)));
}
-
}
void QmitkUSNavigationStepCtUsRegistration::AddTransformedPointsToDataStorage()
{
if (m_GroundTruthProtocolTransformedPoints.find(0) == m_GroundTruthProtocolTransformedPoints.end() ||
m_GroundTruthProtocolTransformedPoints.find(20) == m_GroundTruthProtocolTransformedPoints.end() ||
m_GroundTruthProtocolTransformedPoints.find(40) == m_GroundTruthProtocolTransformedPoints.end() ||
m_GroundTruthProtocolTransformedPoints.find(60) == m_GroundTruthProtocolTransformedPoints.end() ||
m_GroundTruthProtocolTransformedPoints.find(80) == m_GroundTruthProtocolTransformedPoints.end() ||
m_GroundTruthProtocolTransformedPoints.find(100) == m_GroundTruthProtocolTransformedPoints.end())
{
QMessageBox msgBox;
msgBox.setText("Cannot add transformed Points to DataStorage because they do not exist.\
Stopping evaluation the protocol.");
msgBox.exec();
return;
}
std::string nameNode0mm = "GroundTruthProt-Depth0mm";
std::string nameNode20mm = "GroundTruthProt-Depth20mm";
std::string nameNode40mm = "GroundTruthProt-Depth40mm";
std::string nameNode60mm = "GroundTruthProt-Depth60mm";
std::string nameNode80mm = "GroundTruthProt-Depth80mm";
std::string nameNode100mm = "GroundTruthProt-Depth100mm";
- //Add transformed points of depth 0mm to the data storage
+ // Add transformed points of depth 0mm to the data storage
mitk::DataNode::Pointer node0mm = this->GetDataStorage()->GetNamedNode(nameNode0mm);
if (node0mm.IsNull())
{
node0mm = mitk::DataNode::New();
node0mm->SetName(nameNode0mm);
node0mm->SetData(m_GroundTruthProtocolTransformedPoints.at(0));
this->GetDataStorage()->Add(node0mm);
}
else
{
node0mm->SetData(m_GroundTruthProtocolTransformedPoints.at(0));
this->GetDataStorage()->Modified();
}
- if(ui->protocolEvaluationTypeComboBox->currentText().compare("PLANE") == 0 )
+ if (ui->protocolEvaluationTypeComboBox->currentText().compare("PLANE") == 0)
{
- //Add transformed points of depth 20mm to the data storage
+ // Add transformed points of depth 20mm to the data storage
mitk::DataNode::Pointer node20mm = this->GetDataStorage()->GetNamedNode(nameNode20mm);
if (node20mm.IsNull())
{
node20mm = mitk::DataNode::New();
node20mm->SetName(nameNode20mm);
node20mm->SetData(m_GroundTruthProtocolTransformedPoints.at(20));
this->GetDataStorage()->Add(node20mm);
}
else
{
node20mm->SetData(m_GroundTruthProtocolTransformedPoints.at(20));
this->GetDataStorage()->Modified();
}
- //Add transformed points of depth 40mm to the data storage
+ // Add transformed points of depth 40mm to the data storage
mitk::DataNode::Pointer node40mm = this->GetDataStorage()->GetNamedNode(nameNode40mm);
if (node40mm.IsNull())
{
node40mm = mitk::DataNode::New();
node40mm->SetName(nameNode40mm);
node40mm->SetData(m_GroundTruthProtocolTransformedPoints.at(40));
this->GetDataStorage()->Add(node40mm);
}
else
{
node40mm->SetData(m_GroundTruthProtocolTransformedPoints.at(40));
this->GetDataStorage()->Modified();
}
- //Add transformed points of depth 60mm to the data storage
+ // Add transformed points of depth 60mm to the data storage
mitk::DataNode::Pointer node60mm = this->GetDataStorage()->GetNamedNode(nameNode60mm);
if (node60mm.IsNull())
{
node60mm = mitk::DataNode::New();
node60mm->SetName(nameNode60mm);
node60mm->SetData(m_GroundTruthProtocolTransformedPoints.at(60));
this->GetDataStorage()->Add(node60mm);
}
else
{
node60mm->SetData(m_GroundTruthProtocolTransformedPoints.at(60));
this->GetDataStorage()->Modified();
}
- //Add transformed points of depth 80mm to the data storage
+ // Add transformed points of depth 80mm to the data storage
mitk::DataNode::Pointer node80mm = this->GetDataStorage()->GetNamedNode(nameNode80mm);
if (node80mm.IsNull())
{
node80mm = mitk::DataNode::New();
node80mm->SetName(nameNode80mm);
node80mm->SetData(m_GroundTruthProtocolTransformedPoints.at(80));
this->GetDataStorage()->Add(node80mm);
}
else
{
node80mm->SetData(m_GroundTruthProtocolTransformedPoints.at(80));
this->GetDataStorage()->Modified();
}
- //Add transformed points of depth 100mm to the data storage
+ // Add transformed points of depth 100mm to the data storage
mitk::DataNode::Pointer node100mm = this->GetDataStorage()->GetNamedNode(nameNode100mm);
if (node100mm.IsNull())
{
node100mm = mitk::DataNode::New();
node100mm->SetName(nameNode100mm);
node100mm->SetData(m_GroundTruthProtocolTransformedPoints.at(100));
this->GetDataStorage()->Add(node100mm);
}
else
{
node100mm->SetData(m_GroundTruthProtocolTransformedPoints.at(100));
this->GetDataStorage()->Modified();
}
}
- //Do a global reinit
+ // Do a global reinit
mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(this->GetDataStorage());
}
double QmitkUSNavigationStepCtUsRegistration::CalculateMeanFRE()
{
double meanFRE = 0.0;
for (int counter = 0; counter < m_GroundTruthProtocolFRE.size(); ++counter)
{
meanFRE += m_GroundTruthProtocolFRE[counter];
}
return meanFRE / m_GroundTruthProtocolFRE.size();
}
double QmitkUSNavigationStepCtUsRegistration::CalculateStandardDeviationOfFRE(double meanFRE)
{
double variance = 0.0;
for (int counter = 0; counter < m_GroundTruthProtocolFRE.size(); ++counter)
{
variance += ((meanFRE - m_GroundTruthProtocolFRE[counter]) * (meanFRE - m_GroundTruthProtocolFRE[counter]));
}
- variance /= m_GroundTruthProtocolFRE.size(); // calculate the empirical variance (n) and not the sampling variance (n-1)
+ variance /=
+ m_GroundTruthProtocolFRE.size(); // calculate the empirical variance (n) and not the sampling variance (n-1)
return sqrt(variance);
}
void QmitkUSNavigationStepCtUsRegistration::CalculateGroundTruthProtocolTRE()
{
if (m_GroundTruthProtocolTransformedPoints.find(0) == m_GroundTruthProtocolTransformedPoints.end() ||
- m_GroundTruthProtocolTransformedPoints.find(20) == m_GroundTruthProtocolTransformedPoints.end() ||
- m_GroundTruthProtocolTransformedPoints.find(40) == m_GroundTruthProtocolTransformedPoints.end() ||
- m_GroundTruthProtocolTransformedPoints.find(60) == m_GroundTruthProtocolTransformedPoints.end() ||
- m_GroundTruthProtocolTransformedPoints.find(80) == m_GroundTruthProtocolTransformedPoints.end() ||
- m_GroundTruthProtocolTransformedPoints.find(100) == m_GroundTruthProtocolTransformedPoints.end())
+ m_GroundTruthProtocolTransformedPoints.find(20) == m_GroundTruthProtocolTransformedPoints.end() ||
+ m_GroundTruthProtocolTransformedPoints.find(40) == m_GroundTruthProtocolTransformedPoints.end() ||
+ m_GroundTruthProtocolTransformedPoints.find(60) == m_GroundTruthProtocolTransformedPoints.end() ||
+ m_GroundTruthProtocolTransformedPoints.find(80) == m_GroundTruthProtocolTransformedPoints.end() ||
+ m_GroundTruthProtocolTransformedPoints.find(100) == m_GroundTruthProtocolTransformedPoints.end())
{
QMessageBox msgBox;
msgBox.setText("Cannot calculate TRE of Ground-Truth-Protocol because points were not transformed.");
msgBox.exec();
return;
}
// clear the std::map containing possibly data of earlier TRE calculations
m_GroundTruthProtocolTRE.clear();
// loop through all existing point sets containing the transformed points
for (int counter = 0;
m_GroundTruthProtocolTransformedPoints.find(counter) != m_GroundTruthProtocolTransformedPoints.end();
counter += 20)
{
- //calculate the middle point of the point set
+ // calculate the middle point of the point set
mitk::PointSet::Pointer pointSet = m_GroundTruthProtocolTransformedPoints.at(counter);
mitk::Point3D middlePoint;
middlePoint[0] = 0.0;
middlePoint[1] = 0.0;
middlePoint[2] = 0.0;
for (int position = 0; position < pointSet->GetSize(); ++position)
{
middlePoint[0] += pointSet->GetPoint(position)[0];
middlePoint[1] += pointSet->GetPoint(position)[1];
middlePoint[2] += pointSet->GetPoint(position)[2];
}
middlePoint[0] /= pointSet->GetSize();
middlePoint[1] /= pointSet->GetSize();
middlePoint[2] /= pointSet->GetSize();
MITK_INFO << "Calculated MiddlePoint: " << middlePoint;
- //sum up the euclidean distances between the middle point and each transformed point
+ // sum up the euclidean distances between the middle point and each transformed point
double meanDistance = 0.0;
for (int position = 0; position < pointSet->GetSize(); ++position)
{
meanDistance += middlePoint.SquaredEuclideanDistanceTo(pointSet->GetPoint(position));
MITK_INFO << "SquaredEuclideanDistance: " << middlePoint.SquaredEuclideanDistanceTo(pointSet->GetPoint(position));
}
meanDistance /= pointSet->GetSize(); // this can be interpreted as empirical variance
// the root of the empirical variance can be interpreted as the protocols registration TRE
m_GroundTruthProtocolTRE.insert(std::pair<int, double>(counter, sqrt(meanDistance)));
MITK_INFO << "Ground-Truth-Protocol TRE: " << sqrt(meanDistance);
}
-
}
-void QmitkUSNavigationStepCtUsRegistration::EliminateTooSmallLabeledObjects(
- ImageType::Pointer binaryImage)
+void QmitkUSNavigationStepCtUsRegistration::EliminateTooSmallLabeledObjects(ImageType::Pointer binaryImage)
{
BinaryImageToShapeLabelMapFilterType::OutputImageType::Pointer labelMap =
m_BinaryImageToShapeLabelMapFilter->GetOutput();
double voxelVolume = this->GetVoxelVolume();
double fiducialVolume;
unsigned int numberOfPixels;
if (ui->fiducialDiameter3mmRadioButton->isChecked())
{
fiducialVolume = this->GetFiducialVolume(1.5);
numberOfPixels = ceil(fiducialVolume / voxelVolume);
}
else
{
fiducialVolume = this->GetFiducialVolume(2.5);
numberOfPixels = ceil(fiducialVolume / voxelVolume);
}
MITK_INFO << "Voxel Volume = " << voxelVolume << "; Fiducial Volume = " << fiducialVolume;
MITK_INFO << "Number of pixels = " << numberOfPixels;
labelMap = m_BinaryImageToShapeLabelMapFilter->GetOutput();
// The output of this filter is an itk::LabelMap, which contains itk::LabelObject's
MITK_INFO << "There are " << labelMap->GetNumberOfLabelObjects() << " objects.";
// Loop over each region
for (int i = labelMap->GetNumberOfLabelObjects() - 1; i >= 0; --i)
{
// Get the ith region
- BinaryImageToShapeLabelMapFilterType::OutputImageType::LabelObjectType* labelObject = labelMap->GetNthLabelObject(i);
+ BinaryImageToShapeLabelMapFilterType::OutputImageType::LabelObjectType *labelObject =
+ labelMap->GetNthLabelObject(i);
MITK_INFO << "Object " << i << " contains " << labelObject->Size() << " pixel";
- //TODO: Threshold-Wert evtl. experimentell besser abstimmen,
+ // TODO: Threshold-Wert evtl. experimentell besser abstimmen,
// um zu verhindern, dass durch Threshold wahre Fiducial-Kandidaten elimiert werden.
if (labelObject->Size() < numberOfPixels * 0.8)
{
for (unsigned int pixelId = 0; pixelId < labelObject->Size(); pixelId++)
{
binaryImage->SetPixel(labelObject->GetIndex(pixelId), 0);
}
labelMap->RemoveLabelObject(labelObject);
}
}
}
bool QmitkUSNavigationStepCtUsRegistration::EliminateFiducialCandidatesByEuclideanDistances()
{
if (m_CentroidsOfFiducialCandidates.size() < NUMBER_FIDUCIALS_NEEDED)
{
return false;
}
for (int counter = 0; counter < m_CentroidsOfFiducialCandidates.size(); ++counter)
{
int amountOfAcceptedFiducials = 0;
mitk::Point3D fiducialCentroid(m_CentroidsOfFiducialCandidates.at(counter));
- //Loop through all fiducial candidates and calculate the distance between the chosen fiducial
+ // Loop through all fiducial candidates and calculate the distance between the chosen fiducial
// candidate and the other candidates. For each candidate with a right distance between
// Configuration A: 7.93mm and 31.0mm (10 mm distance between fiducial centers) or
// Configuration B: 11.895mm and 45.0mm (15 mm distance between fiducial centers) or
// Configuration C: 15.86mm and 59.0mm (20 mm distance between fiducial centers)
//
// increase the amountOfAcceptedFiducials.
for (int position = 0; position < m_CentroidsOfFiducialCandidates.size(); ++position)
{
if (position == counter)
{
continue;
}
mitk::Point3D otherCentroid(m_CentroidsOfFiducialCandidates.at(position));
double distance = fiducialCentroid.EuclideanDistanceTo(otherCentroid);
switch (ui->fiducialMarkerConfigurationComboBox->currentIndex())
{
// case 0 is equal to fiducial marker configuration A (10mm distance)
case 0:
if (distance > 7.93 && distance < 31.0)
{
++amountOfAcceptedFiducials;
}
break;
// case 1 is equal to fiducial marker configuration B (15mm distance)
case 1:
if (distance > 11.895 && distance < 45.0)
{
++amountOfAcceptedFiducials;
}
break;
// case 2 is equal to fiducial marker configuration C (20mm distance)
case 2:
if (distance > 15.86 && distance < 59.0)
{
++amountOfAcceptedFiducials;
}
break;
}
}
- //The amountOfAcceptedFiducials must be at least 7. Otherwise delete the fiducial candidate
+ // The amountOfAcceptedFiducials must be at least 7. Otherwise delete the fiducial candidate
// from the list of candidates.
if (amountOfAcceptedFiducials < NUMBER_FIDUCIALS_NEEDED - 1)
{
- MITK_INFO << "Deleting fiducial candidate at position: " <<
- m_CentroidsOfFiducialCandidates.at(counter);
+ MITK_INFO << "Deleting fiducial candidate at position: " << m_CentroidsOfFiducialCandidates.at(counter);
m_CentroidsOfFiducialCandidates.erase(m_CentroidsOfFiducialCandidates.begin() + counter);
- if (m_CentroidsOfFiducialCandidates.size() < NUMBER_FIDUCIALS_NEEDED )
+ if (m_CentroidsOfFiducialCandidates.size() < NUMBER_FIDUCIALS_NEEDED)
{
return false;
}
counter = -1;
}
}
- //Classify the rested fiducial candidates by its characteristic Euclidean distances
+ // Classify the rested fiducial candidates by its characteristic Euclidean distances
// between the canidates and remove all candidates with a false distance configuration:
this->ClassifyFiducialCandidates();
return true;
}
void QmitkUSNavigationStepCtUsRegistration::ClassifyFiducialCandidates()
{
MITK_INFO << "ClassifyFiducialCandidates()";
std::vector<int> fiducialCandidatesToBeRemoved;
std::vector<std::vector<double>> distanceVectorsFiducials;
this->CalculateDistancesBetweenFiducials(distanceVectorsFiducials);
for (int counter = 0; counter < distanceVectorsFiducials.size(); ++counter)
{
- int distanceA = 0; // => 10,00mm distance
- int distanceB = 0; // => 14,14mm distance
- int distanceC = 0; // => 17,32mm distance
- int distanceD = 0; // => 22,36mm distance
- int distanceE = 0; // => 24,49mm distance
- int distanceF = 0; // => 28,28mm distance
+ int distanceA = 0; // => 10,00mm distance
+ int distanceB = 0; // => 14,14mm distance
+ int distanceC = 0; // => 17,32mm distance
+ int distanceD = 0; // => 22,36mm distance
+ int distanceE = 0; // => 24,49mm distance
+ int distanceF = 0; // => 28,28mm distance
std::vector<double> &distances = distanceVectorsFiducials.at(counter);
for (int number = 0; number < distances.size(); ++number)
{
double &distance = distances.at(number);
switch (ui->fiducialMarkerConfigurationComboBox->currentIndex())
{
// case 0 is equal to fiducial marker configuration A (10mm distance)
case 0:
if (distance > 7.93 && distance <= 12.07)
{
++distanceA;
}
else if (distance > 12.07 && distance <= 15.73)
{
++distanceB;
}
else if (distance > 15.73 && distance <= 19.84)
{
++distanceC;
}
else if (distance > 19.84 && distance <= 23.425)
{
++distanceD;
}
else if (distance > 23.425 && distance <= 26.385)
{
++distanceE;
}
else if (distance > 26.385 && distance <= 31.00)
{
++distanceF;
}
- break;
+ break;
// case 1 is equal to fiducial marker configuration B (15mm distance)
case 1:
if (distance > 11.895 && distance <= 18.105)
{
++distanceA;
}
else if (distance > 18.105 && distance <= 23.595)
{
++distanceB;
}
else if (distance > 23.595 && distance <= 29.76)
{
++distanceC;
}
else if (distance > 29.76 && distance <= 35.1375)
{
++distanceD;
if (distance > 33.54)
{
++distanceE;
}
}
else if (distance > 35.1375 && distance <= 39.5775)
{
++distanceE;
if (distance < 36.735)
{
++distanceD;
}
}
else if (distance > 39.5775 && distance <= 45.00)
{
++distanceF;
}
- break;
+ break;
// case 2 is equal to fiducial marker configuration C (20mm distance)
case 2:
if (distance > 15.86 && distance <= 24.14)
{
++distanceA;
}
else if (distance > 24.14 && distance <= 31.46)
{
++distanceB;
}
else if (distance > 31.46 && distance <= 39.68)
{
++distanceC;
}
else if (distance > 39.68 && distance <= 46.85)
{
++distanceD;
}
else if (distance > 46.85 && distance <= 52.77)
{
++distanceE;
}
else if (distance > 52.77 && distance <= 59.00)
{
++distanceF;
}
- break;
+ break;
}
- }// End for-loop distances-vector
+ } // End for-loop distances-vector
- //Now, having looped through all distances of one fiducial candidate, check
+ // Now, having looped through all distances of one fiducial candidate, check
// if the combination of different distances is known. The >= is due to the
// possible occurrence of other fiducial candidates that have an distance equal to
// one of the distances A - E. However, false fiducial candidates outside
// the fiducial marker does not have the right distance configuration:
if ((distanceA >= 2 && distanceD >= 2 && distanceE >= 2 && distanceF >= 1 ||
- distanceA >= 1 && distanceB >= 2 && distanceC >= 1 && distanceD >= 2 && distanceE >= 1 ||
- distanceB >= 2 && distanceD >= 4 && distanceF >= 1 ||
- distanceA >= 1 && distanceB >= 1 && distanceD >= 3 && distanceE >= 1 && distanceF >= 1) == false)
+ distanceA >= 1 && distanceB >= 2 && distanceC >= 1 && distanceD >= 2 && distanceE >= 1 ||
+ distanceB >= 2 && distanceD >= 4 && distanceF >= 1 ||
+ distanceA >= 1 && distanceB >= 1 && distanceD >= 3 && distanceE >= 1 && distanceF >= 1) == false)
{
MITK_INFO << "Detected fiducial candidate with unknown distance configuration.";
fiducialCandidatesToBeRemoved.push_back(counter);
}
}
for (int count = fiducialCandidatesToBeRemoved.size() - 1; count >= 0; --count)
{
MITK_INFO << "Removing fiducial candidate " << fiducialCandidatesToBeRemoved.at(count);
- m_CentroidsOfFiducialCandidates.erase(m_CentroidsOfFiducialCandidates.begin()
- + fiducialCandidatesToBeRemoved.at(count));
+ m_CentroidsOfFiducialCandidates.erase(m_CentroidsOfFiducialCandidates.begin() +
+ fiducialCandidatesToBeRemoved.at(count));
}
}
void QmitkUSNavigationStepCtUsRegistration::GetCentroidsOfLabeledObjects()
{
MITK_INFO << "GetCentroidsOfLabeledObjects()";
BinaryImageToShapeLabelMapFilterType::OutputImageType::Pointer labelMap =
m_BinaryImageToShapeLabelMapFilter->GetOutput();
for (int i = labelMap->GetNumberOfLabelObjects() - 1; i >= 0; --i)
{
// Get the ith region
- BinaryImageToShapeLabelMapFilterType::OutputImageType::LabelObjectType* labelObject = labelMap->GetNthLabelObject(i);
+ BinaryImageToShapeLabelMapFilterType::OutputImageType::LabelObjectType *labelObject =
+ labelMap->GetNthLabelObject(i);
MITK_INFO << "Object " << i << " contains " << labelObject->Size() << " pixel";
mitk::Vector3D centroid;
centroid[0] = labelObject->GetCentroid()[0];
centroid[1] = labelObject->GetCentroid()[1];
centroid[2] = labelObject->GetCentroid()[2];
m_CentroidsOfFiducialCandidates.push_back(centroid);
}
- //evtl. for later: itk::LabelMapOverlayImageFilter
+ // evtl. for later: itk::LabelMapOverlayImageFilter
}
void QmitkUSNavigationStepCtUsRegistration::NumerateFiducialMarks()
{
MITK_INFO << "NumerateFiducialMarks()";
bool successFiducialNo1;
bool successFiducialNo4;
bool successFiducialNo2And3;
bool successFiducialNo5;
bool successFiducialNo8;
bool successFiducialNo6;
bool successFiducialNo7;
std::vector<std::vector<double>> distanceVectorsFiducials;
this->CalculateDistancesBetweenFiducials(distanceVectorsFiducials);
successFiducialNo1 = this->FindFiducialNo1(distanceVectorsFiducials);
successFiducialNo4 = this->FindFiducialNo4(distanceVectorsFiducials);
successFiducialNo2And3 = this->FindFiducialNo2And3();
successFiducialNo5 = this->FindFiducialNo5();
successFiducialNo8 = this->FindFiducialNo8();
successFiducialNo6 = this->FindFiducialNo6();
successFiducialNo7 = this->FindFiducialNo7();
- if (!successFiducialNo1 || !successFiducialNo4 || !successFiducialNo2And3 ||
- !successFiducialNo5 || !successFiducialNo8 || !successFiducialNo6 || !successFiducialNo7)
+ if (!successFiducialNo1 || !successFiducialNo4 || !successFiducialNo2And3 || !successFiducialNo5 ||
+ !successFiducialNo8 || !successFiducialNo6 || !successFiducialNo7)
{
QMessageBox msgBox;
msgBox.setText("Cannot numerate/localize all fiducials successfully.");
msgBox.exec();
return;
}
if (m_MarkerFloatingImageCoordinateSystemPointSet.IsNull())
{
m_MarkerFloatingImageCoordinateSystemPointSet = mitk::PointSet::New();
}
else if (m_MarkerFloatingImageCoordinateSystemPointSet->GetSize() != 0)
{
m_MarkerFloatingImageCoordinateSystemPointSet->Clear();
}
for (int counter = 1; counter <= m_FiducialMarkerCentroids.size(); ++counter)
{
m_MarkerFloatingImageCoordinateSystemPointSet->InsertPoint(counter - 1, m_FiducialMarkerCentroids.at(counter));
}
- if( !m_PerformingGroundTruthProtocolEvaluation )
+ if (!m_PerformingGroundTruthProtocolEvaluation)
{
mitk::DataNode::Pointer node = mitk::DataNode::New();
node->SetData(m_MarkerFloatingImageCoordinateSystemPointSet);
node->SetName("MarkerFloatingImageCSPointSet");
- //node->SetFloatProperty("pointsize", 5.0);
+ // node->SetFloatProperty("pointsize", 5.0);
this->GetDataStorage()->Add(node);
}
}
-void QmitkUSNavigationStepCtUsRegistration::CalculateDistancesBetweenFiducials(std::vector<std::vector<double>>& distanceVectorsFiducials)
+void QmitkUSNavigationStepCtUsRegistration::CalculateDistancesBetweenFiducials(
+ std::vector<std::vector<double>> &distanceVectorsFiducials)
{
std::vector<double> distancesBetweenFiducials;
for (int i = 0; i < m_CentroidsOfFiducialCandidates.size(); ++i)
{
distancesBetweenFiducials.clear();
mitk::Point3D fiducialCentroid(m_CentroidsOfFiducialCandidates.at(i));
for (int n = 0; n < m_CentroidsOfFiducialCandidates.size(); ++n)
{
mitk::Point3D otherCentroid(m_CentroidsOfFiducialCandidates.at(n));
distancesBetweenFiducials.push_back(fiducialCentroid.EuclideanDistanceTo(otherCentroid));
}
- //Sort the distances from low to big numbers
+ // Sort the distances from low to big numbers
std::sort(distancesBetweenFiducials.begin(), distancesBetweenFiducials.end());
- //First entry of the distance vector must be 0, so erase it
+ // First entry of the distance vector must be 0, so erase it
if (distancesBetweenFiducials.at(0) == 0.0)
{
distancesBetweenFiducials.erase(distancesBetweenFiducials.begin());
}
- //Add the distance vector to the collecting distances vector
+ // Add the distance vector to the collecting distances vector
distanceVectorsFiducials.push_back(distancesBetweenFiducials);
}
for (int i = 0; i < distanceVectorsFiducials.size(); ++i)
{
MITK_INFO << "Vector " << i << ":";
for (int k = 0; k < distanceVectorsFiducials.at(i).size(); ++k)
{
MITK_INFO << distanceVectorsFiducials.at(i).at(k);
}
}
}
-bool QmitkUSNavigationStepCtUsRegistration::FindFiducialNo1(std::vector<std::vector<double>>& distanceVectorsFiducials)
+bool QmitkUSNavigationStepCtUsRegistration::FindFiducialNo1(std::vector<std::vector<double>> &distanceVectorsFiducials)
{
for (int i = 0; i < distanceVectorsFiducials.size(); ++i)
{
std::vector<double> &distances = distanceVectorsFiducials.at(i);
- if (distances.size() < NUMBER_FIDUCIALS_NEEDED - 1 )
+ if (distances.size() < NUMBER_FIDUCIALS_NEEDED - 1)
{
MITK_WARN << "Cannot find fiducial 1, there aren't found enough fiducial candidates.";
return false;
}
double characteristicDistanceAWithUpperMargin = this->GetCharacteristicDistanceAWithUpperMargin();
if (distances.at(0) <= characteristicDistanceAWithUpperMargin &&
distances.at(1) <= characteristicDistanceAWithUpperMargin)
{
MITK_INFO << "Found Fiducial 1 (PointSet number " << i << ")";
- m_FiducialMarkerCentroids.insert( std::pair<int,mitk::Vector3D>(1, m_CentroidsOfFiducialCandidates.at(i)));
+ m_FiducialMarkerCentroids.insert(std::pair<int, mitk::Vector3D>(1, m_CentroidsOfFiducialCandidates.at(i)));
distanceVectorsFiducials.erase(distanceVectorsFiducials.begin() + i);
m_CentroidsOfFiducialCandidates.erase(m_CentroidsOfFiducialCandidates.begin() + i);
return true;
}
}
return false;
}
bool QmitkUSNavigationStepCtUsRegistration::FindFiducialNo2And3()
{
- if (m_FiducialMarkerCentroids.find(1) == m_FiducialMarkerCentroids.end() )
+ if (m_FiducialMarkerCentroids.find(1) == m_FiducialMarkerCentroids.end())
{
MITK_WARN << "Cannot find fiducial No 2 and 3. Before must be found fiducial No 1.";
return false;
}
mitk::Point3D fiducialNo1(m_FiducialMarkerCentroids.at(1));
mitk::Vector3D fiducialVectorA;
mitk::Vector3D fiducialVectorB;
mitk::Point3D fiducialPointA;
mitk::Point3D fiducialPointB;
bool foundFiducialA = false;
bool foundFiducialB = false;
mitk::Vector3D vectorFiducial1ToFiducialA;
mitk::Vector3D vectorFiducial1ToFiducialB;
for (int i = 0; i < m_CentroidsOfFiducialCandidates.size(); ++i)
{
mitk::Point3D fiducialCentroid(m_CentroidsOfFiducialCandidates.at(i));
double distance = fiducialNo1.EuclideanDistanceTo(fiducialCentroid);
if (distance <= this->GetCharacteristicDistanceAWithUpperMargin())
{
fiducialVectorA = m_CentroidsOfFiducialCandidates.at(i);
fiducialPointA = fiducialCentroid;
m_CentroidsOfFiducialCandidates.erase(m_CentroidsOfFiducialCandidates.begin() + i);
foundFiducialA = true;
break;
}
}
for (int i = 0; i < m_CentroidsOfFiducialCandidates.size(); ++i)
{
mitk::Point3D fiducialCentroid(m_CentroidsOfFiducialCandidates.at(i));
double distance = fiducialNo1.EuclideanDistanceTo(fiducialCentroid);
if (distance <= this->GetCharacteristicDistanceAWithUpperMargin())
{
fiducialVectorB = m_CentroidsOfFiducialCandidates.at(i);
fiducialPointB = fiducialCentroid;
m_CentroidsOfFiducialCandidates.erase(m_CentroidsOfFiducialCandidates.begin() + i);
foundFiducialB = true;
break;
}
}
if (!foundFiducialA || !foundFiducialB)
{
MITK_WARN << "Cannot identify fiducial candidates 2 and 3";
return false;
}
else if (m_CentroidsOfFiducialCandidates.size() == 0)
{
MITK_WARN << "Too less fiducials detected. Cannot identify fiducial candidates 2 and 3";
return false;
}
vectorFiducial1ToFiducialA = fiducialVectorA - m_FiducialMarkerCentroids.at(1);
vectorFiducial1ToFiducialB = fiducialVectorB - m_FiducialMarkerCentroids.at(1);
- vnl_vector<double> crossProductVnl = vnl_cross_3d(vectorFiducial1ToFiducialA.GetVnlVector(), vectorFiducial1ToFiducialB.GetVnlVector());
+ vnl_vector<double> crossProductVnl =
+ vnl_cross_3d(vectorFiducial1ToFiducialA.GetVnlVector(), vectorFiducial1ToFiducialB.GetVnlVector());
mitk::Vector3D crossProduct;
crossProduct.SetVnlVector(crossProductVnl);
- mitk::Vector3D vectorFiducial1ToRandomLeftFiducial = m_CentroidsOfFiducialCandidates.at(0) - m_FiducialMarkerCentroids.at(1);
+ mitk::Vector3D vectorFiducial1ToRandomLeftFiducial =
+ m_CentroidsOfFiducialCandidates.at(0) - m_FiducialMarkerCentroids.at(1);
double scalarProduct = (crossProduct * vectorFiducial1ToRandomLeftFiducial) /
(crossProduct.GetNorm() * vectorFiducial1ToRandomLeftFiducial.GetNorm());
- double alpha = acos(scalarProduct) * 57.29578; //Transform into degree
+ double alpha = acos(scalarProduct) * 57.29578; // Transform into degree
MITK_INFO << "Scalar Product = " << alpha;
if (alpha <= 90)
{
m_FiducialMarkerCentroids[3] = fiducialVectorA;
m_FiducialMarkerCentroids[2] = fiducialVectorB;
}
else
{
m_FiducialMarkerCentroids[2] = fiducialVectorA;
m_FiducialMarkerCentroids[3] = fiducialVectorB;
}
MITK_INFO << "Found Fiducial 2, PointSet: " << m_FiducialMarkerCentroids.at(2);
MITK_INFO << "Found Fiducial 3, PointSet: " << m_FiducialMarkerCentroids.at(3);
return true;
}
-bool QmitkUSNavigationStepCtUsRegistration::FindFiducialNo4(std::vector<std::vector<double>>& distanceVectorsFiducials)
+bool QmitkUSNavigationStepCtUsRegistration::FindFiducialNo4(std::vector<std::vector<double>> &distanceVectorsFiducials)
{
double characteristicDistanceBWithLowerMargin = this->GetCharacteristicDistanceBWithLowerMargin();
double characteristicDistanceBWithUpperMargin = this->GetCharacteristicDistanceBWithUpperMargin();
for (int i = 0; i < distanceVectorsFiducials.size(); ++i)
{
std::vector<double> &distances = distanceVectorsFiducials.at(i);
if (distances.size() < NUMBER_FIDUCIALS_NEEDED - 1)
{
MITK_WARN << "Cannot find fiducial 4, there aren't found enough fiducial candidates.";
return false;
}
if (distances.at(0) > characteristicDistanceBWithLowerMargin &&
distances.at(0) <= characteristicDistanceBWithUpperMargin &&
distances.at(1) > characteristicDistanceBWithLowerMargin &&
distances.at(1) <= characteristicDistanceBWithUpperMargin)
{
MITK_INFO << "Found Fiducial 4 (PointSet number " << i << ")";
m_FiducialMarkerCentroids.insert(std::pair<int, mitk::Vector3D>(4, m_CentroidsOfFiducialCandidates.at(i)));
distanceVectorsFiducials.erase(distanceVectorsFiducials.begin() + i);
m_CentroidsOfFiducialCandidates.erase(m_CentroidsOfFiducialCandidates.begin() + i);
return true;
}
}
return false;
}
bool QmitkUSNavigationStepCtUsRegistration::FindFiducialNo5()
{
if (m_FiducialMarkerCentroids.find(2) == m_FiducialMarkerCentroids.end())
{
MITK_WARN << "To find fiducial No 5, fiducial No 2 has to be found before.";
return false;
}
double characteristicDistanceBWithUpperMargin = this->GetCharacteristicDistanceBWithUpperMargin();
mitk::Point3D fiducialNo2(m_FiducialMarkerCentroids.at(2));
for (int counter = 0; counter < m_CentroidsOfFiducialCandidates.size(); ++counter)
{
mitk::Point3D fiducialCentroid(m_CentroidsOfFiducialCandidates.at(counter));
double distance = fiducialNo2.EuclideanDistanceTo(fiducialCentroid);
if (distance <= characteristicDistanceBWithUpperMargin)
{
m_FiducialMarkerCentroids[5] = m_CentroidsOfFiducialCandidates.at(counter);
m_CentroidsOfFiducialCandidates.erase(m_CentroidsOfFiducialCandidates.begin() + counter);
MITK_INFO << "Found Fiducial No 5, PointSet: " << m_FiducialMarkerCentroids[5];
return true;
}
}
MITK_WARN << "Cannot find fiducial No 5.";
return false;
}
bool QmitkUSNavigationStepCtUsRegistration::FindFiducialNo6()
{
if (m_FiducialMarkerCentroids.find(5) == m_FiducialMarkerCentroids.end())
{
MITK_WARN << "To find fiducial No 6, fiducial No 5 has to be found before.";
return false;
}
double characteristicDistanceAWithUpperMargin = this->GetCharacteristicDistanceAWithUpperMargin();
mitk::Point3D fiducialNo5(m_FiducialMarkerCentroids.at(5));
for (int counter = 0; counter < m_CentroidsOfFiducialCandidates.size(); ++counter)
{
mitk::Point3D fiducialCentroid(m_CentroidsOfFiducialCandidates.at(counter));
double distance = fiducialNo5.EuclideanDistanceTo(fiducialCentroid);
if (distance <= characteristicDistanceAWithUpperMargin)
{
m_FiducialMarkerCentroids[6] = m_CentroidsOfFiducialCandidates.at(counter);
m_CentroidsOfFiducialCandidates.erase(m_CentroidsOfFiducialCandidates.begin() + counter);
MITK_INFO << "Found Fiducial No 6, PointSet: " << m_FiducialMarkerCentroids[6];
return true;
}
}
MITK_WARN << "Cannot find fiducial No 6.";
return false;
}
bool QmitkUSNavigationStepCtUsRegistration::FindFiducialNo7()
{
if (m_FiducialMarkerCentroids.find(8) == m_FiducialMarkerCentroids.end())
{
MITK_WARN << "To find fiducial No 7, fiducial No 8 has to be found before.";
return false;
}
double characteristicDistanceAWithUpperMargin = this->GetCharacteristicDistanceAWithUpperMargin();
mitk::Point3D fiducialNo8(m_FiducialMarkerCentroids.at(8));
for (int counter = 0; counter < m_CentroidsOfFiducialCandidates.size(); ++counter)
{
mitk::Point3D fiducialCentroid(m_CentroidsOfFiducialCandidates.at(counter));
double distance = fiducialNo8.EuclideanDistanceTo(fiducialCentroid);
if (distance <= characteristicDistanceAWithUpperMargin)
{
m_FiducialMarkerCentroids[7] = m_CentroidsOfFiducialCandidates.at(counter);
m_CentroidsOfFiducialCandidates.erase(m_CentroidsOfFiducialCandidates.begin() + counter);
MITK_INFO << "Found Fiducial No 7, PointSet: " << m_FiducialMarkerCentroids[7];
return true;
}
}
MITK_WARN << "Cannot find fiducial No 7.";
return false;
}
bool QmitkUSNavigationStepCtUsRegistration::FindFiducialNo8()
{
if (m_FiducialMarkerCentroids.find(3) == m_FiducialMarkerCentroids.end())
{
MITK_WARN << "To find fiducial No 8, fiducial No 3 has to be found before.";
return false;
}
double characteristicDistanceBWithUpperMargin = this->GetCharacteristicDistanceBWithUpperMargin();
mitk::Point3D fiducialNo3(m_FiducialMarkerCentroids.at(3));
for (int counter = 0; counter < m_CentroidsOfFiducialCandidates.size(); ++counter)
{
mitk::Point3D fiducialCentroid(m_CentroidsOfFiducialCandidates.at(counter));
double distance = fiducialNo3.EuclideanDistanceTo(fiducialCentroid);
if (distance <= characteristicDistanceBWithUpperMargin)
{
m_FiducialMarkerCentroids[8] = m_CentroidsOfFiducialCandidates.at(counter);
m_CentroidsOfFiducialCandidates.erase(m_CentroidsOfFiducialCandidates.begin() + counter);
MITK_INFO << "Found Fiducial No 8, PointSet: " << m_FiducialMarkerCentroids[8];
return true;
}
}
MITK_WARN << "Cannot find fiducial No 8.";
return false;
}
void QmitkUSNavigationStepCtUsRegistration::DefineDataStorageImageFilter()
{
m_IsAPointSetPredicate = mitk::TNodePredicateDataType<mitk::PointSet>::New();
mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
auto isSegmentation = mitk::NodePredicateDataType::New("Segment");
m_IsASurfacePredicate = mitk::NodePredicateDataType::New("Surface");
mitk::NodePredicateOr::Pointer validImages = mitk::NodePredicateOr::New();
validImages->AddPredicate(mitk::NodePredicateAnd::New(isImage, mitk::NodePredicateNot::New(isSegmentation)));
- mitk::NodePredicateNot::Pointer isNotAHelperObject = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(true)));
+ mitk::NodePredicateNot::Pointer isNotAHelperObject =
+ mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(true)));
m_IsOfTypeImagePredicate = mitk::NodePredicateAnd::New(validImages, isNotAHelperObject);
- mitk::NodePredicateProperty::Pointer isBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
+ mitk::NodePredicateProperty::Pointer isBinaryPredicate =
+ mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
mitk::NodePredicateNot::Pointer isNotBinaryPredicate = mitk::NodePredicateNot::New(isBinaryPredicate);
- mitk::NodePredicateAnd::Pointer isABinaryImagePredicate = mitk::NodePredicateAnd::New(m_IsOfTypeImagePredicate, isBinaryPredicate);
- mitk::NodePredicateAnd::Pointer isNotABinaryImagePredicate = mitk::NodePredicateAnd::New(m_IsOfTypeImagePredicate, isNotBinaryPredicate);
+ mitk::NodePredicateAnd::Pointer isABinaryImagePredicate =
+ mitk::NodePredicateAnd::New(m_IsOfTypeImagePredicate, isBinaryPredicate);
+ mitk::NodePredicateAnd::Pointer isNotABinaryImagePredicate =
+ mitk::NodePredicateAnd::New(m_IsOfTypeImagePredicate, isNotBinaryPredicate);
- m_IsASegmentationImagePredicate = mitk::NodePredicateOr::New(isABinaryImagePredicate, mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
- m_IsAPatientImagePredicate = mitk::NodePredicateAnd::New(isNotABinaryImagePredicate, mitk::NodePredicateNot::New(mitk::TNodePredicateDataType<mitk::LabelSetImage>::New()));
+ m_IsASegmentationImagePredicate =
+ mitk::NodePredicateOr::New(isABinaryImagePredicate, mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
+ m_IsAPatientImagePredicate = mitk::NodePredicateAnd::New(
+ isNotABinaryImagePredicate, mitk::NodePredicateNot::New(mitk::TNodePredicateDataType<mitk::LabelSetImage>::New()));
}
void QmitkUSNavigationStepCtUsRegistration::CreateQtPartControl(QWidget *parent)
{
ui->setupUi(parent);
ui->floatingImageComboBox->SetPredicate(m_IsAPatientImagePredicate);
ui->ctImagesToChooseComboBox->SetPredicate(m_IsAPatientImagePredicate);
ui->segmentationComboBox->SetPredicate(m_IsASegmentationImagePredicate);
ui->selectedSurfaceComboBox->SetPredicate(m_IsASurfacePredicate);
ui->pointSetComboBox->SetPredicate(m_IsAPointSetPredicate);
// create signal/slot connections
- connect(ui->floatingImageComboBox, SIGNAL(OnSelectionChanged(const mitk::DataNode*)),
- this, SLOT(OnFloatingImageComboBoxSelectionChanged(const mitk::DataNode*)));
- connect(ui->doRegistrationMarkerToImagePushButton, SIGNAL(clicked()),
- this, SLOT(OnRegisterMarkerToFloatingImageCS()));
- connect(ui->localizeFiducialMarkerPushButton, SIGNAL(clicked()),
- this, SLOT(OnLocalizeFiducials()));
- connect(ui->visualizeCTtoUSregistrationPushButton, SIGNAL(clicked()),
- this, SLOT(OnVisualizeCTtoUSregistration()));
- connect(ui->freezeUnfreezePushButton, SIGNAL(clicked()),
- this, SLOT(OnFreeze()));
- connect(ui->addCtImagePushButton, SIGNAL(clicked()),
- this, SLOT(OnAddCtImageClicked()));
- connect(ui->removeCtImagePushButton, SIGNAL(clicked()),
- this, SLOT(OnRemoveCtImageClicked()));
- connect(ui->evaluateProtocolPushButton, SIGNAL(clicked()),
- this, SLOT(OnEvaluateGroundTruthFiducialLocalizationProtocol()));
- connect(ui->actualizeSegmentationSurfacePSetDataPushButton, SIGNAL(clicked()),
- this, SLOT(OnActualizeSegmentationSurfacePointSetData()));
- connect(ui->calculateTREPushButton, SIGNAL(clicked()),
- this, SLOT(OnGetCursorPosition()));
- connect(ui->calculateCenterPushButton, SIGNAL(clicked()),
- this, SLOT(OnCalculateCenter()));
+ connect(ui->floatingImageComboBox,
+ SIGNAL(OnSelectionChanged(const mitk::DataNode *)),
+ this,
+ SLOT(OnFloatingImageComboBoxSelectionChanged(const mitk::DataNode *)));
+ connect(
+ ui->doRegistrationMarkerToImagePushButton, SIGNAL(clicked()), this, SLOT(OnRegisterMarkerToFloatingImageCS()));
+ connect(ui->localizeFiducialMarkerPushButton, SIGNAL(clicked()), this, SLOT(OnLocalizeFiducials()));
+ connect(ui->visualizeCTtoUSregistrationPushButton, SIGNAL(clicked()), this, SLOT(OnVisualizeCTtoUSregistration()));
+ connect(ui->freezeUnfreezePushButton, SIGNAL(clicked()), this, SLOT(OnFreeze()));
+ connect(ui->addCtImagePushButton, SIGNAL(clicked()), this, SLOT(OnAddCtImageClicked()));
+ connect(ui->removeCtImagePushButton, SIGNAL(clicked()), this, SLOT(OnRemoveCtImageClicked()));
+ connect(
+ ui->evaluateProtocolPushButton, SIGNAL(clicked()), this, SLOT(OnEvaluateGroundTruthFiducialLocalizationProtocol()));
+ connect(ui->actualizeSegmentationSurfacePSetDataPushButton,
+ SIGNAL(clicked()),
+ this,
+ SLOT(OnActualizeSegmentationSurfacePointSetData()));
+ connect(ui->calculateTREPushButton, SIGNAL(clicked()), this, SLOT(OnGetCursorPosition()));
+ connect(ui->calculateCenterPushButton, SIGNAL(clicked()), this, SLOT(OnCalculateCenter()));
+ connect(ui->m_AddSurface, SIGNAL(clicked()), this, SLOT(OnAddSurface()));
+
}
-void QmitkUSNavigationStepCtUsRegistration::OnFloatingImageComboBoxSelectionChanged(const mitk::DataNode* node)
+void QmitkUSNavigationStepCtUsRegistration::OnFloatingImageComboBoxSelectionChanged(const mitk::DataNode *node)
{
MITK_INFO << "OnFloatingImageComboBoxSelectionChanged()";
if (m_FloatingImage.IsNotNull())
{
- //TODO: Define, what will happen if the imageCT is not null...
+ // TODO: Define, what will happen if the imageCT is not null...
}
if (node == nullptr)
{
this->UnsetFloatingImageGeometry();
m_FloatingImage = nullptr;
return;
}
- mitk::DataNode* selectedFloatingImage = ui->floatingImageComboBox->GetSelectedNode();
+ mitk::DataNode *selectedFloatingImage = ui->floatingImageComboBox->GetSelectedNode();
if (selectedFloatingImage == nullptr)
{
this->UnsetFloatingImageGeometry();
m_FloatingImage = nullptr;
return;
}
- mitk::Image::Pointer floatingImage = dynamic_cast<mitk::Image*>(selectedFloatingImage->GetData());
+ mitk::Image::Pointer floatingImage = dynamic_cast<mitk::Image *>(selectedFloatingImage->GetData());
if (floatingImage.IsNull())
{
MITK_WARN << "Failed to cast selected segmentation node to mitk::Image*";
this->UnsetFloatingImageGeometry();
m_FloatingImage = nullptr;
return;
}
m_FloatingImage = floatingImage;
this->SetFloatingImageGeometryInformation(floatingImage.GetPointer());
}
void QmitkUSNavigationStepCtUsRegistration::OnRegisterMarkerToFloatingImageCS()
{
this->CreateMarkerModelCoordinateSystemPointSet();
- //Check for initialization
- if( m_MarkerModelCoordinateSystemPointSet.IsNull() ||
- m_MarkerFloatingImageCoordinateSystemPointSet.IsNull() )
+ // Check for initialization
+ if (m_MarkerModelCoordinateSystemPointSet.IsNull() || m_MarkerFloatingImageCoordinateSystemPointSet.IsNull())
{
MITK_WARN << "Fiducial Landmarks are not initialized yet, cannot register";
return;
}
- //Retrieve fiducials
+ // Retrieve fiducials
if (m_MarkerFloatingImageCoordinateSystemPointSet->GetSize() != m_MarkerModelCoordinateSystemPointSet->GetSize())
{
MITK_WARN << "Not the same number of fiducials, cannot register";
return;
}
else if (m_MarkerFloatingImageCoordinateSystemPointSet->GetSize() < 3)
{
MITK_WARN << "Need at least 3 fiducials, cannot register";
return;
}
- //############### conversion to vtk data types (we will use the vtk landmark based transform) ##########################
- //convert point sets to vtk poly data
+ //############### conversion to vtk data types (we will use the vtk landmark based transform)
+ //########################## convert point sets to vtk poly data
vtkSmartPointer<vtkPoints> sourcePoints = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkPoints> targetPoints = vtkSmartPointer<vtkPoints>::New();
- for (int i = 0; i<m_MarkerModelCoordinateSystemPointSet->GetSize(); i++)
+ for (int i = 0; i < m_MarkerModelCoordinateSystemPointSet->GetSize(); i++)
{
- double point[3] = { m_MarkerModelCoordinateSystemPointSet->GetPoint(i)[0],
- m_MarkerModelCoordinateSystemPointSet->GetPoint(i)[1],
- m_MarkerModelCoordinateSystemPointSet->GetPoint(i)[2] };
+ double point[3] = {m_MarkerModelCoordinateSystemPointSet->GetPoint(i)[0],
+ m_MarkerModelCoordinateSystemPointSet->GetPoint(i)[1],
+ m_MarkerModelCoordinateSystemPointSet->GetPoint(i)[2]};
sourcePoints->InsertNextPoint(point);
- double point_targets[3] = { m_MarkerFloatingImageCoordinateSystemPointSet->GetPoint(i)[0],
- m_MarkerFloatingImageCoordinateSystemPointSet->GetPoint(i)[1],
- m_MarkerFloatingImageCoordinateSystemPointSet->GetPoint(i)[2] };
+ double point_targets[3] = {m_MarkerFloatingImageCoordinateSystemPointSet->GetPoint(i)[0],
+ m_MarkerFloatingImageCoordinateSystemPointSet->GetPoint(i)[1],
+ m_MarkerFloatingImageCoordinateSystemPointSet->GetPoint(i)[2]};
targetPoints->InsertNextPoint(point_targets);
}
//########################### here, the actual transform is computed ##########################
- //compute transform (from marker to ct)
+ // compute transform (from marker to ct)
vtkSmartPointer<vtkLandmarkTransform> transform = vtkSmartPointer<vtkLandmarkTransform>::New();
transform->SetSourceLandmarks(sourcePoints);
transform->SetTargetLandmarks(targetPoints);
transform->SetModeToRigidBody();
transform->Modified();
transform->Update();
- //compute FRE of transform
- double FRE = mitk::StaticIGTHelperFunctions::ComputeFRE(m_MarkerModelCoordinateSystemPointSet, m_MarkerFloatingImageCoordinateSystemPointSet, transform);
+ // compute FRE of transform
+ double FRE = mitk::StaticIGTHelperFunctions::ComputeFRE(
+ m_MarkerModelCoordinateSystemPointSet, m_MarkerFloatingImageCoordinateSystemPointSet, transform);
MITK_INFO << "FRE: " << FRE << " mm";
if (m_PerformingGroundTruthProtocolEvaluation)
{
m_GroundTruthProtocolFRE.push_back(FRE);
}
//#############################################################################################
//############### conversion back to itk/mitk data types ##########################
- //convert from vtk to itk data types
+ // convert from vtk to itk data types
itk::Matrix<float, 3, 3> rotationFloat = itk::Matrix<float, 3, 3>();
itk::Vector<float, 3> translationFloat = itk::Vector<float, 3>();
itk::Matrix<double, 3, 3> rotationDouble = itk::Matrix<double, 3, 3>();
itk::Vector<double, 3> translationDouble = itk::Vector<double, 3>();
vtkSmartPointer<vtkMatrix4x4> m = transform->GetMatrix();
- for (int k = 0; k<3; k++) for (int l = 0; l<3; l++)
- {
- rotationFloat[k][l] = m->GetElement(k, l);
- rotationDouble[k][l] = m->GetElement(k, l);
-
- }
- for (int k = 0; k<3; k++)
+ for (int k = 0; k < 3; k++)
+ for (int l = 0; l < 3; l++)
+ {
+ rotationFloat[k][l] = m->GetElement(k, l);
+ rotationDouble[k][l] = m->GetElement(k, l);
+ }
+ for (int k = 0; k < 3; k++)
{
translationFloat[k] = m->GetElement(k, 3);
translationDouble[k] = m->GetElement(k, 3);
}
MITK_INFO << "Matrix Marker-to-CT Transform:";
- //create mitk affine transform 3D and save it to the class member
+ // create mitk affine transform 3D and save it to the class member
m_TransformMarkerCSToFloatingImageCS = mitk::AffineTransform3D::New();
m_TransformMarkerCSToFloatingImageCS->SetMatrix(rotationDouble);
m_TransformMarkerCSToFloatingImageCS->SetOffset(translationDouble);
MITK_INFO << m_TransformMarkerCSToFloatingImageCS;
//################################################################
//############### object is transformed ##########################
- //transform surface/image
- //only move image if we have one. Sometimes, this widget is used just to register point sets without images.
+ // transform surface/image
+ // only move image if we have one. Sometimes, this widget is used just to register point sets without images.
/*if (m_ImageNode.IsNotNull())
{
//first we have to store the original ct image transform to compose it with the new transform later
mitk::AffineTransform3D::Pointer imageTransform = m_ImageNode->GetData()->GetGeometry()->GetIndexToWorldTransform();
imageTransform->Compose(mitkTransform);
- mitk::AffineTransform3D::Pointer newImageTransform = mitk::AffineTransform3D::New(); //create new image transform... setting the composed directly leads to an error
- itk::Matrix<mitk::ScalarType, 3, 3> rotationFloatNew = imageTransform->GetMatrix();
- itk::Vector<mitk::ScalarType, 3> translationFloatNew = imageTransform->GetOffset();
+ mitk::AffineTransform3D::Pointer newImageTransform = mitk::AffineTransform3D::New(); //create new image transform...
+ setting the composed directly leads to an error itk::Matrix<mitk::ScalarType, 3, 3> rotationFloatNew =
+ imageTransform->GetMatrix(); itk::Vector<mitk::ScalarType, 3> translationFloatNew = imageTransform->GetOffset();
newImageTransform->SetMatrix(rotationFloatNew);
newImageTransform->SetOffset(translationFloatNew);
m_ImageNode->GetData()->GetGeometry()->SetIndexToWorldTransform(newImageTransform);
}*/
- //If this option is set, each point will be transformed and the acutal coordinates of the points change.
+ // If this option is set, each point will be transformed and the acutal coordinates of the points change.
- if( !m_PerformingGroundTruthProtocolEvaluation )
+ if (!m_PerformingGroundTruthProtocolEvaluation)
{
- mitk::PointSet* pointSet_orig = m_MarkerModelCoordinateSystemPointSet;
+ mitk::PointSet *pointSet_orig = m_MarkerModelCoordinateSystemPointSet;
mitk::PointSet::Pointer pointSet_moved = mitk::PointSet::New();
for (int i = 0; i < pointSet_orig->GetSize(); i++)
{
pointSet_moved->InsertPoint(m_TransformMarkerCSToFloatingImageCS->TransformPoint(pointSet_orig->GetPoint(i)));
}
pointSet_orig->Clear();
for (int i = 0; i < pointSet_moved->GetSize(); i++)
pointSet_orig->InsertPoint(pointSet_moved->GetPoint(i));
- //Do a global reinit
+ // Do a global reinit
mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(this->GetDataStorage());
}
+ // Do one update to output all transformations to the console
+ OnVisualizeCTtoUSregistration();
+ OnUpdate();
+ m_UpdateRunning = false;
}
void QmitkUSNavigationStepCtUsRegistration::OnLocalizeFiducials()
{
m_FiducialMarkerCentroids.clear();
m_CentroidsOfFiducialCandidates.clear();
if (m_MarkerFloatingImageCoordinateSystemPointSet.IsNotNull())
{
m_MarkerFloatingImageCoordinateSystemPointSet->Clear();
}
if (!this->FilterFloatingImage())
{
QMessageBox msgBox;
msgBox.setText("Cannot perform filtering of the image. The floating image = nullptr.");
msgBox.exec();
return;
}
mitk::AffineTransform3D::Pointer transform = m_FloatingImage->GetGeometry()->GetIndexToWorldTransform();
MITK_WARN << "IndexToWorldTransform_CTimage = " << transform;
this->GetCentroidsOfLabeledObjects();
if (!this->EliminateFiducialCandidatesByEuclideanDistances() ||
m_CentroidsOfFiducialCandidates.size() != NUMBER_FIDUCIALS_NEEDED)
{
QMessageBox msgBox;
QString text = QString("Have found %1 instead of 8 fiducial candidates.\
- Cannot perform fiducial localization procedure.").arg(m_CentroidsOfFiducialCandidates.size());
+ Cannot perform fiducial localization procedure.")
+ .arg(m_CentroidsOfFiducialCandidates.size());
msgBox.setText(text);
msgBox.exec();
return;
}
- //Before calling NumerateFiducialMarks it must be sure,
+ // Before calling NumerateFiducialMarks it must be sure,
// that there rested only 8 fiducial candidates.
this->NumerateFiducialMarks();
}
void QmitkUSNavigationStepCtUsRegistration::OnVisualizeCTtoUSregistration()
{
emit this->ActualizeCtToUsRegistrationWidget();
- mitk::DataNode* segmentationNode = ui->segmentationComboBox->GetSelectedNode();
+ mitk::DataNode *segmentationNode = ui->segmentationComboBox->GetSelectedNode();
if (segmentationNode == nullptr)
{
QMessageBox msgBox;
msgBox.setText("Cannot visualize CT-to-US registration. There is no segmentation selected.");
msgBox.exec();
return;
}
mitk::AffineTransform3D::Pointer transform = segmentationNode->GetData()->GetGeometry()->GetIndexToWorldTransform();
MITK_WARN << "IndexToWorldTransform_segmentation = " << transform;
- mitk::DataNode* surfaceNode = ui->selectedSurfaceComboBox->GetSelectedNode();
+ mitk::DataNode *surfaceNode = ui->selectedSurfaceComboBox->GetSelectedNode();
if (surfaceNode == nullptr)
{
QMessageBox msgBox;
msgBox.setText("Cannot visualize CT-to-US registration. There is no surface selected.");
msgBox.exec();
return;
}
- mitk::DataNode* pointSetNode = ui->pointSetComboBox->GetSelectedNode();
+ mitk::DataNode *pointSetNode = ui->pointSetComboBox->GetSelectedNode();
if (pointSetNode == nullptr)
{
QMessageBox msgBox;
msgBox.setText("Cannot visualize CT-to-US registration. There is no pointSet selected.");
msgBox.exec();
return;
}
if (this->GetCombinedModality(false).IsNull())
{
QMessageBox msgBox;
msgBox.setText("CombinedModality not yet set.\nPlease try again and click on the button.");
msgBox.exec();
return;
}
if (m_FloatingImageToUltrasoundRegistrationFilter.IsNull())
{
QMessageBox msgBox;
msgBox.setText("Cannot visualize CT-to-US registration.\
The FloatingImageToUltrasoundRegistrationFilter is not initialized.");
msgBox.exec();
return;
}
- //Set the transformation from marker-CS to the sensor-CS accordingly to the chosen user-option
- m_FloatingImageToUltrasoundRegistrationFilter
- ->InitializeTransformationMarkerCSToSensorCS(ui->useNdiTrackerCheckBox->isChecked());
+ // Set the transformation from marker-CS to the sensor-CS accordingly to the chosen user-option
+ m_FloatingImageToUltrasoundRegistrationFilter->InitializeTransformationMarkerCSToSensorCS(
+ ui->useNdiTrackerCheckBox->isChecked());
m_FloatingImageToUltrasoundRegistrationFilter->SetPointSet(pointSetNode);
m_FloatingImageToUltrasoundRegistrationFilter->SetSegmentation(segmentationNode, m_FloatingImage);
m_FloatingImageToUltrasoundRegistrationFilter->SetSurface(surfaceNode);
- m_FloatingImageToUltrasoundRegistrationFilter
- ->SetTransformMarkerCSToFloatingImageCS(m_TransformMarkerCSToFloatingImageCS);
- m_FloatingImageToUltrasoundRegistrationFilter
- ->SetTransformUSimageCSToTrackingCS(this->GetCombinedModality()->GetCalibration());
- m_FloatingImageToUltrasoundRegistrationFilter
- ->ConnectTo(this->GetCombinedModality()->GetNavigationDataSource());
+ m_FloatingImageToUltrasoundRegistrationFilter->SetTransformMarkerCSToFloatingImageCS(
+ m_TransformMarkerCSToFloatingImageCS);
+ m_FloatingImageToUltrasoundRegistrationFilter->SetTransformUSimageCSToTrackingCS(
+ this->GetCombinedModality()->GetCalibration());
+ m_FloatingImageToUltrasoundRegistrationFilter->ConnectTo(this->GetCombinedModality()->GetNavigationDataSource());
+ m_UpdateRunning = true;
}
void QmitkUSNavigationStepCtUsRegistration::OnFreeze()
{
if (this->GetCombinedModality(false).IsNull())
{
return;
}
if (!m_FreezeCombinedModality)
{
m_FreezeCombinedModality = true;
ui->freezeUnfreezePushButton->setText("Unfreeze");
this->GetCombinedModality()->SetIsFreezed(true);
}
else
{
m_FreezeCombinedModality = false;
ui->freezeUnfreezePushButton->setText("Freeze");
this->GetCombinedModality()->SetIsFreezed(false);
}
}
+void QmitkUSNavigationStepCtUsRegistration::OnAddSurface() {
+ mitk::DataNode::Pointer surfaceNode = ui->selectedSurfaceComboBox->GetSelectedNode();
+ if (surfaceNode.IsNull())
+ {
+ QMessageBox msgBox;
+ msgBox.setText("Cannot add surface. There is no surface selected.");
+ msgBox.exec();
+ return;
+ }
+ m_FloatingImageToUltrasoundRegistrationFilter->AddAdditionalSurface(surfaceNode);
+}
+
void QmitkUSNavigationStepCtUsRegistration::OnActualizeSegmentationSurfacePointSetData()
{
- mitk::DataNode* segmentationNode = ui->segmentationComboBox->GetSelectedNode();
+ mitk::DataNode *segmentationNode = ui->segmentationComboBox->GetSelectedNode();
if (segmentationNode == nullptr)
{
QMessageBox msgBox;
msgBox.setText("Cannot actualize segmentation + surface + pointset data. There is no segmentation selected.");
msgBox.exec();
return;
}
- mitk::DataNode* surfaceNode = ui->selectedSurfaceComboBox->GetSelectedNode();
+ mitk::DataNode *surfaceNode = ui->selectedSurfaceComboBox->GetSelectedNode();
if (surfaceNode == nullptr)
{
QMessageBox msgBox;
msgBox.setText("Cannot actualize segmentation + surface + pointset data. There is no surface selected.");
msgBox.exec();
return;
}
- mitk::DataNode* pointSetNode = ui->pointSetComboBox->GetSelectedNode();
+ mitk::DataNode *pointSetNode = ui->pointSetComboBox->GetSelectedNode();
if (pointSetNode == nullptr)
{
QMessageBox msgBox;
msgBox.setText("Cannot actualize segmentation + surface + pointset data. There is no pointSet selected.");
msgBox.exec();
return;
}
m_FloatingImageToUltrasoundRegistrationFilter->SetPointSet(pointSetNode);
m_FloatingImageToUltrasoundRegistrationFilter->SetSegmentation(segmentationNode, m_FloatingImage);
m_FloatingImageToUltrasoundRegistrationFilter->SetSurface(surfaceNode);
}
void QmitkUSNavigationStepCtUsRegistration::OnGetCursorPosition()
{
emit GetCursorPosition();
}
void QmitkUSNavigationStepCtUsRegistration::OnCalculateTRE(mitk::Point3D centroidOfTargetInUSImage)
{
mitk::DataNode::Pointer pointSetNode = ui->pointSetComboBox->GetSelectedNode();
if (pointSetNode.IsNull())
{
QMessageBox msgBox;
msgBox.setText("Cannot calculate TRE. The pointSetComboBox node returned a nullptr.");
msgBox.exec();
return;
}
- mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet*>(pointSetNode->GetData());
+ mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet *>(pointSetNode->GetData());
if (pointSet.IsNull())
{
ui->distanceTREValue->setText(QString("Unknown"));
return;
}
double distance = pointSet->GetPoint(0).EuclideanDistanceTo(centroidOfTargetInUSImage);
ui->distanceTREValue->setText(QString("%1").arg(distance));
}
void QmitkUSNavigationStepCtUsRegistration::OnCalculateCenter()
{
mitk::DataNode::Pointer node = ui->segmentationComboBox->GetSelectedNode();
if (node.IsNull())
{
QMessageBox msgBox;
- msgBox.setText("Cannot calculate the centroid of the segmentation."\
- "The segmentationComboBox node returned a nullptr.");
+ msgBox.setText("Cannot calculate the centroid of the segmentation."
+ "The segmentationComboBox node returned a nullptr.");
msgBox.exec();
return;
}
- mitk::LabelSetImage::Pointer image = dynamic_cast<mitk::LabelSetImage*>(node->GetData());
+ mitk::LabelSetImage::Pointer image = dynamic_cast<mitk::LabelSetImage *>(node->GetData());
if (image.IsNull())
{
MITK_WARN << "Cannot CalculateCenter - the segmentation cannot be converted to mitk::Image";
return;
}
ImageType::Pointer itkImage = ImageType::New();
mitk::CastToItkImage(image, itkImage);
- //Initialize binary image to shape label map filter
+ // Initialize binary image to shape label map filter
BinaryImageToShapeLabelMapFilterType::Pointer shapeLabelMapFilter = BinaryImageToShapeLabelMapFilterType::New();
shapeLabelMapFilter->SetInputForegroundValue(1);
shapeLabelMapFilter->SetInput(itkImage);
shapeLabelMapFilter->Update();
- BinaryImageToShapeLabelMapFilterType::OutputImageType::Pointer labelMap =
- shapeLabelMapFilter->GetOutput();
+ BinaryImageToShapeLabelMapFilterType::OutputImageType::Pointer labelMap = shapeLabelMapFilter->GetOutput();
for (int i = labelMap->GetNumberOfLabelObjects() - 1; i >= 0; --i)
{
// Get the ith region
- BinaryImageToShapeLabelMapFilterType::OutputImageType::LabelObjectType* labelObject = labelMap->GetNthLabelObject(i);
+ BinaryImageToShapeLabelMapFilterType::OutputImageType::LabelObjectType *labelObject =
+ labelMap->GetNthLabelObject(i);
mitk::Vector3D centroid;
centroid[0] = labelObject->GetCentroid()[0];
centroid[1] = labelObject->GetCentroid()[1];
centroid[2] = labelObject->GetCentroid()[2];
MITK_INFO << "Centroid of segmentation = " << centroid;
}
}
void QmitkUSNavigationStepCtUsRegistration::OnAddCtImageClicked()
{
- mitk::DataNode* selectedCtImage = ui->ctImagesToChooseComboBox->GetSelectedNode();
+ mitk::DataNode *selectedCtImage = ui->ctImagesToChooseComboBox->GetSelectedNode();
if (selectedCtImage == nullptr)
{
return;
}
- mitk::Image::Pointer ctImage = dynamic_cast<mitk::Image*>(selectedCtImage->GetData());
+ mitk::Image::Pointer ctImage = dynamic_cast<mitk::Image *>(selectedCtImage->GetData());
if (ctImage.IsNull())
{
MITK_WARN << "Failed to cast selected segmentation node to mitk::Image*";
return;
}
QString name = QString::fromStdString(selectedCtImage->GetName());
- for( int counter = 0; counter < ui->chosenCtImagesListWidget->count(); ++counter)
+ for (int counter = 0; counter < ui->chosenCtImagesListWidget->count(); ++counter)
{
MITK_INFO << ui->chosenCtImagesListWidget->item(counter)->text() << " - " << counter;
MITK_INFO << m_ImagesGroundTruthProtocol.at(counter).GetPointer();
if (ui->chosenCtImagesListWidget->item(counter)->text().compare(name) == 0)
{
MITK_INFO << "CT image already exist in list of chosen CT images. Do not add the image.";
return;
}
}
ui->chosenCtImagesListWidget->addItem(name);
m_ImagesGroundTruthProtocol.push_back(ctImage);
}
void QmitkUSNavigationStepCtUsRegistration::OnRemoveCtImageClicked()
{
int position = ui->chosenCtImagesListWidget->currentRow();
if (ui->chosenCtImagesListWidget->count() == 0 || position < 0)
{
return;
}
m_ImagesGroundTruthProtocol.erase(m_ImagesGroundTruthProtocol.begin() + position);
QListWidgetItem *item = ui->chosenCtImagesListWidget->currentItem();
ui->chosenCtImagesListWidget->removeItemWidget(item);
delete item;
}
void QmitkUSNavigationStepCtUsRegistration::OnEvaluateGroundTruthFiducialLocalizationProtocol()
{
m_GroundTruthProtocolFRE.clear();
if (m_ImagesGroundTruthProtocol.size() != 6)
{
QMessageBox msgBox;
- msgBox.setText("For evaluating the Ground-Truth-Fiducial-Localization-Protocol there must be loaded 6 different CT images.");
+ msgBox.setText(
+ "For evaluating the Ground-Truth-Fiducial-Localization-Protocol there must be loaded 6 different CT images.");
msgBox.exec();
return;
}
m_PerformingGroundTruthProtocolEvaluation = true;
this->CreatePointsToTransformForGroundTruthProtocol();
m_GroundTruthProtocolTransformedPoints.clear();
for (int cycleNo = 0; cycleNo < m_ImagesGroundTruthProtocol.size(); ++cycleNo)
{
m_FloatingImage = m_ImagesGroundTruthProtocol.at(cycleNo);
this->SetFloatingImageGeometryInformation(m_FloatingImage.GetPointer());
this->OnLocalizeFiducials();
this->OnRegisterMarkerToFloatingImageCS();
this->TransformPointsGroundTruthProtocol();
}
this->AddTransformedPointsToDataStorage();
double meanFRE = this->CalculateMeanFRE();
double sdOfFRE = this->CalculateStandardDeviationOfFRE(meanFRE);
this->CalculateGroundTruthProtocolTRE();
ui->meanFREValue->setText(QString("%1").arg(meanFRE));
ui->sdFREValue->setText(QString("%1").arg(sdOfFRE));
if (ui->protocolEvaluationTypeComboBox->currentText().compare("ANGLE") == 0)
{
if (m_GroundTruthProtocolTRE.find(0) != m_GroundTruthProtocolTRE.end())
{
ui->TREValue->setText(QString("%1").arg(m_GroundTruthProtocolTRE.at(0)));
}
}
else if (ui->protocolEvaluationTypeComboBox->currentText().compare("PLANE") == 0)
{
if (m_GroundTruthProtocolTRE.find(0) != m_GroundTruthProtocolTRE.end() &&
- m_GroundTruthProtocolTRE.find(20) != m_GroundTruthProtocolTRE.end() &&
- m_GroundTruthProtocolTRE.find(40) != m_GroundTruthProtocolTRE.end() &&
- m_GroundTruthProtocolTRE.find(60) != m_GroundTruthProtocolTRE.end() &&
- m_GroundTruthProtocolTRE.find(80) != m_GroundTruthProtocolTRE.end() &&
- m_GroundTruthProtocolTRE.find(100) != m_GroundTruthProtocolTRE.end())
+ m_GroundTruthProtocolTRE.find(20) != m_GroundTruthProtocolTRE.end() &&
+ m_GroundTruthProtocolTRE.find(40) != m_GroundTruthProtocolTRE.end() &&
+ m_GroundTruthProtocolTRE.find(60) != m_GroundTruthProtocolTRE.end() &&
+ m_GroundTruthProtocolTRE.find(80) != m_GroundTruthProtocolTRE.end() &&
+ m_GroundTruthProtocolTRE.find(100) != m_GroundTruthProtocolTRE.end())
{
ui->TREValue->setText(QString("Depth 0mm: %1\nDepth 20mm: %2\nDepth 40mm: %3\
\nDepth 60mm: %4\nDepth 80mm: %5\nDepth 100mm: %6")
- .arg(m_GroundTruthProtocolTRE.at(0))
- .arg(m_GroundTruthProtocolTRE.at(20))
- .arg(m_GroundTruthProtocolTRE.at(40))
- .arg(m_GroundTruthProtocolTRE.at(60))
- .arg(m_GroundTruthProtocolTRE.at(80))
- .arg(m_GroundTruthProtocolTRE.at(100)));
+ .arg(m_GroundTruthProtocolTRE.at(0))
+ .arg(m_GroundTruthProtocolTRE.at(20))
+ .arg(m_GroundTruthProtocolTRE.at(40))
+ .arg(m_GroundTruthProtocolTRE.at(60))
+ .arg(m_GroundTruthProtocolTRE.at(80))
+ .arg(m_GroundTruthProtocolTRE.at(100)));
}
}
m_PerformingGroundTruthProtocolEvaluation = false;
}
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCtUsRegistration.h b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCtUsRegistration.h
index aa34b0edd0..3fa084ab50 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCtUsRegistration.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCtUsRegistration.h
@@ -1,237 +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.
===================================================================*/
#ifndef QMITKUSNAVIGATIONSTEPCTUSREGISTRATION_H
#define QMITKUSNAVIGATIONSTEPCTUSREGISTRATION_H
#include "QmitkUSAbstractNavigationStep.h"
#include <mitkNodePredicateDataType.h>
#include <mitkNodePredicateAnd.h>
#include <mitkNodePredicateOr.h>
#include <mitkPointSet.h>
#include <mitkImage.h>
#include <mitkPlaneFit.h>
#include <itkImage.h>
#include <itkThresholdImageFilter.h>
#include <itkBinaryThresholdImageFilter.h>
#include <itkGradientMagnitudeImageFilter.h>
#include <itkLaplacianRecursiveGaussianImageFilter.h>
#include "itkVotingBinaryIterativeHoleFillingImageFilter.h"
#include <itkBinaryImageToShapeLabelMapFilter.h>
namespace itk {
template<class T> class SmartPointer;
}
namespace mitk {
class NodeDisplacementFilter;
class NavigationDataSource;
class PlaneFit;
class FloatingImageToUltrasoundRegistrationFilter;
}
namespace Ui {
class QmitkUSNavigationStepCtUsRegistration;
}
// Declare typedefs:
typedef itk::Image<int, 3> ImageType;
typedef itk::ThresholdImageFilter<ImageType> ThresholdImageFilterType;
typedef itk::BinaryThresholdImageFilter <ImageType, ImageType> BinaryThresholdImageFilterType;
typedef itk::LaplacianRecursiveGaussianImageFilter<ImageType, ImageType> LaplacianRecursiveGaussianImageFilterType;
typedef itk::VotingBinaryIterativeHoleFillingImageFilter<ImageType> VotingBinaryIterativeHoleFillingImageFilterType;
typedef itk::BinaryImageToShapeLabelMapFilter<ImageType> BinaryImageToShapeLabelMapFilterType;
/**
* \brief Navigation step for marking risk structures.
* The user can add risk structures by interacting with the render windows. The
* risk structures are organized in an embedded table view.
*
* The risk structures are stored under DATANAME_BASENODE -> DATANAME_ZONES.
*
* This step is ready for the next step directly after activating. All actions
* to be done in this step are optional.
*/
class QmitkUSNavigationStepCtUsRegistration : public QmitkUSAbstractNavigationStep
{
Q_OBJECT
public:
explicit QmitkUSNavigationStepCtUsRegistration(QWidget *parent = 0);
~QmitkUSNavigationStepCtUsRegistration();
/**
* \brief Initialization of the data storage nodes.
* \return always true
*/
virtual bool OnStartStep();
/**
* \brief Resets widget and filter and removes nodes from the data storage.
* \return always true
*/
virtual bool OnStopStep();
/**
* \brief There is nothing to be done.
* \return always true
*/
virtual bool OnFinishStep();
/**
* \brief Selects input for the node displacement filter and emits "ReadyForNextStep" signal.
* The input selection cannot be done earlier.
* \return
*/
virtual bool OnActivateStep();
virtual bool OnDeactivateStep();
/**
* \brief Updates the tracking validity status and the combined modality.
*/
virtual void OnUpdate();
/**
* The property "settings.interaction-concept" is used.
*/
virtual void OnSettingsChanged(const itk::SmartPointer<mitk::DataNode> settingsNode);
virtual QString GetTitle();
/**
* @return a node displacement filter for the zone surfaces
*/
virtual FilterVector GetFilter();
void OnCalculateTRE(mitk::Point3D centroidOfTargetInUSImage);
signals:
void ActualizeCtToUsRegistrationWidget();
void GetCursorPosition();
protected:
virtual void OnSetCombinedModality();
void UnsetFloatingImageGeometry();
void SetFloatingImageGeometryInformation(mitk::Image* image);
double GetVoxelVolume();
double GetFiducialVolume(double radius);
bool FilterFloatingImage();
void InitializeImageFilters();
double GetCharacteristicDistanceAWithUpperMargin();
double GetCharacteristicDistanceBWithLowerMargin();
double GetCharacteristicDistanceBWithUpperMargin();
double GetMinimalFiducialConfigurationDistance();
void CreateMarkerModelCoordinateSystemPointSet();
//Methods for Ground-Truth-Fiducial-Localization-Protocol-Evaluation
void InitializePointsToTransformForGroundTruthProtocol();
void CreatePointsToTransformForGroundTruthProtocol();
void TransformPointsGroundTruthProtocol();
void AddTransformedPointsToDataStorage();
double CalculateMeanFRE();
double CalculateStandardDeviationOfFRE(double meanFRE);
void CalculateGroundTruthProtocolTRE();
// End methods Ground-Truth-Protocol
void EliminateTooSmallLabeledObjects( ImageType::Pointer binaryImage);
bool EliminateFiducialCandidatesByEuclideanDistances();
void ClassifyFiducialCandidates();
void GetCentroidsOfLabeledObjects();
void NumerateFiducialMarks();
void CalculateDistancesBetweenFiducials(std::vector<std::vector<double>> &distanceVectorsFiducials);
bool FindFiducialNo1(std::vector<std::vector<double>> &distanceVectorsFiducials);
bool FindFiducialNo2And3();
bool FindFiducialNo4(std::vector<std::vector<double>> &distanceVectorsFiducials);
bool FindFiducialNo5();
bool FindFiducialNo6();
bool FindFiducialNo7();
bool FindFiducialNo8();
+ bool m_UpdateRunning;
void DefineDataStorageImageFilter();
void CreateQtPartControl(QWidget *parent);
protected slots:
void OnFloatingImageComboBoxSelectionChanged(const mitk::DataNode* node);
void OnRegisterMarkerToFloatingImageCS();
void OnLocalizeFiducials();
void OnVisualizeCTtoUSregistration();
void OnFreeze();
void OnActualizeSegmentationSurfacePointSetData();
void OnGetCursorPosition();
+ void OnAddSurface();
void OnCalculateCenter();
//Methods for Ground-Truth-Fiducial-Localization-Protocol-Evaluation
void OnAddCtImageClicked();
void OnRemoveCtImageClicked();
void OnEvaluateGroundTruthFiducialLocalizationProtocol();
private:
Ui::QmitkUSNavigationStepCtUsRegistration *ui;
mitk::NodePredicateAnd::Pointer m_IsOfTypeImagePredicate;
mitk::NodePredicateOr::Pointer m_IsASegmentationImagePredicate;
mitk::NodePredicateAnd::Pointer m_IsAPatientImagePredicate;
mitk::TNodePredicateDataType<mitk::PointSet>::Pointer m_IsAPointSetPredicate;
mitk::NodePredicateDataType::Pointer m_IsASurfacePredicate;
itk::SmartPointer<mitk::NavigationDataSource> m_NavigationDataSource;
mitk::Image::Pointer m_FloatingImage;
mitk::PointSet::Pointer m_MarkerModelCoordinateSystemPointSet;
mitk::PointSet::Pointer m_MarkerFloatingImageCoordinateSystemPointSet;
std::vector<mitk::Image::Pointer> m_ImagesGroundTruthProtocol;
bool m_PerformingGroundTruthProtocolEvaluation;
std::vector<double> m_GroundTruthProtocolFRE;
std::map<int, double> m_GroundTruthProtocolTRE;
std::map<int, mitk::Point3D> m_PointsToTransformGroundTruthProtocol;
std::map<int, mitk::PointSet::Pointer> m_GroundTruthProtocolTransformedPoints;
ThresholdImageFilterType::Pointer m_ThresholdFilter;
BinaryThresholdImageFilterType::Pointer m_BinaryThresholdFilter;
LaplacianRecursiveGaussianImageFilterType::Pointer m_LaplacianFilter1;
LaplacianRecursiveGaussianImageFilterType::Pointer m_LaplacianFilter2;
VotingBinaryIterativeHoleFillingImageFilterType::Pointer m_HoleFillingFilter;
BinaryImageToShapeLabelMapFilterType::Pointer m_BinaryImageToShapeLabelMapFilter;
itk::SmartPointer<mitk::FloatingImageToUltrasoundRegistrationFilter> m_FloatingImageToUltrasoundRegistrationFilter;
std::vector<mitk::Vector3D> m_CentroidsOfFiducialCandidates;
std::map<double, mitk::Vector3D> m_EigenVectorsFiducialCandidates;
std::vector<double> m_EigenValuesFiducialCandidates;
mitk::Vector3D m_MeanCentroidFiducialCandidates;
std::map<int, mitk::Vector3D> m_FiducialMarkerCentroids;
mitk::AffineTransform3D::Pointer m_TransformMarkerCSToFloatingImageCS;
/*!
\brief The 3D dimension of the CT image given in index size.
*/
mitk::Vector3D m_ImageDimension;
mitk::Vector3D m_ImageSpacing;
bool m_FreezeCombinedModality;
mitk::Point3D m_CentroidOfTargetInUSImage;
};
#endif // QMITKUSNAVIGATIONSTEPCTUSREGISTRATION_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCtUsRegistration.ui b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCtUsRegistration.ui
index fe3e112e7e..0d2884e4d0 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCtUsRegistration.ui
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCtUsRegistration.ui
@@ -1,377 +1,384 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>QmitkUSNavigationStepCtUsRegistration</class>
<widget class="QWidget" name="QmitkUSNavigationStepCtUsRegistration">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
- <width>403</width>
+ <width>412</width>
<height>933</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QGroupBox" name="optionsGroupBox">
<property name="title">
<string>Options</string>
</property>
<layout class="QFormLayout" name="formLayout">
<item row="0" column="0">
<widget class="QRadioButton" name="fiducialDiameter5mmRadioButton">
<property name="text">
<string>5mm Fiducial Diameter</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QRadioButton" name="fiducialDiameter3mmRadioButton">
<property name="text">
<string>3mm Fiducial Diameter</string>
</property>
<property name="checked">
<bool>false</bool>
</property>
</widget>
</item>
<item row="4" column="0">
<widget class="QLabel" name="selectFiducialMarkerConfigurationLabel">
<property name="text">
<string>Select Fiducial Marker Configuration</string>
</property>
</widget>
</item>
<item row="4" column="1">
<widget class="QComboBox" name="fiducialMarkerConfigurationComboBox">
<item>
<property name="text">
<string>10mm Minimal Distance</string>
</property>
</item>
<item>
<property name="text">
<string>15mm Minimal Distance</string>
</property>
</item>
<item>
<property name="text">
<string>20mm Minimal Distance</string>
</property>
</item>
</widget>
</item>
<item row="1" column="0" colspan="2">
<widget class="QCheckBox" name="useNdiTrackerCheckBox">
<property name="text">
<string>Use NDI-Tracker (if unchecked, Polhemus-Tracker is assumed to be used)</string>
</property>
<property name="autoExclusive">
<bool>false</bool>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="classicWayRegisteringCtImageGroupBox">
<property name="title">
<string>Classic Way Of Registering Floating Image</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_4">
<item>
<widget class="QLabel" name="selectedFloatingImageLabel">
<property name="text">
<string>Selected Floating Image:</string>
</property>
</widget>
</item>
<item>
<widget class="QmitkDataStorageComboBox" name="floatingImageComboBox"/>
</item>
<item>
<spacer name="verticalSpacer_2">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QPushButton" name="localizeFiducialMarkerPushButton">
<property name="text">
<string>Localize Fiducial Marker</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="doRegistrationMarkerToImagePushButton">
<property name="text">
<string>Do Registration Marker CS -> Floating Image CS</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="selectedSegmentationsLabel">
<property name="text">
<string>Selected Segmentation(s):</string>
</property>
</widget>
</item>
<item>
<widget class="QmitkDataStorageComboBox" name="segmentationComboBox"/>
</item>
<item>
<widget class="QLabel" name="selectedSurfaceLabel">
<property name="text">
<string>Selected Surface:</string>
</property>
</widget>
</item>
<item>
<widget class="QmitkDataStorageComboBox" name="selectedSurfaceComboBox"/>
</item>
+ <item>
+ <widget class="QPushButton" name="m_AddSurface">
+ <property name="text">
+ <string>Add to addtional surfaces</string>
+ </property>
+ </widget>
+ </item>
<item>
<widget class="QLabel" name="pointSetComboBoxLabel">
<property name="text">
<string>Selected PointSet:</string>
</property>
</widget>
</item>
<item>
<widget class="QmitkDataStorageComboBox" name="pointSetComboBox"/>
</item>
<item>
<widget class="QPushButton" name="visualizeCTtoUSregistrationPushButton">
<property name="text">
<string>Visualize CT-to-US-registration</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="freezeUnfreezePushButton">
<property name="text">
<string>Freeze</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="actualizeSegmentationSurfacePSetDataPushButton">
<property name="text">
<string>Actualize Segmentation + Surface + PointSet Data</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="calculateTREPushButton">
<property name="text">
<string>Calculate TRE</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="distanceTRELabel">
<property name="text">
<string>Distance (TRE) between centroid of FloatingImage-target and
US-image target (in mm):</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="distanceTREValue">
<property name="text">
<string>0.000</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="groundTruthFiducialLocalizationProtocolGroupBox">
<property name="title">
<string>Ground-Truth-Fiducial-Localization-Protocol</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_2">
<item>
<widget class="QmitkDataStorageComboBox" name="ctImagesToChooseComboBox"/>
</item>
<item>
<widget class="QLabel" name="chosenCtImagesLabel">
<property name="text">
<string>Chosen CT images:</string>
</property>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<property name="topMargin">
<number>0</number>
</property>
<item>
<widget class="QListWidget" name="chosenCtImagesListWidget"/>
</item>
<item>
<layout class="QVBoxLayout" name="verticalLayout_5">
<property name="rightMargin">
<number>0</number>
</property>
<item>
<widget class="QPushButton" name="addCtImagePushButton">
<property name="text">
<string>Add</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="removeCtImagePushButton">
<property name="text">
<string>Remove</string>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_2">
<property name="topMargin">
<number>0</number>
</property>
<item>
<widget class="QLabel" name="label">
<property name="text">
<string>Select Protocol-Evaluation-Type:</string>
</property>
</widget>
</item>
<item>
<widget class="QComboBox" name="protocolEvaluationTypeComboBox">
<item>
<property name="text">
<string>PLANE</string>
</property>
</item>
<item>
<property name="text">
<string>ANGLE</string>
</property>
</item>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QPushButton" name="evaluateProtocolPushButton">
<property name="text">
<string>Evaluate</string>
</property>
</widget>
</item>
<item>
<layout class="QFormLayout" name="formLayout_2">
<property name="fieldGrowthPolicy">
<enum>QFormLayout::ExpandingFieldsGrow</enum>
</property>
<property name="horizontalSpacing">
<number>20</number>
</property>
<property name="verticalSpacing">
<number>10</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<item row="0" column="0">
<widget class="QLabel" name="meanFRELabel">
<property name="text">
<string>Mean FRE (in mm):</string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QLabel" name="meanFREValue">
<property name="text">
<string>0</string>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QLabel" name="sdFRELabel">
<property name="text">
<string>Sd FRE (in mm):</string>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QLabel" name="sdFREValue">
<property name="text">
<string>0</string>
</property>
</widget>
</item>
<item row="2" column="0">
<widget class="QLabel" name="TRELabel">
<property name="text">
<string>TRE (in mm):</string>
</property>
</widget>
</item>
<item row="2" column="1">
<widget class="QLabel" name="TREValue">
<property name="text">
<string>0</string>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QPushButton" name="calculateCenterPushButton">
<property name="text">
<string>Calculate Centroid Of Segmentation</string>
</property>
</widget>
</item>
<item>
<spacer name="verticalSpacer">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
<customwidgets>
<customwidget>
<class>QmitkDataStorageComboBox</class>
<extends>QComboBox</extends>
<header location="global">QmitkDataStorageComboBox.h</header>
</customwidget>
</customwidgets>
<resources>
<include location="../../../resources/USNavigation.qrc"/>
</resources>
<connections/>
</ui>