diff --git a/Modules/SurfaceRegistration/include/mitkShapeComparisonUtil.h b/Modules/SurfaceRegistration/include/mitkShapeComparisonUtil.h index c060f6b60a..4644810dc2 100644 --- a/Modules/SurfaceRegistration/include/mitkShapeComparisonUtil.h +++ b/Modules/SurfaceRegistration/include/mitkShapeComparisonUtil.h @@ -1,55 +1,54 @@ /*=================================================================== 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 ShapeComparisonUtil_h #define ShapeComparisonUtil_h #include #include #include #include #include #include namespace mitk { class MITKSURFACEREGISTRATION_EXPORT ShapeComparisonUtil { public: ShapeComparisonUtil(mitk::Surface::Pointer movedSurface, mitk::Surface::Pointer targetSurface); ~ShapeComparisonUtil(); void calculateSliceDifferences(mitk::PlaneGeometry::Pointer planegeo); void setMovedSurface(mitk::Surface::Pointer node); void setTargetSurface(mitk::Surface::Pointer node); private: mitk::Surface::Pointer m_MovedSurface = nullptr; mitk::Surface::Pointer m_TargetSurface = nullptr; - void printSliceDifferences(std::string outputFile, mitk::ShortestDistanceCalculator *calculator); vtkSmartPointer getPointsOnPlane(vtkSmartPointer pointset, mitk::PlaneGeometry::Pointer planegeo); std::ofstream m_OutputFile; unsigned int m_counter = 0; }; } #endif diff --git a/Modules/SurfaceRegistration/include/mitkShortestDistanceCalculator.h b/Modules/SurfaceRegistration/include/mitkShortestDistanceCalculator.h index 45df071b4c..f8694c4760 100644 --- a/Modules/SurfaceRegistration/include/mitkShortestDistanceCalculator.h +++ b/Modules/SurfaceRegistration/include/mitkShortestDistanceCalculator.h @@ -1,62 +1,64 @@ /*=================================================================== 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 mitkShortestDistanceCalculator_h #define mitkShortestDistanceCalculator_h #include #include namespace mitk{ class ShortestDistanceCalculator { public: ShortestDistanceCalculator(vtkSmartPointer moving, vtkSmartPointer target); ~ShortestDistanceCalculator(); void calculateShortestDistance(); + void calculateCurvature(); + double getDistanceRange(); double getRangeMin(); double getRangeMax(); double getMean(); double getStandardDeviation(); vtkSmartPointer getDistances(); protected: void setDistances(vtkSmartPointer distances); void setRangeMin(double rangeMin); void setRangeMax(double rangeMax); void setMean(double mean); void setStandardDeviation(double std); double calculateVariance(double mean, int pointSetSize) const; private: vtkSmartPointer m_Distances; vtkSmartPointer m_Moving; vtkSmartPointer m_Target; double m_RangeMin; double m_RangeMax; double m_Mean; double m_StandardDeviation; }; }; #endif \ No newline at end of file diff --git a/Modules/SurfaceRegistration/src/DataManagement/MitkShortestDistanceCalculator.cpp b/Modules/SurfaceRegistration/src/DataManagement/MitkShortestDistanceCalculator.cpp index 3dd1fe502c..2bb3ba5bdb 100644 --- a/Modules/SurfaceRegistration/src/DataManagement/MitkShortestDistanceCalculator.cpp +++ b/Modules/SurfaceRegistration/src/DataManagement/MitkShortestDistanceCalculator.cpp @@ -1,151 +1,251 @@ /*=================================================================== 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 "mitkShortestDistanceCalculator.h" #include "vtkCellLocator.h" #include "vtkPointData.h" #include "vtkImplicitPolyDataDistance.h" #include "vtkDoubleArray.h" +#include + +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include + #include // std::abs mitk::ShortestDistanceCalculator::ShortestDistanceCalculator(vtkSmartPointer moving, vtkSmartPointer target) { m_Moving = moving; m_Target = target; } mitk::ShortestDistanceCalculator::~ShortestDistanceCalculator() { m_Moving->Delete(); m_Target->Delete(); m_Distances->Delete(); } void mitk::ShortestDistanceCalculator::calculateShortestDistance() { MITK_INFO << "calculate shortest distance between cells ..."; m_Distances = vtkSmartPointer::New(); double fromPoint[3] = { 0, 0, 0 }; int pointSetSize = 0; double mean = 0; pointSetSize = m_Moving->GetPoints()->GetNumberOfPoints(); vtkSmartPointer implicitPolyDataDistance = vtkSmartPointer::New(); implicitPolyDataDistance->SetInput(m_Target); m_RangeMin = 0; m_RangeMax = 0; for (int i = 0; i < pointSetSize; ++i) { m_Moving->GetPoints()->GetPoint(i, fromPoint); double distance = implicitPolyDataDistance->FunctionValue(fromPoint[0], fromPoint[1], fromPoint[2]); m_Distances->InsertNextValue(distance); if (distance < m_RangeMin) { m_RangeMin = distance; } else if (distance > m_RangeMax) { m_RangeMax = distance; } mean += distance; } m_Mean = mean / pointSetSize; m_StandardDeviation = std::sqrt(calculateVariance(m_Mean, pointSetSize)); MITK_INFO << "Min Value is: " << m_RangeMin; MITK_INFO << "Max Value is: " << m_RangeMax; MITK_INFO << "The Mean is: " << m_Mean; MITK_INFO << "STD: " << m_StandardDeviation; } +void mitk::ShortestDistanceCalculator::calculateCurvature() +{ + //vtkSmartPointer curvaturesFilter = TODO + // vtkSmartPointer::New(); + //curvaturesFilter->AddInputData(m_Target); + ////curvaturesFilter->SetCurvatureTypeToMinimum(); + ////curvaturesFilter->SetCurvatureTypeToMaximum(); + ////curvaturesFilter->SetCurvatureTypeToGaussian(); + //curvaturesFilter->SetCurvatureTypeToMean(); + //curvaturesFilter->Update(); + + //double scalarRange[2]; + // //curvaturesFilter->GetOutput()->GetScalarRange(scalarRange); + //scalarRange[0] = -0.125; + //scalarRange[1] = 0.125; + + + // // Build a lookup table + // vtkSmartPointer colorSeries = + // vtkSmartPointer::New(); + // int scheme = 16; + // colorSeries->SetColorScheme(scheme); + // std::cout << "Using color scheme #: " + // << colorSeries->GetColorScheme() << " is " + // << colorSeries->GetColorSchemeName() << std::endl; + + // vtkSmartPointer lut = + // vtkSmartPointer::New(); + // lut->SetColorSpaceToHSV(); + + // // Use a color series to create a transfer function + // int numColors = colorSeries->GetNumberOfColors(); + // for (int i = 0; i < numColors; i++) + // { + // vtkColor3ub color = colorSeries->GetColor(i); + // double dColor[3]; + // dColor[0] = static_cast (color[0]) / 255.0; + // dColor[1] = static_cast (color[1]) / 255.0; + // dColor[2] = static_cast (color[2]) / 255.0; + // double t = scalarRange[0] + (scalarRange[1] - scalarRange[0]) + // / (numColors - 1) * i; + // lut->AddRGBPoint(t, dColor[0], dColor[1], dColor[2]); + // } + + // // Create a mapper and actor + // vtkSmartPointer mapper = + // vtkSmartPointer::New(); + // mapper->SetInputConnection(curvaturesFilter->GetOutputPort()); + // mapper->SetLookupTable(lut); + // mapper->SetScalarRange(scalarRange); + + // vtkSmartPointer actor = + // vtkSmartPointer::New(); + // actor->SetMapper(mapper); + + // // Create a scalar bar + // vtkSmartPointer scalarBar = + // vtkSmartPointer::New(); + // scalarBar->SetLookupTable(mapper->GetLookupTable()); + // scalarBar->SetTitle( + // curvaturesFilter->GetOutput()->GetPointData()->GetScalars()->GetName()); + // scalarBar->SetNumberOfLabels(5); + + // // Create a renderer, render window, and interactor + // vtkSmartPointer renderer = + // vtkSmartPointer::New(); + // vtkSmartPointer renderWindow = + // vtkSmartPointer::New(); + // renderWindow->AddRenderer(renderer); + // vtkSmartPointer renderWindowInteractor = + // vtkSmartPointer::New(); + // renderWindowInteractor->SetRenderWindow(renderWindow); + + // // Add the actors to the scene + // renderer->AddActor(actor); + // renderer->AddActor2D(scalarBar); + + // renderer->SetBackground(.1, .2, .3); // Background color blue + + // // Render and interact + // renderWindow->Render(); + // renderWindowInteractor->Start(); + +} + double mitk::ShortestDistanceCalculator::getDistanceRange() { double value; if (std::abs(m_RangeMin) < std::abs(m_RangeMax)) { value = std::ceil(std::abs(m_RangeMax)); } else { value = std::ceil(std::abs(m_RangeMin)); } return value; } double mitk::ShortestDistanceCalculator::getRangeMin() { return m_RangeMin; } double mitk::ShortestDistanceCalculator::getRangeMax() { return m_RangeMax; } double mitk::ShortestDistanceCalculator::getMean() { return m_Mean; } double mitk::ShortestDistanceCalculator::getStandardDeviation() { return m_StandardDeviation; } vtkSmartPointer mitk::ShortestDistanceCalculator::getDistances() { return m_Distances; } void mitk::ShortestDistanceCalculator::setDistances(vtkSmartPointer distances) { this->m_Distances = distances; } void mitk::ShortestDistanceCalculator::setRangeMin(double rangeMin) { this->m_RangeMin = rangeMin; } void mitk::ShortestDistanceCalculator::setRangeMax(double rangeMax) { this->m_RangeMax = rangeMax; } void mitk::ShortestDistanceCalculator::setMean(double mean) { this->m_Mean = mean; } void mitk::ShortestDistanceCalculator::setStandardDeviation(double std) { m_StandardDeviation = std; } double mitk::ShortestDistanceCalculator::calculateVariance(double mean, int pointSetSize) const { double variance = 0.0; int counter = 0; for (int i = 0; i < pointSetSize; ++i) { variance += (std::abs(m_Distances->GetValueReference(i))- mean)*(std::abs(m_Distances->GetValueReference(i)) - mean); } variance = variance / (pointSetSize - 1); return variance; } diff --git a/Modules/SurfaceRegistration/src/DataManagement/mitkShapeComparisonUtil.cpp b/Modules/SurfaceRegistration/src/DataManagement/mitkShapeComparisonUtil.cpp index b3274b5370..a5a7339780 100644 --- a/Modules/SurfaceRegistration/src/DataManagement/mitkShapeComparisonUtil.cpp +++ b/Modules/SurfaceRegistration/src/DataManagement/mitkShapeComparisonUtil.cpp @@ -1,100 +1,151 @@ /*=================================================================== 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 "mitkShapeComparisonUtil.h" #include #include #include #include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include #include mitk::ShapeComparisonUtil::ShapeComparisonUtil(mitk::Surface::Pointer movedSurface, mitk::Surface::Pointer targetSurface) { m_MovedSurface = movedSurface; m_TargetSurface = targetSurface; //TODO append timestamp m_OutputFile.open("X:/ergebnissse/results.txt"); } mitk::ShapeComparisonUtil::~ShapeComparisonUtil() { m_OutputFile.close(); m_MovedSurface->Delete(); m_TargetSurface->Delete(); } void mitk::ShapeComparisonUtil::calculateSliceDifferences(mitk::PlaneGeometry::Pointer planegeo) { - m_OutputFile << "/*****************************************************************************/" << std::endl; ++m_counter; m_OutputFile << "Plane Number: " << m_counter << std::endl; - vtkSmartPointer movedPointsOnPlane = getPointsOnPlane(m_MovedSurface->GetVtkPolyData(), planegeo); + vtkSmartPointer movedPointsOnPlane = getPointsOnPlane(m_MovedSurface->GetVtkPolyData(), planegeo); //read access violation vtkSmartPointer targetPointsOnPlane = getPointsOnPlane(m_TargetSurface->GetVtkPolyData(), planegeo); - m_OutputFile << "PointsOnPlane: " << movedPointsOnPlane->GetPoints()->GetNumberOfPoints() << " / " << targetPointsOnPlane->GetPoints()->GetNumberOfPoints() << std::endl; - mitk::PointShortestDistanceCalculator *calculator = new PointShortestDistanceCalculator(movedPointsOnPlane, targetPointsOnPlane); + if (movedPointsOnPlane->GetPoints()->GetNumberOfPoints() != 0 && targetPointsOnPlane->GetPoints()->GetNumberOfPoints() != 0) + { + + m_OutputFile << "PointsOnPlane: " << movedPointsOnPlane->GetPoints()->GetNumberOfPoints() << " / " << targetPointsOnPlane->GetPoints()->GetNumberOfPoints() << std::endl; + mitk::PointShortestDistanceCalculator *calculator = new PointShortestDistanceCalculator(movedPointsOnPlane, targetPointsOnPlane); calculator->calculateShortestDistance(); - + m_OutputFile << " Mean: " << calculator->getMean() << " STD: " << calculator->getStandardDeviation() << - // " Range " << calculator->getRangeMin() << + // " Range " << calculator->getRangeMin() << std::endl; + } } void mitk::ShapeComparisonUtil::setMovedSurface(mitk::Surface::Pointer surface) { this->m_MovedSurface = surface; } void mitk::ShapeComparisonUtil::setTargetSurface(mitk::Surface::Pointer surface) { this->m_TargetSurface = surface; } -void mitk::ShapeComparisonUtil::printSliceDifferences(std::string outputFileName, mitk::ShortestDistanceCalculator *calculator) -{ - m_OutputFile <<" ***************************************************************************** "<< std::endl; - m_OutputFile << "Mean: " << calculator->getMean() << "STD: " << calculator->getStandardDeviation() << - "Range_Min " << calculator->getRangeMin() << "Range_Max " << calculator->getRangeMax() << std::endl; -} - vtkSmartPointer mitk::ShapeComparisonUtil::getPointsOnPlane(vtkSmartPointer pointset, mitk::PlaneGeometry::Pointer planegeo) { vtkSmartPointer pointsOnPlane = vtkSmartPointer::New(); vtkSmartPointer points = vtkSmartPointer::New(); + // set Vertices + // Create the topology of the point (a vertex) + vtkSmartPointer vertices = + vtkSmartPointer::New(); + vtkIdType pid[1]; + + double tempPoint[3] = { 0, 0, 0 }; int pointcounter = 0; - points->InsertPoint(1,tempPoint); + double searchingRange = 0.475 / 2; + //double searchingRange = 0.475; int pointSetSize = pointset->GetPoints()->GetNumberOfPoints(); for (int i = 0; i < pointSetSize; ++i) { pointset->GetPoints()->GetPoint(i, tempPoint); - if(planegeo->Distance(tempPoint) < 0.475) + if(planegeo->Distance(tempPoint) InsertNextPoint(tempPoint); //TODO + points->InsertNextPoint(tempPoint); + pid[0] = points->InsertNextPoint(tempPoint); + vertices->InsertNextCell(1, pid); } } MITK_INFO << "Anzahl Points near plane: " << pointcounter; pointsOnPlane->SetPoints(points); - return pointsOnPlane; // returns null + pointsOnPlane->SetVerts(vertices); + + // Visualize +// vtkSmartPointer mapper = +// vtkSmartPointer::New(); +//#if VTK_MAJOR_VERSION <= 5 +// mapper->SetInput(point); +//#else +// mapper->SetInputData(pointsOnPlane); +//#endif +// +// vtkSmartPointer actor = +// vtkSmartPointer::New(); +// actor->SetMapper(mapper); +// actor->GetProperty()->SetPointSize(2); +// +// vtkSmartPointer renderer = +// vtkSmartPointer::New(); +// vtkSmartPointer renderWindow = +// vtkSmartPointer::New(); +// renderWindow->AddRenderer(renderer); +// vtkSmartPointer renderWindowInteractor = +// vtkSmartPointer::New(); +// renderWindowInteractor->SetRenderWindow(renderWindow); +// +// renderer->AddActor(actor); +// +// renderWindow->Render(); +// renderWindowInteractor->Start(); +// +// + + return pointsOnPlane; } diff --git a/Modules/SurfaceRegistration/src/mitkSurfaceRegistrationManager.cpp b/Modules/SurfaceRegistration/src/mitkSurfaceRegistrationManager.cpp index 52a6f95b8d..62ffbca318 100644 --- a/Modules/SurfaceRegistration/src/mitkSurfaceRegistrationManager.cpp +++ b/Modules/SurfaceRegistration/src/mitkSurfaceRegistrationManager.cpp @@ -1,213 +1,214 @@ /*=================================================================== 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(); } 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); //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(); + m_DistanceCalculator->calculateCurvature(); } 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 d4a837a7a7..8c89d61ad0 100644 --- a/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/QmitkSurfaceRegistration.cpp +++ b/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/QmitkSurfaceRegistration.cpp @@ -1,513 +1,572 @@ /*========================================================================= 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 "org_mitk_gui_qt_surfaceregistration_Activator.h" #include #include #include #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.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.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.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.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.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.selectTargetSurfaceLabel->setText("Selected target surface:"); m_Controls.mappedDataGroupBox->setEnabled(true); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); if (m_movingSurface != nullptr && m_targetSurface.GetPointer() != m_movingSurface.GetPointer()) { m_Controls.registerAndComparePushButton->setEnabled(true); m_Controls.comparePushButton->setEnabled(true); } } } void QmitkSurfaceRegistration::OnSelectedImageChanged(const mitk::DataNode *) { //TODO? } void QmitkSurfaceRegistration::doRegisterAndCompare() { MITK_INFO << "execute clicked..."; + mitk::ProgressBar::GetInstance()->AddStepsToDo(1); + mitk::ProgressBar::GetInstance()->Progress(); + m_SurfaceRegistrationManager = new mitk::SurfaceRegistrationManager(m_movingSurface, m_targetSurface); m_SurfaceRegistrationManager->setMirroring(m_Controls.mirroringCheckBox->isChecked()); m_SurfaceRegistrationManager->performRegistration(); m_registeredSurface = m_SurfaceRegistrationManager->getRegisteredSurface(); + mitk::Image::Pointer currentlySelectedImage =dynamic_cast(m_Controls.imageSelectorComboBox->GetSelectedNode()->GetData()); + mitk::Image::Pointer registeredImg = ConvertSurfaceToImage(currentlySelectedImage, m_registeredSurface); + mitk::Image::Pointer targetImg = ConvertSurfaceToImage(currentlySelectedImage, m_targetSurface); + + mitk::DataNode::Pointer registerdNode = mitk::DataNode::New(); + registerdNode->SetData(registeredImg); + registerdNode->SetVisibility(true); + registerdNode->SetName("RegisteredMovingNode"); + + mitk::DataNode::Pointer targetNode = mitk::DataNode::New(); + targetNode->SetData(targetImg); + targetNode->SetVisibility(true); + targetNode->SetName("TargetNode"); + + this->GetDataStorage()->Add(registerdNode); + this->GetDataStorage()->Add(targetNode); + this->GetDataStorageReference()->GetDataStorage()->Modified(); 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); + mitk::ProgressBar::GetInstance()->Progress(); + doCompare(); } void QmitkSurfaceRegistration::doRegisterAndCompareAll() { MITK_INFO << "Compare all surfaces in Storage "; + + mitk::ProgressBar::GetInstance()->AddStepsToDo(2); + mitk::ProgressBar::GetInstance()->Progress(); + 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(); + mitk::ProgressBar::GetInstance()->Progress(); } void QmitkSurfaceRegistration::doCompare() { + mitk::ProgressBar::GetInstance()->AddStepsToDo(2); + mitk::ProgressBar::GetInstance()->Progress(); 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); + testloadPosition(); + iteratePlanePosition(axial); + iteratePlanePosition(coronal); + iteratePlanePosition(saggital); + mitk::ProgressBar::GetInstance()->Progress(); } 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"); doRegisterAndCompare(); m_movingSurface = right; m_targetSurface = left; m_Controls.mappedDataNameLineEdit->setText(resultName + "MovingR"); doRegisterAndCompare(); } } -void QmitkSurfaceRegistration::reloadDataNodePlanePosition(const mitk::DataNode::Pointer node, int id) + +void QmitkSurfaceRegistration::showLookUpTable(vtkSmartPointer lut) { - if (m_Controls.imageSelectorComboBox->currentIndex() <0) - return; + 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); +} + + +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::reloadDataNodePlanePosition(const mitk::DataNode::Pointer node, int id) +{ QmitkRenderWindow* selectedRenderWindow = 0; - QmitkRenderWindow* axialWindow= this->GetRenderWindowPart()->GetQmitkRenderWindow("axial"); + QmitkRenderWindow* axialWindow = this->GetRenderWindowPart()->GetQmitkRenderWindow("axial"); QmitkRenderWindow* saggitalWindow = this->GetRenderWindowPart()->GetQmitkRenderWindow("sagittal"); QmitkRenderWindow* coronalWindow = this->GetRenderWindowPart()->GetQmitkRenderWindow("coronal"); bool PlanarFigureInitializedWindow = false; - //find initialized renderwindow + //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) + 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(); + 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); + 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) + for (int i = -20; i < stopper; ++i) { MITK_INFO << "Current plane number: " << i; - mitk::PlaneGeometry::Pointer planeGeo = translatePlane( i , plane); + 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); + m_Renderer->ForceImmediateUpdate(); } 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); + newPlaneGeo->Translate(normal * id); MITK_INFO << "Center der neuen Plane: " << newPlaneGeo->GetCenter(); renderer->RequestUpdate(); + m_Renderer = renderer; + m_Renderer->RequestUpdate(); mitk::DataNode* imageNode(m_Controls.imageSelectorComboBox->GetSelectedNode()); mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll(); return newPlaneGeo; } -void QmitkSurfaceRegistration::initializeWithSceneFile() +mitk::Image::Pointer QmitkSurfaceRegistration::ConvertSurfaceToImage(mitk::Image::Pointer image, mitk::Surface::Pointer surface) { - 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()); + mitk::ProgressBar::GetInstance()->AddStepsToDo(1); + mitk::ProgressBar::GetInstance()->Progress(); + + mitk::SurfaceToImageFilter::Pointer surfaceToImageFilter = mitk::SurfaceToImageFilter::New(); + surfaceToImageFilter->MakeOutputBinaryOn(); + surfaceToImageFilter->SetInput(surface); + surfaceToImageFilter->SetImage(image); + try + { + surfaceToImageFilter->Update(); + } + catch (itk::ExceptionObject& excpt) + { + MITK_ERROR << excpt.GetDescription(); + return nullptr; + } + mitk::ProgressBar::GetInstance()->Progress(); + mitk::Image::Pointer resultImage = surfaceToImageFilter->GetOutput(); + return resultImage; } 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(); + 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 c4042e1db9..ad915f9b15 100644 --- a/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/QmitkSurfaceRegistration.h +++ b/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/QmitkSurfaceRegistration.h @@ -1,176 +1,180 @@ /*========================================================================= 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 "ui_SurfaceRegistrationControls.h" #include "usServiceRegistration.h" #include "mitkAnnotation.h" #include "mitkColorBarAnnotation.h" #include "mitkDataStorage.h" #include #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: /*! * @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 doCompare(); - //test - void testloadPosition(); void OnSelectedMovingSurfaceChanged(const mitk::DataNode *); void OnSelectedTargetSurfaceChanged(const mitk::DataNode *); void OnSelectedImageChanged(const mitk::DataNode *); protected: 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::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); - + + + //testing + void initializeWithSceneFile(); + + //test + void testloadPosition(); + /*! * @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(); + mitk::Image::Pointer ConvertSurfaceToImage(mitk::Image::Pointer image, mitk::Surface::Pointer surface); }; #endif // QmitkSurfaceRegistration_h \ No newline at end of file diff --git a/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/org_mitk_gui_qt_surfaceregistration_Activator.cpp b/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/org_mitk_gui_qt_surfaceregistration_Activator.cpp index 3165cf1ca7..c45d2c5c4f 100644 --- a/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/org_mitk_gui_qt_surfaceregistration_Activator.cpp +++ b/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/org_mitk_gui_qt_surfaceregistration_Activator.cpp @@ -1,41 +1,51 @@ /*========================================================================= 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 "org_mitk_gui_qt_surfaceregistration_Activator.h" + #include "QmitkSurfaceRegistration.h" #include -#include -#include +#include +#include US_INITIALIZE_MODULE namespace mitk { + + ctkPluginContext* org_mitk_gui_qt_surfaceregistration_Activator::m_Context = 0; + void org_mitk_gui_qt_surfaceregistration_Activator::start(ctkPluginContext* context) { BERRY_REGISTER_EXTENSION_CLASS(QmitkSurfaceRegistration, context) + m_Context = context; } void org_mitk_gui_qt_surfaceregistration_Activator::stop(ctkPluginContext* context) { Q_UNUSED(context) } + + ctkPluginContext* org_mitk_gui_qt_surfaceregistration_Activator::GetContext() + { + return m_Context; + } } #if QT_VERSION < QT_VERSION_CHECK(5, 0, 0) Q_EXPORT_PLUGIN2(org_mitk_gui_qt_surfaceregistration, mitk::PluginActivator) #endif \ No newline at end of file