diff --git a/Modules/ShapeComparison/include/MitkShapeComparisonManager.h b/Modules/ShapeComparison/include/MitkShapeComparisonManager.h index cf4e5728d2..e3a47b6a5c 100644 --- a/Modules/ShapeComparison/include/MitkShapeComparisonManager.h +++ b/Modules/ShapeComparison/include/MitkShapeComparisonManager.h @@ -1,62 +1,65 @@ /*=================================================================== 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 mitkShapeComparisonManager_h #define mitkShapeComparisonManager_h #include #include #include #include #include namespace mitk { class MITKSHAPECOMPARISON_EXPORT ShapeComparisonManager { public: ShapeComparisonManager(); ~ShapeComparisonManager(); std::map calculateLabelOverlapMetrics(mitk::Image::Pointer firstImg, mitk::Image::Pointer secondImg); std::map calculateLabelOverlapMetricsSlices(mitk::Image::Pointer firstImg, mitk::Image::Pointer secondImg, PlaneGeometry* plane); std::map calculateDistanceMetrics(mitk::Surface::Pointer firstSurface, mitk::Surface::Pointer secondSurface); std::map calculateDistanceMetricsSlices(mitk::Surface::Pointer firstSurface, mitk::Surface::Pointer secondSurface, PlaneGeometry* plane); mitk::Image::Pointer extractSlice(mitk::Image::Pointer img, PlaneGeometry::Pointer plane); void setOutputpath(std::string outputpath); void startOutputGeneration(); + void closeOutputGeneration(); + + void resetSliceCounter(std::string plane, int counter); private: std::map m_LabelOverlapResults; std::string m_outputpath; std::ofstream m_OutputFile; bool m_generateOutput = false; int sliceCounterOverlap = -70; int sliceCounterDistance = -70; }; } #endif diff --git a/Modules/ShapeComparison/src/DataManagement/mitkSurfaceDistanceCalculator.cpp b/Modules/ShapeComparison/src/DataManagement/mitkSurfaceDistanceCalculator.cpp index 2c82784de3..ad95ff74f1 100644 --- a/Modules/ShapeComparison/src/DataManagement/mitkSurfaceDistanceCalculator.cpp +++ b/Modules/ShapeComparison/src/DataManagement/mitkSurfaceDistanceCalculator.cpp @@ -1,133 +1,146 @@ #include "mitkSurfaceDistanceCalculator.h" #include #include #include #include #include #include mitk::SurfaceDistanceCalculator::SurfaceDistanceCalculator(mitk::Surface::Pointer first, mitk::Surface::Pointer second) { this->m_First = first; this->m_Second = second; } mitk::SurfaceDistanceCalculator::~SurfaceDistanceCalculator() { + m_First->Delete(); + m_Second->Delete(); } std::map mitk::SurfaceDistanceCalculator::calculateSurfaceDistanceMetric3D() { std::map results; MITK_INFO << "calculating SurfaceDistanceMetrics 3D"; vtkSmartPointer distancesFirst = m_First->GetVtkPolyData()->GetPointData()->GetScalars("Distances"); vtkSmartPointer distancesSecond = m_Second->GetVtkPolyData()->GetPointData()->GetScalars("Distances"); double asdFirst = calculateAverageSurfaceDistance(distancesFirst); double asdSecond = calculateAverageSurfaceDistance(distancesSecond); double assd = calculateAverageSymmetricSurfaceDistance(asdFirst, asdSecond); results.emplace("ASDFirst", asdFirst); results.emplace("ASDSecond", asdSecond); results.emplace("ASSD", assd); printResults(results); return results; } std::map mitk::SurfaceDistanceCalculator::calculateSurfaceDistanceMetric2D(mitk::PlaneGeometry::Pointer planegeo) { std::map results; - double asdFirst; - double asdSecond; - double assd; - vtkSmartPointer pointsOnFirstPlane = getPointsOnPlane(m_First->GetVtkPolyData(), planegeo); - vtkSmartPointer pointsOnSecondPlane = getPointsOnPlane(m_Second->GetVtkPolyData(), planegeo); - if (pointsOnFirstPlane->GetNumberOfPoints() > 0 && pointsOnSecondPlane->GetNumberOfPoints() > 0) + double asdFirst = -1; + double asdSecond = -1; + double assd = -1; + vtkSmartPointer pointsOnFirstPlane = vtkPolyData::New(); + pointsOnFirstPlane = getPointsOnPlane(m_First->GetVtkPolyData(), planegeo); + vtkSmartPointer pointsOnSecondPlane = vtkPolyData::New(); + pointsOnSecondPlane = getPointsOnPlane(m_Second->GetVtkPolyData(), planegeo); + if (pointsOnFirstPlane->GetNumberOfPoints() > 0 ) { - vtkSmartPointer distancesFirst = pointsOnFirstPlane->GetPointData()->GetScalars("Distances"); - vtkSmartPointer distancesSecond = pointsOnSecondPlane->GetPointData()->GetScalars("Distances"); - MITK_INFO << "distancesFirst: " << distancesFirst.Get()->GetSize(); - MITK_INFO << "distancesSecond: " << distancesSecond.Get()->GetSize(); - double asdFirst = calculateAverageSurfaceDistance(distancesFirst); - double asdSecond = calculateAverageSurfaceDistance(distancesSecond); - double assd = calculateAverageSymmetricSurfaceDistance(asdFirst, asdSecond); - results.emplace("ASDFirst", asdFirst); - results.emplace("ASDSecond", asdSecond); - results.emplace("ASSD", assd); + vtkSmartPointer distancesFirst = vtkDoubleArray::New(); + distancesFirst = pointsOnFirstPlane->GetPointData()->GetScalars("Distances"); + /*MITK_INFO << "distancesFirst: " << distancesFirst->GetSize(); + for (int i = 0; i < distancesFirst->GetSize(); ++i) + { + MITK_INFO << "Distance at: " << distancesFirst.GetPointer()->GetTuple(i)[0]; + }*/ + asdFirst = calculateAverageSurfaceDistance(distancesFirst); + } + if (pointsOnSecondPlane->GetNumberOfPoints() > 0) + { + vtkSmartPointer distancesSecond = vtkDoubleArray::New(); + distancesSecond = pointsOnSecondPlane->GetPointData()->GetScalars("Distances"); + /* MITK_INFO << "distancesSecond: " << distancesSecond->GetSize(); + for (int i = 0; i < distancesSecond->GetSize(); ++i) + { + MITK_INFO << "Distance at: " << distancesSecond.GetPointer()->GetTuple(i)[0]; + }*/ + asdSecond = calculateAverageSurfaceDistance(distancesSecond); } + if (asdFirst > 0 && asdSecond > 0) + { + assd = calculateAverageSymmetricSurfaceDistance(asdFirst, asdSecond); + } + results.emplace("ASSD", assd); results.emplace("ASDFirst", asdFirst); results.emplace("ASDSecond", asdSecond); results.emplace("ASSD", assd); printResults(results); return results; } void mitk::SurfaceDistanceCalculator::printResults(std::map results) { MITK_INFO << "ASDFirst: " << results["ASDFirst"]; MITK_INFO << "ASDSecond: " << results["ASDSecond"]; MITK_INFO << "ASSD: " << results["ASSD"]; } double mitk::SurfaceDistanceCalculator::calculateAverageSurfaceDistance(vtkSmartPointer distances) { - double sum = 0.0; - double result = -1; - for (int i = 0; i < distances->GetSize(); ++i) + double sum = 0.; + double result = -1.; + int size = distances->GetNumberOfValues(); + for (int i = 0; i < size; ++i) { sum += std::abs(distances.GetPointer()->GetTuple(i)[0]); } - if (distances->GetSize() != 0) { - result = sum / distances->GetSize(); + if (size != 0) { + result = sum / size; } return result; } double mitk::SurfaceDistanceCalculator::calculateAverageSymmetricSurfaceDistance(double asdA, double asdB) { return (asdA +asdB)/2; } vtkSmartPointer mitk::SurfaceDistanceCalculator::getPointsOnPlane(vtkSmartPointer pointset, mitk::PlaneGeometry::Pointer planegeo) { vtkSmartPointer pointsOnPlane = vtkSmartPointer::New(); vtkSmartPointer points = vtkSmartPointer::New(); - // Create the topology of the point (a vertex) - vtkSmartPointer vertices = - vtkSmartPointer::New(); vtkIdType pid[1]; vtkSmartPointer scalars = vtkSmartPointer::New(); double tempPoint[3] = { 0, 0, 0 }; int pointcounter = 0; //search for points with half the distance of the spacing z-direction - double searchingRange = planegeo->GetSpacing()[2] / 2; + double searchingRange = planegeo->GetSpacing()[2]* 0.5; int pointSetSize = pointset->GetPoints()->GetNumberOfPoints(); for (int i = 0; i < pointSetSize; ++i) { pointset->GetPoints()->GetPoint(i, tempPoint); if (planegeo->Distance(tempPoint) < searchingRange) { - points->InsertNextPoint(tempPoint); pid[0] = points->InsertNextPoint(tempPoint); - // MITK_INFO << pointset->GetPointData()->GetScalars()->GetComponent(i, 0); - // scalars->FillValue(pointset->GetPointData()->GetScalars()->GetComponent(i, 0)); - scalars->InsertValue(pointcounter, pointset->GetPointData()->GetScalars()->GetComponent(i, 0)); - // scalars->SetValue(i, pointset->GetPointData()->GetScalars()->GetComponent(i, 0)); + scalars->InsertValue(pid[0], pointset->GetPointData()->GetScalars("Distances")->GetComponent(i, 0)); ++pointcounter; } } - MITK_INFO << "Number of Points near plane: " << pointcounter; if (pointcounter > 1) { pointsOnPlane->SetPoints(points); - MITK_INFO << "Scalars: " << scalars->GetSize(); scalars->SetName("Distances"); pointsOnPlane->GetPointData()->SetScalars(scalars); } + return pointsOnPlane; + //MITK_INFO << "PointsOnPlane Size: " << pointsOnPlane->GetNumberOfPoints(); + //MITK_INFO << "Scalar size:" << scalars->GetNumberOfValues(); } diff --git a/Modules/ShapeComparison/src/mitkShapeComparisonManager.cpp b/Modules/ShapeComparison/src/mitkShapeComparisonManager.cpp index d6fa305630..65e98ae27b 100644 --- a/Modules/ShapeComparison/src/mitkShapeComparisonManager.cpp +++ b/Modules/ShapeComparison/src/mitkShapeComparisonManager.cpp @@ -1,158 +1,173 @@ /*=================================================================== 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 "vtkVersion.h" #include "vtkImageViewer.h" #include "vtkImageMapper3D.h" #include "vtkRenderWindowInteractor.h" #include "vtkSmartPointer.h" #include "vtkImageActor.h" #include "vtkInteractorStyleImage.h" #include "vtkRenderer.h" #include "itkRGBPixel.h" #include #include #include mitk::ShapeComparisonManager::ShapeComparisonManager() { + sliceCounterDistance = -70; + sliceCounterDistance = -70; } mitk::ShapeComparisonManager::~ShapeComparisonManager() { - m_OutputFile.close(); + // m_OutputFile.close(); } std::map mitk::ShapeComparisonManager::calculateLabelOverlapMetrics(mitk::Image::Pointer firstImg, mitk::Image::Pointer secondImg) { mitk::LabelOverlapMetricCalculator *labelOverlapCalc = new mitk::LabelOverlapMetricCalculator(firstImg, secondImg); labelOverlapCalc->calculateLabelOverlapMeasures3D(); std::map results = labelOverlapCalc->getResults(); if (m_generateOutput) { m_OutputFile << "/*****************************************************************************/" << std::endl; m_OutputFile << "Global LabelOverlap Metrics" << std::endl; m_OutputFile << "FPR: " << results.at("FPR") << std::endl; m_OutputFile << "FNR: " << results.at("FNR") << std::endl; m_OutputFile << "Dice: " << results.at("Dice") << std::endl; m_OutputFile << "Jaccard: " << results.at("Jaccard") << std::endl; m_OutputFile << "/*****************************************************************************/" << std::endl; } return results; } std::map mitk::ShapeComparisonManager::calculateLabelOverlapMetricsSlices(mitk::Image::Pointer firstImg, mitk::Image::Pointer secondImg, PlaneGeometry* plane) { auto sourceSlice = extractSlice(firstImg, plane->Clone()); auto targetSlice = extractSlice(secondImg, plane->Clone()); auto labelOverlapCalc = new mitk::LabelOverlapMetricCalculator(sourceSlice, targetSlice); labelOverlapCalc->calculateLabelOverlapMeasures2D(); std::map results = labelOverlapCalc->getResults(); if (m_generateOutput) { m_OutputFile << "Local LabelOverlap Metrics" << std::endl; m_OutputFile << "Slice: " << sliceCounterOverlap << std::endl; m_OutputFile << "FPR: " << results.at("FPR") << std::endl; m_OutputFile << "FNR: " << results.at("FNR") << std::endl; m_OutputFile << "Dice: " << results.at("Dice") << std::endl; m_OutputFile << "Jaccard: " << results.at("Jaccard") << std::endl; ++sliceCounterOverlap; } return results; } std::map mitk::ShapeComparisonManager::calculateDistanceMetrics(mitk::Surface::Pointer firstSurface, mitk::Surface::Pointer secondSurface) { auto surfaceDistanceCalc = new mitk::SurfaceDistanceCalculator(firstSurface, secondSurface); MITK_INFO << "New SurfaceDistanceCalculator instantiated."; std::map results = surfaceDistanceCalc->calculateSurfaceDistanceMetric3D(); if (m_generateOutput) { m_OutputFile << "/*****************************************************************************/" << std::endl; m_OutputFile << "Global SurfaceDistance Metrics" << std::endl; m_OutputFile << "ASDFirst: " << results.at("ASDFirst") << std::endl; m_OutputFile << "ASDSecond: " << results.at("ASDSecond") << std::endl; m_OutputFile << "ASSD: " << results.at("ASSD") << std::endl; m_OutputFile << "/*****************************************************************************/" << std::endl; } return results; } std::map mitk::ShapeComparisonManager::calculateDistanceMetricsSlices(mitk::Surface::Pointer firstSurface, mitk::Surface::Pointer secondSurface, PlaneGeometry * plane) { //TODO use PolyData and get points on plane first auto surfaceDistanceCalc = new mitk::SurfaceDistanceCalculator(firstSurface, secondSurface); std::map results = surfaceDistanceCalc->calculateSurfaceDistanceMetric2D(plane); if (m_generateOutput) { m_OutputFile << "Local SurfaceDistance Metrics" << std::endl; m_OutputFile << "Slice: " << sliceCounterDistance << std::endl; m_OutputFile << "ASDFirst: " << results.at("ASDFirst") << std::endl; m_OutputFile << "ASDSecond: " << results.at("ASDSecond") << std::endl; m_OutputFile << "ASSD: " << results.at("ASSD") << std::endl; - ++sliceCounterDistance; + sliceCounterDistance++; } return results; } mitk::Image::Pointer mitk::ShapeComparisonManager::extractSlice(mitk::Image::Pointer img, PlaneGeometry::Pointer planeT) { auto imgSlice = mitk::Image::Pointer(); mitk::ExtractSliceFilter2::Pointer extractSliceFilter = mitk::ExtractSliceFilter2::New(); - MITK_INFO << img->GetReferenceCount(); - MITK_INFO << planeT->GetReferenceCount(); - extractSliceFilter->SetInput(img); extractSliceFilter->SetOutputGeometry(planeT); try { extractSliceFilter->Update(); } catch (const mitk::Exception& exception) { MITK_ERROR << exception.GetDescription(); // return; } imgSlice = extractSliceFilter->GetOutput(); extractSliceFilter->ResetPipeline(); imgSlice->DisconnectPipeline(); return imgSlice; } void mitk::ShapeComparisonManager::setOutputpath(std::string outputpath) { this->m_outputpath = outputpath; } void mitk::ShapeComparisonManager::startOutputGeneration() { m_OutputFile.open(m_outputpath); this->m_generateOutput = true; -} +} +void mitk::ShapeComparisonManager::closeOutputGeneration() +{ + m_OutputFile.close(); +} +void mitk::ShapeComparisonManager::resetSliceCounter(std::string plane, int counter) +{ + if (plane == "axial") + m_OutputFile << "AXIAL-------------------------------------------------------------------------" << std::endl; + if (plane == "coronal") + m_OutputFile << "CORONAL-----------------------------------------------------------------------" << std::endl; + if (plane == "sagittal") + m_OutputFile << "SAGGITAL----------------------------------------------------------------------" << std::endl; + + sliceCounterDistance = counter; + sliceCounterOverlap = counter; +} diff --git a/Modules/SurfaceRegistration/src/DataManagement/MitkShortestDistanceCalculator.cpp b/Modules/SurfaceRegistration/src/DataManagement/MitkShortestDistanceCalculator.cpp index 1771564610..4e5ea44dd0 100644 --- a/Modules/SurfaceRegistration/src/DataManagement/MitkShortestDistanceCalculator.cpp +++ b/Modules/SurfaceRegistration/src/DataManagement/MitkShortestDistanceCalculator.cpp @@ -1,194 +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 +#include 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_Target->GetPoints()->GetNumberOfPoints(); vtkSmartPointer implicitPolyDataDistance = vtkSmartPointer::New(); implicitPolyDataDistance->SetInput(m_Moving); m_RangeMin = 0; m_RangeMax = 0; for (int i = 0; i < pointSetSize; ++i) { 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["Max"] = m_RangeMax; m_Results["Mean"] = m_Mean; m_Results["Std"] = m_StandardDeviation; } vtkSmartPointer mitk::ShortestDistanceCalculator::calculateCurvature() { 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/Plugins/org.mitk.gui.qt.shapecomparison/src/internal/QmitkShapeComparison.cpp b/Plugins/org.mitk.gui.qt.shapecomparison/src/internal/QmitkShapeComparison.cpp index f17a8d6ef0..ec60c79e3a 100644 --- a/Plugins/org.mitk.gui.qt.shapecomparison/src/internal/QmitkShapeComparison.cpp +++ b/Plugins/org.mitk.gui.qt.shapecomparison/src/internal/QmitkShapeComparison.cpp @@ -1,424 +1,425 @@ /*========================================================================= 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 "QmitkShapeComparison.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include "org_mitk_gui_qt_shapecomparison_Activator.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include const std::string QmitkShapeComparison::VIEW_ID = "org.mitk.views.shapecomparison"; QmitkShapeComparison::QmitkShapeComparison(QObject *parent) : m_ParentWidget(0) { } QmitkShapeComparison::~QmitkShapeComparison() { } QWidget * QmitkShapeComparison::GetControls() { return nullptr; } void QmitkShapeComparison::CreateQtPartControl(QWidget *parent) { // create GUI widgets from the Qt Designer's .ui file m_Controls.setupUi(parent); m_Controls.firstImageNameComboBox->SetDataStorage(this->GetDataStorage()); m_Controls.firstImageNameComboBox->SetPredicate(mitk::NodePredicateAnd::New( mitk::TNodePredicateDataType::New(), mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")))); m_Controls.secondImageNameComboBox->SetDataStorage(this->GetDataStorage()); m_Controls.secondImageNameComboBox->SetPredicate(mitk::NodePredicateAnd::New( mitk::TNodePredicateDataType::New(), mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")))); m_Controls.selectGeometryImgComboBox->SetDataStorage(this->GetDataStorage()); m_Controls.selectGeometryImgComboBox->SetPredicate(mitk::NodePredicateAnd::New( mitk::TNodePredicateDataType::New(), mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")))); connect(m_Controls.comparePushButton, SIGNAL(clicked()), this, SLOT(compare())); connect(m_Controls.firstImageNameComboBox, SIGNAL(OnSelectionChanged(const mitk::DataNode *)), this, SLOT(OnSelectedFirstImgChanged(const mitk::DataNode *))); connect(m_Controls.secondImageNameComboBox, SIGNAL(OnSelectionChanged(const mitk::DataNode *)), this, SLOT(OnSelectedSecondImgChanged(const mitk::DataNode *))); m_Controls.comparePushButton->setEnabled(true); mitk::RenderingManager::GetInstance()->SetDataStorage(this->GetDataStorageReference()->GetDataStorage()); mitk::RenderingManager::GetInstance()->InitializeViews(); m_ParentWidget = parent; } void QmitkShapeComparison::SetFocus() { } void QmitkShapeComparison::OnSelectedFirstImgChanged(const mitk::DataNode *node) { if (node != nullptr) { m_firstImg = dynamic_cast(node->GetData()); m_Controls.selectFirstImageLabel->setText("Selected first Image:"); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); if (m_secondImg != nullptr && m_secondImg.GetPointer() != m_firstImg.GetPointer()) { m_Controls.comparePushButton->setEnabled(true); } } } void QmitkShapeComparison::OnSelectedSecondImgChanged(const mitk::DataNode *node) { if (node != nullptr) { m_secondImg = dynamic_cast(node->GetData()); m_Controls.selectSecondImageLabel->setText("Selected second Image:"); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); if (m_firstImg != nullptr && m_secondImg.GetPointer() != m_secondImg.GetPointer()) { m_Controls.comparePushButton->setEnabled(true); } } } void QmitkShapeComparison::compare() { MITK_INFO << "compare clicked!"; mitk::Image* img = dynamic_cast(m_Controls.firstImageNameComboBox->GetSelectedNode()->GetData()); - mitk::ShapeComparisonManager *shapeComparisonManager = new mitk::ShapeComparisonManager(); + m_shapeComparisonManager = new mitk::ShapeComparisonManager(); + m_shapeComparisonManager->setOutputpath("C:/Users/hempe/Desktop/"); + m_shapeComparisonManager->startOutputGeneration(); ////Code for comparison mitk::Surface::Pointer testA = dynamic_cast(this->GetDataStorage()->GetNamedNode("TibiaMovingL")->GetData()); mitk::Surface::Pointer testB = dynamic_cast(this->GetDataStorage()->GetNamedNode("TibiaMovingR")->GetData()); - std::map labelOverlapResults = shapeComparisonManager->calculateLabelOverlapMetrics(m_firstImg, m_secondImg); + std::map labelOverlapResults = m_shapeComparisonManager->calculateLabelOverlapMetrics(m_firstImg, m_secondImg); - std::map distanceMetricsResults = shapeComparisonManager-> + std::map distanceMetricsResults = m_shapeComparisonManager-> calculateDistanceMetrics(testA, testB); - shapeComparisonManager->~ShapeComparisonManager(); + // shapeComparisonManager->~ShapeComparisonManager(); //Results to Qstring m_Controls.labelFPR->setText(QString::number(labelOverlapResults["FPR"])); m_Controls.labelFNR->setText(QString::number(labelOverlapResults["FNR"])); m_Controls.labelDice->setText(QString::number(labelOverlapResults["Dice"])); m_Controls.labelJaccard->setText(QString::number(labelOverlapResults["Jaccard"])); m_Controls.labelVolumeSimilarity->setText(QString::number(labelOverlapResults["VolumeSimilarity"])); testloadPosition(); iteratePlanePositionImages(axial);// TODO solve debug error or run in release mode MITK_INFO << "Now display results!"; iteratePlanePositionSurfaces(testA, testB, axial); std::map diceMap; std::map jaccardMap; std::map FNRMap; std::map FPRMap; std::map asd1Map; std::map asd2Map; std::map assdMap; for (int i = -70; i < 70; ++i) { std::map sliceMap = m_SliceResults.at(i); //labelOverlap diceMap.emplace(i, sliceMap.at("Dice")); if(sliceMap.at("Jaccard") < 2) jaccardMap.emplace(i, sliceMap.at("Jaccard")); if (sliceMap.at("FNR") < 2) FNRMap.emplace(i, sliceMap.at("FNR")); if (sliceMap.at("FPR") < 2) FPRMap.emplace(i, sliceMap.at("FPR")); //SurfaceDistance std::map distanceSliceMap = m_DistanceSliceResults.at(i); if (distanceSliceMap.at("ASDFirst") < 10) asd1Map.emplace(i, distanceSliceMap.at("ASDFirst")); if (distanceSliceMap.at("ASDSecond") < 10) asd2Map.emplace(i, distanceSliceMap.at("ASDSecond")); if (distanceSliceMap.at("ASSD") < 10) assdMap.emplace(i, distanceSliceMap.at("ASSD")); } m_Controls.LabelOverlapTabWidget->Clear(); + m_Controls.DistanceTabWidget->Clear(); m_Controls.LabelOverlapTabWidget->AddData2D(diceMap, "Dice", QmitkChartWidget::ChartType::line); m_Controls.LabelOverlapTabWidget->AddData2D(jaccardMap, "Jaccard", QmitkChartWidget::ChartType::line); m_Controls.LabelOverlapTabWidget->AddData2D(FNRMap, "FNR", QmitkChartWidget::ChartType::line); m_Controls.LabelOverlapTabWidget->AddData2D(FPRMap, "FPR", QmitkChartWidget::ChartType::line); m_Controls.LabelOverlapTabWidget->SetXAxisLabel("Distance from StandardPlane");//rename m_Controls.DistanceTabWidget->AddData2D(asd1Map, "ASD1", QmitkChartWidget::ChartType::line); m_Controls.DistanceTabWidget->AddData2D(asd2Map, "ASD2", QmitkChartWidget::ChartType::line); m_Controls.DistanceTabWidget->AddData2D(assdMap, "ASSD", QmitkChartWidget::ChartType::line); m_Controls.DistanceTabWidget->SetXAxisLabel("Distance from StandardPlane"); // //m_Controls.LabelOverlapTabWidget->baseSize(); m_Controls.LabelOverlapTabWidget->Show(); m_Controls.LabelOverlapTabWidget->setEnabled(true); m_Controls.DistanceTabWidget->Show(); m_Controls.DistanceTabWidget->setEnabled(true); // //iteratePlanePosition(coronal); // // iteratePlanePosition(saggital); } void QmitkShapeComparison::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 QmitkShapeComparison::loadPlanePositions() { 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.selectGeometryImgComboBox->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* QmitkShapeComparison::getPlanePositionManagerService() { ctkPluginContext* context = mitk::org_mitk_gui_qt_shapecomparison_Activator::GetContext(); ctkServiceReference ppmRef = context->getServiceReference(); mitk::PlanePositionManagerService* service = nullptr; service = context->getService(ppmRef); context->ungetService(ppmRef); return service; } void QmitkShapeComparison::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()); mitk::BaseRenderer *rendereri = m_Renderer->GetByName(multiWidgetString.c_str()); } } } void QmitkShapeComparison::iteratePlanePositionImages(Plane plane) { m_SliceResults.clear(); - mitk::ShapeComparisonManager *shapeComparisonManager = new mitk::ShapeComparisonManager(); 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->calculateLabelOverlapMetricsSlices(m_firstImg, m_secondImg, planeGeo); + currentSliceResults = m_shapeComparisonManager->calculateLabelOverlapMetricsSlices(m_firstImg, m_secondImg, planeGeo); m_SliceResults.emplace(i, currentSliceResults); } MITK_INFO << "finished"; - shapeComparisonManager->~ShapeComparisonManager(); + //shapeComparisonManager->~ShapeComparisonManager(); } void QmitkShapeComparison::iteratePlanePositionSurfaces(mitk::Surface::Pointer first, mitk::Surface::Pointer second, Plane plane) { m_DistanceSliceResults.clear(); - mitk::ShapeComparisonManager *shapeComparisonManager = new mitk::ShapeComparisonManager(); 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(first, second, planeGeo); + currentSliceResults = m_shapeComparisonManager->calculateDistanceMetricsSlices(first, second, planeGeo); m_DistanceSliceResults.emplace(i, currentSliceResults); } MITK_INFO << "finished"; - shapeComparisonManager->~ShapeComparisonManager(); + //shapeComparisonManager->~ShapeComparisonManager(); } mitk::PlaneGeometry::Pointer QmitkShapeComparison::translatePlane(int id, Plane plane) { mitk::DataNode::Pointer geoImg = m_Controls.selectGeometryImgComboBox->GetSelectedNode(); std::stringstream multiWidgetStream; multiWidgetStream << "stdmulti.widget"; switch (plane) { case QmitkShapeComparison::axial: multiWidgetStream << 1; break; case QmitkShapeComparison::coronal: multiWidgetStream << 2; break; case QmitkShapeComparison::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); newPlaneGeo->Translate(normal * id); MITK_INFO << "Center der neuen Plane: " << newPlaneGeo->GetCenter(); m_Renderer = renderer; m_Renderer->RequestUpdate(); mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll(); return newPlaneGeo; } void QmitkShapeComparison::testloadPosition() { mitk::DataNode::Pointer selectedNode = m_Controls.selectGeometryImgComboBox->GetSelectedNode(); GetAxisPositions(selectedNode); mitk::RenderingManager::GetInstance()->InitializeViews(); } diff --git a/Plugins/org.mitk.gui.qt.shapecomparison/src/internal/QmitkShapeComparison.h b/Plugins/org.mitk.gui.qt.shapecomparison/src/internal/QmitkShapeComparison.h index d19b91e7b8..b6dd551569 100644 --- a/Plugins/org.mitk.gui.qt.shapecomparison/src/internal/QmitkShapeComparison.h +++ b/Plugins/org.mitk.gui.qt.shapecomparison/src/internal/QmitkShapeComparison.h @@ -1,153 +1,152 @@ /*========================================================================= 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 QmitkShapeComparison_h #define QmitkShapeComparison_h #include #ifdef WIN32 #pragma warning( disable : 4250 ) #endif #include "QVTKWidget.h" #include "QmitkRegisterClasses.h" #include #include #include "ui_ShapeComparisonControls.h" #include "usServiceRegistration.h" #include #include #include #include /*! @brief QmitkShapeComparisonView \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 QmitkShapeComparison : 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) */ QmitkShapeComparison(QObject *parent = 0); virtual ~QmitkShapeComparison(); static const std::string VIEW_ID; virtual void CreateQtPartControl(QWidget *parent); virtual void SetFocus() override; ///*! //@brief Creates the Qt connections needed //*/ QWidget* GetControls(); /// @brief Called when the user clicks the GUI button protected slots: void compare(); void OnSelectedFirstImgChanged(const mitk::DataNode *); void OnSelectedSecondImgChanged(const mitk::DataNode *); protected: private: const std::string outputpath = "";//TODO const mitk::NodePredicateDataType::Pointer isSurface = mitk::NodePredicateDataType::New("Surface"); const mitk::NodePredicateDataType::Pointer isLabelSetImage = mitk::NodePredicateDataType::New("LabelSetImage"); /*! * The parent QWidget */ QWidget* m_ParentWidget; mitk::BaseRenderer *m_Renderer; Ui::ShapeComparisonControls m_Controls; mitk::ShapeComparisonManager *m_ShapeComparisonManager; mitk::Image::Pointer m_firstImg; mitk::Image::Pointer m_secondImg; std::map> m_SliceResults; std::map> m_DistanceSliceResults; //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 iteratePlanePositionImages(Plane plane); //TODO insert image parameters void iteratePlanePositionSurfaces(mitk::Surface::Pointer first, mitk::Surface::Pointer second, 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); - mitk::PlaneGeometry::ConstPointer m_axialPlane; - + mitk::ShapeComparisonManager *m_shapeComparisonManager; }; #endif \ 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 96c93413aa..99819c50ef 100644 --- a/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/QmitkSurfaceRegistration.cpp +++ b/Plugins/org.mitk.gui.qt.surfaceregistration/src/internal/QmitkSurfaceRegistration.cpp @@ -1,885 +1,1129 @@ /*========================================================================= 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 #include +#include +#include + +#define _USE_MATH_DEFINES +#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_ShapeComparisonManager = new mitk::ShapeComparisonManager(); 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(); //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); //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->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) + 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)) { - mitk::DataNode::Pointer node = (*iter); - if (QString(node->GetName().c_str()).contains(QString("orig"), Qt::CaseSensitive)) + if (leftOrigName == "") { - if (leftOrigName == "") - { - leftOrigName = QString(node->GetName().c_str()).remove("_orig"); - } - else if (rightOrigName == "" && rightOrigName != leftOrigName) - { - rightOrigName = QString(node->GetName().c_str()).remove("_orig"); - } + 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; + //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)) + //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)) { - 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)) + 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)) { - 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()); - } + 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()); + } } } + //fillHoles(tibiaLeft); + //fillHoles(tibiaRight); + //fillHoles(fibulaLeft); + //fillHoles(fibulaRight); + //fillHoles(talusLeft); + //fillHoles(talusRight); + + //TIBIA//TIBIA//TIBIA//TIBIA//TIBIA//TIBIA//TIBIA//TIBIA//TIBIA//TIBIA//TIBIA//TIBIA//TIBIA//TIBIA + m_ShapeComparisonManager = new mitk::ShapeComparisonManager(); - m_SurfaceRegistrationManager->setMirroring(m_Controls.mirroringCheckBox->isChecked()); + m_ShapeComparisonManager->setOutputpath("D:/ShapeComparison/TestCase/" + tibiaLeft->GetObjectName() + tibiaRight->GetObjectName() + ".txt"); + m_ShapeComparisonManager->startOutputGeneration(); - ////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; + //calculate Tibia differences performTwoSidedComparison(tibiaLeft, tibiaRight, "Tibia"); - //resultOutput << "Calculating Fibula..." << std::endl; + + mitk::DataNode::Pointer geometryNode = getGeometryNodeFromTarget(tibiaRight); + m_Controls.imageSelectorComboBox->SetSelectedNode(geometryNode); + testloadPosition(); + iteratePlanePositionImages(axial); + + mitk::Surface::Pointer tibiaMovingLeft = dynamic_cast(this->GetDataStorage()->GetNamedNode("TibiaMovingL")->GetData()); + mitk::Surface::Pointer tibiaMovingRight = dynamic_cast(this->GetDataStorage()->GetNamedNode("TibiaMovingR")->GetData()); + + m_SurfaceRegistrationManager = new mitk::SurfaceRegistrationManager(tibiaMovingLeft, tibiaMovingRight); + if (QString(tibiaLeft->GetObjectName().c_str()).contains(QString("L"), Qt::CaseSensitive) && QString(tibiaRight->GetObjectName().c_str()).contains(QString("L"), Qt::CaseSensitive) ) + { + m_SurfaceRegistrationManager->setMirroring(false); + } + else if (QString(tibiaLeft->GetObjectName().c_str()).contains(QString("R"), Qt::CaseSensitive) && QString(tibiaRight->GetObjectName().c_str()).contains(QString("R"), Qt::CaseSensitive)) + { + m_SurfaceRegistrationManager->setMirroring(false); + } + else + { + m_SurfaceRegistrationManager->setMirroring(true); + } + m_SurfaceRegistrationManager->performRegistration(); + mitk::Surface::Pointer registeredTibia = m_SurfaceRegistrationManager->getRegisteredSurface(); + registeredTibia->GetVtkPolyData()->GetPointData()->SetScalars(tibiaMovingLeft->GetVtkPolyData()->GetPointData()->GetScalars()); + + mitk::DataNode::Pointer registeredTibiaMovingL = mitk::DataNode::New(); + registeredTibiaMovingL->SetData(registeredTibia); + registeredTibiaMovingL->SetName("registeredTibiaMovingL"); + this->GetDataStorage()->Add(registeredTibiaMovingL); + mitk::RenderingManager::GetInstance()->RequestUpdateAll(); + + std::map distanceMetricsResultsTibia = m_ShapeComparisonManager->calculateDistanceMetrics(tibiaMovingLeft, tibiaMovingRight); + + geometryNode = getGeometryNodeFromTarget(tibiaLeft); + m_Controls.imageSelectorComboBox->SetSelectedNode(geometryNode); + + testloadPosition(); + iteratePlanePositionSurfaces(registeredTibia, tibiaMovingRight, axial); + testloadPosition(); + iteratePlanePositionSurfaces(registeredTibia, tibiaMovingRight, coronal); + testloadPosition(); + iteratePlanePositionSurfaces(registeredTibia, tibiaMovingRight, saggital); + mitk::RenderingManager::GetInstance()->RequestUpdateAll(); + + + m_ShapeComparisonManager->closeOutputGeneration(); + // m_SurfaceRegistrationManager->~SurfaceRegistrationManager(); + testloadPosition(); + + //FIBULA//FIBULA//FIBULA//FIBULA//FIBULA//FIBULA//FIBULA//FIBULA//FIBULA//FIBULA//FIBULA//FIBULA//FIBULA + + m_ShapeComparisonManager->setOutputpath("D:/ShapeComparison/TestCase/" + fibulaLeft->GetObjectName() + fibulaRight->GetObjectName() + ".txt"); + m_ShapeComparisonManager->startOutputGeneration(); + + //calculate Fibula differences performTwoSidedComparison(fibulaLeft, fibulaRight, "Fibula"); - ////resultOutput << "Calculating Talus..." << std::endl; - // performTwoSidedComparison(talusLeft, talusRight, "Target", resultOutput); - ////TODO end outputstream - //resultOutput.close(); + geometryNode = getGeometryNodeFromTarget(tibiaLeft); + m_Controls.imageSelectorComboBox->SetSelectedNode(geometryNode); + testloadPosition(); + iteratePlanePositionImages(axial); + + mitk::Surface::Pointer fibulaMovingLeft = dynamic_cast(this->GetDataStorage()->GetNamedNode("FibulaMovingL")->GetData()); + mitk::Surface::Pointer fibulaMovingRight = dynamic_cast(this->GetDataStorage()->GetNamedNode("FibulaMovingR")->GetData()); + + std::map distanceMetricsResultsFibula = m_ShapeComparisonManager->calculateDistanceMetrics(fibulaMovingLeft, fibulaMovingRight); + + m_SurfaceRegistrationManager = new mitk::SurfaceRegistrationManager(fibulaMovingLeft, fibulaMovingRight); + if (QString(fibulaLeft->GetObjectName().c_str()).contains(QString("L"), Qt::CaseSensitive) && QString(fibulaRight->GetObjectName().c_str()).contains(QString("L"), Qt::CaseSensitive)) + { + m_SurfaceRegistrationManager->setMirroring(false); + } + else if (QString(fibulaLeft->GetObjectName().c_str()).contains(QString("R"), Qt::CaseSensitive) && QString(fibulaRight->GetObjectName().c_str()).contains(QString("R"), Qt::CaseSensitive)) + { + m_SurfaceRegistrationManager->setMirroring(false); + } + else + { + m_SurfaceRegistrationManager->setMirroring(true); + } + m_SurfaceRegistrationManager->performRegistration(); + mitk::Surface::Pointer registeredFibula = m_SurfaceRegistrationManager->getRegisteredSurface(); + + geometryNode = getGeometryNodeFromTarget(tibiaLeft); + m_Controls.imageSelectorComboBox->SetSelectedNode(geometryNode); testloadPosition(); + iteratePlanePositionSurfaces(registeredFibula, fibulaMovingRight, axial); + testloadPosition(); + iteratePlanePositionSurfaces(registeredFibula, fibulaMovingRight, coronal); + testloadPosition(); + iteratePlanePositionSurfaces(registeredFibula, fibulaMovingRight, saggital); - // iteratePlanePositionImages(axial); - //iteratePlanePositionImages(coronal); - //iteratePlanePositionImages(saggital); - iteratePlanePositionSurfaces("TibiaMovingL","TibiaMovingR",axial); - iteratePlanePositionSurfaces("FibulaMovingL", "FibulaMovingR", axial); + m_ShapeComparisonManager->closeOutputGeneration(); + //m_SurfaceRegistrationManager->~SurfaceRegistrationManager(); + ////resultOutput << "Calculating Talus..." << std::endl; + // performTwoSidedComparison(talusLeft, talusRight, "Target", resultOutput); } mitk::ProgressBar::GetInstance()->Progress(); } void QmitkSurfaceRegistration::doCompare() { - m_SurfaceRegistrationManager->setMirroring(m_Controls.mirroringCheckBox->isChecked()); + mitk::Surface::Pointer testFillHoles = dynamic_cast(m_Controls.movingSurfaceNameComboBox->GetSelectedNode()->GetData()); + fillHoles(testFillHoles); + + mitk::DataNode::Pointer node = mitk::DataNode::New(); + node->SetData(testFillHoles); + node->SetName("NoHoles"); + this->GetDataStorage()->Add(node); + this->GetDataStorageReference()->GetDataStorage()->Modified(); + + mitk::RenderingManager::GetInstance()->InitializeViews(); + mitk::RenderingManager::GetInstance()->RequestUpdateAll(); + + + //TODO + /*m_SurfaceRegistrationManager->setMirroring(m_Controls.mirroringCheckBox->isChecked()); initializeDirectoryList(); - automatizedEvaluation(); + 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::RenderingManager::GetInstance()->InitializeViews(); //mitk::RenderingManager::GetInstance()->RequestUpdateAll(); //vtkSmartPointer lut = m_SurfaceRegistrationManager->getTable(); //showLookUpTable(lut); //testloadPosition(); //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); } else if (allFeetDirs.at(i).contains("Right") && allFeetDirs.at(j).contains("Right")) { m_Controls.mirroringCheckBox->setChecked(false); m_SurfaceRegistrationManager->setMirroring(false); } else { m_Controls.mirroringCheckBox->setChecked(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; + // 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(); + // MITK_INFO << "DS size: " << this->GetDataStorage()->GetAll()->Size(); } void QmitkSurfaceRegistration::performTwoSidedComparison(mitk::Surface::Pointer left, mitk::Surface::Pointer right, QString resultName) { + //set the mirroring 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_Controls.mirroringCheckBox->setChecked(true); m_movingSurface = left; m_targetSurface = right; m_Controls.mappedDataNameLineEdit->setText(resultName +"MovingL"); doRegisterAndCompare(); - double meanA = m_SurfaceRegistrationManager->getDistanceResults()["Mean"]; + //double meanA = m_SurfaceRegistrationManager->getDistanceResults()["Mean"]; m_movingSurface = right; m_targetSurface = left; m_Controls.mappedDataNameLineEdit->setText(resultName + "MovingR"); doRegisterAndCompare(); performTwoSidedLabelOverlapComparison(left, right); - double meanB = m_SurfaceRegistrationManager->getDistanceResults()["Mean"]; + //double meanB = m_SurfaceRegistrationManager->getDistanceResults()["Mean"]; - double ASSD = calculateASSD(meanA, meanB); + //double ASSD = calculateASSD(meanA, meanB); /*resultOutput << " ASSD: " << ASSD << std::endl;*/ } } 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(); - 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"]); + std::map labelOverlapResults = m_ShapeComparisonManager->calculateLabelOverlapMetrics(registeredImg, targetImg); //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(); //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 + m_Controls.imageSelectorComboBox->SetSelectedNode(origImgNode); 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(); + //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) +mitk::Surface::Pointer QmitkSurfaceRegistration::fillHoles(mitk::Surface::Pointer surface) { - return (meanA + meanB)/2; + mitk::Surface::Pointer filledSurface = surface->Clone(); + vtkSmartPointer polyData = surface->GetVtkPolyData(); + vtkSmartPointer fillHolesFilter = + vtkSmartPointer::New(); + #if VTK_MAJOR_VERSION <= 5 + fillHolesFilter->SetInputData(surface->GetVtkPolyData()); + #else + fillHolesFilter->SetInputData(input); + #endif + fillHolesFilter->SetHoleSize(1.0); + + + filledSurface->SetVtkPolyData(fillHolesFilter->GetOutput()); + // Make the triangle windong order consistent + vtkSmartPointer normals = + vtkSmartPointer::New(); + normals->SetInputData(filledSurface->GetVtkPolyData()); + normals->ConsistencyOn(); + normals->SplittingOff(); + normals->Update(); + + // Restore the original normals + normals->GetOutput()->GetPointData()-> + SetNormals(surface->GetVtkPolyData()->GetPointData()->GetNormals()); + polyData = normals->GetOutput(); + filledSurface->SetVtkPolyData(fillHolesFilter->GetOutput()); + return filledSurface; } 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(); + // 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::iteratePlanePositionImages(Plane plane) { - //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(); + //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"); + + std::vector startToStop = { 0,0 }; + std::vector maxDistanceMoving = calculateMaxDistanceFromStandardPlane(plane, m_movingSurface);// TODO registered may be different in size due to ICP + std::vector maxDistanceTarget = calculateMaxDistanceFromStandardPlane(plane, m_targetSurface); + double spacing = std::abs(registeredImg->GetGeometry()->GetSpacing()[0]); + MITK_INFO << "Spacing Img: " << spacing; + startToStop[0] = std::ceil(std::max(maxDistanceMoving[0], maxDistanceTarget[0])); + startToStop[1] = std::ceil(std::max(maxDistanceMoving[1], maxDistanceTarget[1])); - std::map currentSliceResults; - int stopper = 10; // TODO adjust slices to make comparable - for (int i = -10; i < stopper; ++i) + std::map currentSliceResults; + int margin = 5; + int stopper = int(startToStop[1] / spacing) + margin; + int start = int(startToStop[0] / spacing) - margin; + + m_ShapeComparisonManager->resetSliceCounter("axial", start); + MITK_INFO << "start: " << start; + MITK_INFO << "stopper: " << stopper; + for (int i = start; i < stopper; ++i) { MITK_INFO << "Current plane number: " << i; - mitk::PlaneGeometry::Pointer planeGeo = translatePlane(-i, plane)->Clone(); - mitk::PlaneGeometry::Pointer sliceGeometry = translatePlane(-i, plane)->Clone(); // 0 at standard plane position + //mitk::PlaneGeometry::Pointer planeGeo = translatePlane(-i, plane)->Clone(); + mitk::PlaneGeometry::Pointer sliceGeometry = translatePlane(-i, plane)->Clone(); sliceGeometry->ChangeImageGeometryConsideringOriginOffset(true); sliceGeometry->SetImageGeometry(true); - currentSliceResults = shapeComparisonManager->calculateLabelOverlapMetricsSlices(registeredImg, targetImg, sliceGeometry); - - //shapeComparerUtil->calculateSliceDifferences(sliceGeometry); + currentSliceResults = m_ShapeComparisonManager->calculateLabelOverlapMetricsSlices(registeredImg, targetImg, sliceGeometry); } MITK_INFO << "finished"; m_Renderer->ForceImmediateUpdate(); } -//TODO Tibia, Fibula -void QmitkSurfaceRegistration::iteratePlanePositionSurfaces(std::string first, std::string second, Plane plane) +void QmitkSurfaceRegistration::iteratePlanePositionSurfaces(mitk::Surface::Pointer first, mitk::Surface::Pointer 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::vector startToStop = { 0,0 }; + std::vector maxDistanceMoving = calculateMaxDistanceFromStandardPlane(plane, first);// TODO registered may be different in size due to ICP + std::vector maxDistanceTarget = calculateMaxDistanceFromStandardPlane(plane, second); + mitk::Image::Pointer geometryNode = dynamic_cast(getGeometryNodeFromTarget(second)->GetData()); + double spacing = geometryNode->GetGeometry()->GetSpacing()[0]; + MITK_INFO << "Spacing Surf: " << spacing; + int margin = 5; + startToStop[0] = std::ceil(std::max(maxDistanceMoving[0], maxDistanceTarget[0])); + startToStop[1] = std::ceil(std::max(maxDistanceMoving[1], maxDistanceTarget[1])); + + int stopper = int(startToStop[1] / spacing) + margin; std::map currentSliceResults; + int start = int(startToStop[0] / spacing) - margin; + MITK_INFO << "start: " << start; + MITK_INFO << "stopper: " << stopper; - for (int i = -70; i < stopper; ++i) + switch (plane) + { + case axial: + m_ShapeComparisonManager->resetSliceCounter("axial", start); + break; + case coronal: + m_ShapeComparisonManager->resetSliceCounter("coronal", start); + break; + case saggital: + m_ShapeComparisonManager->resetSliceCounter("sagittal", start); + break; + default: + break; + } + + + for (int i = start; i < stopper; ++i) { MITK_INFO << "Current plane number: " << i; mitk::PlaneGeometry::Pointer planeGeo = translatePlane(-i, plane)->Clone(); planeGeo->ChangeImageGeometryConsideringOriginOffset(true); planeGeo->SetImageGeometry(true); + currentSliceResults = m_ShapeComparisonManager->calculateDistanceMetricsSlices(first, second, planeGeo); + } + MITK_INFO << "finished"; +} + +std::vector QmitkSurfaceRegistration::calculateMaxDistanceFromStandardPlane(Plane plane, mitk::Surface::Pointer surface) +{ + std::vector maxDistances = { 0 , 0 }; + //get the current plane position + testloadPosition(); + mitk::PlaneGeometry::Pointer myPlaneGeo; + switch (plane) + { + case QmitkSurfaceRegistration::axial: + myPlaneGeo = translatePlane(0, axial); + break; + case QmitkSurfaceRegistration::coronal: + myPlaneGeo = translatePlane(0, coronal); + break; + case QmitkSurfaceRegistration::saggital: + myPlaneGeo = translatePlane(0, saggital); + break; + default: + break; + } - currentSliceResults = shapeComparisonManager->calculateDistanceMetricsSlices(registeredSurface, targetSurface, planeGeo); - //m_DistanceSliceResults.emplace(i, currentSliceResults); + // for all points from polydata + // project it on axialplane depending on normal + auto polyData = surface->GetVtkPolyData(); + for (int i = 0; i < polyData->GetNumberOfPoints(); ++i) + { + double point[3]; + polyData->GetPoint(i, point); + //estimate maximal length + mitk::Point3D projectedPoint = myPlaneGeo->ProjectPointOntoPlane(point); + + mitk::Line3D line; + line.SetPoint1(point); + line.SetPoint2(projectedPoint); + double angle = myPlaneGeo->Angle(line) / (M_PI/180); + //calculate distance between projected and unprojected point + double distance = std::sqrt((point[0] - projectedPoint[0])*(point[0] - projectedPoint[0]) + + (point[1] - projectedPoint[1])*(point[1] - projectedPoint[1]) + + (point[2] - projectedPoint[2])*(point[2] - projectedPoint[2])); + if (angle < 0) + { + distance = distance * (-1); + } + + if (QString(surface->GetObjectName().c_str()).contains(QString("Fibula"), Qt::CaseSensitive) && plane != axial) + { + //calc min max distance cor sag + if (distance < maxDistances[0]) + { + maxDistances[0] = distance; + /*if (maxDistances[1] == 0) + maxDistances[1] = maxDistances[0];*/ + } + if (distance > maxDistances[1]) + { + maxDistances[1] = distance; + } + } + else if (QString(surface->GetObjectName().c_str()).contains(QString("Talus"), Qt::CaseSensitive) && plane == axial) + { + if (std::abs(distance) > maxDistances[0]) + { + maxDistances[0] = distance; + } + if (std::abs(distance) < maxDistances[1]) + { + maxDistances[1] = distance; + } + } + else + { + if (angle < 0 && distance < maxDistances[0]) + { + maxDistances[0] = distance; + } + if (angle > 0 && distance > maxDistances[1]) + { + maxDistances[1] = distance; + } + } } - MITK_INFO << "finished"; + return maxDistances; } //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::ConstPointer 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); newPlaneGeo->Translate(normal * id); - MITK_INFO << "Center der neuen Plane: " << newPlaneGeo->GetCenter(); + //MITK_INFO << "Center der neuen Plane: " << newPlaneGeo->GetCenter(); renderer->RequestUpdate(); m_Renderer = renderer; m_Renderer->RequestUpdate(); - mitk::DataNode* imageNode(m_Controls.imageSelectorComboBox->GetSelectedNode()); + mitk::DataNode::Pointer 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_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 ea95c90825..94e1f59389 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,201 @@ /*========================================================================= Program: Medical Imaging & Interaction Toolkit Language: C++ Date: $Date$ Version: $Revision$ Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. See MITKCopyright.txt or http://www.mitk.org/copyright.html for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef QmitkSurfaceRegistration_h #define QmitkSurfaceRegistration_h #include #ifdef WIN32 #pragma warning( disable : 4250 ) #endif #include "QVTKWidget.h" #include "QmitkRegisterClasses.h" #include #include +#include #include "ui_SurfaceRegistrationControls.h" #include "usServiceRegistration.h" #include "mitkAnnotation.h" #include "mitkColorBarAnnotation.h" #include "mitkDataStorage.h" #include #include #include #include #include #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; + mitk::ShapeComparisonManager *m_ShapeComparisonManager; + 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); 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 iteratePlanePositionImages(Plane plane); - void iteratePlanePositionSurfaces(std::string first, std::string second, Plane plane); + void iteratePlanePositionSurfaces(mitk::Surface::Pointer first, mitk::Surface::Pointer second, Plane plane); + + std::vector calculateMaxDistanceFromStandardPlane(Plane plane, mitk::Surface::Pointer surface); - double calculateASSD(double meanA, double meanB); + // 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); + + mitk::Surface::Pointer fillHoles(mitk::Surface::Pointer surface); }; #endif // QmitkSurfaceRegistration_h \ No newline at end of file