diff --git a/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.cpp b/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.cpp index 8275fa8aca..ad033b8a4f 100644 --- a/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.cpp +++ b/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.cpp @@ -1,442 +1,533 @@ /*=================================================================== 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 "QmitkToFPointSetWidget.h" +#include #include #include const std::string QmitkToFPointSetWidget::VIEW_ID = "org.mitk.views.qmitktofpointsetwidget"; -QmitkToFPointSetWidget::QmitkToFPointSetWidget(QWidget* parent, Qt::WindowFlags f): QWidget(parent, f) +QmitkToFPointSetWidget::QmitkToFPointSetWidget(QWidget* parent, Qt::WindowFlags f) : QWidget(parent, f) , m_DataStorage(nullptr) , m_DistanceImage(nullptr) , m_CameraIntrinsics(nullptr) -, m_VtkTextActor(nullptr) -, m_ForegroundRenderer1(nullptr) -, m_ForegroundRenderer2(nullptr) -, m_ForegroundRenderer3(nullptr) -, m_RenderWindow1(nullptr) -, m_RenderWindow2(nullptr) -, m_RenderWindow3(nullptr) +, m_TextAnnotationAxial(nullptr) +, m_TextAnnotationSagittal(nullptr) +, m_TextAnnotationCoronal(nullptr) +, m_TextAnnotation3D(nullptr) +, m_RendererAxial(nullptr) +, m_RendererSagittal(nullptr) +, m_RendererCoronal(nullptr) +, m_Renderer3D(nullptr) , m_MeasurementPointSet2D(nullptr) , m_MeasurementPointSet3DNode(nullptr) , m_PointSet2D(nullptr) , m_PointSet3DNode(nullptr) , m_PointSetInteractor(nullptr) , m_MeasurementPointSetInteractor(nullptr) , m_MeasurementPointSetChangedObserverTag(0) , m_PointSetChangedObserverTag(0) , m_WindowHeight(0) { m_Controls = nullptr; CreateQtPartControl(this); } QmitkToFPointSetWidget::~QmitkToFPointSetWidget() { this->CleanUpWidget(); } void QmitkToFPointSetWidget::CreateQtPartControl(QWidget *parent) { if (!m_Controls) { // create GUI widgets m_Controls = new Ui::QmitkToFPointSetWidgetControls; m_Controls->setupUi(parent); this->CreateConnections(); } } void QmitkToFPointSetWidget::CreateConnections() { - if ( m_Controls ) + if (m_Controls) { - connect( (QObject*)(m_Controls->measureButton), SIGNAL(clicked()),(QObject*) this, SLOT(OnMeasurement()) ); - connect( (QObject*)(m_Controls->pointSetButton), SIGNAL(clicked()),(QObject*) this, SLOT(OnPointSet()) ); + connect((QObject*)(m_Controls->measureButton), SIGNAL(clicked()), (QObject*) this, SLOT(OnMeasurement())); + connect((QObject*)(m_Controls->pointSetButton), SIGNAL(clicked()), (QObject*) this, SLOT(OnPointSet())); } } void QmitkToFPointSetWidget::InitializeWidget(QHash renderWindowHashMap, mitk::DataStorage::Pointer dataStorage, mitk::CameraIntrinsics::Pointer cameraIntrinsics) { // initialize members m_CameraIntrinsics = cameraIntrinsics; m_DataStorage = dataStorage; - // m_RenderWindowPart = renderWindowPart; - m_RenderWindow1 = renderWindowHashMap.value("axial")->GetRenderWindow(); - m_RenderWindow2 = renderWindowHashMap.value("sagittal")->GetRenderWindow(); - m_RenderWindow3 = renderWindowHashMap.value("coronal")->GetRenderWindow(); - m_RenderWindow4 = renderWindowHashMap.value("3d")->GetRenderWindow(); - if ((m_RenderWindow1 != nullptr) && (m_RenderWindow2 != nullptr) && (m_RenderWindow3 != nullptr) && (m_RenderWindow4 != nullptr) && (dataStorage.IsNotNull())) + // Get renderers of render windows + m_RendererAxial = renderWindowHashMap.value("axial")->GetRenderer(); + m_RendererSagittal = renderWindowHashMap.value("sagittal")->GetRenderer(); + m_RendererCoronal = renderWindowHashMap.value("coronal")->GetRenderer(); + m_Renderer3D = renderWindowHashMap.value("3d")->GetRenderer(); + if ((m_RendererAxial.IsNotNull()) && (m_RendererSagittal.IsNotNull()) && (m_RendererCoronal.IsNotNull()) && (m_Renderer3D.IsNotNull()) && (dataStorage.IsNotNull())) { // enable buttons m_Controls->pointSetButton->setEnabled(true); m_Controls->measureButton->setEnabled(true); - // initialize overlays - this->m_VtkTextActor = vtkSmartPointer::New(); - this->m_VtkTextActor->SetInput("Choose measurement points with SHIFT+Click"); - m_WindowHeight = renderWindowHashMap.value("axial")->GetRenderer()->GetSizeY(); - this->m_VtkTextActor->SetDisplayPosition(10,m_WindowHeight-30); - this->m_VtkTextActor->GetTextProperty()->SetFontSize(16); - // this->m_VtkTextActor->GetTextProperty()->SetColor(1,0,0); - this->m_VtkTextActor->GetTextProperty()->BoldOn(); - this->m_VtkTextActor->SetVisibility(0); - if (m_ForegroundRenderer1==nullptr) - { - this->m_ForegroundRenderer1 = vtkSmartPointer::New(); - this->m_ForegroundRenderer1->AddActor(m_VtkTextActor); - mitk::VtkLayerController::GetInstance(m_RenderWindow1)->InsertForegroundRenderer(m_ForegroundRenderer1,true); - } - if (m_ForegroundRenderer2==nullptr) - { - this->m_ForegroundRenderer2 = vtkSmartPointer::New(); - this->m_ForegroundRenderer2->AddActor(m_VtkTextActor); - mitk::VtkLayerController::GetInstance(m_RenderWindow2)->InsertForegroundRenderer(m_ForegroundRenderer2,true); - } - if (m_ForegroundRenderer3==nullptr) - { - this->m_ForegroundRenderer3 =vtkSmartPointer::New(); - this->m_ForegroundRenderer3->AddActor(m_VtkTextActor); - mitk::VtkLayerController::GetInstance(m_RenderWindow3)->InsertForegroundRenderer(m_ForegroundRenderer3,true); - } - mitk::DataNode::Pointer measurementPointSet2DNode = dataStorage->GetNamedNode("Measurement PointSet 2D") ; - if(dataStorage->Exists(measurementPointSet2DNode)) + // initialize axial text annotation + m_TextAnnotationAxial = mitk::TextAnnotation2D::New(); + m_TextAnnotationAxial->SetText("Choose measurement points with SHIFT+Click"); + m_TextAnnotationAxial->SetFontSize(16); + m_TextAnnotationAxial->SetColor(1, 0, 0); + m_TextAnnotationAxial->SetOpacity(1); + m_WindowHeight = m_RendererAxial->GetSizeY(); + mitk::Point2D axialAnnotationPosition; + axialAnnotationPosition[0] = 10; + axialAnnotationPosition[0] = m_WindowHeight - 30; + m_TextAnnotationAxial->SetPosition2D(axialAnnotationPosition); + m_TextAnnotationAxial->SetVisibility(false); + // add annotation to axial render window + mitk::LayoutAnnotationRenderer::AddAnnotation(m_TextAnnotationAxial, m_RendererAxial); + // initialize sagittal text annotation + m_TextAnnotationSagittal = mitk::TextAnnotation2D::New(); + m_TextAnnotationSagittal->SetText("Choose measurement points with SHIFT+Click"); + m_TextAnnotationSagittal->SetFontSize(16); + m_TextAnnotationSagittal->SetColor(1, 0, 0); + m_TextAnnotationSagittal->SetOpacity(1); + m_WindowHeight = m_RendererSagittal->GetSizeY(); + mitk::Point2D sagittalAnnotationPosition; + sagittalAnnotationPosition[0] = 10; + sagittalAnnotationPosition[0] = m_WindowHeight - 30; + m_TextAnnotationSagittal->SetPosition2D(sagittalAnnotationPosition); + m_TextAnnotationSagittal->SetVisibility(false); + // add annotation to axial render window + mitk::LayoutAnnotationRenderer::AddAnnotation(m_TextAnnotationSagittal, m_RendererSagittal); + // initialize coronal text annotation + m_TextAnnotationCoronal = mitk::TextAnnotation2D::New(); + m_TextAnnotationCoronal->SetText("Choose measurement points with SHIFT+Click"); + m_TextAnnotationCoronal->SetFontSize(16); + m_TextAnnotationCoronal->SetColor(1, 0, 0); + m_TextAnnotationCoronal->SetOpacity(1); + m_WindowHeight = m_RendererCoronal->GetSizeY(); + mitk::Point2D coronalAnnotationPosition; + coronalAnnotationPosition[0] = 10; + coronalAnnotationPosition[0] = m_WindowHeight - 30; + m_TextAnnotationCoronal->SetPosition2D(coronalAnnotationPosition); + m_TextAnnotationCoronal->SetVisibility(false); + // add annotation to axial render window + mitk::LayoutAnnotationRenderer::AddAnnotation(m_TextAnnotationCoronal, m_RendererCoronal); + // initialize 3D text annotation + m_TextAnnotation3D = mitk::TextAnnotation2D::New(); + m_TextAnnotation3D->SetText("Choose measurement points with SHIFT+Click"); + m_TextAnnotation3D->SetFontSize(16); + m_TextAnnotation3D->SetColor(1, 0, 0); + m_TextAnnotation3D->SetOpacity(1); + m_WindowHeight = m_Renderer3D->GetSizeY(); + mitk::Point2D annotationPosition3D; + annotationPosition3D[0] = 10; + annotationPosition3D[0] = m_WindowHeight - 30; + m_TextAnnotation3D->SetPosition2D(annotationPosition3D); + m_TextAnnotation3D->SetVisibility(false); + // add annotation to axial render window + mitk::LayoutAnnotationRenderer::AddAnnotation(m_TextAnnotation3D, m_Renderer3D); + + //mitk::LayoutAnnotationRenderer::AddAnnotation(m_TextAnnotation, renderWindowHashMap.value("axial")->GetRenderer()); + //mitk::LayoutAnnotationRenderer::AddAnnotation(m_TextAnnotation, renderWindowHashMap.value("coronal")->GetRenderer()); + + //// initialize overlays + //this->m_VtkTextActor = vtkSmartPointer::New(); + //this->m_VtkTextActor->SetInput("Choose measurement points with SHIFT+Click"); + //m_WindowHeight = renderWindowHashMap.value("axial")->GetRenderer()->GetSizeY(); + ////this->m_VtkTextActor->SetDisplayPosition(10, m_WindowHeight - 30); + //this->m_VtkTextActor->SetDisplayPosition(50, 50); + //this->m_VtkTextActor->GetTextProperty()->SetFontSize(16); + ////this->m_VtkTextActor->GetTextProperty()->SetColor(1, 0, 0); + //this->m_VtkTextActor->GetTextProperty()->BoldOn(); + //this->m_VtkTextActor->SetVisibility(1); + //if (m_ForegroundRenderer1==nullptr) + //{ + // this->m_ForegroundRenderer1 = vtkSmartPointer::New(); + // this->m_ForegroundRenderer1->AddActor(m_VtkTextActor); + // mitk::VtkLayerController::GetInstance(m_RenderWindow1)->InsertForegroundRenderer(m_ForegroundRenderer1,true); + //} + //if (m_ForegroundRenderer2==nullptr) + //{ + // this->m_ForegroundRenderer2 = vtkSmartPointer::New(); + // this->m_ForegroundRenderer2->AddActor(m_VtkTextActor); + // mitk::VtkLayerController::GetInstance(m_RenderWindow2)->InsertForegroundRenderer(m_ForegroundRenderer2,true); + //} + //if (m_ForegroundRenderer3==nullptr) + //{ + // this->m_ForegroundRenderer3 =vtkSmartPointer::New(); + // this->m_ForegroundRenderer3->AddActor(m_VtkTextActor); + // mitk::VtkLayerController::GetInstance(m_RenderWindow3)->InsertForegroundRenderer(m_ForegroundRenderer3,true); + //} + + mitk::DataNode::Pointer measurementPointSet2DNode = dataStorage->GetNamedNode("Measurement PointSet 2D"); + if (dataStorage->Exists(measurementPointSet2DNode)) { dataStorage->Remove(measurementPointSet2DNode); } // initialize 2D measurement point set m_MeasurementPointSet2D = mitk::PointSet::New(); measurementPointSet2DNode = mitk::DataNode::New(); measurementPointSet2DNode->SetName("Measurement PointSet 2D"); - measurementPointSet2DNode->SetBoolProperty("helper object",true); - measurementPointSet2DNode->SetBoolProperty("show contour",true); + measurementPointSet2DNode->SetBoolProperty("helper object", true); + measurementPointSet2DNode->SetBoolProperty("show contour", true); measurementPointSet2DNode->SetVisibility(false, renderWindowHashMap.value("3d")->GetRenderer()); measurementPointSet2DNode->SetData(m_MeasurementPointSet2D); dataStorage->Add(measurementPointSet2DNode); m_MeasurementPointSetInteractor = mitk::PointSetDataInteractor::New(); m_MeasurementPointSetInteractor->LoadStateMachine("PointSet.xml"); m_MeasurementPointSetInteractor->SetEventConfig("PointSetConfig.xml"); m_MeasurementPointSetInteractor->SetDataNode(measurementPointSet2DNode); m_MeasurementPointSetInteractor->SetMaxPoints(2); // create observer for m_MeasurementPointSet2D itk::SimpleMemberCommand::Pointer measurementPointSetChangedCommand; measurementPointSetChangedCommand = itk::SimpleMemberCommand::New(); measurementPointSetChangedCommand->SetCallbackFunction(this, &QmitkToFPointSetWidget::MeasurementPointSetChanged); m_MeasurementPointSetChangedObserverTag = m_MeasurementPointSet2D->AddObserver(itk::ModifiedEvent(), measurementPointSetChangedCommand); // initialize 3D measurement PointSet m_MeasurementPointSet3DNode = dataStorage->GetNamedNode("Measurement PointSet 3D"); - if(dataStorage->Exists(m_MeasurementPointSet3DNode)) + if (dataStorage->Exists(m_MeasurementPointSet3DNode)) { dataStorage->Remove(m_MeasurementPointSet3DNode); } m_MeasurementPointSet3DNode = mitk::DataNode::New(); m_MeasurementPointSet3DNode->SetName("Measurement PointSet 3D"); - m_MeasurementPointSet3DNode->SetBoolProperty("helper object",true); - m_MeasurementPointSet3DNode->SetBoolProperty("show contour",true); - m_MeasurementPointSet3DNode->SetFloatProperty("pointsize",5.0f); + m_MeasurementPointSet3DNode->SetBoolProperty("helper object", true); + m_MeasurementPointSet3DNode->SetBoolProperty("show contour", true); + m_MeasurementPointSet3DNode->SetFloatProperty("pointsize", 5.0f); mitk::PointSet::Pointer measurementPointSet3D = mitk::PointSet::New(); m_MeasurementPointSet3DNode->SetData(measurementPointSet3D); dataStorage->Add(m_MeasurementPointSet3DNode); // initialize PointSets - mitk::DataNode::Pointer pointSet2DNode = dataStorage->GetNamedNode("ToF PointSet 2D") ; - if(dataStorage->Exists(pointSet2DNode)) + mitk::DataNode::Pointer pointSet2DNode = dataStorage->GetNamedNode("ToF PointSet 2D"); + if (dataStorage->Exists(pointSet2DNode)) { dataStorage->Remove(pointSet2DNode); } m_PointSet2D = mitk::PointSet::New(); pointSet2DNode = mitk::DataNode::New(); pointSet2DNode->SetName("ToF PointSet 2D"); pointSet2DNode->SetVisibility(false, renderWindowHashMap.value("3d")->GetRenderer()); pointSet2DNode->SetData(m_PointSet2D); dataStorage->Add(pointSet2DNode); m_PointSetInteractor = mitk::PointSetDataInteractor::New(); m_PointSetInteractor->LoadStateMachine("PointSet.xml"); m_PointSetInteractor->SetEventConfig("PointSetConfig.xml"); m_PointSetInteractor->SetDataNode(pointSet2DNode); // create observer for m_MeasurementPointSet2D itk::SimpleMemberCommand::Pointer pointSetChangedCommand; pointSetChangedCommand = itk::SimpleMemberCommand::New(); pointSetChangedCommand->SetCallbackFunction(this, &QmitkToFPointSetWidget::PointSetChanged); m_PointSetChangedObserverTag = m_PointSet2D->AddObserver(itk::ModifiedEvent(), pointSetChangedCommand); // initialize 3D point set mitk::DataNode::Pointer pointSet3DNode = dataStorage->GetNamedNode("ToF PointSet 3D"); - if(dataStorage->Exists(pointSet3DNode)) + if (dataStorage->Exists(pointSet3DNode)) { dataStorage->Remove(pointSet3DNode); } m_PointSet3DNode = mitk::DataNode::New(); m_PointSet3DNode->SetName("ToF PointSet 3D"); - m_PointSet3DNode->SetFloatProperty("pointsize",5.0f); + m_PointSet3DNode->SetFloatProperty("pointsize", 5.0f); mitk::PointSet::Pointer pointSet3D = mitk::PointSet::New(); m_PointSet3DNode->SetData(pointSet3D); dataStorage->Add(m_PointSet3DNode); } } void QmitkToFPointSetWidget::CleanUpWidget() { // toggle button state if (m_Controls->measureButton->isChecked()) { m_Controls->measureButton->setChecked(false); this->OnMeasurement(); } if (m_Controls->pointSetButton->isChecked()) { m_Controls->pointSetButton->setChecked(false); this->OnPointSet(); } // remove observer if (m_MeasurementPointSet2D.IsNotNull()) { m_MeasurementPointSet2D->RemoveObserver(m_MeasurementPointSetChangedObserverTag); } if (m_PointSet2D.IsNotNull()) { m_PointSet2D->RemoveObserver(m_PointSetChangedObserverTag); } -// if (m_DistanceImage.IsNotNull()) -// { -// m_DistanceImage->RemoveObserver(m_DistanceImageChangedObserverTag); -// } - // remove foreground renderer - if (m_ForegroundRenderer1&&m_RenderWindow1) - { - if (mitk::VtkLayerController::GetInstance(m_RenderWindow1)) - { - mitk::VtkLayerController::GetInstance(m_RenderWindow1)->RemoveRenderer(m_ForegroundRenderer1); - } - m_ForegroundRenderer1 = nullptr; - } - if (m_ForegroundRenderer2&&m_RenderWindow2) - { - if (mitk::VtkLayerController::GetInstance(m_RenderWindow2)) - { - mitk::VtkLayerController::GetInstance(m_RenderWindow2)->RemoveRenderer(m_ForegroundRenderer2); - } - m_ForegroundRenderer2 = nullptr; - } - if (m_ForegroundRenderer3&&m_RenderWindow3) - { - if (mitk::VtkLayerController::GetInstance(m_RenderWindow3)) - { - mitk::VtkLayerController::GetInstance(m_RenderWindow3)->RemoveRenderer(m_ForegroundRenderer3); - } - m_ForegroundRenderer3 = nullptr; - } + // if (m_DistanceImage.IsNotNull()) + // { + // m_DistanceImage->RemoveObserver(m_DistanceImageChangedObserverTag); + // } + //// remove foreground renderer + //if (m_ForegroundRenderer1&&m_RenderWindow1) + //{ + // if (mitk::VtkLayerController::GetInstance(m_RenderWindow1)) + // { + // mitk::VtkLayerController::GetInstance(m_RenderWindow1)->RemoveRenderer(m_ForegroundRenderer1); + // } + // m_ForegroundRenderer1 = nullptr; + //} + //if (m_ForegroundRenderer2&&m_RenderWindow2) + //{ + // if (mitk::VtkLayerController::GetInstance(m_RenderWindow2)) + // { + // mitk::VtkLayerController::GetInstance(m_RenderWindow2)->RemoveRenderer(m_ForegroundRenderer2); + // } + // m_ForegroundRenderer2 = nullptr; + //} + //if (m_ForegroundRenderer3&&m_RenderWindow3) + //{ + // if (mitk::VtkLayerController::GetInstance(m_RenderWindow3)) + // { + // mitk::VtkLayerController::GetInstance(m_RenderWindow3)->RemoveRenderer(m_ForegroundRenderer3); + // } + // m_ForegroundRenderer3 = nullptr; + //} if (mitk::RenderingManager::GetInstance()) { mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } } void QmitkToFPointSetWidget::SetDistanceImage(mitk::Image::Pointer distanceImage) { -// // remove existing observer -// if (m_DistanceImage.IsNotNull()) -// { -// m_DistanceImage->RemoveObserver(m_DistanceImageChangedObserverTag); -// } + // // remove existing observer + // if (m_DistanceImage.IsNotNull()) + // { + // m_DistanceImage->RemoveObserver(m_DistanceImageChangedObserverTag); + // } m_DistanceImage = distanceImage; -// // create observer for m_DistanceImage -// itk::SimpleMemberCommand::Pointer distanceImageChangedCommand; -// distanceImageChangedCommand = itk::SimpleMemberCommand::New(); -// distanceImageChangedCommand->SetCallbackFunction(this, &QmitkToFPointSetWidget::MeasurementPointSetChanged); -// m_DistanceImageChangedObserverTag = m_DistanceImage->AddObserver(itk::ModifiedEvent(), distanceImageChangedCommand); + // // create observer for m_DistanceImage + // itk::SimpleMemberCommand::Pointer distanceImageChangedCommand; + // distanceImageChangedCommand = itk::SimpleMemberCommand::New(); + // distanceImageChangedCommand->SetCallbackFunction(this, &QmitkToFPointSetWidget::MeasurementPointSetChanged); + // m_DistanceImageChangedObserverTag = m_DistanceImage->AddObserver(itk::ModifiedEvent(), distanceImageChangedCommand); } void QmitkToFPointSetWidget::SetCameraIntrinsics(mitk::CameraIntrinsics::Pointer cameraIntrinsics) { m_CameraIntrinsics = cameraIntrinsics; } void QmitkToFPointSetWidget::OnMeasurement() { // always show 2D PointSet in foreground mitk::DataNode::Pointer pointSetNode = m_DataStorage->GetNamedNode("Measurement PointSet 2D"); if (pointSetNode.IsNotNull()) { - pointSetNode->SetIntProperty("layer",100); + pointSetNode->SetIntProperty("layer", 100); } if (m_Controls->measureButton->isChecked()) { // disable point set interaction if (m_Controls->pointSetButton->isChecked()) { m_Controls->pointSetButton->setChecked(false); // remove interactor m_PointSetInteractor->EnableInteraction(false); } // show overlays - m_VtkTextActor->SetVisibility(1); - this->m_VtkTextActor->SetInput("Choose measurement points with SHIFT+Click"); + m_TextAnnotationAxial->SetText("Choose measurement points with SHIFT+Click"); + m_TextAnnotationSagittal->SetText("Choose measurement points with SHIFT+Click"); + m_TextAnnotationCoronal->SetText("Choose measurement points with SHIFT+Click"); + m_TextAnnotation3D->SetText("Choose measurement points with SHIFT+Click"); + m_TextAnnotationAxial->SetVisibility(true); + m_TextAnnotationSagittal->SetVisibility(true); + m_TextAnnotationCoronal->SetVisibility(true); + m_TextAnnotation3D->SetVisibility(true); // enable interactor m_MeasurementPointSetInteractor->EnableInteraction(true); // initial update of measurement this->MeasurementPointSetChanged(); } else { // hide overlays - m_VtkTextActor->SetVisibility(0); + m_TextAnnotationAxial->SetVisibility(false); + m_TextAnnotationSagittal->SetVisibility(false); + m_TextAnnotationCoronal->SetVisibility(false); + m_TextAnnotation3D->SetVisibility(false); // disable interactor m_MeasurementPointSetInteractor->EnableInteraction(false); } } void QmitkToFPointSetWidget::OnPointSet() { // always show 2D PointSet in foreground mitk::DataNode::Pointer pointSetNode = m_DataStorage->GetNamedNode("ToF PointSet 2D"); if (pointSetNode.IsNotNull()) { - pointSetNode->SetIntProperty("layer",100); + pointSetNode->SetIntProperty("layer", 100); } if (m_Controls->pointSetButton->isChecked()) { // disable measurement if (m_Controls->measureButton->isChecked()) { m_Controls->measureButton->setChecked(false); // remove interactor m_MeasurementPointSetInteractor->EnableInteraction(false); } // show overlays - m_VtkTextActor->SetVisibility(1); - this->m_VtkTextActor->SetInput("Choose points with SHIFT+Click"); + m_TextAnnotationAxial->SetText("Choose points with SHIFT+Click"); + m_TextAnnotationSagittal->SetText("Choose points with SHIFT+Click"); + m_TextAnnotationCoronal->SetText("Choose points with SHIFT+Click"); + m_TextAnnotation3D->SetText("Choose points with SHIFT+Click"); + m_TextAnnotationAxial->SetVisibility(true); + m_TextAnnotationSagittal->SetVisibility(true); + m_TextAnnotationCoronal->SetVisibility(true); + m_TextAnnotation3D->SetVisibility(true); // enable interactor m_PointSetInteractor->EnableInteraction(true); // initial update of PointSet this->PointSetChanged(); } else { // hide overlays - m_VtkTextActor->SetVisibility(0); + m_TextAnnotationAxial->SetVisibility(false); + m_TextAnnotationSagittal->SetVisibility(false); + m_TextAnnotationCoronal->SetVisibility(false); + m_TextAnnotation3D->SetVisibility(false); // disable interactor m_PointSetInteractor->EnableInteraction(false); } } void QmitkToFPointSetWidget::MeasurementPointSetChanged() { - // replace text actor - this->m_VtkTextActor->SetDisplayPosition(10,m_WindowHeight-30); - if (m_MeasurementPointSet2D->GetSize()==2) + if (m_MeasurementPointSet2D->GetSize() == 2) { // check if points are inside the image range int imageSizeX = m_DistanceImage->GetDimensions()[0]; int imageSizeY = m_DistanceImage->GetDimensions()[1]; mitk::Point3D point1 = m_MeasurementPointSet2D->GetPoint(0); mitk::Point3D point2 = m_MeasurementPointSet2D->GetPoint(1); - if ((point1[0]>=0.0f)&&(point1[0]=0)&&(point1[1]=0.0f)&&(point2[0]=0)&&(point2[1]= 0.0f) && (point1[0] < imageSizeX) && (point1[1] >= 0) && (point1[1] < imageSizeY) && + (point2[0] >= 0.0f) && (point2[0] < imageSizeX) && (point2[1] >= 0) && (point2[1] < imageSizeY)) { // create PointSet filter mitk::ToFDistanceImageToPointSetFilter::Pointer toFDistanceImageToPointSetFilter = mitk::ToFDistanceImageToPointSetFilter::New(); if (m_CameraIntrinsics.IsNotNull()) { toFDistanceImageToPointSetFilter->SetCameraIntrinsics(m_CameraIntrinsics); } toFDistanceImageToPointSetFilter->SetInput(m_DistanceImage); toFDistanceImageToPointSetFilter->SetSubset(m_MeasurementPointSet2D); toFDistanceImageToPointSetFilter->Update(); mitk::PointSet::Pointer measurementPointSet3D = toFDistanceImageToPointSetFilter->GetOutput(); m_MeasurementPointSet3DNode->SetData(measurementPointSet3D); // calculate distance between points - if (measurementPointSet3D->GetSize()==2) + if (measurementPointSet3D->GetSize() == 2) { mitk::Point3D point1 = measurementPointSet3D->GetPoint(0); mitk::Point3D point2 = measurementPointSet3D->GetPoint(1); float distance = point1.EuclideanDistanceTo(point2); std::stringstream stream; - stream<m_VtkTextActor->SetInput(stream.str().c_str()); + stream << distance << " mm"; + m_TextAnnotationAxial->SetText(stream.str().c_str()); + m_TextAnnotationSagittal->SetText(stream.str().c_str()); + m_TextAnnotationCoronal->SetText(stream.str().c_str()); + m_TextAnnotation3D->SetText(stream.str().c_str()); + //this->m_VtkTextActor->SetInput(stream.str().c_str()); } else { - this->m_VtkTextActor->SetInput("Choose measurement points with SHIFT+Click"); + m_TextAnnotationAxial->SetText("Choose measurement points with SHIFT+Click"); + m_TextAnnotationSagittal->SetText("Choose measurement points with SHIFT+Click"); + m_TextAnnotationCoronal->SetText("Choose measurement points with SHIFT+Click"); + m_TextAnnotation3D->SetText("Choose measurement points with SHIFT+Click"); } } else { - this->m_VtkTextActor->SetInput("Measurement outside image range."); + this->m_TextAnnotationAxial->SetText("Measurement outside image range."); + this->m_TextAnnotationSagittal->SetText("Measurement outside image range."); + this->m_TextAnnotationCoronal->SetText("Measurement outside image range."); + this->m_TextAnnotation3D->SetText("Measurement outside image range."); } } else { // initialize 3D pointset empty mitk::PointSet::Pointer pointSet3D = mitk::PointSet::New(); m_MeasurementPointSet3DNode->SetData(pointSet3D); } } void QmitkToFPointSetWidget::PointSetChanged() { if (m_DistanceImage.IsNotNull()) { - int imageSizeX = m_DistanceImage->GetDimensions()[0]; - int imageSizeY = m_DistanceImage->GetDimensions()[1]; - int pointSetValid = 1; - for (int i=0; iGetSize(); i++) - { - mitk::Point3D currentPoint = m_PointSet2D->GetPoint(i); - if ((currentPoint[0]>=0.0f)&&(currentPoint[0]=0)&&(currentPoint[1]GetDimensions()[0]; + int imageSizeY = m_DistanceImage->GetDimensions()[1]; + int pointSetValid = 1; + for (int i = 0; i < m_PointSet2D->GetSize(); i++) { - pointSetValid*=0; + mitk::Point3D currentPoint = m_PointSet2D->GetPoint(i); + if ((currentPoint[0] >= 0.0f) && (currentPoint[0] < imageSizeX) && (currentPoint[1] >= 0) && (currentPoint[1] < imageSizeY)) + { + pointSetValid *= 1; + } + else + { + pointSetValid *= 0; + } } - } - if (m_PointSet2D->GetSize()>0) - { - if (pointSetValid) + if (m_PointSet2D->GetSize() > 0) { - // create PointSet filter - mitk::ToFDistanceImageToPointSetFilter::Pointer toFDistanceImageToPointSetFilter = mitk::ToFDistanceImageToPointSetFilter::New(); - if (m_CameraIntrinsics.IsNotNull()) + if (pointSetValid) { - toFDistanceImageToPointSetFilter->SetCameraIntrinsics(m_CameraIntrinsics); + // create PointSet filter + mitk::ToFDistanceImageToPointSetFilter::Pointer toFDistanceImageToPointSetFilter = mitk::ToFDistanceImageToPointSetFilter::New(); + if (m_CameraIntrinsics.IsNotNull()) + { + toFDistanceImageToPointSetFilter->SetCameraIntrinsics(m_CameraIntrinsics); + } + toFDistanceImageToPointSetFilter->SetInput(m_DistanceImage); + toFDistanceImageToPointSetFilter->SetSubset(m_PointSet2D); + toFDistanceImageToPointSetFilter->Update(); + mitk::PointSet::Pointer pointSet3D = toFDistanceImageToPointSetFilter->GetOutput(); + m_PointSet3DNode->SetData(pointSet3D); + this->m_TextAnnotation3D->SetText("Choose points with SHIFT+Click"); } - toFDistanceImageToPointSetFilter->SetInput(m_DistanceImage); - toFDistanceImageToPointSetFilter->SetSubset(m_PointSet2D); - toFDistanceImageToPointSetFilter->Update(); - mitk::PointSet::Pointer pointSet3D = toFDistanceImageToPointSetFilter->GetOutput(); - m_PointSet3DNode->SetData(pointSet3D); - this->m_VtkTextActor->SetInput("Choose points with SHIFT+Click"); } + else + { + this->m_TextAnnotation3D->SetText("Point set outside image range."); + } + } else { - this->m_VtkTextActor->SetInput("Point set outside image range."); + // initialize 3D pointset empty + mitk::PointSet::Pointer pointSet3D = mitk::PointSet::New(); + m_PointSet3DNode->SetData(pointSet3D); } } - else - { - // initialize 3D pointset empty - mitk::PointSet::Pointer pointSet3D = mitk::PointSet::New(); - m_PointSet3DNode->SetData(pointSet3D); - } - } } diff --git a/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.h b/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.h index 0b79b6ff13..1dd799368f 100644 --- a/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.h +++ b/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.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 _QmitkToFPointSetWidget_H_INCLUDED #define _QmitkToFPointSetWidget_H_INCLUDED #include #include "ui_QmitkToFPointSetWidgetControls.h" //mitk headers #include #include #include #include #include +#include #include //Qmitk headers #include // vtk includes #include #include #include /** * @brief Widget allowing interaction with point sets for measurement and PointSet definition * * The widget allows to * 1. Measure the distance between two points in 3D ToF space by clicking the points in the 2D slices * 2. Defining a ToF PointSet both in 2D and 3D. CameraIntrinsics are used for calculation between 2D and 3D * * NOTE: * You have to make sure that the widget is initialized at a position in the plugin using it, where the distance * image is available. CleanUp has to be called to make sure that all observers and renderers are removed correctly. * * @ingroup ToFUI */ class MITKTOFUI_EXPORT QmitkToFPointSetWidget :public QWidget { //this is needed for all Qt objects that should have a MOC object (everything that derives from QObject) Q_OBJECT public: static const std::string VIEW_ID; QmitkToFPointSetWidget(QWidget* p = nullptr, Qt::WindowFlags f1 = nullptr); ~QmitkToFPointSetWidget() override; /* @brief This method is part of the widget an needs not to be called seperately. */ virtual void CreateQtPartControl(QWidget *parent); /* @brief This method is part of the widget an needs not to be called seperately. (Creation of the connections of main and control widget.)*/ virtual void CreateConnections(); /*! \brief initializes the widget. Observers to the change events of the point sets are created, text actors are activated to be rendered into the foreground of the render window. \param stdMultiWidget QmitkStdMultiWidget used for painting overlays for measurement \param dataStorage DataStorage to add PointSets \param distanceImage range image used to calculate 3D PointSet from 2D index */ void InitializeWidget(QHash renderWindowHashMap, mitk::DataStorage::Pointer dataStorage, mitk::CameraIntrinsics::Pointer cameraIntrinsics=nullptr); /*! \brief cleans up the widget when it's functionality is not used anymore. Removes observers and deletes foreground renderer */ void CleanUpWidget(); /*! \brief set the image holding the distance information used for measuring */ void SetDistanceImage(mitk::Image::Pointer distanceImage); /*! \brief Set intrinsic parameters of the used device */ void SetCameraIntrinsics(mitk::CameraIntrinsics::Pointer cameraIntrinsics); signals: protected slots: /*! \brief Activates the interactor for the measurement point set */ void OnMeasurement(); /*! \brief Activates the interactor for the point set */ void OnPointSet(); protected: /*! \brief function called when the 2D measurement PointSet has changed */ void MeasurementPointSetChanged(); /*! \brief function called when the 2D PointSet has changed */ void PointSetChanged(); Ui::QmitkToFPointSetWidgetControls* m_Controls; ///< member holding the UI elements of this widget mitk::DataStorage::Pointer m_DataStorage; ///< member holding the set DataStorage mitk::Image::Pointer m_DistanceImage; ///< image holding the range data of the ToF camera mitk::CameraIntrinsics::Pointer m_CameraIntrinsics; ///< intrinsic parameters of the camera - vtkSmartPointer m_VtkTextActor; ///< actor containing the text of the overlay - vtkSmartPointer m_ForegroundRenderer1; ///< renderer responsible for text rendering in the foreground of widget 1 - vtkSmartPointer m_ForegroundRenderer2; ///< renderer responsible for text rendering in the foreground of widget 2 - vtkSmartPointer m_ForegroundRenderer3; ///< renderer responsible for text rendering in the foreground of widget 3 - vtkSmartPointer m_RenderWindow1; ///< vtk render window used for showing overlay in widget 1 - vtkSmartPointer m_RenderWindow2; ///< vtk render window used for showing overlay in widget 2 - vtkSmartPointer m_RenderWindow3; ///< vtk render window used for showing overlay in widget 3 - vtkSmartPointer m_RenderWindow4; ///< vtk render window used for showing overlay in widget 3 + mitk::TextAnnotation2D::Pointer m_TextAnnotationAxial; ///< text annotation used to display measurements in axial window + mitk::TextAnnotation2D::Pointer m_TextAnnotationSagittal; ///< text annotation used to display measurement in axial window + mitk::TextAnnotation2D::Pointer m_TextAnnotationCoronal; ///< text annotation used to display measurement in axial window + mitk::TextAnnotation2D::Pointer m_TextAnnotation3D; ///< text annotation used to display measurement in 3d window + mitk::VtkPropRenderer::Pointer m_RendererAxial; ///< renderer of axial render window + mitk::VtkPropRenderer::Pointer m_RendererSagittal; ///< renderer of sagittal render window + mitk::VtkPropRenderer::Pointer m_RendererCoronal; ///< renderer of coronal render window + mitk::VtkPropRenderer::Pointer m_Renderer3D; ///< renderer of 3D render window mitk::PointSet::Pointer m_MeasurementPointSet2D; ///< PointSet holding the 2D ToF image point selection used for measuring mitk::DataNode::Pointer m_MeasurementPointSet3DNode; ///< DataNode holding the 3D ToF coordinates used for measuring mitk::PointSet::Pointer m_PointSet2D; ///< PointSet holding the 2D ToF image points mitk::DataNode::Pointer m_PointSet3DNode; ///< DataNode holding the 3D ToF coordinates mitk::PointSetDataInteractor::Pointer m_PointSetInteractor; ///< PointSetInteractor used for PointSet definition mitk::PointSetDataInteractor::Pointer m_MeasurementPointSetInteractor; ///< PointSetInteractor used for measurement long m_MeasurementPointSetChangedObserverTag; ///< observer tag for measurement PointSet observer long m_PointSetChangedObserverTag; ///< observer tag for PointSet observer // long m_DistanceImageChangedObserverTag; ///< observer tag for distance image observer int m_WindowHeight; ///< Height of the renderWindow private: }; #endif // _QmitkToFPointSetWidget_H_INCLUDED