diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.cpp index 55cf197d54..f00972ed30 100644 --- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.cpp +++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.cpp @@ -1,935 +1,1020 @@ /*=================================================================== 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 "QmitkUSNavigationStepMarkerIntervention.h" #include "ui_QmitkUSNavigationStepMarkerIntervention.h" -#include +#include "mitkBaseRenderer.h" #include "mitkContourModel.h" #include "mitkNeedleProjectionFilter.h" #include "mitkNodeDisplacementFilter.h" #include "mitkSurface.h" -#include "mitkBaseRenderer.h" -#include "mitkOverlayManager.h" -#include "mitkTextOverlay2D.h" -#include "mitkOverlay2DLayouter.h" +#include "mitkTextAnnotation2D.h" +#include +#include -#include "../Filter/mitkUSNavigationTargetUpdateFilter.h" -#include "../Filter/mitkUSNavigationTargetOcclusionFilter.h" #include "../Filter/mitkUSNavigationTargetIntersectionFilter.h" +#include "../Filter/mitkUSNavigationTargetOcclusionFilter.h" +#include "../Filter/mitkUSNavigationTargetUpdateFilter.h" -#include "../Widgets/QmitkZoneProgressBar.h" #include "../USNavigationMarkerPlacement.h" +#include "../Widgets/QmitkZoneProgressBar.h" #include "../mitkUSTargetPlacementQualityCalculator.h" -#include "usModuleRegistry.h" #include "../Interactors/mitkUSPointMarkInteractor.h" +#include "usModuleRegistry.h" #include "mitkLookupTable.h" #include "mitkLookupTableProperty.h" #include "mitkSurface.h" // VTK -#include "vtkSmartPointer.h" #include "vtkCellLocator.h" -#include "vtkOBBTree.h" -#include "vtkIdList.h" -#include "vtkPolyData.h" #include "vtkDataSet.h" -#include "vtkTransformPolyDataFilter.h" +#include "vtkDoubleArray.h" +#include "vtkFloatArray.h" +#include "vtkIdList.h" #include "vtkLinearTransform.h" +#include "vtkLookupTable.h" #include "vtkMath.h" +#include "vtkOBBTree.h" #include "vtkPointData.h" -#include "vtkFloatArray.h" -#include "vtkLookupTable.h" #include "vtkPointData.h" -#include "vtkDoubleArray.h" -#include "vtkWarpScalar.h" -#include "vtkSphereSource.h" +#include "vtkPolyData.h" #include "vtkSelectEnclosedPoints.h" +#include "vtkSmartPointer.h" +#include "vtkSphereSource.h" +#include "vtkTransformPolyDataFilter.h" +#include "vtkWarpScalar.h" -QmitkUSNavigationStepMarkerIntervention::QmitkUSNavigationStepMarkerIntervention(QWidget *parent) : -QmitkUSAbstractNavigationStep(parent), -m_NumberOfTargets(0), -m_TargetProgressBar(0), -m_PlannedTargetProgressBar(0), -m_CurrentTargetIndex(0), -m_CurrentTargetReached(false), -m_ShowPlanningColors(false), -m_NeedleProjectionFilter(mitk::NeedleProjectionFilter::New()), -m_NodeDisplacementFilter(mitk::NodeDisplacementFilter::New()), -m_TargetUpdateFilter(mitk::USNavigationTargetUpdateFilter::New()), -m_TargetOcclusionFilter(mitk::USNavigationTargetOcclusionFilter::New()), -m_TargetIntersectionFilter(mitk::USNavigationTargetIntersectionFilter::New()), -m_PlacementQualityCalculator(mitk::USTargetPlacementQualityCalculator::New()), -m_ListenerTargetCoordinatesChanged(this, &QmitkUSNavigationStepMarkerIntervention::UpdateTargetCoordinates), -m_TargetStructureWarnOverlay(mitk::TextOverlay2D::New()), -m_ReferenceSensorIndex(1), m_NeedleSensorIndex(0), -ui(new Ui::QmitkUSNavigationStepMarkerIntervention) +QmitkUSNavigationStepMarkerIntervention::QmitkUSNavigationStepMarkerIntervention(QWidget *parent) + : QmitkUSAbstractNavigationStep(parent), + m_NumberOfTargets(0), + m_TargetProgressBar(0), + m_PlannedTargetProgressBar(0), + m_CurrentTargetIndex(0), + m_CurrentTargetReached(false), + m_ShowPlanningColors(false), + m_NeedleProjectionFilter(mitk::NeedleProjectionFilter::New()), + m_NodeDisplacementFilter(mitk::NodeDisplacementFilter::New()), + m_TargetUpdateFilter(mitk::USNavigationTargetUpdateFilter::New()), + m_TargetOcclusionFilter(mitk::USNavigationTargetOcclusionFilter::New()), + m_TargetIntersectionFilter(mitk::USNavigationTargetIntersectionFilter::New()), + m_PlacementQualityCalculator(mitk::USTargetPlacementQualityCalculator::New()), + m_ListenerTargetCoordinatesChanged(this, &QmitkUSNavigationStepMarkerIntervention::UpdateTargetCoordinates), + m_TargetStructureWarnOverlay(mitk::TextAnnotation2D::New()), + m_ReferenceSensorIndex(1), + m_NeedleSensorIndex(0), + ui(new Ui::QmitkUSNavigationStepMarkerIntervention) { - m_ActiveTargetColor[0] = 1; m_ActiveTargetColor[1] = 1; m_ActiveTargetColor[2] = 0; - m_InactiveTargetColor[0] = 1; m_InactiveTargetColor[1] = 1; m_InactiveTargetColor[2] = 0.5; - m_ReachedTargetColor[0] = 0.6; m_ReachedTargetColor[1] = 1; m_ReachedTargetColor[2] = 0.6; + m_ActiveTargetColor[0] = 1; + m_ActiveTargetColor[1] = 1; + m_ActiveTargetColor[2] = 0; + m_InactiveTargetColor[0] = 1; + m_InactiveTargetColor[1] = 1; + m_InactiveTargetColor[2] = 0.5; + m_ReachedTargetColor[0] = 0.6; + m_ReachedTargetColor[1] = 1; + m_ReachedTargetColor[2] = 0.6; ui->setupUi(this); connect(ui->freezeImageButton, SIGNAL(SignalFreezed(bool)), this, SLOT(OnFreeze(bool))); connect(ui->backToLastTargetButton, SIGNAL(clicked()), this, SLOT(OnBackToLastTargetClicked())); connect(ui->targetReachedButton, SIGNAL(clicked()), this, SLOT(OnTargetLeft())); connect(this, SIGNAL(TargetReached(int)), this, SLOT(OnTargetReached())); connect(this, SIGNAL(TargetLeft(int)), this, SLOT(OnTargetLeft())); - connect(ui->riskStructuresRangeWidget, SIGNAL(SignalZoneViolated(const mitk::DataNode*, mitk::Point3D)), - this, SLOT(OnRiskZoneViolated(const mitk::DataNode*, mitk::Point3D))); + connect(ui->riskStructuresRangeWidget, + SIGNAL(SignalZoneViolated(const mitk::DataNode *, mitk::Point3D)), + this, + SLOT(OnRiskZoneViolated(const mitk::DataNode *, mitk::Point3D))); m_PointMarkInteractor = mitk::USPointMarkInteractor::New(); m_PointMarkInteractor->CoordinatesChangedEvent.AddListener(m_ListenerTargetCoordinatesChanged); this->GenerateTargetColorLookupTable(); m_TargetProgressBar = new QmitkZoneProgressBar(QString::fromStdString("Target: %1 mm"), 200, 0, this); m_TargetProgressBar->SetTextFormatInvalid("Target is not on Needle Path"); ui->targetStructuresRangeLayout->addWidget(m_TargetProgressBar); m_TargetUpdateFilter->SetScalarArrayIdentifier("USNavigation::ReachedTargetScores"); } QmitkUSNavigationStepMarkerIntervention::~QmitkUSNavigationStepMarkerIntervention() { mitk::DataStorage::Pointer dataStorage = this->GetDataStorage(false); if (dataStorage.IsNotNull()) { // remove the node for the needle path - mitk::DataNode::Pointer node = this->GetNamedDerivedNode("Needle Path", QmitkUSAbstractNavigationStep::DATANAME_BASENODE); - if (node.IsNotNull()) { dataStorage->Remove(node); } + mitk::DataNode::Pointer node = + this->GetNamedDerivedNode("Needle Path", QmitkUSAbstractNavigationStep::DATANAME_BASENODE); + if (node.IsNotNull()) + { + dataStorage->Remove(node); + } } - if (m_SegmentationNode.IsNotNull()) { this->GetDataStorage()->Remove(m_SegmentationNode); } - if (m_ForegroundModelPointsNode.IsNotNull()) { this->GetDataStorage()->Remove(m_ForegroundModelPointsNode); } + if (m_SegmentationNode.IsNotNull()) + { + this->GetDataStorage()->Remove(m_SegmentationNode); + } + if (m_ForegroundModelPointsNode.IsNotNull()) + { + this->GetDataStorage()->Remove(m_ForegroundModelPointsNode); + } delete ui; m_PointMarkInteractor->CoordinatesChangedEvent.RemoveListener(m_ListenerTargetCoordinatesChanged); } bool QmitkUSNavigationStepMarkerIntervention::OnStartStep() { m_NeedleProjectionFilter->SelectInput(m_NeedleSensorIndex); // create node for Needle Projection - mitk::DataNode::Pointer node = this->GetNamedDerivedNodeAndCreate("Needle Path", QmitkUSAbstractNavigationStep::DATANAME_BASENODE); + mitk::DataNode::Pointer node = + this->GetNamedDerivedNodeAndCreate("Needle Path", QmitkUSAbstractNavigationStep::DATANAME_BASENODE); node->SetData(m_NeedleProjectionFilter->GetProjection()); node->SetBoolProperty("show contour", true); - // get overlay manager for the standard multi widget (for displaying alert - // message on the render windows) - mitk::BaseRenderer* renderer = mitk::BaseRenderer::GetByName("stdmulti.widget4"); - if (renderer) { m_OverlayManager = renderer->GetOverlayManager(); } - // initialize warning overlay (and do not display it, yet) m_TargetStructureWarnOverlay->SetText("Warning: Needle is Inside the Target Structure."); m_TargetStructureWarnOverlay->SetVisibility(false); // set position and font size for the text overlay mitk::Point2D overlayPosition; overlayPosition.SetElement(0, 10.0f); overlayPosition.SetElement(1, 10.0f); m_TargetStructureWarnOverlay->SetPosition2D(overlayPosition); m_TargetStructureWarnOverlay->SetFontSize(18); // overlay should be red mitk::Color color; - color[0] = 1; color[1] = 0; color[2] = 0; + color[0] = 1; + color[1] = 0; + color[2] = 0; m_TargetStructureWarnOverlay->SetColor(color); - m_OverlayManager->AddOverlay(m_TargetStructureWarnOverlay.GetPointer()); + mitk::ManualPlacementAnnotationRenderer::AddAnnotation(m_TargetStructureWarnOverlay.GetPointer(), "stdmulti.widget4"); return true; } bool QmitkUSNavigationStepMarkerIntervention::OnStopStep() { mitk::DataStorage::Pointer dataStorage = this->GetDataStorage(); // remove all reached nodes from the data storage - for (QVector >::iterator it = m_ReachedTargetsNodes.begin(); - it != m_ReachedTargetsNodes.end(); ++it) + for (QVector>::iterator it = m_ReachedTargetsNodes.begin(); + it != m_ReachedTargetsNodes.end(); + ++it) { dataStorage->Remove(*it); } m_ReachedTargetsNodes.clear(); m_CurrentTargetIndex = 0; // reset button states ui->freezeImageButton->setEnabled(false); ui->backToLastTargetButton->setEnabled(false); ui->targetReachedButton->setEnabled(true); // make sure that it is unfreezed after stopping the step ui->freezeImageButton->Unfreeze(); // remove base node for reached targets from the data storage mitk::DataNode::Pointer reachedTargetsNode = this->GetNamedDerivedNode( - QmitkUSAbstractNavigationStep::DATANAME_BASENODE, - USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS); - if (reachedTargetsNode.IsNotNull()) { dataStorage->Remove(reachedTargetsNode); } + QmitkUSAbstractNavigationStep::DATANAME_BASENODE, USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS); + if (reachedTargetsNode.IsNotNull()) + { + dataStorage->Remove(reachedTargetsNode); + } return true; } bool QmitkUSNavigationStepMarkerIntervention::OnFinishStep() { return true; } bool QmitkUSNavigationStepMarkerIntervention::OnActivateStep() { this->ClearZones(); // clear risk zones before adding new ones // get target node from data storage and make sure that it contains data m_TargetNode = this->GetNamedDerivedNode(USNavigationMarkerPlacement::DATANAME_TARGETSURFACE, - USNavigationMarkerPlacement::DATANAME_TUMOUR); + USNavigationMarkerPlacement::DATANAME_TUMOUR); if (m_TargetNode.IsNull() || m_TargetNode->GetData() == 0) { mitkThrow() << "Target node (" << USNavigationMarkerPlacement::DATANAME_TARGETSURFACE << ") must not be null."; } // get target data and make sure that it is a surface - m_TargetSurface = dynamic_cast(m_TargetNode->GetData()); + m_TargetSurface = dynamic_cast(m_TargetNode->GetData()); if (m_TargetSurface.IsNull()) { - mitkThrow() << "Target node (" << USNavigationMarkerPlacement::DATANAME_TARGETSURFACE << ") data must be of type mitk::Surface"; + mitkThrow() << "Target node (" << USNavigationMarkerPlacement::DATANAME_TARGETSURFACE + << ") data must be of type mitk::Surface"; } // delete progress bars for reinitializing them again afterwards if (m_PlannedTargetProgressBar) { ui->targetStructuresRangeLayout->removeWidget(m_PlannedTargetProgressBar); delete m_PlannedTargetProgressBar; m_PlannedTargetProgressBar = 0; } m_NodeDisplacementFilter->SelectInput(m_ReferenceSensorIndex); this->UpdateTargetProgressDisplay(); - mitk::DataNode::Pointer tumourNode = this->GetNamedDerivedNode( - USNavigationMarkerPlacement::DATANAME_TUMOUR, QmitkUSAbstractNavigationStep::DATANAME_BASENODE); + mitk::DataNode::Pointer tumourNode = this->GetNamedDerivedNode(USNavigationMarkerPlacement::DATANAME_TUMOUR, + QmitkUSAbstractNavigationStep::DATANAME_BASENODE); if (tumourNode.IsNotNull()) { // do not show tumour node during intervention (target surface is shown) tumourNode->SetBoolProperty("visible", false); // add tumour as a risk structure ui->riskStructuresRangeWidget->AddZone(tumourNode); } // set target structure for target update filter m_TargetUpdateFilter->SetTargetStructure(m_TargetNode); m_TargetOcclusionFilter->SetTargetStructure(m_TargetNode); // set lookup table of tumour node m_TargetNode->SetProperty("LookupTable", m_TargetColorLookupTableProperty); // - mitk::DataNode::Pointer targetsBaseNode = this->GetNamedDerivedNode( - USNavigationMarkerPlacement::DATANAME_TARGETS, QmitkUSAbstractNavigationStep::DATANAME_BASENODE); + mitk::DataNode::Pointer targetsBaseNode = this->GetNamedDerivedNode(USNavigationMarkerPlacement::DATANAME_TARGETS, + QmitkUSAbstractNavigationStep::DATANAME_BASENODE); mitk::DataStorage::SetOfObjects::ConstPointer plannedTargetNodes; - if (targetsBaseNode.IsNotNull()) { plannedTargetNodes = this->GetDataStorage()->GetDerivations(targetsBaseNode); } + if (targetsBaseNode.IsNotNull()) + { + plannedTargetNodes = this->GetDataStorage()->GetDerivations(targetsBaseNode); + } if (plannedTargetNodes.IsNotNull() && plannedTargetNodes->Size() > 0) { for (mitk::DataStorage::SetOfObjects::ConstIterator it = plannedTargetNodes->Begin(); - it != plannedTargetNodes->End(); ++it) + it != plannedTargetNodes->End(); + ++it) { m_PlannedTargetsNodes.push_back(it->Value()); } m_PlannedTargetProgressBar = new QmitkZoneProgressBar(QString::fromStdString("Planned Target"), 200, 0); ui->targetStructuresRangeLayout->addWidget(m_PlannedTargetProgressBar); } // add progress bars for risk zone nodes - mitk::DataNode::Pointer zonesBaseNode = this->GetNamedDerivedNode( - USNavigationMarkerPlacement::DATANAME_ZONES, QmitkUSAbstractNavigationStep::DATANAME_BASENODE); + mitk::DataNode::Pointer zonesBaseNode = this->GetNamedDerivedNode(USNavigationMarkerPlacement::DATANAME_ZONES, + QmitkUSAbstractNavigationStep::DATANAME_BASENODE); // only add progress bars if the base node for zones was created if (zonesBaseNode.IsNotNull()) { mitk::DataStorage::SetOfObjects::ConstPointer zoneNodes = this->GetDataStorage()->GetDerivations(zonesBaseNode); - for (mitk::DataStorage::SetOfObjects::ConstIterator it = zoneNodes->Begin(); - it != zoneNodes->End(); ++it) + for (mitk::DataStorage::SetOfObjects::ConstIterator it = zoneNodes->Begin(); it != zoneNodes->End(); ++it) { ui->riskStructuresRangeWidget->AddZone(it->Value()); } m_TargetOcclusionFilter->SelectStartPositionInput(m_NeedleSensorIndex); m_TargetOcclusionFilter->SetObstacleStructures(zoneNodes); } return true; } bool QmitkUSNavigationStepMarkerIntervention::OnDeactivateStep() { ui->freezeImageButton->Unfreeze(); return true; } void QmitkUSNavigationStepMarkerIntervention::OnUpdate() { // get navigation data source and make sure that it is not null mitk::NavigationDataSource::Pointer navigationDataSource = this->GetCombinedModality()->GetNavigationDataSource(); if (navigationDataSource.IsNull()) { - MITK_ERROR("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepMarkerIntervention") - << "Navigation Data Source of Combined Modality must not be null."; + MITK_ERROR("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepMarkerIntervention") << "Navigation Data Source of Combined Modality must not be null."; mitkThrow() << "Navigation Data Source of Combined Modality must not be null."; } ui->riskStructuresRangeWidget->UpdateDistancesToNeedlePosition(navigationDataSource->GetOutput(m_NeedleSensorIndex)); this->UpdateBodyMarkerStatus(navigationDataSource->GetOutput(m_ReferenceSensorIndex)); this->UpdateTargetColors(); this->UpdateTargetScore(); this->UpdateTargetViolationStatus(); } void QmitkUSNavigationStepMarkerIntervention::OnSettingsChanged(const itk::SmartPointer settingsNode) { - if (settingsNode.IsNull()) { return; } + if (settingsNode.IsNull()) + { + return; + } int numberOfTargets; if (settingsNode->GetIntProperty("settings.number-of-targets", numberOfTargets)) { m_NumberOfTargets = numberOfTargets; m_TargetUpdateFilter->SetNumberOfTargets(numberOfTargets); m_PlacementQualityCalculator->SetOptimalAngle(m_TargetUpdateFilter->GetOptimalAngle()); } std::string referenceSensorName; if (settingsNode->GetStringProperty("settings.reference-name-selected", referenceSensorName)) { m_ReferenceSensorName = referenceSensorName; } std::string needleSensorName; if (settingsNode->GetStringProperty("settings.needle-name-selected", needleSensorName)) { m_NeedleSensorName = needleSensorName; } this->UpdateSensorsNames(); } QString QmitkUSNavigationStepMarkerIntervention::GetTitle() { return "Computer-assisted Intervention"; } bool QmitkUSNavigationStepMarkerIntervention::GetIsRestartable() { return true; } QmitkUSAbstractNavigationStep::FilterVector QmitkUSNavigationStepMarkerIntervention::GetFilter() { FilterVector filter; filter.push_back(m_NeedleProjectionFilter.GetPointer()); filter.push_back(m_NodeDisplacementFilter.GetPointer()); filter.push_back(m_TargetOcclusionFilter.GetPointer()); return filter; } void QmitkUSNavigationStepMarkerIntervention::OnSetCombinedModality() { mitk::USCombinedModality::Pointer combinedModality = this->GetCombinedModality(false); if (combinedModality.IsNotNull()) { mitk::AffineTransform3D::Pointer calibration = combinedModality->GetCalibration(); if (calibration.IsNotNull()) { m_NeedleProjectionFilter->SetTargetPlane(calibration); } } ui->freezeImageButton->SetCombinedModality(combinedModality, m_ReferenceSensorIndex); this->UpdateSensorsNames(); } void QmitkUSNavigationStepMarkerIntervention::OnTargetReached() { m_CurrentTargetReached = true; } void QmitkUSNavigationStepMarkerIntervention::OnTargetLeft() { m_CurrentTargetReached = false; m_CurrentTargetIndex++; - if (m_CurrentTargetIndex >= 0 - && static_cast(m_CurrentTargetIndex) >= m_NumberOfTargets) + if (m_CurrentTargetIndex >= 0 && static_cast(m_CurrentTargetIndex) >= m_NumberOfTargets) { ui->targetReachedButton->setDisabled(true); } ui->backToLastTargetButton->setEnabled(true); ui->freezeImageButton->setEnabled(true); this->UpdateTargetProgressDisplay(); if (m_ReachedTargetsNodes.size() < m_CurrentTargetIndex) { mitk::DataNode::Pointer node = mitk::DataNode::New(); - node->SetName((QString("Target ") + QString("%1").arg(m_CurrentTargetIndex, 2, 10, QLatin1Char('0'))).toStdString()); - this->GetDataStorage()->Add(node, this->GetNamedDerivedNodeAndCreate(USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS, - QmitkUSAbstractNavigationStep::DATANAME_BASENODE)); + node->SetName( + (QString("Target ") + QString("%1").arg(m_CurrentTargetIndex, 2, 10, QLatin1Char('0'))).toStdString()); + this->GetDataStorage()->Add( + node, + this->GetNamedDerivedNodeAndCreate(USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS, + QmitkUSAbstractNavigationStep::DATANAME_BASENODE)); m_ReachedTargetsNodes.push_back(node); } mitk::DataNode::Pointer node = m_ReachedTargetsNodes.at(m_CurrentTargetIndex - 1); mitk::Surface::Pointer zone = mitk::Surface::New(); // create a vtk sphere with given radius vtkSphereSource *vtkData = vtkSphereSource::New(); vtkData->SetRadius(5); vtkData->SetCenter(0, 0, 0); vtkData->Update(); zone->SetVtkPolyData(vtkData->GetOutput()); vtkData->Delete(); // set vtk sphere and origin to data node node->SetData(zone); - node->GetData()->GetGeometry()->SetOrigin(this->GetCombinedModality()->GetNavigationDataSource()->GetOutput(m_NeedleSensorIndex)->GetPosition()); + node->GetData()->GetGeometry()->SetOrigin( + this->GetCombinedModality()->GetNavigationDataSource()->GetOutput(m_NeedleSensorIndex)->GetPosition()); node->SetColor(0.2, 0.9, 0.2); this->UpdateTargetCoordinates(node); } void QmitkUSNavigationStepMarkerIntervention::OnBackToLastTargetClicked() { if (m_CurrentTargetIndex < 1) { MITK_WARN << "Cannot go back to last target as there is no last target."; return; } m_CurrentTargetIndex--; if (m_ReachedTargetsNodes.size() > m_CurrentTargetIndex) { this->GetDataStorage()->Remove(m_ReachedTargetsNodes.last()); - MITK_INFO("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepMarkerIntervention") << "Removed Target " << m_ReachedTargetsNodes.size(); + MITK_INFO("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepMarkerIntervention") << "Removed Target " << m_ReachedTargetsNodes.size(); m_ReachedTargetsNodes.pop_back(); } - if (m_CurrentTargetIndex == 0) { ui->backToLastTargetButton->setDisabled(true); } - if (m_CurrentTargetIndex >= 0 - && static_cast(m_CurrentTargetIndex) < m_NumberOfTargets) + if (m_CurrentTargetIndex == 0) + { + ui->backToLastTargetButton->setDisabled(true); + } + if (m_CurrentTargetIndex >= 0 && static_cast(m_CurrentTargetIndex) < m_NumberOfTargets) { ui->targetReachedButton->setEnabled(true); } ui->freezeImageButton->setEnabled(false); ui->freezeImageButton->Unfreeze(); this->UpdateTargetProgressDisplay(); m_TargetUpdateFilter->RemovePositionOfTarget(m_CurrentTargetIndex); } void QmitkUSNavigationStepMarkerIntervention::OnFreeze(bool freezed) { if (freezed) { this->GetCombinedModality()->SetIsFreezed(true); // load state machine and event config for data interactor m_PointMarkInteractor->LoadStateMachine("USPointMarkInteractions.xml", us::ModuleRegistry::GetModule("MitkUS")); m_PointMarkInteractor->SetEventConfig("globalConfig.xml"); if (m_CurrentTargetIndex < 1) { mitkThrow() << "Current target index has to be greater zero when freeze button is clicked."; } if (m_ReachedTargetsNodes.size() < m_CurrentTargetIndex) { mitk::DataNode::Pointer node = mitk::DataNode::New(); - node->SetName((QString("Target ") + QString("%1").arg(m_CurrentTargetIndex, 2, 10, QLatin1Char('0'))).toStdString()); - this->GetDataStorage()->Add(node, this->GetNamedDerivedNodeAndCreate(USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS, - QmitkUSAbstractNavigationStep::DATANAME_BASENODE)); + node->SetName( + (QString("Target ") + QString("%1").arg(m_CurrentTargetIndex, 2, 10, QLatin1Char('0'))).toStdString()); + this->GetDataStorage()->Add( + node, + this->GetNamedDerivedNodeAndCreate(USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS, + QmitkUSAbstractNavigationStep::DATANAME_BASENODE)); m_ReachedTargetsNodes.push_back(node); } m_PointMarkInteractor->SetDataNode(m_ReachedTargetsNodes.last()); } else { m_PointMarkInteractor->SetDataNode(0); this->GetCombinedModality()->SetIsFreezed(false); } } void QmitkUSNavigationStepMarkerIntervention::OnShowPlanningView(bool show) { m_ShowPlanningColors = show; } -void QmitkUSNavigationStepMarkerIntervention::OnRiskZoneViolated(const mitk::DataNode* node, mitk::Point3D position) +void QmitkUSNavigationStepMarkerIntervention::OnRiskZoneViolated(const mitk::DataNode *node, mitk::Point3D position) { MITK_INFO << "Risk zone (" << node->GetName() << ") violated at position " << position << "."; } void QmitkUSNavigationStepMarkerIntervention::ClearZones() { ui->riskStructuresRangeWidget->ClearZones(); // remove all reached target nodes from the data storage and clear the list mitk::DataStorage::Pointer dataStorage = this->GetDataStorage(); - for (QVector::iterator it = m_ReachedTargetsNodes.begin(); - it != m_ReachedTargetsNodes.end(); ++it) + for (QVector::iterator it = m_ReachedTargetsNodes.begin(); it != m_ReachedTargetsNodes.end(); + ++it) { - if (it->IsNotNull()) { dataStorage->Remove(*it); } + if (it->IsNotNull()) + { + dataStorage->Remove(*it); + } } m_ReachedTargetsNodes.clear(); } -void QmitkUSNavigationStepMarkerIntervention::UpdateTargetCoordinates(mitk::DataNode* dataNode) +void QmitkUSNavigationStepMarkerIntervention::UpdateTargetCoordinates(mitk::DataNode *dataNode) { m_NodeDisplacementFilter->ResetNodes(); - for (QVector >::iterator it = m_ReachedTargetsNodes.begin(); - it != m_ReachedTargetsNodes.end(); ++it) + for (QVector>::iterator it = m_ReachedTargetsNodes.begin(); + it != m_ReachedTargetsNodes.end(); + ++it) { if (it->IsNotNull() && (*it)->GetData() != 0) { m_NodeDisplacementFilter->AddNode(*it); } } - mitk::BaseData* baseData = dataNode->GetData(); + mitk::BaseData *baseData = dataNode->GetData(); if (!baseData) { mitkThrow() << "Data of the data node must not be null."; } mitk::BaseGeometry::Pointer geometry = baseData->GetGeometry(); if (geometry.IsNull()) { mitkThrow() << "Geometry of the data node must not be null."; } m_TargetUpdateFilter->SetControlNode(m_CurrentTargetIndex - 1, dataNode); if (m_PlannedTargetsNodes.size() > m_CurrentTargetIndex - 1) { m_PlannedTargetsNodes.at(m_CurrentTargetIndex - 1)->SetVisibility(false); } - MITK_INFO("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepMarkerIntervention") - << "Target " << m_CurrentTargetIndex << " reached at position " << geometry->GetOrigin(); + MITK_INFO("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepMarkerIntervention") << "Target " << m_CurrentTargetIndex << " reached at position " + << geometry->GetOrigin(); this->CalculateTargetPlacementQuality(); } void QmitkUSNavigationStepMarkerIntervention::UpdateBodyMarkerStatus(mitk::NavigationData::Pointer bodyMarker) { if (bodyMarker.IsNull()) { - MITK_ERROR("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepMarkerIntervention") + MITK_ERROR("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepMarkerIntervention") << "Current Navigation Data for body marker of Combined Modality must not be null."; mitkThrow() << "Current Navigation Data for body marker of Combined Modality must not be null."; } bool valid = bodyMarker->IsDataValid(); // update body marker status label if (valid) { ui->bodyMarkerTrackingStatusLabel->setStyleSheet( "background-color: #8bff8b; margin-right: 1em; margin-left: 1em; border: 1px solid grey"); ui->bodyMarkerTrackingStatusLabel->setText("Body marker is inside the tracking volume."); } else { ui->bodyMarkerTrackingStatusLabel->setStyleSheet( "background-color: #ff7878; margin-right: 1em; margin-left: 1em; border: 1px solid grey"); ui->bodyMarkerTrackingStatusLabel->setText("Body marker is not inside the tracking volume."); } ui->targetStructuresRangeGroupBox->setEnabled(valid); ui->riskStructuresRangeGroupBox->setEnabled(valid); } void QmitkUSNavigationStepMarkerIntervention::GenerateTargetColorLookupTable() { vtkSmartPointer lookupTable = vtkSmartPointer::New(); lookupTable->SetHueRange(0.0, 0.33); lookupTable->SetSaturationRange(1.0, 1.0); lookupTable->SetValueRange(1.0, 1.0); lookupTable->SetTableRange(0.0, 1.0); lookupTable->Build(); mitk::LookupTable::Pointer lut = mitk::LookupTable::New(); lut->SetVtkLookupTable(lookupTable); m_TargetColorLookupTableProperty = mitk::LookupTableProperty::New(lut); } void QmitkUSNavigationStepMarkerIntervention::UpdateTargetColors() { - if (m_TargetNode.IsNull()) { return; } + if (m_TargetNode.IsNull()) + { + return; + } m_TargetNode->SetColor(1, 1, 1); - mitk::BaseData* targetNodeData = m_TargetNode->GetData(); - if (targetNodeData == 0) { return; } + mitk::BaseData *targetNodeData = m_TargetNode->GetData(); + if (targetNodeData == 0) + { + return; + } - mitk::Surface::Pointer targetNodeSurface = dynamic_cast(targetNodeData); + mitk::Surface::Pointer targetNodeSurface = dynamic_cast(targetNodeData); vtkSmartPointer targetNodeSurfaceVtk = targetNodeSurface->GetVtkPolyData(); - vtkPointData* targetPointData = targetNodeSurface->GetVtkPolyData()->GetPointData(); + vtkPointData *targetPointData = targetNodeSurface->GetVtkPolyData()->GetPointData(); - vtkFloatArray* scalars = dynamic_cast(targetPointData->GetScalars("USNavigation::Occlusion")); - vtkFloatArray* targetScoreScalars; + vtkFloatArray *scalars = dynamic_cast(targetPointData->GetScalars("USNavigation::Occlusion")); + vtkFloatArray *targetScoreScalars; if (m_ShowPlanningColors) { - targetScoreScalars = dynamic_cast(targetPointData->GetScalars("USNavigation::PlanningScalars")); + targetScoreScalars = dynamic_cast(targetPointData->GetScalars("USNavigation::PlanningScalars")); } else { - targetScoreScalars = dynamic_cast(targetPointData->GetScalars("USNavigation::ReachedTargetScores")); + targetScoreScalars = + dynamic_cast(targetPointData->GetScalars("USNavigation::ReachedTargetScores")); } - if (!scalars || !targetScoreScalars) { return; } + if (!scalars || !targetScoreScalars) + { + return; + } unsigned int numberOfTupels = scalars->GetNumberOfTuples(); - vtkSmartPointer colors = - vtkSmartPointer::New(); + vtkSmartPointer colors = vtkSmartPointer::New(); colors->SetNumberOfComponents(1); colors->SetNumberOfTuples(numberOfTupels); colors->SetName("Colors"); double color, intersection, markerScore; for (unsigned int n = 0; n < numberOfTupels; n++) { scalars->GetTuple(n, &intersection); targetScoreScalars->GetTuple(n, &markerScore); if (intersection > 0) { color = 0; } else { color = markerScore; } colors->SetTuple(n, &color); } if (numberOfTupels > 0) { targetNodeSurfaceVtk->GetPointData()->SetScalars(colors); targetNodeSurfaceVtk->GetPointData()->Update(); } } void QmitkUSNavigationStepMarkerIntervention::UpdateTargetScore() { - if (m_NeedleProjectionFilter->GetProjection()->GetSize() != 2) { return; } + if (m_NeedleProjectionFilter->GetProjection()->GetSize() != 2) + { + return; + } vtkSmartPointer targetSurfaceVtk = m_TargetSurface->GetVtkPolyData(); m_TargetIntersectionFilter->SetTargetSurface(m_TargetSurface); m_TargetIntersectionFilter->SetLine(m_NeedleProjectionFilter->GetProjection()); m_TargetIntersectionFilter->CalculateIntersection(); if (m_TargetIntersectionFilter->GetIsIntersecting()) { - vtkFloatArray* scalars = dynamic_cast(targetSurfaceVtk->GetPointData()->GetScalars("USNavigation::ReachedTargetScores")); + vtkFloatArray *scalars = + dynamic_cast(targetSurfaceVtk->GetPointData()->GetScalars("USNavigation::ReachedTargetScores")); double score; scalars->GetTuple(m_TargetIntersectionFilter->GetIntersectionNearestSurfacePointId(), &score); double color[3]; m_TargetColorLookupTableProperty->GetLookupTable()->GetVtkLookupTable()->GetColor(score, color); float colorF[3]; - colorF[0] = color[0]; colorF[1] = color[1]; colorF[2] = color[2]; + colorF[0] = color[0]; + colorF[1] = color[1]; + colorF[2] = color[2]; m_TargetProgressBar->SetColor(colorF); m_TargetProgressBar->SetBorderColor(colorF); m_TargetProgressBar->setValue(m_TargetIntersectionFilter->GetDistanceToIntersection()); if (m_PlannedTargetProgressBar) { - vtkFloatArray* scalars = dynamic_cast(targetSurfaceVtk->GetPointData()->GetScalars("USNavigation::PlanningScalars")); + vtkFloatArray *scalars = + dynamic_cast(targetSurfaceVtk->GetPointData()->GetScalars("USNavigation::PlanningScalars")); if (scalars) { double score; scalars->GetTuple(m_TargetIntersectionFilter->GetIntersectionNearestSurfacePointId(), &score); double color[3]; m_TargetColorLookupTableProperty->GetLookupTable()->GetVtkLookupTable()->GetColor(score, color); float colorF[3]; - colorF[0] = color[0]; colorF[1] = color[1]; colorF[2] = color[2]; + colorF[0] = color[0]; + colorF[1] = color[1]; + colorF[2] = color[2]; m_PlannedTargetProgressBar->SetColor(colorF); m_PlannedTargetProgressBar->SetBorderColor(colorF); m_PlannedTargetProgressBar->SetTextFormatValid("Planned Target: %1 mm"); mitk::Point3D intersectionPoint = m_TargetIntersectionFilter->GetIntersectionPoint(); mitk::ScalarType minDistance = -1; - for (QVector >::iterator it = m_PlannedTargetsNodes.begin(); - it != m_PlannedTargetsNodes.end(); ++it) + for (QVector>::iterator it = m_PlannedTargetsNodes.begin(); + it != m_PlannedTargetsNodes.end(); + ++it) { - mitk::ScalarType distance = intersectionPoint.EuclideanDistanceTo((*it)->GetData()->GetGeometry()->GetOrigin()); - if (minDistance < 0 || distance < minDistance) { minDistance = distance; } + mitk::ScalarType distance = + intersectionPoint.EuclideanDistanceTo((*it)->GetData()->GetGeometry()->GetOrigin()); + if (minDistance < 0 || distance < minDistance) + { + minDistance = distance; + } } m_PlannedTargetProgressBar->setValue(minDistance); } } } else { m_TargetProgressBar->setValueInvalid(); } } void QmitkUSNavigationStepMarkerIntervention::UpdateTargetProgressDisplay() { QString description; if (m_CurrentTargetIndex >= m_NumberOfTargets) { description = "All Targets Reached"; - if (m_TargetProgressBar) { m_TargetProgressBar->hide(); } + if (m_TargetProgressBar) + { + m_TargetProgressBar->hide(); + } } else { - description = QString("Distance to Target ") + QString::number(m_CurrentTargetIndex + 1) - + QString(" of ") + QString::number(m_NumberOfTargets); - if (m_TargetProgressBar) { m_TargetProgressBar->show(); } + description = QString("Distance to Target ") + QString::number(m_CurrentTargetIndex + 1) + QString(" of ") + + QString::number(m_NumberOfTargets); + if (m_TargetProgressBar) + { + m_TargetProgressBar->show(); + } } ui->targetStructuresRangeGroupBox->setTitle(description); } void QmitkUSNavigationStepMarkerIntervention::UpdatePlannedTargetProgressDisplay() { // make sure that the needle projection consists of two points - if (m_NeedleProjectionFilter->GetProjection()->GetSize() != 2) { return; } + if (m_NeedleProjectionFilter->GetProjection()->GetSize() != 2) + { + return; + } vtkSmartPointer targetSurfaceVtk = m_TargetSurface->GetVtkPolyData(); m_TargetIntersectionFilter->SetTargetSurface(m_TargetSurface); m_TargetIntersectionFilter->SetLine(m_NeedleProjectionFilter->GetProjection()); m_TargetIntersectionFilter->CalculateIntersection(); // update target progress bar according to the color of the intersection // point on the target surface and the distance to the intersection if (m_TargetIntersectionFilter->GetIsIntersecting()) { - vtkFloatArray* scalars = dynamic_cast(targetSurfaceVtk->GetPointData()->GetScalars("Colors")); + vtkFloatArray *scalars = dynamic_cast(targetSurfaceVtk->GetPointData()->GetScalars("Colors")); double score; scalars->GetTuple(m_TargetIntersectionFilter->GetIntersectionNearestSurfacePointId(), &score); double color[3]; m_TargetColorLookupTableProperty->GetLookupTable()->GetVtkLookupTable()->GetColor(score, color); float colorF[3]; - colorF[0] = color[0]; colorF[1] = color[1]; colorF[2] = color[2]; + colorF[0] = color[0]; + colorF[1] = color[1]; + colorF[2] = color[2]; m_TargetProgressBar->SetColor(colorF); m_TargetProgressBar->SetBorderColor(colorF); m_TargetProgressBar->setValue(m_TargetIntersectionFilter->GetDistanceToIntersection()); } else { - float red[3] = { 0.6, 0, 0 }; + float red[3] = {0.6, 0, 0}; m_TargetProgressBar->SetBorderColor(red); m_TargetProgressBar->setValueInvalid(); } } void QmitkUSNavigationStepMarkerIntervention::UpdateTargetViolationStatus() { // transform vtk polydata according to mitk geometry - vtkSmartPointer transformFilter = - vtkSmartPointer::New(); + vtkSmartPointer transformFilter = vtkSmartPointer::New(); transformFilter->SetInputData(0, m_TargetSurface->GetVtkPolyData()); transformFilter->SetTransform(m_TargetSurface->GetGeometry()->GetVtkTransform()); transformFilter->Update(); vtkSmartPointer enclosedPoints = vtkSmartPointer::New(); enclosedPoints->Initialize(transformFilter->GetOutput()); mitk::Point3D needleTip = m_NeedleProjectionFilter->GetProjection()->GetPoint(0); // show warning if the needle tip is inside the target surface if (enclosedPoints->IsInsideSurface(needleTip[0], needleTip[1], needleTip[2])) { if (!m_TargetStructureWarnOverlay->IsVisible(NULL)) { m_TargetStructureWarnOverlay->SetVisibility(true); mitk::DataNode::Pointer targetViolationResult = mitk::DataNode::New(); targetViolationResult->SetName("TargetViolation"); targetViolationResult->SetProperty("USNavigation::TargetViolationPoint", mitk::Point3dProperty::New(needleTip)); emit SignalIntermediateResult(targetViolationResult); } - MITK_INFO("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepMarkerIntervention") - << "Target surface violated at " << needleTip << "."; + MITK_INFO("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepMarkerIntervention") << "Target surface violated at " << needleTip << "."; } else { m_TargetStructureWarnOverlay->SetVisibility(false); } } void QmitkUSNavigationStepMarkerIntervention::CalculateTargetPlacementQuality() { // clear quality display if there aren't all targets reached if (m_ReachedTargetsNodes.size() != m_NumberOfTargets) { ui->placementQualityGroupBox->setEnabled(false); ui->angleDifferenceValue->setText(""); ui->centersOfMassValue->setText(""); return; } ui->placementQualityGroupBox->setEnabled(true); - mitk::Surface::Pointer targetSurface = dynamic_cast(m_TargetNode->GetData()); + mitk::Surface::Pointer targetSurface = dynamic_cast(m_TargetNode->GetData()); if (targetSurface.IsNull()) { mitkThrow() << "Target surface must not be null."; } m_PlacementQualityCalculator->SetTargetSurface(targetSurface); mitk::PointSet::Pointer targetPointSet = mitk::PointSet::New(); // copy the origins of all reached target nodes into a point set // for the quality calculator mitk::PointSet::PointIdentifier n = 0; - for (QVector >::iterator it = m_ReachedTargetsNodes.begin(); - it != m_ReachedTargetsNodes.end(); ++it) + for (QVector>::iterator it = m_ReachedTargetsNodes.begin(); + it != m_ReachedTargetsNodes.end(); + ++it) { targetPointSet->InsertPoint(n++, (*it)->GetData()->GetGeometry()->GetOrigin()); } m_PlacementQualityCalculator->SetTargetPoints(targetPointSet); m_PlacementQualityCalculator->Update(); double centersOfMassDistance = m_PlacementQualityCalculator->GetCentersOfMassDistance(); - ui->centersOfMassValue->setText(QString::number( - centersOfMassDistance, 103, 2) + " mm"); + ui->centersOfMassValue->setText(QString::number(centersOfMassDistance, 103, 2) + " mm"); double meanAnglesDifference = m_PlacementQualityCalculator->GetMeanAngleDifference(); - ui->angleDifferenceValue->setText(QString::number( - meanAnglesDifference, 103, 2) + QString::fromLatin1(" °")); + ui->angleDifferenceValue->setText(QString::number(meanAnglesDifference, 103, 2) + QString::fromLatin1(" °")); // create an intermediate result of the placement quality mitk::DataNode::Pointer placementQualityResult = mitk::DataNode::New(); placementQualityResult->SetName("PlacementQuality"); placementQualityResult->SetFloatProperty("USNavigation::CentersOfMassDistance", centersOfMassDistance); placementQualityResult->SetFloatProperty("USNavigation::MeanAngleDifference", meanAnglesDifference); - placementQualityResult->SetProperty("USNavigation::AngleDifferences", + placementQualityResult->SetProperty( + "USNavigation::AngleDifferences", mitk::GenericProperty::New(m_PlacementQualityCalculator->GetAngleDifferences())); if (m_PlannedTargetsNodes.size() == m_NumberOfTargets) { mitk::VnlVector reachedPlannedDifferences; double reachedPlannedDifferencesSum = 0; double reachedPlannedDifferencesMax = 0; reachedPlannedDifferences.set_size(m_NumberOfTargets); // get sum and maximum of the planning / reality differences for (unsigned int n = 0; n < m_NumberOfTargets; ++n) { - mitk::ScalarType distance = m_PlannedTargetsNodes.at(n)->GetData()->GetGeometry()->GetOrigin() - .EuclideanDistanceTo(m_ReachedTargetsNodes.at(n)->GetData()->GetGeometry()->GetOrigin()); + mitk::ScalarType distance = + m_PlannedTargetsNodes.at(n)->GetData()->GetGeometry()->GetOrigin().EuclideanDistanceTo( + m_ReachedTargetsNodes.at(n)->GetData()->GetGeometry()->GetOrigin()); reachedPlannedDifferences.put(n, distance); reachedPlannedDifferencesSum += distance; - if (distance > reachedPlannedDifferencesMax) { reachedPlannedDifferencesMax = distance; } + if (distance > reachedPlannedDifferencesMax) + { + reachedPlannedDifferencesMax = distance; + } } // add distances between planning and reality to the quality intermediate result placementQualityResult->SetProperty("USNavigation::PlanningRealityDistances", - mitk::GenericProperty::New(reachedPlannedDifferences)); - placementQualityResult->SetProperty("USNavigation::MeanPlanningRealityDistance", + mitk::GenericProperty::New(reachedPlannedDifferences)); + placementQualityResult->SetProperty( + "USNavigation::MeanPlanningRealityDistance", mitk::DoubleProperty::New(reachedPlannedDifferencesSum / static_cast(m_NumberOfTargets))); placementQualityResult->SetProperty("USNavigation::MaximumPlanningRealityDistance", - mitk::DoubleProperty::New(reachedPlannedDifferencesMax)); + mitk::DoubleProperty::New(reachedPlannedDifferencesMax)); } emit SignalIntermediateResult(placementQualityResult); } void QmitkUSNavigationStepMarkerIntervention::UpdateSensorsNames() { mitk::USCombinedModality::Pointer combinedModality = this->GetCombinedModality(false); - if (combinedModality.IsNull()) { return; } + if (combinedModality.IsNull()) + { + return; + } mitk::NavigationDataSource::Pointer navigationDataSource = combinedModality->GetNavigationDataSource(); - if (navigationDataSource.IsNull()) { return; } + if (navigationDataSource.IsNull()) + { + return; + } if (!m_NeedleSensorName.empty()) { try { m_NeedleSensorIndex = navigationDataSource->GetOutputIndex(m_NeedleSensorName); } catch (const std::exception &e) { - MITK_WARN("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPlacementPlanning") - << "Cannot get index for needle sensor name: " << e.what(); + MITK_WARN("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepPlacementPlanning") << "Cannot get index for needle sensor name: " << e.what(); } } if (this->GetNavigationStepState() >= QmitkUSAbstractNavigationStep::State_Active) { m_NeedleProjectionFilter->SelectInput(m_NeedleSensorIndex); } if (!m_ReferenceSensorName.empty()) { try { m_ReferenceSensorIndex = navigationDataSource->GetOutputIndex(m_ReferenceSensorName); } catch (const std::exception &e) { - MITK_WARN("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPlacementPlanning") - << "Cannot get index for reference sensor name: " << e.what(); + MITK_WARN("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepPlacementPlanning") << "Cannot get index for reference sensor name: " << e.what(); } } if (this->GetNavigationStepState() >= QmitkUSAbstractNavigationStep::State_Active) { m_NodeDisplacementFilter->SelectInput(m_ReferenceSensorIndex); } ui->freezeImageButton->SetCombinedModality(combinedModality, m_ReferenceSensorIndex); } diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.h b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.h index ca10e2334e..2f54e50fc5 100644 --- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.h +++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.h @@ -1,172 +1,171 @@ /*=================================================================== 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 QMITKUSNAVIGATIONSTEPMARKERINTERVENTION_H #define QMITKUSNAVIGATIONSTEPMARKERINTERVENTION_H #include "QmitkUSAbstractNavigationStep.h" -namespace mitk { -class DataNode; -class NeedleProjectionFilter; -class NodeDisplacementFilter; -class USNavigationGrabCutSegmentationUpdateFilter; -class USNavigationTargetUpdateFilter; -class USNavigationTargetOcclusionFilter; -class USNavigationTargetIntersectionFilter; -class USPointMarkInteractor; -class LookupTableProperty; -class Surface; -class OverlayManager; -class TextOverlay2D; -class USTargetPlacementQualityCalculator; +namespace mitk +{ + class DataNode; + class NeedleProjectionFilter; + class NodeDisplacementFilter; + class USNavigationGrabCutSegmentationUpdateFilter; + class USNavigationTargetUpdateFilter; + class USNavigationTargetOcclusionFilter; + class USNavigationTargetIntersectionFilter; + class USPointMarkInteractor; + class LookupTableProperty; + class Surface; + class TextAnnotation2D; + class USTargetPlacementQualityCalculator; } -namespace Ui { -class QmitkUSNavigationStepMarkerIntervention; +namespace Ui +{ + class QmitkUSNavigationStepMarkerIntervention; } class QmitkZoneProgressBar; /** * \brief Navigation step for the actual marker placement. */ class QmitkUSNavigationStepMarkerIntervention : public QmitkUSAbstractNavigationStep { Q_OBJECT signals: void TargetReached(int); void TargetLeft(int); protected slots: void OnTargetReached(); void OnTargetLeft(); void OnBackToLastTargetClicked(); void OnFreeze(bool); void OnShowPlanningView(bool); - void OnRiskZoneViolated(const mitk::DataNode*, mitk::Point3D); + void OnRiskZoneViolated(const mitk::DataNode *, mitk::Point3D); public: explicit QmitkUSNavigationStepMarkerIntervention(QWidget *parent = 0); ~QmitkUSNavigationStepMarkerIntervention(); virtual bool OnStartStep(); virtual bool OnStopStep(); virtual bool OnFinishStep(); virtual bool OnActivateStep(); virtual bool OnDeactivateStep(); virtual void OnUpdate(); virtual void OnSettingsChanged(const itk::SmartPointer settingsNode); virtual QString GetTitle(); virtual bool GetIsRestartable(); virtual FilterVector GetFilter(); protected: virtual void OnSetCombinedModality(); void ClearZones(); - void UpdateTargetCoordinates(mitk::DataNode*); + void UpdateTargetCoordinates(mitk::DataNode *); void UpdateBodyMarkerStatus(mitk::NavigationData::Pointer bodyMarker); void GenerateTargetColorLookupTable(); void UpdateTargetColors(); /** * \brief */ void UpdateTargetScore(); /** * \brief Updates display showing the number of the currently active target. */ void UpdateTargetProgressDisplay(); /** * \brief Updates color and distance of the progress bar for the planned target. * The intersection between needle path and target surface is calculated and * the color is got from the intersection point. */ void UpdatePlannedTargetProgressDisplay(); /** * \brief Tests for target violation and updates the display accordingly. * This method tests if the needle tip is inside the target surface. */ void UpdateTargetViolationStatus(); /** * \brief Calculates and display quality metrics if all three markers are placed. */ void CalculateTargetPlacementQuality(); void UpdateSensorsNames(); - unsigned int m_NumberOfTargets; - - QVector > m_ZoneNodes; - QVector > m_PlannedTargetsNodes; - QVector > m_ReachedTargetsNodes; + unsigned int m_NumberOfTargets; - itk::SmartPointer m_SegmentationNode; - itk::SmartPointer m_ForegroundModelPointsNode; + QVector> m_ZoneNodes; + QVector> m_PlannedTargetsNodes; + QVector> m_ReachedTargetsNodes; - QmitkZoneProgressBar* m_TargetProgressBar; - QmitkZoneProgressBar* m_PlannedTargetProgressBar; + itk::SmartPointer m_SegmentationNode; + itk::SmartPointer m_ForegroundModelPointsNode; - int m_CurrentTargetIndex; - bool m_CurrentTargetReached; + QmitkZoneProgressBar *m_TargetProgressBar; + QmitkZoneProgressBar *m_PlannedTargetProgressBar; - mitk::ScalarType m_ActiveTargetColor[3]; - mitk::ScalarType m_InactiveTargetColor[3]; - mitk::ScalarType m_ReachedTargetColor[3]; + int m_CurrentTargetIndex; + bool m_CurrentTargetReached; - bool m_ShowPlanningColors; - itk::SmartPointer m_PointMarkInteractor; + mitk::ScalarType m_ActiveTargetColor[3]; + mitk::ScalarType m_InactiveTargetColor[3]; + mitk::ScalarType m_ReachedTargetColor[3]; - itk::SmartPointer m_TargetNode; - itk::SmartPointer m_TargetColorLookupTableProperty; + bool m_ShowPlanningColors; + itk::SmartPointer m_PointMarkInteractor; - itk::SmartPointer m_TargetSurface; + itk::SmartPointer m_TargetNode; + itk::SmartPointer m_TargetColorLookupTableProperty; + itk::SmartPointer m_TargetSurface; - itk::SmartPointer m_NeedleProjectionFilter; - itk::SmartPointer m_NodeDisplacementFilter; + itk::SmartPointer m_NeedleProjectionFilter; + itk::SmartPointer m_NodeDisplacementFilter; - itk::SmartPointer m_TargetUpdateFilter; - itk::SmartPointer m_TargetOcclusionFilter; - itk::SmartPointer m_TargetIntersectionFilter; - itk::SmartPointer m_PlacementQualityCalculator; + itk::SmartPointer m_TargetUpdateFilter; + itk::SmartPointer m_TargetOcclusionFilter; + itk::SmartPointer m_TargetIntersectionFilter; + itk::SmartPointer m_PlacementQualityCalculator; - itk::SmartPointer m_OverlayManager; - itk::SmartPointer m_TargetStructureWarnOverlay; + itk::SmartPointer m_TargetStructureWarnOverlay; - std::string m_ReferenceSensorName; - std::string m_NeedleSensorName; + std::string m_ReferenceSensorName; + std::string m_NeedleSensorName; - unsigned int m_ReferenceSensorIndex; - unsigned int m_NeedleSensorIndex; + unsigned int m_ReferenceSensorIndex; + unsigned int m_NeedleSensorIndex; private: - mitk::MessageDelegate1 m_ListenerTargetCoordinatesChanged; + mitk::MessageDelegate1 m_ListenerTargetCoordinatesChanged; Ui::QmitkUSNavigationStepMarkerIntervention *ui; }; #endif // QMITKUSNAVIGATIONSTEPMARKERINTERVENTION_H diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.cpp index 5a60858b51..ee9412bb47 100644 --- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.cpp +++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.cpp @@ -1,778 +1,817 @@ /*=================================================================== 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 "QmitkUSNavigationStepPlacementPlanning.h" #include "ui_QmitkUSNavigationStepPlacementPlanning.h" -#include "usModuleRegistry.h" #include "../Interactors/mitkUSPointMarkInteractor.h" -#include "mitkNodeDisplacementFilter.h" -#include "mitkNeedleProjectionFilter.h" #include "../mitkUSTargetPlacementQualityCalculator.h" +#include "mitkNeedleProjectionFilter.h" +#include "mitkNodeDisplacementFilter.h" +#include "usModuleRegistry.h" -#include "../Filter/mitkUSNavigationTargetUpdateFilter.h" #include "../Filter/mitkUSNavigationTargetIntersectionFilter.h" +#include "../Filter/mitkUSNavigationTargetUpdateFilter.h" #include "../USNavigationMarkerPlacement.h" -#include -#include "mitkSurface.h" #include "mitkLookupTableProperty.h" +#include "mitkSurface.h" +#include -#include "mitkOverlayManager.h" -#include "mitkTextOverlay3D.h" +#include "mitkLayoutAnnotationRenderer.h" +#include "mitkTextAnnotation3D.h" -#include "vtkSmartPointer.h" -#include "vtkPolyData.h" #include "vtkFloatArray.h" -#include "vtkPointData.h" #include "vtkLookupTable.h" +#include "vtkPointData.h" +#include "vtkPolyData.h" +#include "vtkSmartPointer.h" -#include "vtkSphereSource.h" #include "vtkLineSource.h" +#include "vtkSphereSource.h" -#include "vtkTransformPolyDataFilter.h" -#include "vtkLinearTransform.h" #include "vtkCenterOfMass.h" +#include "vtkLinearTransform.h" #include "vtkPoints.h" +#include "vtkTransformPolyDataFilter.h" #include "vtkUnstructuredGrid.h" #include "vtkMath.h" -QmitkUSNavigationStepPlacementPlanning::QmitkUSNavigationStepPlacementPlanning(QWidget *parent) : - QmitkUSAbstractNavigationStep(parent), - m_NumberOfTargets(0), - m_CurrentTargetIndex(0), - m_BodyMarkerValid(false), - m_PointMarkInteractor(mitk::USPointMarkInteractor::New()), - m_TargetUpdateFilter(mitk::USNavigationTargetUpdateFilter::New()), - m_NodeDisplacementFilter(mitk::NodeDisplacementFilter::New()), - m_NeedleProjectionFilter(mitk::NeedleProjectionFilter::New()), - m_TargetIntersectionFilter(mitk::USNavigationTargetIntersectionFilter::New()), - m_PlacementQualityCalculator(mitk::USTargetPlacementQualityCalculator::New()), - m_ListenerTargetCoordinatesChanged(this, &QmitkUSNavigationStepPlacementPlanning::UpdateTargetCoordinates), - m_ReferenceSensorIndex(1), m_NeedleSensorIndex(0), - ui(new Ui::QmitkUSNavigationStepPlacementPlanning) +QmitkUSNavigationStepPlacementPlanning::QmitkUSNavigationStepPlacementPlanning(QWidget *parent) + : QmitkUSAbstractNavigationStep(parent), + m_NumberOfTargets(0), + m_CurrentTargetIndex(0), + m_BodyMarkerValid(false), + m_PointMarkInteractor(mitk::USPointMarkInteractor::New()), + m_TargetUpdateFilter(mitk::USNavigationTargetUpdateFilter::New()), + m_NodeDisplacementFilter(mitk::NodeDisplacementFilter::New()), + m_NeedleProjectionFilter(mitk::NeedleProjectionFilter::New()), + m_TargetIntersectionFilter(mitk::USNavigationTargetIntersectionFilter::New()), + m_PlacementQualityCalculator(mitk::USTargetPlacementQualityCalculator::New()), + m_ListenerTargetCoordinatesChanged(this, &QmitkUSNavigationStepPlacementPlanning::UpdateTargetCoordinates), + m_ReferenceSensorIndex(1), + m_NeedleSensorIndex(0), + ui(new Ui::QmitkUSNavigationStepPlacementPlanning) { ui->setupUi(this); - connect( ui->freezeImageButton, SIGNAL(SignalFreezed(bool)), this, SLOT(OnFreeze(bool)) ); + connect(ui->freezeImageButton, SIGNAL(SignalFreezed(bool)), this, SLOT(OnFreeze(bool))); m_TargetUpdateFilter->SetScalarArrayIdentifier("USNavigation::PlanningPlacement"); this->GenerateTargetColorLookupTable(); } QmitkUSNavigationStepPlacementPlanning::~QmitkUSNavigationStepPlacementPlanning() { delete ui; } bool QmitkUSNavigationStepPlacementPlanning::OnStartStep() { // create node for needle projection - mitk::DataNode::Pointer node = this->GetNamedDerivedNodeAndCreate("Needle Path", QmitkUSAbstractNavigationStep::DATANAME_BASENODE); + mitk::DataNode::Pointer node = + this->GetNamedDerivedNodeAndCreate("Needle Path", QmitkUSAbstractNavigationStep::DATANAME_BASENODE); node->SetData(m_NeedleProjectionFilter->GetProjection()); node->SetBoolProperty("show contour", true); // make sure that the targets node exist in the data storage this->GetNamedDerivedNodeAndCreate(USNavigationMarkerPlacement::DATANAME_TARGETS, - QmitkUSAbstractNavigationStep::DATANAME_BASENODE); + QmitkUSAbstractNavigationStep::DATANAME_BASENODE); this->GetNamedDerivedNodeAndCreate(USNavigationMarkerPlacement::DATANAME_TARGETS_PATHS, - QmitkUSAbstractNavigationStep::DATANAME_BASENODE); + QmitkUSAbstractNavigationStep::DATANAME_BASENODE); // listen to event of point mark interactor m_PointMarkInteractor->CoordinatesChangedEvent.AddListener(m_ListenerTargetCoordinatesChanged); return true; } bool QmitkUSNavigationStepPlacementPlanning::OnStopStep() { // remove listener to event of point mark interactor m_PointMarkInteractor->CoordinatesChangedEvent.RemoveListener(m_ListenerTargetCoordinatesChanged); m_CurrentTargetIndex = 0; m_TargetUpdateFilter->Reset(); m_NodeDisplacementFilter->ResetNodes(); // remove the planned target nodes from the data storage mitk::DataStorage::Pointer dataStorage = this->GetDataStorage(); - for ( QVector >::iterator it = m_PlannedTargetNodes.begin(); - it != m_PlannedTargetNodes.end(); ++it ) + for (QVector>::iterator it = m_PlannedTargetNodes.begin(); + it != m_PlannedTargetNodes.end(); + ++it) { dataStorage->Remove(*it); } m_PlannedTargetNodes.clear(); // remove the planned target path nodes from the data storage - for ( QVector >::iterator it = m_PlannedNeedlePaths.begin(); - it != m_PlannedNeedlePaths.end(); ++it ) + for (QVector>::iterator it = m_PlannedNeedlePaths.begin(); + it != m_PlannedNeedlePaths.end(); + ++it) { dataStorage->Remove(*it); } m_PlannedNeedlePaths.clear(); // remove the targets node from the data storage - mitk::DataNode::Pointer targetsNode = this->GetNamedDerivedNode( - USNavigationMarkerPlacement::DATANAME_TARGETS, - QmitkUSAbstractNavigationStep::DATANAME_BASENODE); - if ( targetsNode.IsNotNull() ) { dataStorage->Remove(targetsNode); } + mitk::DataNode::Pointer targetsNode = this->GetNamedDerivedNode(USNavigationMarkerPlacement::DATANAME_TARGETS, + QmitkUSAbstractNavigationStep::DATANAME_BASENODE); + if (targetsNode.IsNotNull()) + { + dataStorage->Remove(targetsNode); + } // remove the target paths node from the data storage mitk::DataNode::Pointer targetPathsNode = this->GetNamedDerivedNode( - USNavigationMarkerPlacement::DATANAME_TARGETS_PATHS, - QmitkUSAbstractNavigationStep::DATANAME_BASENODE); - if ( targetPathsNode.IsNotNull() ) { dataStorage->Remove(targetPathsNode); } + USNavigationMarkerPlacement::DATANAME_TARGETS_PATHS, QmitkUSAbstractNavigationStep::DATANAME_BASENODE); + if (targetPathsNode.IsNotNull()) + { + dataStorage->Remove(targetPathsNode); + } // make sure that the image is no longer freezed after stopping ui->freezeImageButton->Unfreeze(); return true; } bool QmitkUSNavigationStepPlacementPlanning::OnRestartStep() { this->OnStopStep(); this->OnStartStep(); return true; } bool QmitkUSNavigationStepPlacementPlanning::OnFinishStep() { // create scalars showing the planned positions on the target surface - if ( ! m_PlannedTargetNodes.isEmpty() ) + if (!m_PlannedTargetNodes.isEmpty()) { mitk::USNavigationTargetUpdateFilter::Pointer planningSurfaceFilter = mitk::USNavigationTargetUpdateFilter::New(); planningSurfaceFilter->SetOptimalAngle(0); planningSurfaceFilter->SetScalarArrayIdentifier("USNavigation::PlanningScalars"); planningSurfaceFilter->SetUseMaximumScore(true); planningSurfaceFilter->SetTargetStructure(m_TargetNode); unsigned int n = 0; - for ( QVector >::iterator it = m_PlannedTargetNodes.begin(); - it != m_PlannedTargetNodes.end(); ++it ) + for (QVector>::iterator it = m_PlannedTargetNodes.begin(); + it != m_PlannedTargetNodes.end(); + ++it) { bool isSurfaceEmpty; - if ( ((*it)->GetBoolProperty("surface_empty", isSurfaceEmpty)) && isSurfaceEmpty ) + if (((*it)->GetBoolProperty("surface_empty", isSurfaceEmpty)) && isSurfaceEmpty) { // remove node from data storage if it is not fully planned this->GetDataStorage()->Remove(*it); } else { // set origin to filter for coloring target surface (good // positions are positions near to the origin) planningSurfaceFilter->SetControlNode(n, *it); } n++; } } // make sure that the image is no longer freezed after finishing ui->freezeImageButton->Unfreeze(); return true; } bool QmitkUSNavigationStepPlacementPlanning::OnActivateStep() { emit SignalReadyForNextStep(); m_NodeDisplacementFilter->SelectInput(m_ReferenceSensorIndex); m_NeedleProjectionFilter->SelectInput(m_NeedleSensorIndex); - if ( m_PlannedTargetNodes.empty() ) { m_CurrentTargetIndex = 0; } - else { m_CurrentTargetIndex = m_PlannedTargetNodes.size() - 1; } + if (m_PlannedTargetNodes.empty()) + { + m_CurrentTargetIndex = 0; + } + else + { + m_CurrentTargetIndex = m_PlannedTargetNodes.size() - 1; + } m_TargetNode = this->GetNamedDerivedNode(USNavigationMarkerPlacement::DATANAME_TARGETSURFACE, - USNavigationMarkerPlacement::DATANAME_TUMOUR); + USNavigationMarkerPlacement::DATANAME_TUMOUR); m_TargetNode->SetBoolProperty("visible", true); // set lookup table of tumour node m_TargetNode->SetProperty("LookupTable", m_TargetColorLookupTableProperty); m_TargetUpdateFilter->SetTargetStructure(m_TargetNode); - for ( QVector >::iterator it = m_PlannedTargetNodes.begin(); - it != m_PlannedTargetNodes.end(); ++it ) + for (QVector>::iterator it = m_PlannedTargetNodes.begin(); + it != m_PlannedTargetNodes.end(); + ++it) { (*it)->SetBoolProperty("visible", true); } this->UpdateTargetDescriptions(); - //m_TargetUpdateFilter->UpdateTargetScores(); + // m_TargetUpdateFilter->UpdateTargetScores(); return true; } bool QmitkUSNavigationStepPlacementPlanning::OnDeactivateStep() { ui->freezeImageButton->Unfreeze(); return true; } void QmitkUSNavigationStepPlacementPlanning::OnUpdate() { this->UpdateTargetColors(); - // get navigation data source and make sure that it is not null + // get navigation data source and make sure that it is not null mitk::NavigationDataSource::Pointer navigationDataSource = this->GetCombinedModality()->GetNavigationDataSource(); - if ( navigationDataSource.IsNull() ) + if (navigationDataSource.IsNull()) { - MITK_ERROR("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPunctuationIntervention") - << "Navigation Data Source of Combined Modality must not be null."; + MITK_ERROR("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepPunctuationIntervention") << "Navigation Data Source of Combined Modality must not be null."; mitkThrow() << "Navigation Data Source of Combined Modality must not be null."; } navigationDataSource->Update(); this->UpdateBodyMarkerStatus(navigationDataSource->GetOutput(m_ReferenceSensorIndex)); ui->freezeImageButton->setEnabled(m_BodyMarkerValid); mitk::PointSet::Pointer needleProjectionPointSet = m_NeedleProjectionFilter->GetProjection(); - if ( needleProjectionPointSet->GetSize() == 2 ) + if (needleProjectionPointSet->GetSize() == 2) { - m_TargetIntersectionFilter->SetTargetSurface(dynamic_cast(m_TargetNode->GetData())); + m_TargetIntersectionFilter->SetTargetSurface(dynamic_cast(m_TargetNode->GetData())); m_TargetIntersectionFilter->SetLine(needleProjectionPointSet); m_TargetIntersectionFilter->CalculateIntersection(); - if ( m_TargetIntersectionFilter->GetIsIntersecting() ) + if (m_TargetIntersectionFilter->GetIsIntersecting()) { // only enable button if body marker is in the tracking volume, too ui->placeTargetButton->setEnabled(m_BodyMarkerValid); ui->placeTargetButton->setToolTip(""); - if ( m_PlannedTargetNodes.size() == m_NumberOfTargets - 1 ) + if (m_PlannedTargetNodes.size() == m_NumberOfTargets - 1) { mitk::PointSet::Pointer targetPointSet = mitk::PointSet::New(); mitk::PointSet::PointIdentifier n = 0; - for ( QVector >::iterator it = m_PlannedTargetNodes.begin(); - it != m_PlannedTargetNodes.end(); ++it ) + for (QVector>::iterator it = m_PlannedTargetNodes.begin(); + it != m_PlannedTargetNodes.end(); + ++it) { targetPointSet->InsertPoint(n++, (*it)->GetData()->GetGeometry()->GetOrigin()); } targetPointSet->InsertPoint(n, m_TargetIntersectionFilter->GetIntersectionPoint()); - this->CalculatePlanningQuality(dynamic_cast(m_TargetNode->GetData()), targetPointSet); + this->CalculatePlanningQuality(dynamic_cast(m_TargetNode->GetData()), targetPointSet); } } else { ui->placeTargetButton->setEnabled(false); - ui->placeTargetButton->setToolTip("Target cannot be placed as the needle path is not intersecting the target surface."); + ui->placeTargetButton->setToolTip( + "Target cannot be placed as the needle path is not intersecting the target surface."); // no not show planning quality if not all nodes are planned for now // and there is no needle path intersection - if ( m_PlannedTargetNodes.size() < m_NumberOfTargets ) + if (m_PlannedTargetNodes.size() < m_NumberOfTargets) { ui->angleDifferenceValue->setText(""); ui->centersOfMassValue->setText(""); } } } } void QmitkUSNavigationStepPlacementPlanning::OnSettingsChanged(const itk::SmartPointer settingsNode) { int numberOfTargets; - if ( settingsNode->GetIntProperty("settings.number-of-targets", numberOfTargets) ) + if (settingsNode->GetIntProperty("settings.number-of-targets", numberOfTargets)) { m_NumberOfTargets = numberOfTargets; m_TargetUpdateFilter->SetNumberOfTargets(numberOfTargets); m_PlacementQualityCalculator->SetOptimalAngle(m_TargetUpdateFilter->GetOptimalAngle()); } std::string referenceSensorName; - if ( settingsNode->GetStringProperty("settings.reference-name-selected", referenceSensorName) ) + if (settingsNode->GetStringProperty("settings.reference-name-selected", referenceSensorName)) { m_ReferenceSensorName = referenceSensorName; } std::string needleSensorName; - if ( settingsNode->GetStringProperty("settings.needle-name-selected", needleSensorName) ) + if (settingsNode->GetStringProperty("settings.needle-name-selected", needleSensorName)) { m_NeedleSensorName = needleSensorName; } this->UpdateSensorsNames(); } QString QmitkUSNavigationStepPlacementPlanning::GetTitle() { return "Placement Planning"; } QmitkUSAbstractNavigationStep::FilterVector QmitkUSNavigationStepPlacementPlanning::GetFilter() { FilterVector filterVector; filterVector.push_back(m_NodeDisplacementFilter.GetPointer()); filterVector.push_back(m_NeedleProjectionFilter.GetPointer()); return filterVector; } void QmitkUSNavigationStepPlacementPlanning::OnSetCombinedModality() { mitk::USCombinedModality::Pointer combinedModality = this->GetCombinedModality(false); - if ( combinedModality.IsNotNull() ) + if (combinedModality.IsNotNull()) { mitk::AffineTransform3D::Pointer calibration = combinedModality->GetCalibration(); - if ( calibration.IsNotNull() ) + if (calibration.IsNotNull()) { m_NeedleProjectionFilter->SetTargetPlane(calibration); } } ui->freezeImageButton->SetCombinedModality(combinedModality, m_ReferenceSensorIndex); this->UpdateSensorsNames(); } void QmitkUSNavigationStepPlacementPlanning::OnFreeze(bool freeze) { - if (freeze) this->GetCombinedModality()->SetIsFreezed(true); - if ( freeze ) + if (freeze) + this->GetCombinedModality()->SetIsFreezed(true); + if (freeze) { // load state machine and event config for data interactor m_PointMarkInteractor->LoadStateMachine("USPointMarkInteractions.xml", us::ModuleRegistry::GetModule("MitkUS")); m_PointMarkInteractor->SetEventConfig("globalConfig.xml"); this->CreateTargetNodesIfNecessary(); m_PointMarkInteractor->SetDataNode(m_PlannedTargetNodes.at(m_CurrentTargetIndex)); } else { m_PointMarkInteractor->SetDataNode(0); } - if (!freeze) this->GetCombinedModality()->SetIsFreezed(false); + if (!freeze) + this->GetCombinedModality()->SetIsFreezed(false); } void QmitkUSNavigationStepPlacementPlanning::OnPlaceTargetButtonClicked() { this->CreateTargetNodesIfNecessary(); mitk::DataNode::Pointer currentNode = m_PlannedTargetNodes.at(m_CurrentTargetIndex); currentNode->SetData(this->CreateSphere(5)); currentNode->SetBoolProperty("surface_empty", false); mitk::PointSet::Pointer needleProjection = m_NeedleProjectionFilter->GetProjection(); - m_TargetIntersectionFilter->SetTargetSurface(dynamic_cast(m_TargetNode->GetData())); + m_TargetIntersectionFilter->SetTargetSurface(dynamic_cast(m_TargetNode->GetData())); m_TargetIntersectionFilter->SetLine(m_NeedleProjectionFilter->GetProjection()); m_TargetIntersectionFilter->CalculateIntersection(); mitk::Point3D intersectionPoint = m_TargetIntersectionFilter->GetIntersectionPoint(); currentNode->GetData()->GetGeometry()->SetOrigin(intersectionPoint); m_TargetUpdateFilter->SetControlNode(m_CurrentTargetIndex, currentNode); mitk::PointSet::Pointer plannedPath = mitk::PointSet::New(); m_PlannedNeedlePaths.at(m_CurrentTargetIndex)->SetData(plannedPath); plannedPath->SetPoint(0, needleProjection->GetPoint(0)); plannedPath->SetPoint(1, intersectionPoint); - if ( m_CurrentTargetIndex < m_NumberOfTargets - 1 ) + if (m_CurrentTargetIndex < m_NumberOfTargets - 1) { this->OnGoToNextTarget(); } else { this->UpdateTargetDescriptions(); } this->ReinitNodeDisplacementFilter(); - MITK_INFO("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPlacementPlanning") - << "Target " << m_CurrentTargetIndex+1 << " planned at position " << intersectionPoint << "."; + MITK_INFO("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepPlacementPlanning") << "Target " << m_CurrentTargetIndex + 1 << " planned at position " + << intersectionPoint << "."; } void QmitkUSNavigationStepPlacementPlanning::OnGoToPreviousTarget() { - if ( m_CurrentTargetIndex < 1 ) + if (m_CurrentTargetIndex < 1) { mitkThrow() << "Cannot go to previous target as current target is first target."; } m_CurrentTargetIndex--; this->UpdateTargetDescriptions(); } void QmitkUSNavigationStepPlacementPlanning::OnGoToNextTarget() { m_CurrentTargetIndex++; this->UpdateTargetDescriptions(); } void QmitkUSNavigationStepPlacementPlanning::OnRemoveCurrentTargetClicked() { - if ( m_CurrentTargetIndex >= m_PlannedTargetNodes.size() ) + if (m_CurrentTargetIndex >= m_PlannedTargetNodes.size()) { MITK_WARN << "Cannot remove current target as there aren't as much planned target nodes."; return; } this->GetDataStorage()->Remove(m_PlannedTargetNodes.at(m_CurrentTargetIndex)); m_PlannedTargetNodes.remove(m_CurrentTargetIndex); this->GetDataStorage()->Remove(m_PlannedNeedlePaths.at(m_CurrentTargetIndex)); m_PlannedNeedlePaths.remove(m_CurrentTargetIndex); this->ReinitNodeDisplacementFilter(); - for ( unsigned int n = 0; n < m_PlannedTargetNodes.size(); ++n ) + for (unsigned int n = 0; n < m_PlannedTargetNodes.size(); ++n) { // set name of the target node according to its new index m_PlannedTargetNodes.at(n)->SetName( - QString("Target %1").arg(n+1, m_NumberOfTargets / 10 + 1, 10, QLatin1Char('0')).toStdString()); + QString("Target %1").arg(n + 1, m_NumberOfTargets / 10 + 1, 10, QLatin1Char('0')).toStdString()); m_PlannedNeedlePaths.at(n)->SetName( - QString("Target Path %1").arg(n+1, m_NumberOfTargets / 10 + 1, 10, QLatin1Char('0')).toStdString()); + QString("Target Path %1").arg(n + 1, m_NumberOfTargets / 10 + 1, 10, QLatin1Char('0')).toStdString()); } m_TargetUpdateFilter->RemovePositionOfTarget(m_CurrentTargetIndex); m_CurrentTargetIndex = m_PlannedTargetNodes.size(); this->UpdateTargetDescriptions(); - MITK_INFO("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPlacementPlanning") - << "Planned target " << m_CurrentTargetIndex + 1 << " removed."; + MITK_INFO("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepPlacementPlanning") << "Planned target " << m_CurrentTargetIndex + 1 << " removed."; } void QmitkUSNavigationStepPlacementPlanning::CreateTargetNodesIfNecessary() { mitk::DataStorage::Pointer dataStorage = this->GetDataStorage(); - while ( m_PlannedTargetNodes.size() <= m_CurrentTargetIndex ) + while (m_PlannedTargetNodes.size() <= m_CurrentTargetIndex) { - QString targetNumber = QString("%1").arg(m_PlannedTargetNodes.size()+1, m_NumberOfTargets / 10 + 1, 10, QLatin1Char('0')); + QString targetNumber = + QString("%1").arg(m_PlannedTargetNodes.size() + 1, m_NumberOfTargets / 10 + 1, 10, QLatin1Char('0')); mitk::DataNode::Pointer targetNode = this->GetNamedDerivedNodeAndCreate( - (QString("Target ")+targetNumber).toStdString().c_str(), - USNavigationMarkerPlacement::DATANAME_TARGETS); + (QString("Target ") + targetNumber).toStdString().c_str(), USNavigationMarkerPlacement::DATANAME_TARGETS); targetNode->SetOpacity(0.5); targetNode->SetBoolProperty("surface_empty", true); targetNode->SetData(mitk::Surface::New()); m_PlannedTargetNodes.push_back(targetNode); - mitk::DataNode::Pointer targetPathNode = this->GetNamedDerivedNodeAndCreate( - (QString("Target Path ")+targetNumber).toStdString().c_str(), - USNavigationMarkerPlacement::DATANAME_TARGETS_PATHS); + mitk::DataNode::Pointer targetPathNode = + this->GetNamedDerivedNodeAndCreate((QString("Target Path ") + targetNumber).toStdString().c_str(), + USNavigationMarkerPlacement::DATANAME_TARGETS_PATHS); targetPathNode->SetOpacity(0.5); targetPathNode->SetColor(1, 1, 1); targetPathNode->SetColor(1, 1, 1, NULL, "contourcolor"); targetPathNode->SetBoolProperty("show contour", true); m_PlannedNeedlePaths.push_back(targetPathNode); mitk::Surface::Pointer pathSurface = mitk::Surface::New(); targetPathNode->SetData(pathSurface); } } -void QmitkUSNavigationStepPlacementPlanning::UpdateTargetCoordinates(mitk::DataNode* dataNode) +void QmitkUSNavigationStepPlacementPlanning::UpdateTargetCoordinates(mitk::DataNode *dataNode) { bool surfaceEmpty; - if ( dataNode->GetBoolProperty("surface_empty", surfaceEmpty) && surfaceEmpty ) + if (dataNode->GetBoolProperty("surface_empty", surfaceEmpty) && surfaceEmpty) { mitk::Point3D origin = dataNode->GetData()->GetGeometry()->GetOrigin(); dataNode->SetData(this->CreateSphere(5)); dataNode->SetBoolProperty("surface_empty", false); dataNode->GetData()->GetGeometry()->SetOrigin(origin); } this->ReinitNodeDisplacementFilter(); - mitk::BaseData* baseData = dataNode->GetData(); - if ( ! baseData ) + mitk::BaseData *baseData = dataNode->GetData(); + if (!baseData) { mitkThrow() << "Data of the data node must not be null."; } mitk::BaseGeometry::Pointer geometry = baseData->GetGeometry(); - if ( geometry.IsNull() ) + if (geometry.IsNull()) { mitkThrow() << "Geometry of the data node must not be null."; } m_TargetUpdateFilter->SetControlNode(m_CurrentTargetIndex, dataNode); - MITK_INFO("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPlacementPlanning") - << "Target " << m_CurrentTargetIndex+1 << " planned at position " << geometry->GetOrigin() << "."; + MITK_INFO("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepPlacementPlanning") << "Target " << m_CurrentTargetIndex + 1 << " planned at position " + << geometry->GetOrigin() << "."; - if ( ui->freezeImageButton->isChecked() ) + if (ui->freezeImageButton->isChecked()) { ui->freezeImageButton->Unfreeze(); - if ( m_CurrentTargetIndex < m_NumberOfTargets - 1 ) + if (m_CurrentTargetIndex < m_NumberOfTargets - 1) { this->OnGoToNextTarget(); } } this->UpdateTargetDescriptions(); } void QmitkUSNavigationStepPlacementPlanning::UpdateTargetColors() { - if ( m_TargetNode.IsNull() ) { return; } + if (m_TargetNode.IsNull()) + { + return; + } - m_TargetNode->SetColor(1,1,1); + m_TargetNode->SetColor(1, 1, 1); - mitk::BaseData* targetNodeData = m_TargetNode->GetData(); - if ( targetNodeData == 0 ) { return; } + mitk::BaseData *targetNodeData = m_TargetNode->GetData(); + if (targetNodeData == 0) + { + return; + } - mitk::Surface::Pointer targetNodeSurface = dynamic_cast(targetNodeData); + mitk::Surface::Pointer targetNodeSurface = dynamic_cast(targetNodeData); vtkSmartPointer targetNodeSurfaceVtk = targetNodeSurface->GetVtkPolyData(); - vtkFloatArray* targetScoreScalars = dynamic_cast( + vtkFloatArray *targetScoreScalars = dynamic_cast( targetNodeSurface->GetVtkPolyData()->GetPointData()->GetScalars("USNavigation::PlanningPlacement")); - if ( ! targetScoreScalars ) { return; } + if (!targetScoreScalars) + { + return; + } unsigned int numberOfTupels = targetScoreScalars->GetNumberOfTuples(); - vtkSmartPointer colors = - vtkSmartPointer::New(); + vtkSmartPointer colors = vtkSmartPointer::New(); colors->SetNumberOfComponents(1); colors->SetNumberOfTuples(numberOfTupels); colors->SetName("Colors"); double markerScore; - for ( unsigned int n = 0; n < numberOfTupels; n++ ) + for (unsigned int n = 0; n < numberOfTupels; n++) { targetScoreScalars->GetTuple(n, &markerScore); colors->SetTuple(n, &markerScore); } - if ( numberOfTupels > 0 ) + if (numberOfTupels > 0) { targetNodeSurfaceVtk->GetPointData()->SetScalars(colors); targetNodeSurfaceVtk->GetPointData()->Update(); } } void QmitkUSNavigationStepPlacementPlanning::UpdateTargetDescriptions() { ui->previousButton->setEnabled(m_CurrentTargetIndex > 0); ui->nextButton->setEnabled(m_CurrentTargetIndex + 1 < m_PlannedTargetNodes.size()); ui->removeButton->setEnabled(m_PlannedTargetNodes.size() > 0); - ui->currentTargetLabel->setText(QString("Planning Target %1 of %2").arg(m_CurrentTargetIndex+1).arg(m_NumberOfTargets)); + ui->currentTargetLabel->setText( + QString("Planning Target %1 of %2").arg(m_CurrentTargetIndex + 1).arg(m_NumberOfTargets)); ui->removeButton->setEnabled(m_CurrentTargetIndex < m_PlannedTargetNodes.size()); this->CalculatePlanningQuality(); } void QmitkUSNavigationStepPlacementPlanning::GenerateTargetColorLookupTable() { vtkSmartPointer lookupTable = vtkSmartPointer::New(); lookupTable->SetHueRange(0.0, 0.27); lookupTable->SetSaturationRange(1.0, 1.0); lookupTable->SetValueRange(1.0, 1.0); lookupTable->SetTableRange(0.0, 1.0); lookupTable->Build(); mitk::LookupTable::Pointer lut = mitk::LookupTable::New(); lut->SetVtkLookupTable(lookupTable); m_TargetColorLookupTableProperty = mitk::LookupTableProperty::New(lut); } void QmitkUSNavigationStepPlacementPlanning::ReinitNodeDisplacementFilter() { m_NodeDisplacementFilter->ResetNodes(); - for (QVector >::iterator it = m_PlannedTargetNodes.begin(); - it != m_PlannedTargetNodes.end(); ++it) + for (QVector>::iterator it = m_PlannedTargetNodes.begin(); + it != m_PlannedTargetNodes.end(); + ++it) { if (it->IsNotNull() && (*it)->GetData() != 0) { m_NodeDisplacementFilter->AddNode(*it); } } - for (QVector >::iterator it = m_PlannedNeedlePaths.begin(); - it != m_PlannedNeedlePaths.end(); ++it) + for (QVector>::iterator it = m_PlannedNeedlePaths.begin(); + it != m_PlannedNeedlePaths.end(); + ++it) { if (it->IsNotNull() && (*it)->GetData() != 0) { m_NodeDisplacementFilter->AddNode(*it); } } } void QmitkUSNavigationStepPlacementPlanning::CalculatePlanningQuality() { - if ( m_PlannedTargetNodes.size() != m_NumberOfTargets ) + if (m_PlannedTargetNodes.size() != m_NumberOfTargets) { ui->angleDifferenceLabel->setEnabled(false); ui->centersOfMassLabel->setEnabled(false); ui->allTargetsPlannedLabel->setEnabled(false); ui->angleDifferenceValue->setText(""); ui->centersOfMassValue->setText(""); return; } ui->angleDifferenceLabel->setEnabled(true); ui->centersOfMassLabel->setEnabled(true); ui->allTargetsPlannedLabel->setEnabled(true); mitk::PointSet::Pointer targetPointSet = mitk::PointSet::New(); mitk::PointSet::PointIdentifier n = 0; - for ( QVector >::iterator it = m_PlannedTargetNodes.begin(); - it != m_PlannedTargetNodes.end(); ++it ) + for (QVector>::iterator it = m_PlannedTargetNodes.begin(); + it != m_PlannedTargetNodes.end(); + ++it) { targetPointSet->InsertPoint(n++, (*it)->GetData()->GetGeometry()->GetOrigin()); } mitk::DataNode::Pointer planningQualityResult = - this->CalculatePlanningQuality(dynamic_cast(m_TargetNode->GetData()), targetPointSet); + this->CalculatePlanningQuality(dynamic_cast(m_TargetNode->GetData()), targetPointSet); emit SignalIntermediateResult(planningQualityResult); } mitk::DataNode::Pointer QmitkUSNavigationStepPlacementPlanning::CalculatePlanningQuality( mitk::Surface::Pointer targetSurface, mitk::PointSet::Pointer targetPoints) { - if ( targetSurface.IsNull() ) + if (targetSurface.IsNull()) { mitkThrow() << "Target surface must not be null."; } m_PlacementQualityCalculator->SetTargetSurface(targetSurface); m_PlacementQualityCalculator->SetTargetPoints(targetPoints); m_PlacementQualityCalculator->Update(); mitk::DataNode::Pointer planningQualityResult = mitk::DataNode::New(); planningQualityResult->SetName("PlanningQuality"); - double centersOfMassDistance = m_PlacementQualityCalculator->GetCentersOfMassDistance(); - ui->centersOfMassValue->setText(QString::number( - centersOfMassDistance, 103, 2) + " mm"); + ui->centersOfMassValue->setText(QString::number(centersOfMassDistance, 103, 2) + " mm"); planningQualityResult->SetFloatProperty("USNavigation::CentersOfMassDistance", centersOfMassDistance); - if ( m_PlannedTargetNodes.size() > 1 ) + if (m_PlannedTargetNodes.size() > 1) { double meanAnglesDifference = m_PlacementQualityCalculator->GetMeanAngleDifference(); - ui->angleDifferenceValue->setText(QString::number( - meanAnglesDifference, 103, 2) + QString::fromLatin1(" °")); + ui->angleDifferenceValue->setText(QString::number(meanAnglesDifference, 103, 2) + QString::fromLatin1(" °")); planningQualityResult->SetFloatProperty("USNavigation::MeanAngleDifference", meanAnglesDifference); - planningQualityResult->SetProperty("USNavigation::AngleDifferences", + planningQualityResult->SetProperty( + "USNavigation::AngleDifferences", mitk::GenericProperty::New(m_PlacementQualityCalculator->GetAngleDifferences())); } else { ui->angleDifferenceValue->setText("not valid for one point"); } return planningQualityResult; } itk::SmartPointer QmitkUSNavigationStepPlacementPlanning::CreateSphere(float radius) { mitk::Surface::Pointer surface = mitk::Surface::New(); // create a vtk sphere with fixed radius vtkSphereSource *vtkData = vtkSphereSource::New(); - vtkData->SetRadius( 5 ); - vtkData->SetCenter(0,0,0); + vtkData->SetRadius(5); + vtkData->SetCenter(0, 0, 0); vtkData->Update(); surface->SetVtkPolyData(vtkData->GetOutput()); vtkData->Delete(); return surface; } void QmitkUSNavigationStepPlacementPlanning::UpdateBodyMarkerStatus(mitk::NavigationData::Pointer bodyMarker) { - if ( bodyMarker.IsNull() ) + if (bodyMarker.IsNull()) { - MITK_ERROR("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPunctuationIntervention") + MITK_ERROR("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepPunctuationIntervention") << "Current Navigation Data for body marker of Combined Modality must not be null."; mitkThrow() << "Current Navigation Data for body marker of Combined Modality must not be null."; } m_BodyMarkerValid = bodyMarker->IsDataValid(); // update body marker status label if (m_BodyMarkerValid) { ui->bodyMarkerTrackingStatusLabel->setStyleSheet( "background-color: #8bff8b; margin-right: 1em; margin-left: 1em; border: 1px solid grey"); ui->bodyMarkerTrackingStatusLabel->setText("Body marker is inside the tracking volume."); } else { ui->bodyMarkerTrackingStatusLabel->setStyleSheet( - "background-color: #ff7878; margin-right: 1em; margin-left: 1em; border: 1px solid grey"); + "background-color: #ff7878; margin-right: 1em; margin-left: 1em; border: 1px solid grey"); ui->bodyMarkerTrackingStatusLabel->setText("Body marker is not inside the tracking volume."); } } void QmitkUSNavigationStepPlacementPlanning::UpdateSensorsNames() { mitk::USCombinedModality::Pointer combinedModality = this->GetCombinedModality(false); - if ( combinedModality.IsNull() ) { return; } + if (combinedModality.IsNull()) + { + return; + } mitk::NavigationDataSource::Pointer navigationDataSource = combinedModality->GetNavigationDataSource(); - if ( navigationDataSource.IsNull() ) { return; } + if (navigationDataSource.IsNull()) + { + return; + } - if ( ! m_NeedleSensorName.empty() ) + if (!m_NeedleSensorName.empty()) { try { m_NeedleSensorIndex = navigationDataSource->GetOutputIndex(m_NeedleSensorName); } - catch ( const std::exception &e ) + catch (const std::exception &e) { - MITK_WARN("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPlacementPlanning") - << "Cannot get index for needle sensor name: " << e.what(); + MITK_WARN("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepPlacementPlanning") << "Cannot get index for needle sensor name: " << e.what(); } } - if ( this->GetNavigationStepState() >= QmitkUSAbstractNavigationStep::State_Active ) + if (this->GetNavigationStepState() >= QmitkUSAbstractNavigationStep::State_Active) { m_NeedleProjectionFilter->SelectInput(m_NeedleSensorIndex); } - if ( ! m_ReferenceSensorName.empty() ) + if (!m_ReferenceSensorName.empty()) { try { m_ReferenceSensorIndex = navigationDataSource->GetOutputIndex(m_ReferenceSensorName); } - catch ( const std::exception &e ) + catch (const std::exception &e) { - MITK_WARN("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPlacementPlanning") - << "Cannot get index for reference sensor name: " << e.what(); + MITK_WARN("QmitkUSAbstractNavigationStep") + ("QmitkUSNavigationStepPlacementPlanning") << "Cannot get index for reference sensor name: " << e.what(); } } - if ( this->GetNavigationStepState() >= QmitkUSAbstractNavigationStep::State_Active ) + if (this->GetNavigationStepState() >= QmitkUSAbstractNavigationStep::State_Active) { m_NodeDisplacementFilter->SelectInput(m_ReferenceSensorIndex); } ui->freezeImageButton->SetCombinedModality(combinedModality, m_ReferenceSensorIndex); } diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.h b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.h index fd52c89e18..05b320bf36 100644 --- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.h +++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.h @@ -1,147 +1,148 @@ /*=================================================================== 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 QMITKUSNAVIGATIONSTEPPLACEMENTPLANNING_H #define QMITKUSNAVIGATIONSTEPPLACEMENTPLANNING_H #include "QmitkUSAbstractNavigationStep.h" -namespace Ui { -class QmitkUSNavigationStepPlacementPlanning; +namespace Ui +{ + class QmitkUSNavigationStepPlacementPlanning; } -namespace mitk { -class USNavigationTargetUpdateFilter; -class USNavigationTargetIntersectionFilter; -class USPointMarkInteractor; -class NodeDisplacementFilter; -class NeedleProjectionFilter; -class LookupTableProperty; -class OverlayManager; -class TextOverlay3D; -class Surface; -class PointSet; -class USTargetPlacementQualityCalculator; +namespace mitk +{ + class USNavigationTargetUpdateFilter; + class USNavigationTargetIntersectionFilter; + class USPointMarkInteractor; + class NodeDisplacementFilter; + class NeedleProjectionFilter; + class LookupTableProperty; + class TextAnnotation3D; + class Surface; + class PointSet; + class USTargetPlacementQualityCalculator; } /** * \brief Navigation step for planning the positions for implanting markers. * * The planned targets are stored in the data storage under DATANAME_BASENODE -> * DATANAME_TARGETS and the needle path to the planned targets are stored under * DATANAME_BASENODE -> DATANAME_TARGETS_PATHS. The target structure is expected * to be stored under DATANAME_BASENODE -> DATANAME_TUMOR -> * DATANAME_TARGETSURFACE. * */ class QmitkUSNavigationStepPlacementPlanning : public QmitkUSAbstractNavigationStep { Q_OBJECT protected slots: /** * \brief Freezes or unfreezes the combined modality. * In freeze state an interactor is activated in the render window, so the * position of the currently active target can be planned by clicking into the * render window. */ void OnFreeze(bool freezed); /** * \brief Plan target position at the intersection between needle path and target surface. */ void OnPlaceTargetButtonClicked(); /** * \brief Selects the previous target as active target. */ void OnGoToPreviousTarget(); /** * \brief Selects the next target as active target. */ void OnGoToNextTarget(); /** * \brief The currently active target is removed from the data storage. */ void OnRemoveCurrentTargetClicked(); public: explicit QmitkUSNavigationStepPlacementPlanning(QWidget *parent = 0); ~QmitkUSNavigationStepPlacementPlanning(); virtual QString GetTitle(); virtual FilterVector GetFilter(); protected: virtual bool OnStartStep(); virtual bool OnStopStep(); virtual bool OnRestartStep(); virtual bool OnFinishStep(); virtual bool OnActivateStep(); virtual bool OnDeactivateStep(); virtual void OnUpdate(); virtual void OnSettingsChanged(const itk::SmartPointer settingsNode); virtual void OnSetCombinedModality(); void CreateTargetNodesIfNecessary(); - void UpdateTargetCoordinates(mitk::DataNode*); + void UpdateTargetCoordinates(mitk::DataNode *); void UpdateTargetColors(); void UpdateTargetDescriptions(); void GenerateTargetColorLookupTable(); void ReinitNodeDisplacementFilter(); void CalculatePlanningQuality(); - itk::SmartPointer CalculatePlanningQuality(itk::SmartPointer targetSurface, itk::SmartPointer); + itk::SmartPointer CalculatePlanningQuality(itk::SmartPointer targetSurface, + itk::SmartPointer); itk::SmartPointer CreateSphere(float radius); void UpdateBodyMarkerStatus(mitk::NavigationData::Pointer bodyMarker); void UpdateSensorsNames(); - int m_NumberOfTargets; - int m_CurrentTargetIndex; - bool m_BodyMarkerValid; + int m_NumberOfTargets; + int m_CurrentTargetIndex; + bool m_BodyMarkerValid; - itk::SmartPointer m_PointMarkInteractor; - itk::SmartPointer m_TargetUpdateFilter; - itk::SmartPointer m_NodeDisplacementFilter; - itk::SmartPointer m_NeedleProjectionFilter; - itk::SmartPointer m_TargetIntersectionFilter; - itk::SmartPointer m_PlacementQualityCalculator; + itk::SmartPointer m_PointMarkInteractor; + itk::SmartPointer m_TargetUpdateFilter; + itk::SmartPointer m_NodeDisplacementFilter; + itk::SmartPointer m_NeedleProjectionFilter; + itk::SmartPointer m_TargetIntersectionFilter; + itk::SmartPointer m_PlacementQualityCalculator; - itk::SmartPointer m_TargetColorLookupTableProperty; + itk::SmartPointer m_TargetColorLookupTableProperty; - itk::SmartPointer m_TargetNode; - QVector > m_PlannedTargetNodes; - QVector > m_PlannedNeedlePaths; + itk::SmartPointer m_TargetNode; + QVector> m_PlannedTargetNodes; + QVector> m_PlannedNeedlePaths; - itk::SmartPointer m_OverlayManager; - itk::SmartPointer m_CurrentTargetNodeOverlay; + itk::SmartPointer m_CurrentTargetNodeOverlay; - std::string m_ReferenceSensorName; - std::string m_NeedleSensorName; + std::string m_ReferenceSensorName; + std::string m_NeedleSensorName; - unsigned int m_ReferenceSensorIndex; - unsigned int m_NeedleSensorIndex; + unsigned int m_ReferenceSensorIndex; + unsigned int m_NeedleSensorIndex; private: - mitk::MessageDelegate1 m_ListenerTargetCoordinatesChanged; + mitk::MessageDelegate1 m_ListenerTargetCoordinatesChanged; Ui::QmitkUSNavigationStepPlacementPlanning *ui; }; #endif // QMITKUSNAVIGATIONSTEPPLACEMENTPLANNING_H diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.cpp index 43e847db9c..98ccf1c6a4 100644 --- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.cpp +++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.cpp @@ -1,693 +1,713 @@ /*=================================================================== 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 "USNavigationMarkerPlacement.h" #include "ui_USNavigationMarkerPlacement.h" #include "NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.h" -#include "NavigationStepWidgets/QmitkUSNavigationStepTumourSelection.h" -#include "NavigationStepWidgets/QmitkUSNavigationStepZoneMarking.h" -#include "NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.h" #include "NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.h" +#include "NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.h" #include "NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.h" +#include "NavigationStepWidgets/QmitkUSNavigationStepTumourSelection.h" +#include "NavigationStepWidgets/QmitkUSNavigationStepZoneMarking.h" #include "SettingsWidgets/QmitkUSNavigationCombinedSettingsWidget.h" #include "mitkIRenderingManager.h" #include "mitkNodeDisplacementFilter.h" #include "mitkUSCombinedModality.h" -#include "mitkOverlay2DLayouter.h" #include -#include "IO/mitkUSNavigationStepTimer.h" #include "IO/mitkUSNavigationExperimentLogging.h" +#include "IO/mitkUSNavigationStepTimer.h" -#include -#include -#include +#include #include +#include #include -#include +#include +#include #include "QmitkRenderWindow.h" -#include "QmitkStdMultiWidgetEditor.h" #include "QmitkStdMultiWidget.h" +#include "QmitkStdMultiWidgetEditor.h" +#include "mitkLayoutAnnotationRenderer.h" // scene serialization -#include -#include +#include #include #include -#include +#include +#include const std::string USNavigationMarkerPlacement::VIEW_ID = "org.mitk.views.usmarkerplacement"; -const char* USNavigationMarkerPlacement::DATANAME_TUMOUR = "Tumour"; -const char* USNavigationMarkerPlacement::DATANAME_TARGETSURFACE = "Target Surface"; -const char* USNavigationMarkerPlacement::DATANAME_ZONES = "Zones"; -const char* USNavigationMarkerPlacement::DATANAME_TARGETS = "Targets"; -const char* USNavigationMarkerPlacement::DATANAME_TARGETS_PATHS = "Target Paths"; -const char* USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS = "Reached Targets"; - -USNavigationMarkerPlacement::USNavigationMarkerPlacement() : -m_UpdateTimer(new QTimer(this)), -m_ImageAndNavigationDataLoggingTimer(new QTimer(this)), -m_StdMultiWidget(0), -m_ReinitAlreadyDone(false), -m_IsExperimentRunning(false), -m_NavigationStepTimer(mitk::USNavigationStepTimer::New()), -m_ExperimentLogging(mitk::USNavigationExperimentLogging::New()), -m_AblationZonesDisplacementFilter(mitk::NodeDisplacementFilter::New()), -m_IconRunning(QPixmap(":/USNavigation/record.png")), -m_IconNotRunning(QPixmap(":/USNavigation/record-gray.png")), -m_USImageLoggingFilter(mitk::USImageLoggingFilter::New()), -m_NavigationDataRecorder(mitk::NavigationDataRecorder::New()), -m_SceneNumber(1), -m_WarnOverlay(mitk::TextOverlay2D::New()), -m_ListenerDeviceChanged(this, &USNavigationMarkerPlacement::OnCombinedModalityPropertyChanged), -m_NeedleIndex(0), -m_MarkerIndex(1), -ui(new Ui::USNavigationMarkerPlacement) +const char *USNavigationMarkerPlacement::DATANAME_TUMOUR = "Tumour"; +const char *USNavigationMarkerPlacement::DATANAME_TARGETSURFACE = "Target Surface"; +const char *USNavigationMarkerPlacement::DATANAME_ZONES = "Zones"; +const char *USNavigationMarkerPlacement::DATANAME_TARGETS = "Targets"; +const char *USNavigationMarkerPlacement::DATANAME_TARGETS_PATHS = "Target Paths"; +const char *USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS = "Reached Targets"; + +USNavigationMarkerPlacement::USNavigationMarkerPlacement() + : m_UpdateTimer(new QTimer(this)), + m_ImageAndNavigationDataLoggingTimer(new QTimer(this)), + m_StdMultiWidget(0), + m_ReinitAlreadyDone(false), + m_IsExperimentRunning(false), + m_NavigationStepTimer(mitk::USNavigationStepTimer::New()), + m_ExperimentLogging(mitk::USNavigationExperimentLogging::New()), + m_AblationZonesDisplacementFilter(mitk::NodeDisplacementFilter::New()), + m_IconRunning(QPixmap(":/USNavigation/record.png")), + m_IconNotRunning(QPixmap(":/USNavigation/record-gray.png")), + m_USImageLoggingFilter(mitk::USImageLoggingFilter::New()), + m_NavigationDataRecorder(mitk::NavigationDataRecorder::New()), + m_SceneNumber(1), + m_WarnOverlay(mitk::TextAnnotation2D::New()), + m_ListenerDeviceChanged(this, &USNavigationMarkerPlacement::OnCombinedModalityPropertyChanged), + m_NeedleIndex(0), + m_MarkerIndex(1), + ui(new Ui::USNavigationMarkerPlacement) { connect(m_UpdateTimer, SIGNAL(timeout()), this, SLOT(OnTimeout())); - connect(m_ImageAndNavigationDataLoggingTimer, SIGNAL(timeout()), this, SLOT(OnImageAndNavigationDataLoggingTimeout())); + connect( + m_ImageAndNavigationDataLoggingTimer, SIGNAL(timeout()), this, SLOT(OnImageAndNavigationDataLoggingTimeout())); // scale running (and not running) icon the specific height m_IconRunning = m_IconRunning.scaledToHeight(20, Qt::SmoothTransformation); m_IconNotRunning = m_IconNotRunning.scaledToHeight(20, Qt::SmoothTransformation); // set prefix for experiment logging (only keys with this prefix are taken // into consideration m_ExperimentLogging->SetKeyPrefix("USNavigation::"); - m_UpdateTimer->start(33); //every 33 Milliseconds = 30 Frames/Second + m_UpdateTimer->start(33); // every 33 Milliseconds = 30 Frames/Second } USNavigationMarkerPlacement::~USNavigationMarkerPlacement() { // make sure that the experiment got finished before destructing the object - if (m_IsExperimentRunning) { this->OnFinishExperiment(); } + if (m_IsExperimentRunning) + { + this->OnFinishExperiment(); + } // remove listener for ultrasound device changes if (m_CombinedModality.IsNotNull() && m_CombinedModality->GetUltrasoundDevice().IsNotNull()) { m_CombinedModality->GetUltrasoundDevice()->RemovePropertyChangedListener(m_ListenerDeviceChanged); } delete ui; } void USNavigationMarkerPlacement::OnChangeAblationZone(int id, int newSize) { - if ((m_AblationZonesVector.size() < id) || (id < 0)) { return; } + if ((m_AblationZonesVector.size() < id) || (id < 0)) + { + return; + } MITK_INFO << "Ablation Zone " << id << " changed, new size: " << newSize; // create a vtk sphere with given radius vtkSphereSource *vtkData = vtkSphereSource::New(); vtkData->SetRadius(newSize / 2); vtkData->SetCenter(0, 0, 0); vtkData->SetPhiResolution(20); vtkData->SetThetaResolution(20); vtkData->Update(); - mitk::Surface::Pointer zoneSurface = dynamic_cast(m_AblationZonesVector.at(id)->GetData()); + mitk::Surface::Pointer zoneSurface = dynamic_cast(m_AblationZonesVector.at(id)->GetData()); zoneSurface->SetVtkPolyData(vtkData->GetOutput()); vtkData->Delete(); } void USNavigationMarkerPlacement::OnAddAblationZone(int size) { - m_AblationZonesDisplacementFilter->SetInitialReferencePose(m_CombinedModality->GetNavigationDataSource()->GetOutput(m_MarkerIndex)); + m_AblationZonesDisplacementFilter->SetInitialReferencePose( + m_CombinedModality->GetNavigationDataSource()->GetOutput(m_MarkerIndex)); mitk::DataNode::Pointer NewAblationZone = mitk::DataNode::New(); mitk::Point3D origin = m_CombinedModality->GetNavigationDataSource()->GetOutput(m_NeedleIndex)->GetPosition(); MITK_INFO("USNavigationLogging") << "Ablation Zone Added, initial size: " << size << ", origin: " << origin; mitk::Surface::Pointer zone = mitk::Surface::New(); // create a vtk sphere with given radius vtkSphereSource *vtkData = vtkSphereSource::New(); vtkData->SetRadius(size / 2); vtkData->SetCenter(0, 0, 0); vtkData->SetPhiResolution(20); vtkData->SetThetaResolution(20); vtkData->Update(); zone->SetVtkPolyData(vtkData->GetOutput()); vtkData->Delete(); // set vtk sphere and origin to data node (origin must be set // again, because of the new sphere set as data) NewAblationZone->SetData(zone); NewAblationZone->GetData()->GetGeometry()->SetOrigin(origin); mitk::Color SphereColor = mitk::Color(); - //default color + // default color SphereColor[0] = 102; SphereColor[1] = 0; SphereColor[2] = 204; NewAblationZone->SetColor(SphereColor); NewAblationZone->SetOpacity(0.3); // set name of zone std::stringstream name; name << "Ablation Zone" << m_AblationZonesVector.size(); NewAblationZone->SetName(name.str()); // add zone to filter m_AblationZonesDisplacementFilter->AddNode(NewAblationZone); m_AblationZonesVector.push_back(NewAblationZone); this->GetDataStorage()->Add(NewAblationZone); } void USNavigationMarkerPlacement::CreateQtPartControl(QWidget *parent) { m_Parent = parent; ui->setupUi(parent); connect(ui->navigationProcessWidget, - SIGNAL(SignalCombinedModalityChanged(itk::SmartPointer)), - this, SLOT(OnCombinedModalityChanged(itk::SmartPointer))); + SIGNAL(SignalCombinedModalityChanged(itk::SmartPointer)), + this, + SLOT(OnCombinedModalityChanged(itk::SmartPointer))); connect(ui->navigationProcessWidget, - SIGNAL(SignalSettingsChanged(itk::SmartPointer)), - this, SLOT(OnSettingsChanged(itk::SmartPointer))); + SIGNAL(SignalSettingsChanged(itk::SmartPointer)), + this, + SLOT(OnSettingsChanged(itk::SmartPointer))); - connect(ui->navigationProcessWidget, SIGNAL(SignalActiveNavigationStepChanged(int)), - this, SLOT(OnActiveNavigationStepChanged(int))); + connect(ui->navigationProcessWidget, + SIGNAL(SignalActiveNavigationStepChanged(int)), + this, + SLOT(OnActiveNavigationStepChanged(int))); connect(ui->startExperimentButton, SIGNAL(clicked()), this, SLOT(OnStartExperiment())); connect(ui->finishExperimentButton, SIGNAL(clicked()), this, SLOT(OnFinishExperiment())); - connect(ui->navigationProcessWidget, SIGNAL(SignalIntermediateResult(const itk::SmartPointer)), - this, SLOT(OnIntermediateResultProduced(const itk::SmartPointer))); + connect(ui->navigationProcessWidget, + SIGNAL(SignalIntermediateResult(const itk::SmartPointer)), + this, + SLOT(OnIntermediateResultProduced(const itk::SmartPointer))); ui->navigationProcessWidget->SetDataStorage(this->GetDataStorage()); // indicate that no experiment is running at start ui->runningLabel->setPixmap(m_IconNotRunning); ui->navigationProcessWidget->SetSettingsWidget(new QmitkUSNavigationCombinedSettingsWidget(m_Parent)); } -void USNavigationMarkerPlacement::OnCombinedModalityPropertyChanged(const std::string& key, const std::string&) +void USNavigationMarkerPlacement::OnCombinedModalityPropertyChanged(const std::string &key, const std::string &) { if (key == mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DEPTH) { m_ReinitAlreadyDone = false; this->ReinitOnImage(); - // make sure that the overlay is not added twice - if (m_OverlayManager.IsNotNull()) { m_OverlayManager->RemoveOverlay(m_WarnOverlay.GetPointer()); } - if (m_CombinedModality.IsNotNull() && !m_CombinedModality->GetIsCalibratedForCurrentStatus()) { - if (m_OverlayManager.IsNotNull()) { m_OverlayManager->AddOverlay(m_WarnOverlay.GetPointer()); } + mitk::LayoutAnnotationRenderer::AddAnnotation( + m_WarnOverlay.GetPointer(), "stdmulti.widget1", mitk::LayoutAnnotationRenderer::TopLeft); MITK_WARN << "No calibration available for the selected ultrasound image depth."; } } } void USNavigationMarkerPlacement::SetFocus() { this->ReinitOnImage(); } void USNavigationMarkerPlacement::OnTimeout() { if (!m_StdMultiWidget) { // try to get the standard multi widget if it couldn't be got before - mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart(); + mitk::IRenderWindowPart *renderWindow = this->GetRenderWindowPart(); - QmitkStdMultiWidgetEditor* multiWidgetEditor - = dynamic_cast(renderWindow); + QmitkStdMultiWidgetEditor *multiWidgetEditor = dynamic_cast(renderWindow); // if there is a standard multi widget now, disable the level window and // change the layout to 2D up and 3d down if (multiWidgetEditor) { m_StdMultiWidget = multiWidgetEditor->GetStdMultiWidget(); if (m_StdMultiWidget) { m_StdMultiWidget->DisableStandardLevelWindow(); m_StdMultiWidget->changeLayoutTo2DUpAnd3DDown(); } } - if (m_OverlayManager.IsNull()) { this->CreateOverlays(); } + this->CreateOverlays(); } - if (m_CombinedModality.IsNotNull() && !this->m_CombinedModality->GetIsFreezed()) //if the combined modality is freezed: do nothing + if (m_CombinedModality.IsNotNull() && + !this->m_CombinedModality->GetIsFreezed()) // if the combined modality is freezed: do nothing { ui->navigationProcessWidget->UpdateNavigationProgress(); m_AblationZonesDisplacementFilter->Update(); - //update the 3D window only every fourth time to speed up the rendering (at least in 2D) + // update the 3D window only every fourth time to speed up the rendering (at least in 2D) this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS); // make sure that a reinit was performed on the image this->ReinitOnImage(); } } void USNavigationMarkerPlacement::OnImageAndNavigationDataLoggingTimeout() { // update filter for logging navigation data and ultrasound images if (m_CombinedModality.IsNotNull()) { m_NavigationDataRecorder->Update(); - //get last messages for logging filer and store them + // get last messages for logging filer and store them std::vector messages = m_LoggingBackend.GetNavigationMessages(); std::string composedMessage = ""; - for (int i = 0; i < messages.size(); i++) { composedMessage += messages.at(i); } + for (int i = 0; i < messages.size(); i++) + { + composedMessage += messages.at(i); + } m_USImageLoggingFilter->AddMessageToCurrentImage(composedMessage); m_LoggingBackend.ClearNavigationMessages(); - //update logging filter + // update logging filter m_USImageLoggingFilter->Update(); } } void USNavigationMarkerPlacement::OnStartExperiment() { // get name for the experiment by a QInputDialog bool ok; if (m_ExperimentName.isEmpty()) - { //default: current date - m_ExperimentName = QString::number(QDateTime::currentDateTime().date().year()) + "_" - + QString::number(QDateTime::currentDateTime().date().month()) + "_" - + QString::number(QDateTime::currentDateTime().date().day()) + "_experiment_" - + QString::number(QDateTime::currentDateTime().time().hour()) + "." - + QString::number(QDateTime::currentDateTime().time().minute()); + { // default: current date + m_ExperimentName = QString::number(QDateTime::currentDateTime().date().year()) + "_" + + QString::number(QDateTime::currentDateTime().date().month()) + "_" + + QString::number(QDateTime::currentDateTime().date().day()) + "_experiment_" + + QString::number(QDateTime::currentDateTime().time().hour()) + "." + + QString::number(QDateTime::currentDateTime().time().minute()); } - m_ExperimentName = QInputDialog::getText(m_Parent, QString("Experiment Name"), QString("Name of the Experiment"), QLineEdit::Normal, m_ExperimentName, &ok); + m_ExperimentName = QInputDialog::getText( + m_Parent, QString("Experiment Name"), QString("Name of the Experiment"), QLineEdit::Normal, m_ExperimentName, &ok); MITK_INFO("USNavigationLogging") << "Experiment started: " << m_ExperimentName.toStdString(); if (ok && !m_ExperimentName.isEmpty()) { // display error message and call the function recursivly if a directory // with the given name already exists QDir experimentResultsDir(m_ResultsDirectory + QDir::separator() + m_ExperimentName); if (experimentResultsDir.exists()) { - QMessageBox::critical(m_Parent, "Results Directory Exists", "The result directory already exists.\nPlease choose an other name."); + QMessageBox::critical( + m_Parent, "Results Directory Exists", "The result directory already exists.\nPlease choose an other name."); this->OnStartExperiment(); } else { QDir(m_ResultsDirectory).mkdir(m_ExperimentName); m_ExperimentResultsSubDirectory = m_ResultsDirectory + QDir::separator() + m_ExperimentName; // experiment is running now ui->runningLabel->setPixmap(m_IconRunning); ui->navigationProcessWidget->EnableInteraction(true); // (re)start timer for navigation step durations m_NavigationStepTimer->Reset(); - m_NavigationStepTimer->SetOutputFileName(QString(m_ExperimentResultsSubDirectory + QDir::separator() - + QString("durations.cvs")).toStdString()); + m_NavigationStepTimer->SetOutputFileName( + QString(m_ExperimentResultsSubDirectory + QDir::separator() + QString("durations.cvs")).toStdString()); m_NavigationStepTimer->SetActiveIndex(0, m_NavigationSteps.at(0)->GetTitle().toStdString()); ui->finishExperimentButton->setEnabled(true); ui->startExperimentButton->setDisabled(true); // initialize and register logging backend QString loggingFilename = m_ExperimentResultsSubDirectory + QDir::separator() + "logging.txt"; m_LoggingBackend.SetOutputFileName(loggingFilename.toStdString()); mbilog::RegisterBackend(&m_LoggingBackend); // initialize and start navigation data recorder form xml recording m_NavigationDataRecorder->StartRecording(); m_IsExperimentRunning = true; m_ImageAndNavigationDataLoggingTimer->start(1000); // (re)start experiment logging and set output file name m_ExperimentLogging->Reset(); - m_ExperimentLogging->SetFileName(QString(m_ExperimentResultsSubDirectory + QDir::separator() + "experiment-logging.xml").toStdString()); + m_ExperimentLogging->SetFileName( + QString(m_ExperimentResultsSubDirectory + QDir::separator() + "experiment-logging.xml").toStdString()); } } } void USNavigationMarkerPlacement::OnFinishExperiment() { this->WaitCursorOn(); MITK_INFO("USNavigationLogging") << "Experiment finished!"; - MITK_INFO("USNavigationLogging") << "Position/Orientation of needle tip: " << (dynamic_cast(m_CombinedModality->GetTrackingDevice()->GetOutput(0)))->GetPosition(); - MITK_INFO("USNavigationLogging") << "Position of target: " << m_TargetNodeDisplacementFilter->GetRawDisplacementNavigationData(0)->GetPosition(); + MITK_INFO("USNavigationLogging") + << "Position/Orientation of needle tip: " + << (dynamic_cast(m_CombinedModality->GetTrackingDevice()->GetOutput(0)))->GetPosition(); + MITK_INFO("USNavigationLogging") + << "Position of target: " << m_TargetNodeDisplacementFilter->GetRawDisplacementNavigationData(0)->GetPosition(); MITK_INFO("USNavigationLogging") << "Total duration: " << m_NavigationStepTimer->GetTotalDuration(); ui->navigationProcessWidget->FinishCurrentNavigationStep(); m_ImageAndNavigationDataLoggingTimer->stop(); ui->runningLabel->setPixmap(m_IconNotRunning); ui->navigationProcessWidget->EnableInteraction(false); m_NavigationStepTimer->Stop(); // make sure that the navigation process will be start from beginning at the // next experiment ui->navigationProcessWidget->ResetNavigationProcess(); ui->finishExperimentButton->setDisabled(true); ui->startExperimentButton->setEnabled(true); MITK_INFO("USNavigationLogging") << "Writing logging data to " << m_ExperimentResultsSubDirectory.toStdString(); // save ultrasound images to the file system QDir(m_ExperimentResultsSubDirectory).mkdir("ImageStream"); m_USImageLoggingFilter->Update(); m_USImageLoggingFilter->SetImageFilesExtension(".jpg"); - m_USImageLoggingFilter->SaveImages(QString(m_ExperimentResultsSubDirectory + QDir::separator() + "ImageStream" + QDir::separator()).toStdString()); + m_USImageLoggingFilter->SaveImages( + QString(m_ExperimentResultsSubDirectory + QDir::separator() + "ImageStream" + QDir::separator()).toStdString()); m_USImageLoggingFilter = mitk::USImageLoggingFilter::New(); m_NavigationDataRecorder->StopRecording(); // Write data to csv and xml file - mitk::IOUtil::SaveBaseData(m_NavigationDataRecorder->GetNavigationDataSet(), (QString(m_ExperimentResultsSubDirectory + QDir::separator() + "navigation-data.xml").toStdString().c_str())); - mitk::IOUtil::SaveBaseData(m_NavigationDataRecorder->GetNavigationDataSet(), (QString(m_ExperimentResultsSubDirectory + QDir::separator() + "navigation-data.csv").toStdString().c_str())); - - //write logged navigation data messages to separate file + mitk::IOUtil::SaveBaseData( + m_NavigationDataRecorder->GetNavigationDataSet(), + (QString(m_ExperimentResultsSubDirectory + QDir::separator() + "navigation-data.xml").toStdString().c_str())); + mitk::IOUtil::SaveBaseData( + m_NavigationDataRecorder->GetNavigationDataSet(), + (QString(m_ExperimentResultsSubDirectory + QDir::separator() + "navigation-data.csv").toStdString().c_str())); + + // write logged navigation data messages to separate file std::stringstream csvNavigationMessagesFilename; - csvNavigationMessagesFilename << m_ExperimentResultsSubDirectory.toStdString() << QDir::separator().toLatin1() << "CSVNavigationMessagesLogFile.csv"; - MITK_INFO("USNavigationLogging") << "Writing logged navigation messages to separate csv file: " << csvNavigationMessagesFilename.str(); + csvNavigationMessagesFilename << m_ExperimentResultsSubDirectory.toStdString() << QDir::separator().toLatin1() + << "CSVNavigationMessagesLogFile.csv"; + MITK_INFO("USNavigationLogging") << "Writing logged navigation messages to separate csv file: " + << csvNavigationMessagesFilename.str(); m_LoggingBackend.WriteCSVFileWithNavigationMessages(csvNavigationMessagesFilename.str()); mbilog::UnregisterBackend(&m_LoggingBackend); m_IsExperimentRunning = false; m_ImageAndNavigationDataLoggingTimer->stop(); m_CombinedModality = 0; // reset scene number for next experiment m_SceneNumber = 1; this->WaitCursorOff(); MITK_INFO("USNavigationLogging") << "Finished!"; } -void USNavigationMarkerPlacement::OnCombinedModalityChanged(itk::SmartPointer combinedModality) +void USNavigationMarkerPlacement::OnCombinedModalityChanged( + itk::SmartPointer combinedModality) { // remove old listener for ultrasound device changes if (m_CombinedModality.IsNotNull() && m_CombinedModality->GetUltrasoundDevice().IsNotNull()) { m_CombinedModality->GetUltrasoundDevice()->RemovePropertyChangedListener(m_ListenerDeviceChanged); } m_CombinedModality = combinedModality; m_ReinitAlreadyDone = false; // add a listener for ultrasound device changes if (m_CombinedModality.IsNotNull() && m_CombinedModality->GetUltrasoundDevice().IsNotNull()) { m_CombinedModality->GetUltrasoundDevice()->AddPropertyChangedListener(m_ListenerDeviceChanged); } // update navigation data recorder for using the new combined modality mitk::NavigationDataSource::Pointer navigationDataSource = combinedModality->GetNavigationDataSource(); m_NavigationDataRecorder->ConnectTo(navigationDataSource); m_NavigationDataRecorder->ResetRecording(); // TODO check for correct connection // for (unsigned int n = 0; n < navigationDataSource->GetNumberOfIndexedOutputs(); ++n) // { // m_NavigationDataRecorder->AddNavigationData(navigationDataSource->GetOutput(n)); // } // update ultrasound image logging filter for using the new combined modality mitk::USDevice::Pointer ultrasoundImageSource = combinedModality->GetUltrasoundDevice(); for (unsigned int n = 0; n < ultrasoundImageSource->GetNumberOfIndexedOutputs(); ++n) { m_USImageLoggingFilter->SetInput(n, ultrasoundImageSource->GetOutput(n)); } // update ablation zone filter for using the new combined modality for (unsigned int n = 0; n < navigationDataSource->GetNumberOfIndexedOutputs(); ++n) { m_AblationZonesDisplacementFilter->SetInput(n, navigationDataSource->GetOutput(n)); } m_AblationZonesDisplacementFilter->SelectInput(m_MarkerIndex); // make sure that a reinit is done for the new images this->ReinitOnImage(); } void USNavigationMarkerPlacement::OnSettingsChanged(itk::SmartPointer settings) { std::string applicationName; if (!settings->GetStringProperty("settings.application", applicationName)) { // set default application if the string property is not available applicationName = "Marker Placement"; } // create navigation step widgets according to the selected application if (applicationName != m_CurrentApplicationName) { m_CurrentApplicationName = applicationName; QmitkUSNavigationProcessWidget::NavigationStepVector navigationSteps; if (applicationName == "Punction") { - QmitkUSNavigationStepCombinedModality* stepCombinedModality = - new QmitkUSNavigationStepCombinedModality(m_Parent); - QmitkUSNavigationStepTumourSelection* stepTumourSelection = - new QmitkUSNavigationStepTumourSelection(m_Parent); + QmitkUSNavigationStepCombinedModality *stepCombinedModality = new QmitkUSNavigationStepCombinedModality(m_Parent); + QmitkUSNavigationStepTumourSelection *stepTumourSelection = new QmitkUSNavigationStepTumourSelection(m_Parent); stepTumourSelection->SetTargetSelectionOptional(true); m_TargetNodeDisplacementFilter = stepTumourSelection->GetTumourNodeDisplacementFilter(); - QmitkUSNavigationStepZoneMarking* stepZoneMarking = - new QmitkUSNavigationStepZoneMarking(m_Parent); - QmitkUSNavigationStepPunctuationIntervention* stepIntervention = + QmitkUSNavigationStepZoneMarking *stepZoneMarking = new QmitkUSNavigationStepZoneMarking(m_Parent); + QmitkUSNavigationStepPunctuationIntervention *stepIntervention = new QmitkUSNavigationStepPunctuationIntervention(m_Parent); connect(stepIntervention, SIGNAL(AddAblationZoneClicked(int)), this, SLOT(OnAddAblationZone(int))); connect(stepIntervention, SIGNAL(AblationZoneChanged(int, int)), this, SLOT(OnChangeAblationZone(int, int))); m_NavigationStepNames = std::vector(); navigationSteps.push_back(stepCombinedModality); m_NavigationStepNames.push_back("Combined Modality Initialization"); navigationSteps.push_back(stepTumourSelection); m_NavigationStepNames.push_back("Target Selection"); navigationSteps.push_back(stepZoneMarking); m_NavigationStepNames.push_back("Critical Structure Marking"); navigationSteps.push_back(stepIntervention); m_NavigationStepNames.push_back("Intervention"); } else if (applicationName == "Marker Placement") { - QmitkUSNavigationStepCombinedModality* stepCombinedModality = - new QmitkUSNavigationStepCombinedModality(m_Parent); - QmitkUSNavigationStepTumourSelection* stepTumourSelection = - new QmitkUSNavigationStepTumourSelection(m_Parent); + QmitkUSNavigationStepCombinedModality *stepCombinedModality = new QmitkUSNavigationStepCombinedModality(m_Parent); + QmitkUSNavigationStepTumourSelection *stepTumourSelection = new QmitkUSNavigationStepTumourSelection(m_Parent); m_TargetNodeDisplacementFilter = stepTumourSelection->GetTumourNodeDisplacementFilter(); - QmitkUSNavigationStepZoneMarking* stepZoneMarking = - new QmitkUSNavigationStepZoneMarking(m_Parent); - QmitkUSNavigationStepPlacementPlanning* stepPlacementPlanning = + QmitkUSNavigationStepZoneMarking *stepZoneMarking = new QmitkUSNavigationStepZoneMarking(m_Parent); + QmitkUSNavigationStepPlacementPlanning *stepPlacementPlanning = new QmitkUSNavigationStepPlacementPlanning(m_Parent); - QmitkUSNavigationStepMarkerIntervention* stepMarkerIntervention = + QmitkUSNavigationStepMarkerIntervention *stepMarkerIntervention = new QmitkUSNavigationStepMarkerIntervention(m_Parent); m_NavigationStepNames = std::vector(); navigationSteps.push_back(stepCombinedModality); m_NavigationStepNames.push_back("Combined Modality Initialization"); navigationSteps.push_back(stepTumourSelection); m_NavigationStepNames.push_back("Target Selection"); navigationSteps.push_back(stepZoneMarking); m_NavigationStepNames.push_back("Critical Structure Marking"); navigationSteps.push_back(stepPlacementPlanning); m_NavigationStepNames.push_back("Placement Planning"); navigationSteps.push_back(stepMarkerIntervention); m_NavigationStepNames.push_back("Marker Intervention"); } // set navigation step widgets to the process widget ui->navigationProcessWidget->SetNavigationSteps(navigationSteps); for (QmitkUSNavigationProcessWidget::NavigationStepIterator it = m_NavigationSteps.begin(); - it != m_NavigationSteps.end(); ++it) + it != m_NavigationSteps.end(); + ++it) { delete *it; } m_NavigationSteps.clear(); m_NavigationSteps = navigationSteps; } // initialize gui according to the experiment mode setting bool experimentMode = false; settings->GetBoolProperty("settings.experiment-mode", experimentMode); ui->startExperimentButton->setVisible(experimentMode); ui->finishExperimentButton->setVisible(experimentMode); ui->runningLabel->setVisible(experimentMode); if (experimentMode && !m_IsExperimentRunning) { ui->navigationProcessWidget->ResetNavigationProcess(); ui->navigationProcessWidget->EnableInteraction(false); ui->runningLabel->setPixmap(m_IconNotRunning); } else if (!experimentMode) { - if (m_IsExperimentRunning) { this->OnFinishExperiment(); } + if (m_IsExperimentRunning) + { + this->OnFinishExperiment(); + } ui->navigationProcessWidget->EnableInteraction(true); } // get the results directory from the settings and use home directory if // there is no results directory configured std::string resultsDirectory; if (settings->GetStringProperty("settings.experiment-results-directory", resultsDirectory)) { m_ResultsDirectory = QString::fromStdString(resultsDirectory); } else { m_ResultsDirectory = QDir::homePath(); } // make sure that the results directory exists QDir resultsDirectoryQDir = QDir(m_ResultsDirectory); if (!resultsDirectoryQDir.exists()) { resultsDirectoryQDir.mkpath(m_ResultsDirectory); } MITK_INFO << "Results Directory: " << m_ResultsDirectory.toStdString(); } void USNavigationMarkerPlacement::OnActiveNavigationStepChanged(int index) { // update navigation step timer each time the active navigation step changes m_NavigationStepTimer->SetActiveIndex(index, m_NavigationSteps.at(index)->GetTitle().toStdString()); - if (m_NavigationStepNames.size() <= index) { MITK_INFO("USNavigationLogging") << "Someting went wrong: unknown navigation step!"; } - else { MITK_INFO("USNavigationLogging") << "Navigation step finished/changed, next step: " << this->m_NavigationStepNames.at(index).toStdString() << "; duration until now: " << m_NavigationStepTimer->GetTotalDuration(); } + if (m_NavigationStepNames.size() <= index) + { + MITK_INFO("USNavigationLogging") << "Someting went wrong: unknown navigation step!"; + } + else + { + MITK_INFO("USNavigationLogging") << "Navigation step finished/changed, next step: " + << this->m_NavigationStepNames.at(index).toStdString() + << "; duration until now: " << m_NavigationStepTimer->GetTotalDuration(); + } } void USNavigationMarkerPlacement::OnIntermediateResultProduced(const itk::SmartPointer resultsNode) { // intermediate results only matter during an experiment - if (!m_IsExperimentRunning) { return; } + if (!m_IsExperimentRunning) + { + return; + } this->WaitCursorOn(); // set results node to the experiment logging (for saving contents to the // file system) m_ExperimentLogging->SetResult(resultsNode); std::string resultsName; if (!resultsNode->GetName(resultsName)) { MITK_WARN << "Could not get name of current results node."; return; } // save the mitk scene - std::string scenefile = QString(m_ExperimentResultsSubDirectory + QDir::separator() - + QString("Scene %1 - ").arg(m_SceneNumber++, 2, 10, QChar('0')) - + QString::fromStdString(resultsName).replace(":", "_") + ".mitk").toStdString(); + std::string scenefile = QString(m_ExperimentResultsSubDirectory + QDir::separator() + + QString("Scene %1 - ").arg(m_SceneNumber++, 2, 10, QChar('0')) + + QString::fromStdString(resultsName).replace(":", "_") + ".mitk") + .toStdString(); MITK_INFO << "Saving Scene File: " << scenefile; mitk::SceneIO::Pointer sceneIO = mitk::SceneIO::New(); mitk::NodePredicateNot::Pointer isNotHelperObject = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(true))); mitk::DataStorage::SetOfObjects::ConstPointer nodesToBeSaved = this->GetDataStorage()->GetSubset(isNotHelperObject); this->Convert2DImagesTo3D(nodesToBeSaved); sceneIO->SaveScene(nodesToBeSaved, this->GetDataStorage(), scenefile); this->WaitCursorOff(); } void USNavigationMarkerPlacement::ReinitOnImage() { if (!m_ReinitAlreadyDone && m_CombinedModality.IsNotNull()) { // make sure that the output is already calibrated correctly // (if the zoom level was changed recently) m_CombinedModality->Modified(); m_CombinedModality->Update(); mitk::Image::Pointer image = m_CombinedModality->GetOutput(); if (image.IsNotNull() && image->IsInitialized()) { // make a reinit on the ultrasound image - mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart(); + mitk::IRenderWindowPart *renderWindow = this->GetRenderWindowPart(); if (renderWindow != NULL && image->GetTimeGeometry()->IsValid()) { renderWindow->GetRenderingManager()->InitializeViews( image->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true); renderWindow->GetRenderingManager()->RequestUpdateAll(); } this->RequestRenderWindowUpdate(); m_ReinitAlreadyDone = true; } } } void USNavigationMarkerPlacement::Convert2DImagesTo3D(mitk::DataStorage::SetOfObjects::ConstPointer nodes) { - for (mitk::DataStorage::SetOfObjects::ConstIterator it = nodes->Begin(); - it != nodes->End(); ++it) + for (mitk::DataStorage::SetOfObjects::ConstIterator it = nodes->Begin(); it != nodes->End(); ++it) { if (it->Value()->GetData() && strcmp(it->Value()->GetData()->GetNameOfClass(), "Image") == 0) { // convert image to 3d image if it is 2d at the moment - mitk::Image::Pointer image = dynamic_cast(it->Value()->GetData()); - if (image.IsNotNull() && image->GetDimension() == 2 - && !image->GetGeometry()->Is2DConvertable()) + mitk::Image::Pointer image = dynamic_cast(it->Value()->GetData()); + if (image.IsNotNull() && image->GetDimension() == 2 && !image->GetGeometry()->Is2DConvertable()) { mitk::Convert2Dto3DImageFilter::Pointer convert2DTo3DImageFilter = mitk::Convert2Dto3DImageFilter::New(); convert2DTo3DImageFilter->SetInput(image); convert2DTo3DImageFilter->Update(); it->Value()->SetData(convert2DTo3DImageFilter->GetOutput()); } } } } void USNavigationMarkerPlacement::CreateOverlays() { // initialize warning overlay (and do not display it, yet) m_WarnOverlay->SetText("Warning: No calibration available for current depth."); // set position and font size for the text overlay // (nonesense postition as a layouter is used, but it ignored // the overlay without setting a position here) mitk::Point2D overlayPosition; overlayPosition.SetElement(0, -50.0f); overlayPosition.SetElement(1, -50.0f); m_WarnOverlay->SetPosition2D(overlayPosition); m_WarnOverlay->SetFontSize(22); m_WarnOverlay->SetColor(1, 0, 0); // overlay should be red - - mitk::BaseRenderer* renderer = mitk::BaseRenderer::GetByName("stdmulti.widget1"); - if (renderer) - { - m_OverlayManager = renderer->GetOverlayManager(); - - //add layouter if it doesn't exist yet - if (!m_OverlayManager->GetLayouter(renderer, mitk::Overlay2DLayouter::STANDARD_2D_TOP())) - { - m_OverlayManager->AddLayouter(mitk::Overlay2DLayouter::CreateLayouter(mitk::Overlay2DLayouter::STANDARD_2D_TOP(), renderer).GetPointer()); - } - - /* causes a crash when closing the view and opening it again, so deactivated at the moment TODO!! - //set layouter to warn overlay - m_OverlayManager->SetLayouter(m_WarnOverlay.GetPointer(), mitk::Overlay2DLayouter::STANDARD_2D_TOP(), renderer); - */ - } } diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.h b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.h index 3120d86164..f43ddf3e90 100644 --- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.h +++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.h @@ -1,187 +1,190 @@ /*=================================================================== 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 USNAVIGATIONMARKERPLACEMENT_H #define USNAVIGATIONMARKERPLACEMENT_H #include -#include -#include "Widgets/QmitkUSNavigationProcessWidget.h" #include "IO/mitkUSNavigationLoggingBackend.h" -#include "mitkUSImageLoggingFilter.h" +#include "Widgets/QmitkUSNavigationProcessWidget.h" #include "mitkNavigationDataRecorder.h" #include "mitkNodeDisplacementFilter.h" +#include "mitkUSImageLoggingFilter.h" #include -#include -#include +#include +#include -namespace itk { - template class SmartPointer; +namespace itk +{ + template + class SmartPointer; } -namespace mitk { +namespace mitk +{ class USNavigationStepTimer; class USNavigationExperimentLogging; } -namespace Ui { +namespace Ui +{ class USNavigationMarkerPlacement; } class QmitkUSAbstractNavigationStep; class QmitkStdMultiWidget; class QTimer; class QSignalMapper; /** * \brief View for navigated marker placement using the combined modality. * This view utilizes the QmitkUSNavigationProcessWidget to do the navigation * process. It can be switched between widgets for marker placement and widgets * for punctuation. * * An experiment mode allows for logging results, durations and the ultrasound * images. */ class USNavigationMarkerPlacement : public QmitkAbstractView { Q_OBJECT - protected slots: +protected slots: /** * \brief Called periodically to update the rendering. * The standard multi widget is changed to fit the navigation process once it * is available and a reinit on the ultrasound image is done for a new image * node. */ void OnTimeout(); /** * \brief Called periodically during an experiment for logging the ultrasound images. */ void OnImageAndNavigationDataLoggingTimeout(); /** * \brief Initializes anything neccessary for an experiment. * The user is asked for a directory for storing the results and the logging * is started. */ void OnStartExperiment(); /** * \brief Stops logging and saves everything to the file system. */ void OnFinishExperiment(); void OnCombinedModalityChanged(itk::SmartPointer); /** * \brief Switches the navigation step widgets if the navigation application was changed. */ void OnSettingsChanged(itk::SmartPointer); /** * \brief Updates the timer for the navigation steps durations every time the active navigation step changes. */ void OnActiveNavigationStepChanged(int); /** * \brief The data node is given to the experiment logging and scene is saved to the file system. */ void OnIntermediateResultProduced(const itk::SmartPointer); void OnAddAblationZone(int size); void OnChangeAblationZone(int id, int newSize); public: - static const char* DATANAME_TUMOUR; - static const char* DATANAME_TARGETSURFACE; - static const char* DATANAME_ZONES; - static const char* DATANAME_TARGETS; - static const char* DATANAME_TARGETS_PATHS; - static const char* DATANAME_REACHED_TARGETS; + static const char *DATANAME_TUMOUR; + static const char *DATANAME_TARGETSURFACE; + static const char *DATANAME_ZONES; + static const char *DATANAME_TARGETS; + static const char *DATANAME_TARGETS_PATHS; + static const char *DATANAME_REACHED_TARGETS; explicit USNavigationMarkerPlacement(); ~USNavigationMarkerPlacement(); virtual void CreateQtPartControl(QWidget *parent); static const std::string VIEW_ID; - void OnCombinedModalityPropertyChanged(const std::string&, const std::string&); + void OnCombinedModalityPropertyChanged(const std::string &, const std::string &); protected: /** * \brief A reinit on the ultrasound image is performed every time the view gets the focus. */ virtual void SetFocus(); /** * \brief Helper function which performs a reinit on the ultrasound image. */ void ReinitOnImage(); /** * \brief Helper function for being able to serialize the 2d ultrasound image. */ void Convert2DImagesTo3D(mitk::DataStorage::SetOfObjects::ConstPointer nodes); void CreateOverlays(); - QWidget* m_Parent; + QWidget *m_Parent; QmitkUSNavigationProcessWidget::NavigationStepVector m_NavigationSteps; - QTimer* m_UpdateTimer; - QTimer* m_ImageAndNavigationDataLoggingTimer; - QmitkStdMultiWidget* m_StdMultiWidget; - itk::SmartPointer m_CombinedModality; - bool m_ReinitAlreadyDone; - bool m_IsExperimentRunning; - std::string m_CurrentApplicationName; - - itk::SmartPointer m_NavigationStepTimer; + QTimer *m_UpdateTimer; + QTimer *m_ImageAndNavigationDataLoggingTimer; + QmitkStdMultiWidget *m_StdMultiWidget; + itk::SmartPointer m_CombinedModality; + bool m_ReinitAlreadyDone; + bool m_IsExperimentRunning; + std::string m_CurrentApplicationName; + + itk::SmartPointer m_NavigationStepTimer; itk::SmartPointer m_ExperimentLogging; - QPixmap m_IconRunning; - QPixmap m_IconNotRunning; + QPixmap m_IconRunning; + QPixmap m_IconNotRunning; - QString m_ResultsDirectory; - QString m_ExperimentName; - QString m_ExperimentResultsSubDirectory; - std::vector m_NavigationStepNames; //stores the names of the navigation steps which are currently used (for logging purposes) + QString m_ResultsDirectory; + QString m_ExperimentName; + QString m_ExperimentResultsSubDirectory; + std::vector + m_NavigationStepNames; // stores the names of the navigation steps which are currently used (for logging purposes) - mitk::USNavigationLoggingBackend m_LoggingBackend; - mitk::USImageLoggingFilter::Pointer m_USImageLoggingFilter; - mitk::NavigationDataRecorder::Pointer m_NavigationDataRecorder; //records navigation data files - mitk::NodeDisplacementFilter::Pointer m_TargetNodeDisplacementFilter; - mitk::NodeDisplacementFilter::Pointer m_AblationZonesDisplacementFilter; - std::vector m_AblationZonesVector; + mitk::USNavigationLoggingBackend m_LoggingBackend; + mitk::USImageLoggingFilter::Pointer m_USImageLoggingFilter; + mitk::NavigationDataRecorder::Pointer m_NavigationDataRecorder; // records navigation data files + mitk::NodeDisplacementFilter::Pointer m_TargetNodeDisplacementFilter; + mitk::NodeDisplacementFilter::Pointer m_AblationZonesDisplacementFilter; + std::vector m_AblationZonesVector; int m_NeedleIndex; int m_MarkerIndex; - int m_SceneNumber; + int m_SceneNumber; - itk::SmartPointer m_OverlayManager; - itk::SmartPointer m_WarnOverlay; + itk::SmartPointer m_WarnOverlay; private: - mitk::MessageDelegate2 m_ListenerDeviceChanged; + mitk::MessageDelegate2 m_ListenerDeviceChanged; Ui::USNavigationMarkerPlacement *ui; }; #endif // USNAVIGATIONMARKERPLACEMENT_H