diff --git a/Modules/ShapeComparison/include/MitkShapeComparisonManager.h b/Modules/ShapeComparison/include/MitkShapeComparisonManager.h new file mode 100644 index 0000000000..790c748f52 --- /dev/null +++ b/Modules/ShapeComparison/include/MitkShapeComparisonManager.h @@ -0,0 +1,60 @@ +/*=================================================================== + +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 + + +namespace mitk +{ + class MITKSHAPECOMPARISON_EXPORT ShapeComparisonManager + { + public: + + ShapeComparisonManager(mitk::Image::Pointer firstImg, mitk::Image::Pointer secondImg); + ~ShapeComparisonManager(); + + void setFirstImage(mitk::Image::Pointer firstImg); + void setSecondImage(mitk::Image::Pointer secondImg); + + void calculateMetrics(); + void calculateMetricsSlices(PlaneGeometry* plane, int slicenumber); + std::map getLabelOverlapResults(); + mitk::Image::Pointer getMFirstSlice(); + mitk::Image::Pointer getMSecondSlice(); + + + private: + + mitk::Image::Pointer m_firstImg; + mitk::Image::Pointer m_secondImg; + + mitk::Image::Pointer m_firstImgSlice; + mitk::Image::Pointer m_secondImgSlice; + + std::map m_LabelOverlapResults; + + mitk::Image::Pointer extractImageSlice(mitk::Image::Pointer img, PlaneGeometry* plane, int sliceNumber); + + }; +} + +#endif diff --git a/Modules/ShapeComparison/include/mitkLabelOverlapMetricCalculator.h b/Modules/ShapeComparison/include/mitkLabelOverlapMetricCalculator.h new file mode 100644 index 0000000000..6901a9bc36 --- /dev/null +++ b/Modules/ShapeComparison/include/mitkLabelOverlapMetricCalculator.h @@ -0,0 +1,56 @@ +/*=================================================================== + +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 mitkLabelOverlapMetricCalculator_h +#define mitkLabelOverlapMetricCalculator_h + +#include + +#include "itkImage.h" +#include +#include + + +namespace mitk +{ + class LabelOverlapMetricCalculator + { + public: + LabelOverlapMetricCalculator(mitk::Image::Pointer first, mitk::Image::Pointer second); + ~LabelOverlapMetricCalculator(); + void calculateLabelOverlapMeasures3D(); + void calculateLabelOverlapMeasures2D(); + + std::map getResults(); + void printResults(); + + protected: + + + + private: + + mitk::Image::Pointer m_firstImg; + mitk::Image::Pointer m_secondImg; + + std::map m_Results; + + }; + + +} + +#endif diff --git a/Modules/ShapeComparison/src/DataManagement/mitkLabelOverlapMetricCalculator.cpp b/Modules/ShapeComparison/src/DataManagement/mitkLabelOverlapMetricCalculator.cpp new file mode 100644 index 0000000000..dc9a465e6f --- /dev/null +++ b/Modules/ShapeComparison/src/DataManagement/mitkLabelOverlapMetricCalculator.cpp @@ -0,0 +1,154 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "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" + + + + + + +mitk::LabelOverlapMetricCalculator::LabelOverlapMetricCalculator(mitk::Image::Pointer first, mitk::Image::Pointer second) +{ + this->m_firstImg = first; + this->m_secondImg = second; +} + +mitk::LabelOverlapMetricCalculator::~LabelOverlapMetricCalculator() +{ + m_firstImg->Delete(); + m_secondImg->Delete(); +} + + +void mitk::LabelOverlapMetricCalculator::calculateLabelOverlapMeasures3D() +{ + MITK_INFO << "calculateLabelOverlapMeasures"; + // Create ITK image, cast from MITK image + typedef itk::Image ImageType; + + + ImageType::Pointer itkFirstImg = ImageType::New(); + mitk::CastToItkImage(m_firstImg, itkFirstImg);//ImagetoITKImage + ImageType::Pointer itkSecondImg = ImageType::New(); + mitk::CastToItkImage(m_secondImg, itkSecondImg); + + + + MITK_INFO << "itk casts"; + typedef itk::LabelOverlapMeasuresImageFilter FilterType; + FilterType::Pointer filter = FilterType::New(); + filter->SetSourceImage(itkFirstImg); + filter->SetTargetImage(itkSecondImg); + MITK_INFO << "Update"; + filter->Update(); + + //fill result map + m_Results["Dice"] = filter->GetDiceCoefficient(); + m_Results["FNR"] = filter->GetFalseNegativeError(); + m_Results["FPR"] = filter->GetFalsePositiveError(); + m_Results["Jaccard"] = filter->GetJaccardCoefficient(); + m_Results["VolumeSimilarity"] = filter->GetVolumeSimilarity(); +} + +void mitk::LabelOverlapMetricCalculator::calculateLabelOverlapMeasures2D() +{ + MITK_INFO << "calculateLabelOverlapMeasures"; + // Create ITK image, cast from MITK image + typedef itk::Image ImageType; + + + ImageType::Pointer itkFirstImg = ImageType::New(); + mitk::CastToItkImage(m_firstImg, itkFirstImg);//ImagetoITKImage + ImageType::Pointer itkSecondImg = ImageType::New(); + mitk::CastToItkImage(m_secondImg, itkSecondImg); + +// //black img +// vtkSmartPointer actor = +// vtkSmartPointer::New(); +//#if VTK_MAJOR_VERSION <= 5 +// actor->SetInput(connector->GetOutput()); +//#else +// actor->GetMapper()->SetInputData(m_secondImg->GetVtkImageData()); +//#endif +// vtkSmartPointer renderer = +// vtkSmartPointer::New(); +// renderer->AddActor(actor); +// renderer->ResetCamera(); +// +// vtkSmartPointer renderWindow = +// vtkSmartPointer::New(); +// renderWindow->AddRenderer(renderer); +// +// vtkSmartPointer renderWindowInteractor = +// vtkSmartPointer::New(); +// vtkSmartPointer style = +// vtkSmartPointer::New(); +// +// renderWindowInteractor->SetInteractorStyle(style); +// +// renderWindowInteractor->SetRenderWindow(renderWindow); +// renderWindowInteractor->Initialize(); +// +// renderWindowInteractor->Start(); + + MITK_INFO << "itk casts"; + typedef itk::LabelOverlapMeasuresImageFilter FilterType; + FilterType::Pointer filter = FilterType::New(); + filter->SetSourceImage(itkFirstImg); + filter->SetTargetImage(itkSecondImg); + MITK_INFO << "Update"; + filter->Update(); + + //fill result map + m_Results["Dice"] = filter->GetDiceCoefficient(); + m_Results["FNR"] = filter->GetFalseNegativeError(); + m_Results["FPR"] = filter->GetFalsePositiveError(); + m_Results["Jaccard"] = filter->GetJaccardCoefficient(); + m_Results["VolumeSimilarity"] = filter->GetVolumeSimilarity(); +} +std::map mitk::LabelOverlapMetricCalculator::getResults() +{ + return m_Results; +} + +void mitk::LabelOverlapMetricCalculator::printResults() +{ + MITK_INFO << "FPR: " << m_Results["FPR"]; + MITK_INFO << "FNR: " << m_Results["FNR"]; + MITK_INFO << "Dice: " << m_Results["Dice"]; + MITK_INFO << "Jaccard: " << m_Results["Jaccard"]; + MITK_INFO << "Volume Similarity: " << m_Results["VolumeSimilarity"]; +} + diff --git a/Modules/ShapeComparison/src/mitkShapeComparisonManager.cpp b/Modules/ShapeComparison/src/mitkShapeComparisonManager.cpp new file mode 100644 index 0000000000..736dc8f08d --- /dev/null +++ b/Modules/ShapeComparison/src/mitkShapeComparisonManager.cpp @@ -0,0 +1,138 @@ +/*=================================================================== + +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 "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(mitk::Image::Pointer firstImg, mitk::Image::Pointer secondImg) +{ + this->m_firstImg = firstImg; + this->m_secondImg = secondImg; +} + +mitk::ShapeComparisonManager::~ShapeComparisonManager() +{ + +} + +void mitk::ShapeComparisonManager::setFirstImage(mitk::Image::Pointer firstImg) +{ + this->m_firstImg = firstImg; +} + +void mitk::ShapeComparisonManager::setSecondImage(mitk::Image::Pointer secondImg) +{ + this->m_secondImg = secondImg; +} + +void mitk::ShapeComparisonManager::calculateMetrics() +{ + mitk::LabelOverlapMetricCalculator *labelOverlapCalc = new mitk::LabelOverlapMetricCalculator(m_firstImg, m_secondImg); + MITK_INFO << "New LabelOverlapCalculator instantiated."; + labelOverlapCalc->calculateLabelOverlapMeasures3D(); + m_LabelOverlapResults = labelOverlapCalc->getResults(); +} + +void mitk::ShapeComparisonManager::calculateMetricsSlices(PlaneGeometry* plane, int slicenumber) +{ + /*int box = 250; + for (int i = 0; i < box; ++i) + {*/ + mitk::Image::Pointer sourceSlice = extractImageSlice(m_firstImg, plane, slicenumber); + m_firstImgSlice = sourceSlice; + mitk::Image::Pointer targetSlice = extractImageSlice(m_secondImg, plane, slicenumber); + m_secondImgSlice = targetSlice; + /* mitk::ImageStatisticsHolder* sourceStatHolder = sourceSlice->GetStatistics(); + mitk::ImageStatisticsHolder* targetStatHolder = sourceSlice->GetStatistics();*/ + //if (sourceStatHolder->GetScalarValueMax() > 0 && targetStatHolder->GetScalarValueMax() > 0) TODO + //{ + mitk::LabelOverlapMetricCalculator *labelOverlapCalc = new mitk::LabelOverlapMetricCalculator(sourceSlice, targetSlice); + labelOverlapCalc->calculateLabelOverlapMeasures2D(); + labelOverlapCalc->printResults(); + //} + //} +} + +std::map mitk::ShapeComparisonManager::getLabelOverlapResults() +{ + return m_LabelOverlapResults; +} + +mitk::Image::Pointer mitk::ShapeComparisonManager::getMFirstSlice() +{ + return m_firstImgSlice; +} + +mitk::Image::Pointer mitk::ShapeComparisonManager::getMSecondSlice() +{ + return m_secondImgSlice; +} + +mitk::Image::Pointer mitk::ShapeComparisonManager::extractImageSlice(mitk::Image::Pointer img, PlaneGeometry* planeT, int sliceNumber) +{ + + //double spacingX = img->GetGeometry()->GetSpacing()[0]; positive vlaue + //double spacingY = img->GetGeometry()->GetSpacing()[1]; + //double spacingZ = img->GetGeometry()->GetSpacing()[2]; + //std::array spacing = { -0.47499999999999992, 0.47499999999999992, 0.47500228881835938 }; + // std::array spacing = { spacingX, spacingY, spacingZ }; + //double actualsliceNumber = sliceNumber * spacing[2]; + + //plane->InitializeStandardPlane(256.0, 256.0, image->GetTimeGeometry()->GetGeometryForTimeStep(0)->GetSpacing(), mitk::PlaneGeometry::Axial, sliceNumber); + //planeT->InitializeStandardPlane(256.0, 256.0, img->GetTimeGeometry()->GetGeometryForTimeStep(0)->GetSpacing()); + //planeT->SetSpacing(mitk::Vector3D(spacing.data())); + + // planeT->SetOrigin(img->GetTimeGeometry()->GetGeometryForTimeStep(0)->GetOrigin()); + //mitk::Point3D modOrigin; + //modOrigin[0] = planeT->GetOrigin()[0]; + //modOrigin[1] = planeT->GetOrigin()[1]; + //modOrigin[2] = planeT->GetOrigin()[2] + actualsliceNumber; + //planeT->SetOrigin(modOrigin); + mitk::Image::Pointer imgSlice = mitk::Image::New(); + mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(); + extractor->SetInput(img); + extractor->SetWorldGeometry(planeT); + extractor->SetOutputDimensionality(2); + extractor->SetInPlaneResampleExtentByGeometry(true); + extractor->SetResliceTransformByGeometry(img->GetTimeGeometry()->GetGeometryForTimeStep(0)); + extractor->SetInterpolationMode(mitk::ExtractSliceFilter::RESLICE_NEAREST); + extractor->Update(); + imgSlice = extractor->GetOutput(); + + return imgSlice; +} + + + diff --git a/Plugins/org.mitk.gui.qt.shapecomparison/src/internal/QmitkShapeComparison.cpp b/Plugins/org.mitk.gui.qt.shapecomparison/src/internal/QmitkShapeComparison.cpp new file mode 100644 index 0000000000..96edf1ab55 --- /dev/null +++ b/Plugins/org.mitk.gui.qt.shapecomparison/src/internal/QmitkShapeComparison.cpp @@ -0,0 +1,402 @@ +/*========================================================================= + +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 + + + + + +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()); + + int sliceNumber = 120; + //double spacingX = img->GetGeometry()->GetSpacing()[0]; positive vlaue + //double spacingY = img->GetGeometry()->GetSpacing()[1]; + //double spacingZ = img->GetGeometry()->GetSpacing()[2]; + std::array spacing = { -0.47499999999999992, 0.47499999999999992, 0.47500228881835938 }; + // std::array spacing = { spacingX, spacingY, spacingZ }; + double actualsliceNumber = sliceNumber * spacing[2]; + mitk::PlaneGeometry::Pointer planeT = mitk::PlaneGeometry::New(); + //plane->InitializeStandardPlane(256.0, 256.0, image->GetTimeGeometry()->GetGeometryForTimeStep(0)->GetSpacing(), mitk::PlaneGeometry::Axial, sliceNumber); + planeT->InitializeStandardPlane(256.0, 256.0, img->GetTimeGeometry()->GetGeometryForTimeStep(0)->GetSpacing()); + planeT->SetSpacing(mitk::Vector3D(spacing.data())); + mitk::Image::Pointer imgSlice = mitk::Image::New(); + planeT->SetOrigin(img->GetTimeGeometry()->GetGeometryForTimeStep(0)->GetOrigin()); + mitk::Point3D modOrigin; + modOrigin[0] = planeT->GetOrigin()[0]; + modOrigin[1] = planeT->GetOrigin()[1]; + modOrigin[2] = planeT->GetOrigin()[2] + actualsliceNumber; + planeT->SetOrigin(modOrigin); + mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(); + extractor->SetInput(img); + extractor->SetWorldGeometry(planeT); + extractor->SetOutputDimensionality(2); + extractor->SetInPlaneResampleExtentByGeometry(true); + extractor->SetResliceTransformByGeometry(img->GetTimeGeometry()->GetGeometryForTimeStep(0)); + extractor->SetInterpolationMode(mitk::ExtractSliceFilter::RESLICE_NEAREST); + extractor->Update(); + imgSlice = extractor->GetOutput(); + + mitk::DataNode::Pointer testNode = mitk::DataNode::New(); + testNode->SetData(imgSlice); + testNode->SetVisibility(true); + testNode->SetName("TestImage"); + + this->GetDataStorage()->Add(testNode); + this->GetDataStorageReference()->GetDataStorage()->Modified(); + + // mitk::Image* img = dynamic_cast( m_Controls.firstImageNameComboBox->GetSelectedNode()->GetData()); + ////Code for comparison + mitk::ShapeComparisonManager *shapeComparisonManager = new mitk::ShapeComparisonManager(m_firstImg, m_secondImg); + shapeComparisonManager->calculateMetrics(); + std::map labelOverlapResults = shapeComparisonManager->getLabelOverlapResults(); + //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"])); + + //// // careful + //testloadPosition(); + + + iteratePlanePosition(axial); + // //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::iteratePlanePosition(Plane plane) +{ + int stopper = 1; + for (int i = 0; i < stopper; ++i) + { + MITK_INFO << "Current plane number: " << i; + mitk::PlaneGeometry::Pointer planeGeo = translatePlane(120, plane); + //TODO + //mitk::Image::Pointer imgSlice = mitk::Image::New(); + //mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(); + //extractor->SetInput(m_firstImg); + //extractor->SetWorldGeometry(planeGeo); + //extractor->SetOutputDimensionality(2); + //extractor->SetInPlaneResampleExtentByGeometry(true); + //extractor->SetResliceTransformByGeometry(m_firstImg->GetTimeGeometry()->GetGeometryForTimeStep(0)); + //extractor->SetInterpolationMode(mitk::ExtractSliceFilter::RESLICE_NEAREST); + //extractor->Update(); + //imgSlice = extractor->GetOutput(); + + //mitk::DataNode::Pointer testNode = mitk::DataNode::New(); + //testNode->SetData(imgSlice); + //testNode->SetVisibility(true); + //testNode->SetName("TestNode"); + + //this->GetDataStorage()->Add(testNode); + //this->GetDataStorageReference()->GetDataStorage()->Modified(); + + //mitk::ShapeComparisonManager *shapeComparisonManager = new mitk::ShapeComparisonManager(m_firstImg, m_secondImg); + //TODO + + //shapeComparisonManager->calculateMetricsSlices(planeGeo, 120); + + } + MITK_INFO << "finished"; +} + +mitk::PlaneGeometry::Pointer QmitkShapeComparison::translatePlane(int id, Plane plane) +{ + mitk::DataNode::Pointer dataNode = 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); // normal already in world cords?! + 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 new file mode 100644 index 0000000000..cf56b38587 --- /dev/null +++ b/Plugins/org.mitk.gui.qt.shapecomparison/src/internal/QmitkShapeComparison.h @@ -0,0 +1,149 @@ +/*========================================================================= + +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; + + //test + void testloadPosition(); + + + + /*! + * @brief Reloads the plane position of the node in the corresponding rendering window + * @param int id Id of the markerID corresponding to the rendering window + * @param const DataNode::Pointer node + */ + void reloadDataNodePlanePosition(const mitk::DataNode::Pointer node, int id); + + + enum Plane { axial, coronal, saggital }; + /*! + * @brief loads the adjusted plan positions from the data storage. The rendering windows are updated afterwards. + * @returns true if plane positions are successfully loaded + */ + bool loadPlanePositions(); + + mitk::PlanePositionManagerService* getPlanePositionManagerService(); + + //TODO + void GetAxisPositions(mitk::DataNode::Pointer node); + + void iteratePlanePosition(Plane plane); + + + + /*! + * @brief translates the plane in direction of its normal by the length of the id + * @param int id the lenght of the normal + * @param Plane plane the plane to translate + */ + mitk::PlaneGeometry::Pointer translatePlane(int id, Plane plane); + + mitk::PlaneGeometry::ConstPointer m_axialPlane; + +}; + +#endif \ No newline at end of file diff --git a/Plugins/org.mitk.gui.qt.shapecomparison/src/internal/ShapeComparisonControls.ui b/Plugins/org.mitk.gui.qt.shapecomparison/src/internal/ShapeComparisonControls.ui new file mode 100644 index 0000000000..e004cbd128 --- /dev/null +++ b/Plugins/org.mitk.gui.qt.shapecomparison/src/internal/ShapeComparisonControls.ui @@ -0,0 +1,435 @@ + + + ShapeComparisonControls + + + Qt::WindowModal + + + + 0 + 0 + 372 + 680 + + + + + 0 + 0 + + + + + 0 + 100 + + + + Form + + + + + + true + + + + 0 + 0 + + + + + 0 + 75 + + + + First + + + false + + + + + + + + + + + 0 + 0 + 0 + + + + + + + 0 + 0 + 0 + + + + + + + 0 + 0 + 0 + + + + + + + + + 0 + 0 + 0 + + + + + + + 0 + 0 + 0 + + + + + + + 0 + 0 + 0 + + + + + + + + + 0 + 0 + 0 + + + + + + + 0 + 0 + 0 + + + + + + + 0 + 0 + 0 + + + + + + + + -1 + + + QLabel { color: rgb(0, 0, 0) } + + + Select first Image + + + + + + + true + + + + + + + + + + true + + + + 0 + 0 + + + + + 0 + 95 + + + + Second + + + false + + + + + + + 0 + 0 + + + + QLabel { color: rgb(0, 0, 0) } + + + Select second Image + + + + + + + + + + + + + + 0 + 0 + + + + + 0 + 0 + + + + Geometry + + + + + + + 0 + 0 + + + + + + + + + + + Output path + + + + + + + true + + + + 0 + 0 + + + + compare + + + + + + + + 0 + 0 + + + + + 0 + 100 + + + + Results + + + + + + 0 + + + 15 + + + + + FNR: + + + + + + + + + + + + + + Jaccard Coeff: + + + + + + + + + + + + + + + + + + + + + FPR: + + + + + + + + + + + + + + + + + + + + + Volume Similarity: + + + + + + + Dice Coeff: + + + + + + + + + true + + + 1 + + + + false + + + + 0 + 0 + + + + false + + + Label Overlap + + + + + + + + + + Page + + + + + + + + + + + Qt::Vertical + + + QSizePolicy::Expanding + + + + 20 + 188 + + + + + + + + + QmitkDataStorageComboBox + QComboBox +
QmitkDataStorageComboBox.h
+ + + + +