diff --git a/Modules/SurfaceRegistration/include/MitkSurfaceRegistrationManager.h b/Modules/SurfaceRegistration/include/MitkSurfaceRegistrationManager.h index 353f16da0d..404dfa7ef6 100644 --- a/Modules/SurfaceRegistration/include/MitkSurfaceRegistrationManager.h +++ b/Modules/SurfaceRegistration/include/MitkSurfaceRegistrationManager.h @@ -1,86 +1,87 @@ /*=================================================================== 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(); mitk::Surface::Pointer performRegistration(); void performComparison(); vtkSmartPointer getTable(); mitk::DataNode::Pointer getColourTransformedDataNode(); void setMirroring(bool mirroring); bool getMirroring(); mitk::Surface::Pointer getRegisteredSurface(); std::map getDistanceResults(); 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; std::map m_DistanceResults; + vtkSmartPointer m_CurvatureResults; }; } #endif diff --git a/Modules/SurfaceRegistration/include/mitkShapeComparisonUtil.h b/Modules/SurfaceRegistration/include/mitkShapeComparisonUtil.h index 4644810dc2..826b9a3b6e 100644 --- a/Modules/SurfaceRegistration/include/mitkShapeComparisonUtil.h +++ b/Modules/SurfaceRegistration/include/mitkShapeComparisonUtil.h @@ -1,54 +1,55 @@ /*=================================================================== 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); - + void setOutputPath(std::string path); private: mitk::Surface::Pointer m_MovedSurface = nullptr; mitk::Surface::Pointer m_TargetSurface = nullptr; - vtkSmartPointer getPointsOnPlane(vtkSmartPointer pointset, mitk::PlaneGeometry::Pointer planegeo); + vtkSmartPointer getPointsOnPlane(vtkSmartPointer pointset, mitk::PlaneGeometry::Pointer planegeo); + std::string path; 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 e8152bbee0..07641f559a 100644 --- a/Modules/SurfaceRegistration/include/mitkShortestDistanceCalculator.h +++ b/Modules/SurfaceRegistration/include/mitkShortestDistanceCalculator.h @@ -1,68 +1,69 @@ /*=================================================================== 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(); + vtkSmartPointer calculateCurvature(); double getDistanceRange(); double getRangeMin(); double getRangeMax(); double getMean(); double getStandardDeviation(); std::map getResults(); 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_CurvatureResults; vtkSmartPointer m_Moving; vtkSmartPointer m_Target; double m_RangeMin; double m_RangeMax; double m_Mean; double m_StandardDeviation; std::map m_Results; }; }; #endif \ No newline at end of file diff --git a/Modules/SurfaceRegistration/include/mitkSurfaceRegistrationICP.h b/Modules/SurfaceRegistration/include/mitkSurfaceRegistrationICP.h index dd228e7325..7be18b4831 100644 --- a/Modules/SurfaceRegistration/include/mitkSurfaceRegistrationICP.h +++ b/Modules/SurfaceRegistration/include/mitkSurfaceRegistrationICP.h @@ -1,34 +1,77 @@ /*=================================================================== 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 + namespace mitk{ #ifndef mitkSurfaceRegistrationICP_h #define mitkSurfaceRegistrationICP_h class SurfaceRegistrationICP { public: SurfaceRegistrationICP(); ~SurfaceRegistrationICP(); mitk::Surface::Pointer CalculateICP(mitk::Surface::Pointer movingSurface, mitk::Surface::Pointer targetSurface); + private: + + void SafeTransformationMatrix(vtkMatrix4x4 *matrix, std::string path); }; #endif -}; \ No newline at end of file +}; + +namespace mitk { + /** \brief Load a VNL matrix from file + * + * \param filename file and path as std::string + * \tparam T element type + * \tparam M number of matrix rows + * \tparam N number of matrix columns + */ + template + vnl_matrix_fixed ReadVNLMatrixFromFile(std::string filename) + { + std::ifstream read(filename.c_str()); + vnl_matrix_fixed matrix; + read >> matrix; + read.close(); + return matrix; + } + + /** \brief Write a VNL matrix to file + * + * \param filename file and path as std::string + * \tparam T element type + * \tparam M number of matrix rows + * \tparam N number of matrix columns + */ + template + void WriteVNLMatrixToFile(std::string filename, vnl_matrix_fixed matrix) + { + std::ofstream write(filename.c_str()); + write << matrix; + write.close(); + } +} \ No newline at end of file diff --git a/Modules/SurfaceRegistration/src/DataManagement/MitkShortestDistanceCalculator.cpp b/Modules/SurfaceRegistration/src/DataManagement/MitkShortestDistanceCalculator.cpp index 6504d8d503..1771564610 100644 --- a/Modules/SurfaceRegistration/src/DataManagement/MitkShortestDistanceCalculator.cpp +++ b/Modules/SurfaceRegistration/src/DataManagement/MitkShortestDistanceCalculator.cpp @@ -1,259 +1,194 @@ /*=================================================================== 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(); + pointSetSize = m_Target->GetPoints()->GetNumberOfPoints(); vtkSmartPointer implicitPolyDataDistance = vtkSmartPointer::New(); - implicitPolyDataDistance->SetInput(m_Target); + implicitPolyDataDistance->SetInput(m_Moving); m_RangeMin = 0; m_RangeMax = 0; for (int i = 0; i < pointSetSize; ++i) { - m_Moving->GetPoints()->GetPoint(i, fromPoint); + m_Target->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 += std::abs(distance); } m_Mean = mean / pointSetSize; m_StandardDeviation = std::sqrt(calculateVariance(m_Mean, pointSetSize)); //fill result map - m_Results["Min"] = m_RangeMin; + m_Results["Min"] = m_RangeMin; m_Results["Max"] = m_RangeMax; m_Results["Mean"] = m_Mean; m_Results["Std"] = m_StandardDeviation; } -void mitk::ShortestDistanceCalculator::calculateCurvature() +vtkSmartPointer 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(); + vtkSmartPointer curvaturesFilter = + 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; + + vtkSmartPointer curvature = curvaturesFilter->GetOutput()->GetPointData()->GetScalars(); + return curvature; } std::map mitk::ShortestDistanceCalculator::getResults() { return m_Results; } 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 += 1; //variance += (std::abs(m_Distances->GetValueReference(i))- mean)*(std::abs(m_Distances->GetValueReference(i)) - mean); TODO } variance = variance / (pointSetSize - 1); return variance; } diff --git a/Modules/SurfaceRegistration/src/DataManagement/mitkSurfaceRegistrationICP.cpp b/Modules/SurfaceRegistration/src/DataManagement/mitkSurfaceRegistrationICP.cpp index 2af85b129a..0a1ef252c9 100644 --- a/Modules/SurfaceRegistration/src/DataManagement/mitkSurfaceRegistrationICP.cpp +++ b/Modules/SurfaceRegistration/src/DataManagement/mitkSurfaceRegistrationICP.cpp @@ -1,53 +1,73 @@ #include "mitkSurfaceRegistrationICP.h" #include #include #include #include #include #include #include + + + mitk::SurfaceRegistrationICP::SurfaceRegistrationICP() { } mitk::SurfaceRegistrationICP::~SurfaceRegistrationICP() { } mitk::Surface::Pointer mitk::SurfaceRegistrationICP::CalculateICP(mitk::Surface::Pointer movingSurface, mitk::Surface::Pointer targetSurface) { MITK_INFO << "start registration"; vtkSmartPointer icp = vtkSmartPointer::New(); icp->SetCheckMeanDistance(1); mitk::Surface::Pointer movedData = mitk::Surface::New(); icp->SetSource(movingSurface->GetVtkPolyData()); icp->SetTarget(targetSurface->GetVtkPolyData()); icp->SetMaximumNumberOfIterations(1000); icp->SetMaximumMeanDistance(0.01); icp->SetMeanDistanceModeToRMS(); icp->StartByMatchingCentroidsOn(); icp->SetMaximumNumberOfLandmarks(100000); icp->Modified(); vtkSmartPointer transform = vtkSmartPointer::New(); transform = icp->GetLandmarkTransform(); vtkSmartPointer icpTransformFilter = vtkSmartPointer::New(); icpTransformFilter->SetInputData(movingSurface->GetVtkPolyData()); icpTransformFilter->SetTransform(icp); icpTransformFilter->Update(); vtkSmartPointer m = icp->GetMatrix(); MITK_INFO << "The resulting matrix is: " << *m; MITK_INFO << "The mean distance is: " << icp->GetMeanDistance(); movedData->SetVtkPolyData(icpTransformFilter->GetOutput()); movedData->Modified(); - MITK_INFO << "registration done"; + MITK_INFO << "registration done"; + //save TransformationMatrix + std::string path = "D:/ShapeComparison/TestCase/ICPtrafo" + movingSurface->GetObjectName() + "To" + targetSurface->GetObjectName() + ".txt"; + SafeTransformationMatrix(m,path); return movedData; -} \ No newline at end of file +} + +void mitk::SurfaceRegistrationICP::SafeTransformationMatrix(vtkMatrix4x4 *matrix, std::string path) +{ + //transform vtkmatrix to vnl + vnl_matrix_fixed vnlmatrix; + for (int i = 0; i < 4; ++i) + for (int j = 0; j < 4; ++j) + vnlmatrix(i, j) = matrix->GetElement(i,j); + + mitk::WriteVNLMatrixToFile(path, vnlmatrix); + +} + + diff --git a/Modules/SurfaceRegistration/src/mitkSurfaceRegistrationManager.cpp b/Modules/SurfaceRegistration/src/mitkSurfaceRegistrationManager.cpp index 38e8d94870..b8fcfc7f08 100644 --- a/Modules/SurfaceRegistration/src/mitkSurfaceRegistrationManager.cpp +++ b/Modules/SurfaceRegistration/src/mitkSurfaceRegistrationManager.cpp @@ -1,220 +1,224 @@ /*=================================================================== 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; - } - + //if (m_RegisteredSurface != nullptr) + //{ + // currentSurface = m_RegisteredSurface; + //} + //else if(m_MirroredSurface!= nullptr) + //{ + // currentSurface = m_MirroredSurface; + //} + //else + //{ + // currentSurface = m_MovingSurface; + //} + + //set named Scalars + + currentSurface = m_TargetSurface; + + m_DistanceCalculator->getDistances()->SetName("Distances"); currentSurface->GetVtkPolyData()->GetPointData()->SetScalars(m_DistanceCalculator->getDistances()); + m_CurvatureResults->SetName("Curvatures"); + currentSurface->GetVtkPolyData()->GetPointData()->AddArray(m_CurvatureResults); + //currentSurface->GetVtkPolyData()->GetPointData()->SetScalars(m_CurvatureResults); + 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", -3.5); transformedNode->SetFloatProperty("ScalarsRangeMaximum", 3.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; } std::map mitk::SurfaceRegistrationManager::getDistanceResults() { return m_DistanceResults; } 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(); TODO m_DistanceResults = m_DistanceCalculator->getResults(); + m_CurvatureResults = m_DistanceCalculator->calculateCurvature(); //TODO refactor in seperated class } 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/resources/icon2.png b/Plugins/org.mitk.gui.qt.surfaceregistration/resources/icon2.png new file mode 100644 index 0000000000..2829a099af Binary files /dev/null and b/Plugins/org.mitk.gui.qt.surfaceregistration/resources/icon2.png differ 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 7b2c9c5754..96c93413aa 100644 --- a/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/QmitkSurfaceRegistration.cpp +++ b/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/QmitkSurfaceRegistration.cpp @@ -1,833 +1,885 @@ /*========================================================================= 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 #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); m_Controls.comparePushButton->setEnabled(true); //initializeWithSceneFile(); - + m_SurfaceRegistrationManager = new mitk::SurfaceRegistrationManager(nullptr, nullptr); m_ParentWidget = parent; } void QmitkSurfaceRegistration::OnSelectedMovingSurfaceChanged(const mitk::DataNode *node) { if (node != nullptr) { m_movingSurface = dynamic_cast(node->GetData()); m_movingSurface->SetObjectName(node->GetObjectName()); 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_targetSurface->SetObjectName(node->GetObjectName()); 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::ProgressBar::GetInstance()->AddStepsToDo(2); mitk::ProgressBar::GetInstance()->Progress(); MITK_INFO << "Moving Name: " + m_movingSurface->GetObjectName(); MITK_INFO << "Target Name: " + m_targetSurface->GetObjectName(); m_SurfaceRegistrationManager = new mitk::SurfaceRegistrationManager(m_movingSurface, m_targetSurface); m_SurfaceRegistrationManager->setMirroring(m_Controls.mirroringCheckBox->isChecked()); m_SurfaceRegistrationManager->performRegistration(); m_SurfaceRegistrationManager->setMirroring(false); m_registeredSurface = m_SurfaceRegistrationManager->getRegisteredSurface(); - mitk::DataNode::Pointer registeredSurface = mitk::DataNode::New(); - registeredSurface->SetData(m_registeredSurface); - registeredSurface->SetVisibility(true); - registeredSurface->SetName(m_movingSurface->GetObjectName() + "_RegisteredSurface"); - - // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! //make sure to automatically select orig img mitk::DataNode::Pointer origImgNode = getGeometryNodeFromTarget(m_targetSurface); MITK_INFO << "Original name of target: " + origImgNode->GetName(); - //m_Controls.imageSelectorComboBox->SetSelectedNode(origImgNode); + m_Controls.imageSelectorComboBox->SetSelectedNode(origImgNode); //mitk::Image::Pointer currentlySelectedImage =dynamic_cast(m_Controls.imageSelectorComboBox->GetSelectedNode()->GetData()); mitk::Image::Pointer currentlySelectedImage = dynamic_cast(origImgNode->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(m_movingSurface->GetObjectName()+ "_Registered"); + registerdNode->SetColor(1.0, 1.0, 0.0); mitk::DataNode::Pointer targetNode = mitk::DataNode::New(); targetNode->SetData(targetImg); targetNode->SetVisibility(true); targetNode->SetName(m_targetSurface->GetObjectName() + "_Target"); this->GetDataStorage()->Add(registerdNode); this->GetDataStorage()->Add(targetNode); - this->GetDataStorage()->Add(registeredSurface); 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(); } 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 isImage = mitk::NodePredicateDataType::New("Image"); mitk::DataStorage::SetOfObjects::ConstPointer images = datastorage->GetSubset(isImage); QString leftOrigName; QString rightOrigName; if (!images->empty()) { for (mitk::DataStorage::SetOfObjects::const_iterator iter = images->begin(); iter != images->end(); ++iter) { mitk::DataNode::Pointer node = (*iter); if (QString(node->GetName().c_str()).contains(QString("orig"), Qt::CaseSensitive)) { if (leftOrigName == "") { leftOrigName = QString(node->GetName().c_str()).remove("_orig"); } else if (rightOrigName == "" && rightOrigName != leftOrigName) { rightOrigName = QString(node->GetName().c_str()).remove("_orig"); } } } } 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(leftOrigName), 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()); tibiaLeft->SetObjectName("Tibia_"+ leftOrigName.toStdString()); } 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()); fibulaLeft->SetObjectName("Fibula_" +leftOrigName.toStdString()); } 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()); talusLeft->SetObjectName("Talus_" + leftOrigName.toStdString()); } }//check for right else if (QString(node->GetName().c_str()).contains(QString(rightOrigName), 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()); tibiaRight->SetObjectName("Tibia_" + rightOrigName.toStdString()); } 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()); fibulaRight->SetObjectName("Fibula_" + rightOrigName.toStdString()); } 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()); talusRight->SetObjectName("Talus_" + rightOrigName.toStdString()); } } } - //TODO start outputstream - //ASSD - //Overlap - // std::string path = m_movingSurface->GetP TODO Get Property (?) path - remplate + results - std::string resultFile = m_mainDirectory.toStdString() + "Results_" + leftOrigName.toStdString() + "_" + rightOrigName.toStdString() + ".txt"; - MITK_INFO << "printing Results" + resultFile; - std::ofstream resultOutput = ofstream(resultFile, std::ofstream::out); - resultOutput << "Calculating Tibia..." << std::endl; - performTwoSidedComparison(tibiaLeft, tibiaRight, "Tibia", resultOutput); - resultOutput << "Calculating Fibula..." << std::endl; - performTwoSidedComparison(fibulaLeft, fibulaRight, "Fibula", resultOutput); - //resultOutput << "Calculating Talus..." << std::endl; - //performTwoSidedComparison(talusLeft, talusRight, "Target", resultOutput); - - //TODO end outputstream - resultOutput.close(); + + m_SurfaceRegistrationManager->setMirroring(m_Controls.mirroringCheckBox->isChecked()); + + ////TODO start outputstream + //std::string resultFile = m_mainDirectory.toStdString() + "Results_" + leftOrigName.toStdString() + "_" + rightOrigName.toStdString() + ".txt"; + ////MITK_INFO << "printing Results" + resultFile; + //std::ofstream resultOutput = ofstream(resultFile, std::ofstream::out); + //resultOutput << "Calculating Tibia..." << std::endl; + performTwoSidedComparison(tibiaLeft, tibiaRight, "Tibia"); + //resultOutput << "Calculating Fibula..." << std::endl; + performTwoSidedComparison(fibulaLeft, fibulaRight, "Fibula"); + ////resultOutput << "Calculating Talus..." << std::endl; + // performTwoSidedComparison(talusLeft, talusRight, "Target", resultOutput); + + ////TODO end outputstream + //resultOutput.close(); + + testloadPosition(); + + // iteratePlanePositionImages(axial); + //iteratePlanePositionImages(coronal); + //iteratePlanePositionImages(saggital); + + iteratePlanePositionSurfaces("TibiaMovingL","TibiaMovingR",axial); + iteratePlanePositionSurfaces("FibulaMovingL", "FibulaMovingR", axial); } mitk::ProgressBar::GetInstance()->Progress(); } void QmitkSurfaceRegistration::doCompare() { + m_SurfaceRegistrationManager->setMirroring(m_Controls.mirroringCheckBox->isChecked()); initializeDirectoryList(); automatizedEvaluation(); - /* 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::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(); + //mitk::RenderingManager::GetInstance()->InitializeViews(); + //mitk::RenderingManager::GetInstance()->RequestUpdateAll(); - vtkSmartPointer lut = m_SurfaceRegistrationManager->getTable(); - showLookUpTable(lut); + //vtkSmartPointer lut = m_SurfaceRegistrationManager->getTable(); + //showLookUpTable(lut); - testloadPosition(); + //testloadPosition(); - iteratePlanePosition(axial); - iteratePlanePosition(coronal); - iteratePlanePosition(saggital); - mitk::ProgressBar::GetInstance()->Progress();*/ + //iteratePlanePosition(axial); + //iteratePlanePosition(coronal); + //iteratePlanePosition(saggital); + //mitk::ProgressBar::GetInstance()->Progress(); } void QmitkSurfaceRegistration::initializeDirectoryList() { // QDir directory = QDir(m_mainDirectory); QStringList foundDirs = directory.entryList(QDir::AllDirs); m_Directories = QStringList(); if (foundDirs.first() == "." ) { foundDirs.pop_front(); } if (foundDirs.first() == "..") { foundDirs.pop_front(); } for (int i = 0; i < foundDirs.size() ; ++i) { m_Directories.insert(i,m_mainDirectory +foundDirs[i]); MITK_INFO << m_Directories.at(i); } MITK_INFO << " *...............................*"; } void QmitkSurfaceRegistration::automatizedEvaluation() { QStringList allFeetDirs; QStringList::const_iterator constIterator; for (int i = 0; i < m_Directories.size(); ++i) { allFeetDirs.append((m_Directories.at(i)+ "/Left")); allFeetDirs.append((m_Directories.at(i) + "/Right")); } for (int i = 0; i < allFeetDirs.size() - 1; ++i) { for (int j = i + 1; j < allFeetDirs.size(); ++j) { MITK_INFO << allFeetDirs.at(i).toStdString(); MITK_INFO << allFeetDirs.at(j).toStdString(); if (allFeetDirs.at(i).contains("Left") && allFeetDirs.at(j).contains("Left")) { m_Controls.mirroringCheckBox->setChecked(false); - // m_SurfaceRegistrationManager->setMirroring(false); + m_SurfaceRegistrationManager->setMirroring(false); } else if (allFeetDirs.at(i).contains("Right") && allFeetDirs.at(j).contains("Right")) { m_Controls.mirroringCheckBox->setChecked(false); - // m_SurfaceRegistrationManager->setMirroring(false); + m_SurfaceRegistrationManager->setMirroring(false); } else { m_Controls.mirroringCheckBox->setChecked(true); - // m_SurfaceRegistrationManager->setMirroring(true); + m_SurfaceRegistrationManager->setMirroring(true); } compareAnklePath(allFeetDirs.at(i), allFeetDirs.at(j)); } } } void QmitkSurfaceRegistration::compareAnklePath(QString pathA, QString pathB) { //load scene Files QString pathAtemplate = pathA + "/template.mitk"; MITK_INFO << "PathA: " << pathA.toStdString(); MITK_INFO << "PathB: " << pathB.toStdString(); QString pathBtemplate = pathB + "/template.mitk"; mitk::SceneIO::Pointer sceneIO = mitk::SceneIO::New(); sceneIO->LoadScene(pathAtemplate.toStdString(), this->GetDataStorageReference()->GetDataStorage(), false); sceneIO->LoadScene(pathBtemplate.toStdString(), this->GetDataStorageReference()->GetDataStorage(), false); this->GetDataStorageReference()->GetDataStorage()->Modified(); mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll(); mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(this->GetDataStorageReference()->GetDataStorage()); //evaluate doRegisterAndCompareAll(); std::string filename = pathA.toStdString() + "/Results/" + pathB.remove(m_mainDirectory).remove("/").toStdString()+ "results.mitk"; MITK_INFO << "Filename: " << filename; - sceneIO->SaveScene(this->GetDataStorage()->GetAll(), this->GetDataStorage(), filename); + // sceneIO->SaveScene(this->GetDataStorage()->GetAll(), this->GetDataStorage(), filename); //Close Project auto allItems = this->GetDataStorage()->GetAll(); int size = allItems->Size(); for (int i = 0; i < size; ++i) { this->GetDataStorage()->Remove(allItems->at(i)); } MITK_INFO << "DS size: " << this->GetDataStorage()->GetAll()->Size(); } -void QmitkSurfaceRegistration::performTwoSidedComparison(mitk::Surface::Pointer left, mitk::Surface::Pointer right, QString resultName, std::ofstream &resultOutput) +void QmitkSurfaceRegistration::performTwoSidedComparison(mitk::Surface::Pointer left, mitk::Surface::Pointer right, QString resultName) { + if ( QString(left->GetObjectName().c_str()).contains("L") && QString(right->GetObjectName().c_str()).contains("L")) + { + m_Controls.mirroringCheckBox->setChecked(false); + m_SurfaceRegistrationManager->setMirroring(false); + } + else if (QString(left->GetObjectName().c_str()).contains("R") && QString(right->GetObjectName().c_str()).contains("R")) + { + m_Controls.mirroringCheckBox->setChecked(false); + m_SurfaceRegistrationManager->setMirroring(false); + } + else + { + m_Controls.mirroringCheckBox->setChecked(true); + m_SurfaceRegistrationManager->setMirroring(true); + } + + if (left != nullptr && right != nullptr) { // m_Controls.mirroringCheckBox->setChecked(true); m_movingSurface = left; m_targetSurface = right; m_Controls.mappedDataNameLineEdit->setText(resultName +"MovingL"); doRegisterAndCompare(); double meanA = m_SurfaceRegistrationManager->getDistanceResults()["Mean"]; m_movingSurface = right; m_targetSurface = left; m_Controls.mappedDataNameLineEdit->setText(resultName + "MovingR"); doRegisterAndCompare(); - performTwoSidedLabelOverlapComparison(left, right, resultOutput); + performTwoSidedLabelOverlapComparison(left, right); double meanB = m_SurfaceRegistrationManager->getDistanceResults()["Mean"]; double ASSD = calculateASSD(meanA, meanB); - resultOutput << " ASSD: " << ASSD << std::endl; + /*resultOutput << " ASSD: " << ASSD << std::endl;*/ } } -void QmitkSurfaceRegistration::performTwoSidedLabelOverlapComparison(mitk::Surface::Pointer left, mitk::Surface::Pointer right, std::ofstream &resultOutput) +void QmitkSurfaceRegistration::performTwoSidedLabelOverlapComparison(mitk::Surface::Pointer left, mitk::Surface::Pointer right) { auto datastorage = this->GetDataStorage(); mitk::Image::Pointer registeredImg; mitk::Image::Pointer targetImg; mitk::DataNode::Pointer origImgNode; if (QString(left->GetObjectName().c_str()).contains(QString("L"), Qt::CaseSensitive)) { auto registeredNode = datastorage->GetNamedNode(left->GetObjectName() + "_Registered"); registeredImg = dynamic_cast(registeredNode->GetData()); auto targetNode = datastorage->GetNamedNode(right->GetObjectName() + "_Target"); targetImg = dynamic_cast(targetNode->GetData()); origImgNode = getGeometryNodeFromTarget(right); } else if (QString(left->GetObjectName().c_str()).contains(QString("R"), Qt::CaseSensitive)) { auto registeredNode = datastorage->GetNamedNode(right->GetObjectName() + "_Registered"); registeredImg = dynamic_cast(registeredNode->GetData()); auto targetNode = datastorage->GetNamedNode(left->GetObjectName() + "_Target"); targetImg = dynamic_cast(targetNode->GetData()); origImgNode = getGeometryNodeFromTarget(left); } m_Controls.imageSelectorComboBox->SetSelectedNode(origImgNode); testloadPosition(); - // testing - mitk::DataNode::Pointer testRegNode = mitk::DataNode::New(); - testRegNode->SetData(registeredImg); - testRegNode->SetVisibility(true); - testRegNode->SetName("RegTest"); - - mitk::DataNode::Pointer testTarNode = mitk::DataNode::New(); - testTarNode->SetData(targetImg); - testTarNode->SetVisibility(true); - testTarNode->SetName("TarTest"); - - this->GetDataStorage()->Add(testRegNode); - this->GetDataStorage()->Add(testTarNode); - this->GetDataStorageReference()->GetDataStorage()->Modified(); - //testing// - - mitk::ShapeComparisonManager *shapeComparisonManager = new mitk::ShapeComparisonManager(registeredImg, targetImg); - shapeComparisonManager->calculateMetrics(); - std::map labelOverlapResults = shapeComparisonManager->getLabelOverlapResults(); + mitk::ShapeComparisonManager *shapeComparisonManager = new mitk::ShapeComparisonManager(); + std::map labelOverlapResults = shapeComparisonManager->calculateLabelOverlapMetrics(registeredImg, targetImg); MITK_INFO << "FPR: " << QString::number(labelOverlapResults["FPR"]); MITK_INFO << "FNR: " << QString::number(labelOverlapResults["FNR"]); MITK_INFO << "Dice: " << QString::number(labelOverlapResults["Dice"]); MITK_INFO << "Jaccard: " << QString::number(labelOverlapResults["Jaccard"]); - resultOutput << " FPR: " << QString::number(labelOverlapResults["FPR"]) << std::endl; - resultOutput << " FNR: " << QString::number(labelOverlapResults["FNR"]) << std::endl; - resultOutput << " Dice: " << QString::number(labelOverlapResults["Dice"]) << std::endl; - resultOutput << " Jaccard: " << QString::number(labelOverlapResults["Jaccard"]) << std::endl; //MITK_INFO << "Volume Similarity: " << QString::number(labelOverlapResults[""]); + + //TODO calculate SurfaceDistanceMetrics } mitk::DataNode::Pointer QmitkSurfaceRegistration::getGeometryNodeFromTarget(mitk::Surface::Pointer target) { mitk::NodePredicateDataType::Pointer isImage = mitk::NodePredicateDataType::New("Image"); auto datastorage = this->GetDataStorage(); mitk::DataStorage::SetOfObjects::ConstPointer images = datastorage->GetSubset(isImage); mitk::DataNode::Pointer origImgNode = mitk::DataNode::New(); if (!images->empty()) { //iterate over all child nodes with NodePredicateProperty for (mitk::DataStorage::SetOfObjects::const_iterator iter = images->begin(); iter != images->end(); ++iter) { mitk::DataNode::Pointer node = (*iter); std::string name = node->GetObjectName(); - // MITK_INFO << "DS: " << this->GetDataStorage()->GetAll()->Size(); //check for for orig if (QString(node->GetName().c_str()).contains(QString("orig"), Qt::CaseSensitive)) { if (QString(target->GetObjectName().c_str()).contains(QString("R"), Qt::CaseSensitive) && QString(node->GetName().c_str()).contains(QString("R"), Qt::CaseSensitive)) { origImgNode = node; } else if (QString(target->GetObjectName().c_str()).contains(QString("L"), Qt::CaseSensitive) && QString(node->GetName().c_str()).contains(QString("L"), Qt::CaseSensitive)) { origImgNode = node; } } } } + m_Controls.imageSelectorComboBox->SetSelectedNode(origImgNode);// QmitkDataStorageComboBox: item not available + MITK_INFO << m_Controls.imageSelectorComboBox->GetSelectedNode()->GetName(); return origImgNode; } 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); } double QmitkSurfaceRegistration::calculateASSD(double meanA, double meanB) { return (meanA + meanB)/2; } void QmitkSurfaceRegistration::initializeWithSceneFile() { std::string fileNameRight= "D:/ShapeComparison/TestCase/AA246/Right/template.mitk"; std::string fileNameLeft = "D:/ShapeComparison/TestCase/AA246/Left/template.mitk"; mitk::SceneIO::Pointer sceneIO = mitk::SceneIO::New(); sceneIO->LoadScene(fileNameRight, this->GetDataStorageReference()->GetDataStorage(), false); sceneIO->LoadScene(fileNameLeft, 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* 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) +void QmitkSurfaceRegistration::iteratePlanePositionImages(Plane plane) { - mitk::ShapeComparisonUtil *shapeComparer = new mitk::ShapeComparisonUtil(m_registeredSurface, m_targetSurface); - //TODO choose from img props - int stopper = 50; - for (int i = -20; i < stopper; ++i) + //mitk::ShapeComparisonUtil *shapeComparerUtil = new mitk::ShapeComparisonUtil(m_registeredSurface, m_targetSurface); + + auto datastorage = this->GetDataStorage(); + mitk::Image::Pointer registeredImg = dynamic_cast(datastorage->GetNamedNode(m_movingSurface->GetObjectName() + "_Registered")->GetData()); + registeredImg->SetObjectName(m_movingSurface->GetObjectName() + "_Registered"); + mitk::Image::Pointer targetImg = dynamic_cast(datastorage->GetNamedNode(m_targetSurface->GetObjectName() + "_Target")->GetData()); //moving? + targetImg->SetObjectName(m_targetSurface->GetObjectName() + "_Target"); + mitk::ShapeComparisonManager *shapeComparisonManager = new mitk::ShapeComparisonManager(); + shapeComparisonManager->setOutputpath("D:/ShapeComparison/TestCase/" + registeredImg->GetObjectName() + targetImg->GetObjectName()+ "LabelOverlap.txt"); + shapeComparisonManager->startOutputGeneration(); + + std::map currentSliceResults; + int stopper = 10; // TODO adjust slices to make comparable + for (int i = -10; i < stopper; ++i) { MITK_INFO << "Current plane number: " << i; - mitk::PlaneGeometry::Pointer planeGeo = translatePlane(i, plane); - shapeComparer->calculateSliceDifferences(planeGeo); + mitk::PlaneGeometry::Pointer planeGeo = translatePlane(-i, plane)->Clone(); + mitk::PlaneGeometry::Pointer sliceGeometry = translatePlane(-i, plane)->Clone(); // 0 at standard plane position + + sliceGeometry->ChangeImageGeometryConsideringOriginOffset(true); + sliceGeometry->SetImageGeometry(true); + + currentSliceResults = shapeComparisonManager->calculateLabelOverlapMetricsSlices(registeredImg, targetImg, sliceGeometry); + + //shapeComparerUtil->calculateSliceDifferences(sliceGeometry); } MITK_INFO << "finished"; m_Renderer->ForceImmediateUpdate(); } +//TODO Tibia, Fibula +void QmitkSurfaceRegistration::iteratePlanePositionSurfaces(std::string first, std::string second, Plane plane) +{ + + auto datastorage = this->GetDataStorage(); + mitk::Surface::Pointer registeredSurface = dynamic_cast(this->GetDataStorage()->GetNamedNode(first)->GetData()); + mitk::Surface::Pointer targetSurface = dynamic_cast(this->GetDataStorage()->GetNamedNode(second)->GetData()); + mitk::ShapeComparisonManager *shapeComparisonManager = new mitk::ShapeComparisonManager(); + shapeComparisonManager->setOutputpath("D:/ShapeComparison/TestCase/" + registeredSurface->GetObjectName() + targetSurface->GetObjectName() + "SurfaceDistance.txt"); + shapeComparisonManager->startOutputGeneration(); + + int stopper = 70; + std::map currentSliceResults; + + for (int i = -70; i < stopper; ++i) + { + MITK_INFO << "Current plane number: " << i; + mitk::PlaneGeometry::Pointer planeGeo = translatePlane(-i, plane)->Clone(); + planeGeo->ChangeImageGeometryConsideringOriginOffset(true); + planeGeo->SetImageGeometry(true); + + currentSliceResults = shapeComparisonManager->calculateDistanceMetricsSlices(registeredSurface, targetSurface, planeGeo); + //m_DistanceSliceResults.emplace(i, currentSliceResults); + } + MITK_INFO << "finished"; +} + + + +//TODO calculateSurfaceDistanceMetricsSlices + 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->GetIndexToWorldTransform()->GetInverseTransform()->TransformVector(normal); 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; } mitk::Image::Pointer QmitkSurfaceRegistration::ConvertSurfaceToImage(mitk::Image::Pointer image, mitk::Surface::Pointer surface) { 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_INFO << "testload Position"; 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 8581cc44a1..ea95c90825 100644 --- a/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/QmitkSurfaceRegistration.h +++ b/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/QmitkSurfaceRegistration.h @@ -1,196 +1,196 @@ /*========================================================================= 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 /*! @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(); 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; QStringList m_Directories; QString m_mainDirectory = "D:/ShapeComparison/TestCase/"; //automatization void initializeDirectoryList(); void automatizedEvaluation(); void compareAnklePath(QString pathA, QString pathB); - void performTwoSidedComparison(mitk::Surface::Pointer left, mitk::Surface::Pointer right, QString resultName, std::ofstream& resultOutput); + void performTwoSidedComparison(mitk::Surface::Pointer left, mitk::Surface::Pointer right, QString resultName); - void performTwoSidedLabelOverlapComparison(mitk::Surface::Pointer left, mitk::Surface::Pointer right, std::ofstream& resultOutput); + void performTwoSidedLabelOverlapComparison(mitk::Surface::Pointer left, mitk::Surface::Pointer right); mitk::DataNode::Pointer getGeometryNodeFromTarget(mitk::Surface::Pointer target); //testing void initializeWithSceneFile(); 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); - + void iteratePlanePositionImages(Plane plane); + void iteratePlanePositionSurfaces(std::string first, std::string second, Plane plane); double calculateASSD(double meanA, double meanB); /*! * @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); mitk::Image::Pointer ConvertSurfaceToImage(mitk::Image::Pointer image, mitk::Surface::Pointer surface); void showLookUpTable(vtkSmartPointer lut); }; #endif // QmitkSurfaceRegistration_h \ No newline at end of file