diff --git a/Modules/SurfaceRegistration/include/MitkSurfaceRegistrationManager.h b/Modules/SurfaceRegistration/include/MitkSurfaceRegistrationManager.h index 3b6956c05a..6959a38028 100644 --- a/Modules/SurfaceRegistration/include/MitkSurfaceRegistrationManager.h +++ b/Modules/SurfaceRegistration/include/MitkSurfaceRegistrationManager.h @@ -1,82 +1,84 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef mitkSurfaceRegistrationManager_h #define mitkSurfaceRegistrationManager_h #include "mitkSurface.h" #include #include "mitkDataNode.h" #include #include #include #include #include #include #include #include #include #include namespace mitk { class MITKSURFACEREGISTRATION_EXPORT SurfaceRegistrationManager { public: SurfaceRegistrationManager(mitk::Surface::Pointer moving, mitk::Surface::Pointer target); ~SurfaceRegistrationManager(); - void execute(); + mitk::Surface::Pointer performRegistration(); + void performComparison(); + vtkSmartPointer getTable(); mitk::DataNode::Pointer getColourTransformedDataNode(); void setMirroring(bool mirroring); bool getMirroring(); mitk::Surface::Pointer getRegisteredSurface(); private: void manageICPCalculation(); void manageCalculateDistances(); void createLookUpTable(); void printPoints(mitk::Surface::Pointer surfaceA, mitk::Surface::Pointer surfaceB);//for test purposes --> CPD mitk::Surface::Pointer m_MovingSurface; mitk::Surface::Pointer m_TargetSurface; mitk::Surface::Pointer m_RegisteredSurface; mitk::Surface::Pointer m_MirroredSurface; ShortestDistanceCalculator *m_DistanceCalculator; vtkSmartPointer m_LookupTable; bool m_Mirroring = false; }; } #endif diff --git a/Modules/SurfaceRegistration/include/mitkPointShortestDistanceCalculator.cpp b/Modules/SurfaceRegistration/include/mitkPointShortestDistanceCalculator.cpp index cbac3fd38e..05fbde395d 100644 --- a/Modules/SurfaceRegistration/include/mitkPointShortestDistanceCalculator.cpp +++ b/Modules/SurfaceRegistration/include/mitkPointShortestDistanceCalculator.cpp @@ -1,96 +1,94 @@ /*=================================================================== 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 "mitkPointShortestDistanceCalculator.h" #include "vtkCellLocator.h" #include "vtkPointData.h" #include "vtkImplicitPolyDataDistance.h" #include "vtkDoubleArray.h" #include #include #include #include #include #include #include // std::abs mitk::PointShortestDistanceCalculator::PointShortestDistanceCalculator(vtkSmartPointer moving, vtkSmartPointer target) : ShortestDistanceCalculator(moving, target) { m_Moving = moving; m_Target = target; } mitk::PointShortestDistanceCalculator::~PointShortestDistanceCalculator() { m_Moving->Delete(); m_Target->Delete(); m_Distances->Delete(); } void mitk::PointShortestDistanceCalculator::calculateShortestDistance() { MITK_INFO << "calculate shortest distance between points..."; m_Distances = vtkSmartPointer::New(); - double fromPoint[3]; - double closestPoint[3]; + double fromPoint[3] = { 0,0,0 }; + double closestPoint[3] = { 0,0,0 }; int pointSetSize = 0; - double mean = 0; - double rangeMin = 0; - double rangeMax = 0; + double mean = 0.0; + double rangeMin = 0.0; + double rangeMax = 0.0; pointSetSize = m_Moving->GetPoints()->GetNumberOfPoints(); // Create the tree vtkSmartPointer kDTree = vtkSmartPointer::New(); kDTree->SetDataSet(m_Target); kDTree->BuildLocator(); for (int i = 0; i < pointSetSize; ++i) { m_Moving->GetPoints()->GetPoint(i, fromPoint); vtkIdType iD = kDTree->FindClosestPoint(fromPoint); kDTree->GetDataSet()->GetPoint(iD, closestPoint); double distance = sqrt(vtkMath::Distance2BetweenPoints(fromPoint, closestPoint)); - /* double distance = std::sqrt(((fromPoint[0] - closestPoint[0])*(fromPoint[0] - closestPoint[0])) + - ((fromPoint[1] - closestPoint[1]) * (fromPoint[1] - closestPoint[1])) + ((fromPoint[2] - closestPoint[2]) * (fromPoint[2] - closestPoint[2])));*/ m_Distances->InsertNextValue(distance); if (distance < rangeMin) { rangeMin = distance; } else if (distance > rangeMax) { rangeMax = distance; } mean += distance; } mean = mean / pointSetSize; setDistances(m_Distances); double standardDeviation = std::sqrt(calculateVariance(mean, pointSetSize)); setStandardDeviation(standardDeviation); MITK_INFO << "Min Value is: " << rangeMin; MITK_INFO << "Max Value is: " << rangeMax; MITK_INFO << "The Mean is: " << mean; MITK_INFO << "STD: " << standardDeviation; setMean(mean); setRangeMax(rangeMax); setRangeMax(rangeMin); } diff --git a/Modules/SurfaceRegistration/src/mitkSurfaceRegistrationManager.cpp b/Modules/SurfaceRegistration/src/mitkSurfaceRegistrationManager.cpp index b90d6723a9..52a6f95b8d 100644 --- a/Modules/SurfaceRegistration/src/mitkSurfaceRegistrationManager.cpp +++ b/Modules/SurfaceRegistration/src/mitkSurfaceRegistrationManager.cpp @@ -1,201 +1,213 @@ /*=================================================================== 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 #include #include #include #include #include #include #include +#include #include #include #include #include #include #include #include mitk::SurfaceRegistrationManager::SurfaceRegistrationManager(mitk::Surface::Pointer moving, mitk::Surface::Pointer target) { this->m_MovingSurface = moving; this->m_TargetSurface = target; this->m_Mirroring = false; createLookUpTable(); } mitk::SurfaceRegistrationManager::~SurfaceRegistrationManager() { m_MovingSurface->Delete(); m_TargetSurface->Delete(); m_RegisteredSurface->Delete(); m_LookupTable->Delete(); } -void mitk::SurfaceRegistrationManager::execute() +mitk::Surface::Pointer mitk::SurfaceRegistrationManager::performRegistration() { - if (m_Mirroring) { MitkSurfaceMirroringHelper *mirroringHelper = new MitkSurfaceMirroringHelper(); m_MirroredSurface = mirroringHelper->performMirroring(m_MovingSurface); } //printPoints(); //after mirroring manageICPCalculation(); - //printPoints(); - printPoints(m_RegisteredSurface, m_TargetSurface); //before mirroring - MITK_INFO << "Print Points after registration!"; + //printPoints(); + //printPoints(m_RegisteredSurface, m_TargetSurface); //after mirroring + //mitk::IOUtil::Save(m_RegisteredSurface, "testRegistered.stl"); + //mitk::IOUtil::Save(m_TargetSurface, "testTarget.stl"); + + return m_RegisteredSurface; +} + +void mitk::SurfaceRegistrationManager::performComparison() +{ + if (m_Mirroring) + { + MitkSurfaceMirroringHelper *mirroringHelper = new MitkSurfaceMirroringHelper(); + m_MirroredSurface = mirroringHelper->performMirroring(m_MovingSurface); + } manageCalculateDistances(); } vtkSmartPointer mitk::SurfaceRegistrationManager::getTable() { return m_LookupTable; } mitk::DataNode::Pointer mitk::SurfaceRegistrationManager::getColourTransformedDataNode() { mitk::Surface::Pointer currentSurface; if (m_RegisteredSurface != nullptr) { currentSurface = m_RegisteredSurface; } else if(m_MirroredSurface!= nullptr) { currentSurface = m_MirroredSurface; } else { currentSurface = m_MovingSurface; } currentSurface->GetVtkPolyData()->GetPointData()->SetScalars(m_DistanceCalculator->getDistances()); currentSurface->GetVtkPolyData()->GetPointData()->Update(); //convert m_LookUpTable to mitk LookUpTable mitk::LookupTable::Pointer lut = mitk::LookupTable::New(); lut->SetVtkLookupTable(m_LookupTable); mitk::LookupTableProperty::Pointer prop = mitk::LookupTableProperty::New(lut); currentSurface->GetVtkPolyData()->GetPointData()->Update(); mitk::DataNode::Pointer transformedNode = mitk::DataNode::New(); transformedNode->SetProperty("LookupTable", prop); transformedNode->SetBoolProperty("scalar visibility", true); transformedNode->SetBoolProperty("color mode", true); //set Range of Lut double range = m_DistanceCalculator->getDistanceRange(); transformedNode->SetFloatProperty("ScalarsRangeMinimum", range*-1); transformedNode->SetFloatProperty("ScalarsRangeMaximum", range); //transformedNode->SetFloatProperty("ScalarsRangeMinimum", -5); //transformedNode->SetFloatProperty("ScalarsRangeMaximum", 5); // Configure material so that only scalar colors are shown transformedNode->SetColor(1.0f, 1.0f, 1.0f); transformedNode->SetOpacity(1.0f); transformedNode->SetFloatProperty("material.wireframeLineWidth", 2.0f); //Set view of plane to VTK_SURFACE transformedNode->SetProperty("material.representation", mitk::VtkRepresentationProperty::New());//VTK_SURFACE currently default // save colored surface node transformedNode->SetData(currentSurface); return transformedNode; } void mitk::SurfaceRegistrationManager::setMirroring(bool mirroring) { this->m_Mirroring = mirroring; } bool mitk::SurfaceRegistrationManager::getMirroring() { return m_Mirroring; } mitk::Surface::Pointer mitk::SurfaceRegistrationManager::getRegisteredSurface() { return m_RegisteredSurface; } void mitk::SurfaceRegistrationManager::manageICPCalculation() { MITK_INFO << "Starting registration"; m_RegisteredSurface = mitk::Surface::New(); mitk::SurfaceRegistrationICP *registrationHelper = new SurfaceRegistrationICP(); if (m_Mirroring) { m_RegisteredSurface = registrationHelper->CalculateICP(m_MirroredSurface, m_TargetSurface); } else { m_RegisteredSurface = registrationHelper->CalculateICP(m_MovingSurface, m_TargetSurface); } } void mitk::SurfaceRegistrationManager::manageCalculateDistances() { if (m_RegisteredSurface != nullptr) { m_DistanceCalculator = new ShortestDistanceCalculator(m_RegisteredSurface->GetVtkPolyData(), m_TargetSurface->GetVtkPolyData()); } else if(m_Mirroring) { m_DistanceCalculator = new ShortestDistanceCalculator(m_MirroredSurface->GetVtkPolyData(), m_TargetSurface->GetVtkPolyData()); } else { m_DistanceCalculator = new ShortestDistanceCalculator(m_MovingSurface->GetVtkPolyData(), m_TargetSurface->GetVtkPolyData()); } m_DistanceCalculator->calculateShortestDistance(); } void mitk::SurfaceRegistrationManager::createLookUpTable() { m_LookupTable = vtkSmartPointer::New(); m_LookupTable->SetNumberOfTableValues(25); m_LookupTable->Build(); } void mitk::SurfaceRegistrationManager::printPoints(mitk::Surface::Pointer surfaceA, mitk::Surface::Pointer surfaceB) { MITK_INFO << "printing Points"; std::ofstream OutputFileMoving; OutputFileMoving.open("movingPoints.txt"); int pointNumber = surfaceA->GetVtkPolyData()->GetPoints()->GetNumberOfPoints(); double printPoint[3] = { 0,0,0 }; for (int i = 0; i < pointNumber; ++i) { surfaceA->GetVtkPolyData()->GetPoints()->GetPoint(i, printPoint); OutputFileMoving << printPoint[0]<<" " << printPoint[1] << " " << printPoint[2] <GetVtkPolyData()->GetPoints()->GetNumberOfPoints(); double printPoint2[3] = { 0,0,0 }; for (int i = 0; i < pointNumber2; ++i) { surfaceB->GetVtkPolyData()->GetPoints()->GetPoint(i, printPoint2); OutputFileTarget << printPoint2[0] << " " << printPoint2[1] << " " << printPoint2[2] << std::endl; } OutputFileTarget.close(); } \ No newline at end of file diff --git a/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/QmitkSurfaceRegistration.cpp b/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/QmitkSurfaceRegistration.cpp index 45cc312691..d4a837a7a7 100644 --- a/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/QmitkSurfaceRegistration.cpp +++ b/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/QmitkSurfaceRegistration.cpp @@ -1,254 +1,513 @@ /*========================================================================= Program: Medical Imaging & Interaction Toolkit Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. See MITKCopyright.txt or http://www.mitk.org/copyright.html for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "QmitkSurfaceRegistration.h" -#include -#include + +//#include +//#include #include #include #include #include +#include +#include +#include + + #include #include #include #include #include #include #include #include #include #include +#include "org_mitk_gui_qt_surfaceregistration_Activator.h" + #include -#include +#include +#include #include #include #include +#include + const std::string QmitkSurfaceRegistration::VIEW_ID = "org.mitk.views.surfaceregistration"; QmitkSurfaceRegistration::QmitkSurfaceRegistration(QObject *parent) : m_ParentWidget(0) { } QmitkSurfaceRegistration::~QmitkSurfaceRegistration() { m_movingSurface = nullptr; m_targetSurface = nullptr; } void QmitkSurfaceRegistration::SetFocus() { - m_Controls.executePushButton->setFocus(); + m_Controls.registerAndComparePushButton->setFocus(); } QWidget * QmitkSurfaceRegistration::GetControls() { return nullptr; } void QmitkSurfaceRegistration::CreateQtPartControl(QWidget *parent) { // create GUI widgets from the Qt Designer's .ui file m_Controls.setupUi(parent); m_Controls.movingSurfaceNameComboBox->SetDataStorage(this->GetDataStorage()); m_Controls.movingSurfaceNameComboBox->SetPredicate(mitk::NodePredicateAnd::New( mitk::TNodePredicateDataType::New(), mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")))); m_Controls.targetSurfaceNameComboBox->SetDataStorage(this->GetDataStorage()); m_Controls.targetSurfaceNameComboBox->SetPredicate(mitk::NodePredicateAnd::New( mitk::TNodePredicateDataType::New(), mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")))); + m_Controls.imageSelectorComboBox->SetDataStorage(this->GetDataStorage()); + m_Controls.imageSelectorComboBox->SetPredicate(mitk::NodePredicateAnd::New( + mitk::TNodePredicateDataType::New(), + mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")))); - connect(m_Controls.executePushButton, SIGNAL(clicked()), this, SLOT(doExecute())); + connect(m_Controls.registerAndComparePushButton, SIGNAL(clicked()), this, SLOT(doRegisterAndCompare())); connect(m_Controls.movingSurfaceNameComboBox, SIGNAL(OnSelectionChanged(const mitk::DataNode *)), this, SLOT(OnSelectedMovingSurfaceChanged(const mitk::DataNode *))); connect(m_Controls.targetSurfaceNameComboBox, SIGNAL(OnSelectionChanged(const mitk::DataNode *)), this, SLOT(OnSelectedTargetSurfaceChanged(const mitk::DataNode *))); - connect(m_Controls.executeAllPushButton, SIGNAL(clicked()), this, SLOT(doExecuteAll())); + connect(m_Controls.imageSelectorComboBox, SIGNAL(OnSelectionChanged(const mitk::DataNode *)), this, SLOT(OnSelectedImageChanged(const mitk::DataNode *))); + connect(m_Controls.registerAndCompareAllPushButton, SIGNAL(clicked()), this, SLOT(doRegisterAndCompareAll())); + connect(m_Controls.comparePushButton, SIGNAL(clicked()), this, SLOT(doCompare())); mitk::RenderingManager::GetInstance()->SetDataStorage(this->GetDataStorageReference()->GetDataStorage()); mitk::RenderingManager::GetInstance()->InitializeViews(); m_Controls.automatizedGroupBox->setEnabled(true); m_Controls.OutputLineEdit->setEnabled(true); - m_Controls.executeAllPushButton->setEnabled(true); + m_Controls.registerAndCompareAllPushButton->setEnabled(true); + + initializeWithSceneFile(); m_ParentWidget = parent; } void QmitkSurfaceRegistration::OnSelectedMovingSurfaceChanged(const mitk::DataNode *node) { if (node != nullptr) { m_movingSurface = dynamic_cast(node->GetData()); m_Controls.selectMovingSurfaceLabel->setText("Selected moving surface:"); m_Controls.mirroringCheckBox->setEnabled(true); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); if (m_targetSurface != nullptr && m_targetSurface.GetPointer() != m_movingSurface.GetPointer()) { - m_Controls.executePushButton->setEnabled(true); + m_Controls.registerAndComparePushButton->setEnabled(true); + m_Controls.comparePushButton->setEnabled(true); } } } void QmitkSurfaceRegistration::OnSelectedTargetSurfaceChanged(const mitk::DataNode *node) { if (node != nullptr) { m_targetSurface = dynamic_cast(node->GetData()); m_Controls.selectTargetSurfaceLabel->setText("Selected moving surface:"); m_Controls.mappedDataGroupBox->setEnabled(true); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); if (m_movingSurface != nullptr && m_targetSurface.GetPointer() != m_movingSurface.GetPointer()) { - m_Controls.executePushButton->setEnabled(true); + m_Controls.registerAndComparePushButton->setEnabled(true); + m_Controls.comparePushButton->setEnabled(true); } } } -void QmitkSurfaceRegistration::doExecute() +void QmitkSurfaceRegistration::OnSelectedImageChanged(const mitk::DataNode *) +{ + //TODO? +} + +void QmitkSurfaceRegistration::doRegisterAndCompare() { MITK_INFO << "execute clicked..."; - m_ShapeComparisonManager = new mitk::ShapeComparisonManager(m_movingSurface, m_targetSurface); - m_ShapeComparisonManager->setMirroring(m_Controls.mirroringCheckBox->isChecked()); - m_ShapeComparisonManager->execute(); + m_SurfaceRegistrationManager = new mitk::SurfaceRegistrationManager(m_movingSurface, m_targetSurface); + m_SurfaceRegistrationManager->setMirroring(m_Controls.mirroringCheckBox->isChecked()); + m_SurfaceRegistrationManager->performRegistration(); + m_registeredSurface = m_SurfaceRegistrationManager->getRegisteredSurface(); + + m_SurfaceRegistrationManager->performComparison(); + mitk::DataNode::Pointer colouredData = mitk::DataNode::New(); - colouredData = m_ShapeComparisonManager->getColourTransformedDataNode(); + colouredData = m_SurfaceRegistrationManager->getColourTransformedDataNode(); colouredData->SetName(m_Controls.mappedDataNameLineEdit->text().toStdString()); this->GetDataStorage()->Add(colouredData); this->GetDataStorageReference()->GetDataStorage()->Modified(); mitk::RenderingManager::GetInstance()->InitializeViews(); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); - vtkSmartPointer lut = m_ShapeComparisonManager->getTable(); + vtkSmartPointer lut = m_SurfaceRegistrationManager->getTable(); showLookUpTable(lut); } -void QmitkSurfaceRegistration::doExecuteAll() +void QmitkSurfaceRegistration::doRegisterAndCompareAll() { MITK_INFO << "Compare all surfaces in Storage "; auto datastorage = this->GetDataStorage(); mitk::NodePredicateDataType::Pointer isSurface = mitk::NodePredicateDataType::New("Surface"); mitk::DataStorage::SetOfObjects::ConstPointer surfaces = datastorage->GetSubset(isSurface); if (!surfaces->empty()) { //initialize variables mitk::Surface::Pointer tibiaLeft= nullptr; mitk::Surface::Pointer fibulaLeft = nullptr; mitk::Surface::Pointer talusLeft = nullptr; mitk::Surface::Pointer tibiaRight = nullptr; mitk::Surface::Pointer fibulaRight = nullptr; mitk::Surface::Pointer talusRight = nullptr; //iterate over all child nodes with NodePredicateProperty for (mitk::DataStorage::SetOfObjects::const_iterator iter = surfaces->begin(); iter != surfaces->end(); ++iter) { mitk::DataNode::Pointer node = (*iter); //check for left if (QString(node->GetName().c_str()).contains(QString("L"), Qt::CaseSensitive)) { if (QString(node->GetName().c_str()).contains(QString("Tibia"), Qt::CaseSensitive)) { mitk::DataNode* tibiaNode(this->GetDataStorage()->GetNamedNode(node->GetName())); tibiaLeft = dynamic_cast(tibiaNode->GetData()); } else if (QString(node->GetName().c_str()).contains(QString("Fibula"), Qt::CaseSensitive)) { mitk::DataNode* fibulaNode(this->GetDataStorage()->GetNamedNode(node->GetName())); fibulaLeft = dynamic_cast(fibulaNode->GetData()); } else if (QString(node->GetName().c_str()).contains(QString("Talus"), Qt::CaseSensitive)) { mitk::DataNode* talusNode(this->GetDataStorage()->GetNamedNode(node->GetName())); talusLeft = dynamic_cast(talusNode->GetData()); } }//check for right else if (QString(node->GetName().c_str()).contains(QString("R"), Qt::CaseSensitive)) { if (QString(node->GetName().c_str()).contains(QString("Tibia"), Qt::CaseSensitive)) { mitk::DataNode* tibiaMovingNode(this->GetDataStorage()->GetNamedNode(node->GetName())); tibiaRight = dynamic_cast(tibiaMovingNode->GetData()); } else if (QString(node->GetName().c_str()).contains(QString("Fibula"), Qt::CaseSensitive)) { mitk::DataNode* fibulaMovingNode(this->GetDataStorage()->GetNamedNode(node->GetName())); fibulaRight = dynamic_cast(fibulaMovingNode->GetData()); } else if (QString(node->GetName().c_str()).contains(QString("Talus"), Qt::CaseSensitive)) { mitk::DataNode* talusMovingNode(this->GetDataStorage()->GetNamedNode(node->GetName())); talusRight = dynamic_cast(talusMovingNode->GetData()); } } } MITK_INFO << "Calculating Tibia..."; performTwoSidedComparison(tibiaLeft, tibiaRight, "Tibia"); MITK_INFO << "Calculating Fibula..."; performTwoSidedComparison(fibulaLeft, fibulaRight, "Fibula"); MITK_INFO << "Calculating Talus..."; performTwoSidedComparison(talusLeft, talusRight, "Target"); } + testloadPosition(); } -void QmitkSurfaceRegistration::performTwoSidedComparison(mitk::Surface::Pointer left, mitk::Surface::Pointer right, QString resultName) +void QmitkSurfaceRegistration::doCompare() { + m_SurfaceRegistrationManager = new mitk::SurfaceRegistrationManager(m_movingSurface, m_targetSurface); + m_SurfaceRegistrationManager->performComparison(); + mitk::DataNode::Pointer colouredData = mitk::DataNode::New(); + colouredData = m_SurfaceRegistrationManager->getColourTransformedDataNode(); + colouredData->SetName(m_Controls.mappedDataNameLineEdit->text().toStdString()); + this->GetDataStorage()->Add(colouredData); + this->GetDataStorageReference()->GetDataStorage()->Modified(); + + mitk::RenderingManager::GetInstance()->InitializeViews(); + mitk::RenderingManager::GetInstance()->RequestUpdateAll(); + + vtkSmartPointer lut = m_SurfaceRegistrationManager->getTable(); + showLookUpTable(lut); + // careful + // testloadPosition(); + + //iteratePlanePosition(axial); + //iteratePlanePosition(coronal); + // iteratePlanePosition(saggital); + +} + +void QmitkSurfaceRegistration::performTwoSidedComparison(mitk::Surface::Pointer left, mitk::Surface::Pointer right, QString resultName) +{ if (left != nullptr && right != nullptr) { m_Controls.mirroringCheckBox->setChecked(true); - m_movingSurface = left; m_targetSurface = right; m_Controls.mappedDataNameLineEdit->setText(resultName + "MovingL"); - doExecute(); + doRegisterAndCompare(); m_movingSurface = right; m_targetSurface = left; m_Controls.mappedDataNameLineEdit->setText(resultName + "MovingR"); - doExecute(); + doRegisterAndCompare(); } } +void QmitkSurfaceRegistration::reloadDataNodePlanePosition(const mitk::DataNode::Pointer node, int id) +{ + if (m_Controls.imageSelectorComboBox->currentIndex() <0) + return; + + QmitkRenderWindow* selectedRenderWindow = 0; + QmitkRenderWindow* axialWindow= this->GetRenderWindowPart()->GetQmitkRenderWindow("axial"); + QmitkRenderWindow* saggitalWindow = this->GetRenderWindowPart()->GetQmitkRenderWindow("sagittal"); + QmitkRenderWindow* coronalWindow = this->GetRenderWindowPart()->GetQmitkRenderWindow("coronal"); + + bool PlanarFigureInitializedWindow = false; + //find initialized renderwindow + if (node->GetBoolProperty("PlanarFigureInitializedWindow", + PlanarFigureInitializedWindow, axialWindow->GetRenderer())) + { + selectedRenderWindow = axialWindow; + } + if (!selectedRenderWindow && node->GetBoolProperty( + "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow, + saggitalWindow->GetRenderer())) + { + selectedRenderWindow = saggitalWindow; + } + if (!selectedRenderWindow && node->GetBoolProperty( + "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow, + coronalWindow->GetRenderer())) + { + selectedRenderWindow = coronalWindow; + } + if (selectedRenderWindow) + { + { + mitk::PlanePositionManagerService* service = this->getPlanePositionManagerService(); + selectedRenderWindow->GetSliceNavigationController()->ExecuteOperation(service->GetPlanePosition(id)); + } + mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll(); + } +} + +bool QmitkSurfaceRegistration::loadPlanePositions() +{ + MITK_INFO << m_Controls.imageSelectorComboBox->currentIndex(); + if (m_Controls.imageSelectorComboBox->currentIndex() <0) + return false; + + mitk::PlanePositionManagerService* service = this->getPlanePositionManagerService(); + int sliceIndex = 0; + mitk::PlanarCircle::Pointer positionMarker = mitk::PlanarCircle::New(); + + mitk::NodePredicateProperty::Pointer isMarker = mitk::NodePredicateProperty::New("isPositionNode", mitk::BoolProperty::New(true)); + mitk::DataStorage::SetOfObjects::ConstPointer markers; + + //load all nodes that are children of the working node in data storage + mitk::DataNode* imageNode(m_Controls.imageSelectorComboBox->GetSelectedNode()); + markers = this->GetDataStorage()->GetDerivations(imageNode, isMarker); + if (!markers->empty()) + { + //iterate over all child nodes with NodePredicateProperty + for (mitk::DataStorage::SetOfObjects::const_iterator iter = markers->begin(); iter != markers->end(); ++iter) + { + int markerId; + std::string nodeName = (*iter)->GetName(); + //get position nodes in the data manager and add them with the planepositionmanger service + if (nodeName == "Planeposition coronal") + { + mitk::DataNode::Pointer coronalPosNode = (*iter); + coronalPosNode->GetIntProperty("sliceIndex", sliceIndex); + positionMarker = dynamic_cast (coronalPosNode->GetData()); + mitk::PlaneGeometry::ConstPointer corPlane = positionMarker->GetPlaneGeometry(); + markerId = service->AddNewPlanePosition(corPlane, sliceIndex); + coronalPosNode->SetIntProperty("Plane Position ID", markerId); + } + else if (nodeName == "Planeposition axial") + { + mitk::DataNode::Pointer axialPosNode = (*iter); + axialPosNode->GetIntProperty("sliceIndex", sliceIndex); + positionMarker = dynamic_cast (axialPosNode->GetData()); + mitk::PlaneGeometry::ConstPointer axiPlane = positionMarker->GetPlaneGeometry(); + markerId = service->AddNewPlanePosition(axiPlane, sliceIndex); + axialPosNode->SetIntProperty("Plane Position ID", markerId); + } + else if (nodeName == "Planeposition sagittal") + { + mitk::DataNode::Pointer sagittalPosNode = (*iter); + sagittalPosNode->GetIntProperty("sliceIndex", sliceIndex); + positionMarker = dynamic_cast (sagittalPosNode->GetData()); + mitk::PlaneGeometry::ConstPointer sagPlane = positionMarker->GetPlaneGeometry(); + markerId = service->AddNewPlanePosition(sagPlane, sliceIndex); + sagittalPosNode->SetIntProperty("Plane Position ID", markerId); + } + (*iter)->GetIntProperty("Plane Position ID", markerId); + this->reloadDataNodePlanePosition((*iter), markerId); + mitk::RenderingManager::GetInstance()->RequestUpdateAll(); + } + mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll(); + return true; + } + return false; +} + +mitk::PlanePositionManagerService* QmitkSurfaceRegistration::getPlanePositionManagerService() +{ + ctkPluginContext* context = mitk::org_mitk_gui_qt_surfaceregistration_Activator::GetContext(); + ctkServiceReference ppmRef = context->getServiceReference(); + mitk::PlanePositionManagerService* service = nullptr; + service = context->getService(ppmRef); + context->ungetService(ppmRef); + return service; +} + +void QmitkSurfaceRegistration::GetAxisPositions(mitk::DataNode::Pointer node) +{ + bool planePosLoaded = loadPlanePositions(); + if (planePosLoaded) + { + for (int i = 1; i <= 3; i++) + { + std::stringstream multiWidgetStream; + multiWidgetStream << "stdmulti.widget"; + multiWidgetStream << i; + std::string multiWidgetString = multiWidgetStream.str(); + mitk::BaseRenderer *rendereri = mitk::BaseRenderer::GetByName(multiWidgetString.c_str()); + } + } +} + +void QmitkSurfaceRegistration::iteratePlanePosition(Plane plane) +{ + mitk::ShapeComparisonUtil *shapeComparer = new mitk::ShapeComparisonUtil(m_registeredSurface, m_targetSurface); + //TODO choose from img props + int stopper = 50; + for (int i = -5; i < stopper; ++i) + { + MITK_INFO << "Current plane number: " << i; + mitk::PlaneGeometry::Pointer planeGeo = translatePlane( i , plane); + shapeComparer->calculateSliceDifferences(planeGeo); + } + MITK_INFO << "finished"; +} + void QmitkSurfaceRegistration::showLookUpTable(vtkSmartPointer lut) { mitk::BaseRenderer::Pointer renderer = mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4")); m_colorBarAnnotation = mitk::ColorBarAnnotation::New(); mitk::LookupTable::Pointer mitkTable = mitk::LookupTable::New(); mitkTable->SetVtkLookupTable(lut); mitk::LookupTableProperty::Pointer prop = mitk::LookupTableProperty::New(mitkTable); m_colorBarAnnotation->SetProperty("ColorBarAnnotation.LookupTable", prop.GetPointer()); MITK_INFO<GetPropertyList(); m_colorBarAnnotation->SetNumberOfLabels(9); m_colorBarAnnotation->SetAnnotationTextScaling(true); m_colorBarAnnotation->SetDrawAnnotations(true); m_colorBarAnnotation->SetDrawTickLabels(true); mitk::LayoutAnnotationRenderer::AddAnnotation( m_colorBarAnnotation, renderer, mitk::LayoutAnnotationRenderer::Right, 10, 10, 10); } +mitk::PlaneGeometry::Pointer QmitkSurfaceRegistration::translatePlane(int id, Plane plane) +{ + mitk::DataNode::Pointer dataNode = m_Controls.imageSelectorComboBox->GetSelectedNode(); + + std::stringstream multiWidgetStream; + multiWidgetStream << "stdmulti.widget"; + switch (plane) + { + case QmitkSurfaceRegistration::axial: + multiWidgetStream << 1; + break; + case QmitkSurfaceRegistration::coronal: + multiWidgetStream << 2; + break; + case QmitkSurfaceRegistration::saggital: + multiWidgetStream << 3; + break; + default: + break; + } + std::string multiWidgetString = multiWidgetStream.str(); + mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetByName(multiWidgetString.c_str()); + const mitk::PlaneGeometry* planeGeo = dynamic_cast(renderer->GetCurrentWorldPlaneGeometry()); + mitk::PlaneGeometry::Pointer newPlaneGeo = mitk::PlaneGeometry::New(); + newPlaneGeo = planeGeo->Clone(); + mitk::Vector3D normal = newPlaneGeo->GetNormal(); + + newPlaneGeo->GetIndexToWorldTransform()->GetInverseTransform()->TransformVector(normal); // normal already in world cords?! + newPlaneGeo->Translate(normal * id); + + MITK_INFO << "Center der neuen Plane: " << newPlaneGeo->GetCenter(); + renderer->RequestUpdate(); + mitk::DataNode* imageNode(m_Controls.imageSelectorComboBox->GetSelectedNode()); + mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll(); + + return newPlaneGeo; +} +void QmitkSurfaceRegistration::initializeWithSceneFile() +{ + std::string fileName = "D:/data/AllComplete/AA246/template.mitk"; + mitk::SceneIO::Pointer sceneIO = mitk::SceneIO::New(); + sceneIO->LoadScene(fileName, this->GetDataStorageReference()->GetDataStorage(), false); + + this->GetDataStorageReference()->GetDataStorage()->Modified(); + mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll(); + mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(this->GetDataStorageReference()->GetDataStorage()); +} + +void QmitkSurfaceRegistration::testloadPosition() +{ + mitk::DataNode::Pointer selectedNode = m_Controls.imageSelectorComboBox->GetSelectedNode(); + mitk::DataNode::Pointer leftOrigNode = nullptr; + mitk::DataNode::Pointer rightOrigNode = nullptr; + if (QString(selectedNode->GetName().c_str()).contains(QString("L"), Qt::CaseSensitive)) + { + GetAxisPositions(selectedNode); + leftOrigNode = selectedNode.GetPointer(); + } + else if (QString(selectedNode->GetName().c_str()).contains(QString("R"), Qt::CaseSensitive)) + { + GetAxisPositions(selectedNode); + rightOrigNode = selectedNode.GetPointer(); + } + mitk::RenderingManager::GetInstance()->InitializeViews(); +} diff --git a/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/QmitkSurfaceRegistration.h b/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/QmitkSurfaceRegistration.h index ff4f57a99e..c4042e1db9 100644 --- a/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/QmitkSurfaceRegistration.h +++ b/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/QmitkSurfaceRegistration.h @@ -1,124 +1,176 @@ /*========================================================================= Program: Medical Imaging & Interaction Toolkit Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. See MITKCopyright.txt or http://www.mitk.org/copyright.html for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef QmitkSurfaceRegistration_h #define QmitkSurfaceRegistration_h #include #ifdef WIN32 #pragma warning( disable : 4250 ) #endif #include "QVTKWidget.h" #include "QmitkRegisterClasses.h" #include -#include +#include #include "ui_SurfaceRegistrationControls.h" #include "usServiceRegistration.h" #include "mitkAnnotation.h" #include "mitkColorBarAnnotation.h" #include "mitkDataStorage.h" #include #include #include + +#include +//#include TODO + /*! @brief QmitkSurfaceRegistrationView \warning This class is not yet documented. Use "git blame" and ask the author to provide basic documentation. \sa QmitkFunctionality \ingroup ${plugin_target}_internal */ class QmitkSurfaceRegistration : public QmitkAbstractView { // this is needed for all Qt objects that should have a Qt meta-object // (everything that derives from QObject and wants to have signal/slots) private: Q_OBJECT public: /*! @brief Constructor. Called by SampleApp (or other apps that use functionalities) */ QmitkSurfaceRegistration(QObject *parent = 0); virtual ~QmitkSurfaceRegistration(); static const std::string VIEW_ID; virtual void CreateQtPartControl(QWidget *parent); virtual void SetFocus() override; ///*! //@brief Creates the Qt connections needed //*/ QWidget* GetControls(); /// @brief Called when the user clicks the GUI button protected slots: - void doExecute(); + /*! + * @brief executes registration of moving and target surface, + * then calculates the closest distances and displays them through a lookuptable. + * TODO comparison + */ + void doRegisterAndCompare(); + + /*! + * @brief Iterates through all files in the data storage and executes for all pairs of tibia, fibula and talus + */ + void doRegisterAndCompareAll(); - void doExecuteAll(); + void doCompare(); - void OnSelectedMovingSurfaceChanged(const mitk::DataNode *); + //test + void testloadPosition(); + void OnSelectedMovingSurfaceChanged(const mitk::DataNode *); void OnSelectedTargetSurfaceChanged(const mitk::DataNode *); + void OnSelectedImageChanged(const mitk::DataNode *); protected: - // /*! - //@brief called by QmitkFunctionality when DataManager's selection has changed - // */ - //void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList& nodes) override; - private: /*! * The parent QWidget */ QWidget* m_ParentWidget; mitk::BaseRenderer *m_Renderer; /*! * @brief A pointer to the node of the moving surface. */ mitk::Surface::Pointer m_movingSurface; /*! * @brief A pointer to the node of the target surface. */ mitk::Surface::Pointer m_targetSurface; - mitk::ShapeComparisonManager *m_ShapeComparisonManager; + + mitk::Surface::Pointer m_registeredSurface; + + mitk::SurfaceRegistrationManager *m_SurfaceRegistrationManager; Ui::SurfaceRegistrationControls m_Controls; mitk::ColorBarAnnotation::Pointer m_colorBarAnnotation; void showLookUpTable(vtkSmartPointer lut); + + //automatization void performTwoSidedComparison(mitk::Surface::Pointer left, mitk::Surface::Pointer right, QString resultName); + + /*! + * @brief Reloads the plane position of the node in the corresponding rendering window + * @param int id Id of the markerID corresponding to the rendering window + * @param const DataNode::Pointer node + */ + void reloadDataNodePlanePosition(const mitk::DataNode::Pointer node, int id); + + + enum Plane { axial, coronal, saggital }; + /*! + * @brief loads the adjusted plan positions from the data storage. The rendering windows are updated afterwards. + * @returns true if plane positions are successfully loaded + */ + bool loadPlanePositions(); + + mitk::PlanePositionManagerService* getPlanePositionManagerService(); + + //TODO + void GetAxisPositions(mitk::DataNode::Pointer node); + + void iteratePlanePosition(Plane plane); + + + + /*! + * @brief translates the plane in direction of its normal by the length of the id + * @param int id the lenght of the normal + * @param Plane plane the plane to translate + */ + mitk::PlaneGeometry::Pointer translatePlane(int id, Plane plane); + + //testing + void initializeWithSceneFile(); + }; #endif // QmitkSurfaceRegistration_h \ No newline at end of file diff --git a/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/SurfaceRegistrationControls.ui b/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/SurfaceRegistrationControls.ui index 7a4da598a1..6a0e182866 100644 --- a/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/SurfaceRegistrationControls.ui +++ b/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/SurfaceRegistrationControls.ui @@ -1,417 +1,436 @@ SurfaceRegistrationControls Qt::WindowModal true 0 0 434 566 - + 0 0 - 100 - 100 + 0 + 90 16777215 16777215 + + + 0 + 90 + + QmitkTemplate true 0 0 0 95 Moving false 0 0 QLabel { color: rgb(0, 0, 0) } Select moving surface false Mirroring true 0 0 0 75 Target false 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 QLabel { color: rgb(0, 0, 0) } Select target surface true false 0 0 0 75 0 75 Mapped Data 0 0 0 0 0 0 120 120 120 Type mapped data name: defaultMappedData - + false - Execute + Compare + + + + + + + false + + + Register and compare 0 0 - 0 + 200 95 - Automatized Evaluation + Automated Evaluation - - - - 10 - 20 - 388 - 22 - - - - - 0 - 0 - - - - OutputFile.txt - - - - - - - - false - - - - 10 - 50 - 388 - 28 - - - - - 0 - 0 - - - - Execute for All - - + + + + + true + + + + 0 + 0 + + + + + + + + + 0 + 0 + + + + OutputFile.txt + + + + + + + + + + false + + + + 0 + 0 + + + + Register and compare alll + + + + Qt::Vertical 20 40 QmitkDataStorageComboBox QComboBox
QmitkDataStorageComboBox.h