void QmitkMatchPointRegistrationManipulator::OnSliceChanged()
{
mitk::Point3D currentSelectedPosition = GetRenderWindowPart()->GetSelectedPosition(NULL);
unsigned int currentSelectedTimeStep = GetRenderWindowPart()->GetTimeNavigationController()->GetTime()->GetPos();
if (m_currentSelectedPosition != currentSelectedPosition
|| m_currentSelectedTimeStep != currentSelectedTimeStep
|| m_selectedNodeTime > m_currentPositionTime)
{
//the current position has been changed or the selected node has been changed since the last position validation -> check position
m_currentSelectedPosition = currentSelectedPosition;
m_currentSelectedTimeStep = currentSelectedTimeStep;
m_currentPositionTime.Modified();
if (this->m_EvalNode.IsNotNull())
{
this->m_EvalNode->SetProperty(mitk::nodeProp_RegEvalCurrentPosition, mitk::GenericProperty<mitk::Point3D>::New(currentSelectedPosition));
}
if (m_activeManipulation && m_Controls.comboCenter->currentIndex() == 2)
{ //update transform with the current position.
OnCenterTypeChanged(m_Controls.comboCenter->currentIndex());
}
}
}
void QmitkImageStatisticsView::Visible()
{
m_Visible = true;
mitk::IRenderWindowPart* renderWindow = GetRenderWindowPart();
if (renderWindow)
{
itk::ReceptorMemberCommand<QmitkImageStatisticsView>::Pointer cmdTimeEvent =
itk::ReceptorMemberCommand<QmitkImageStatisticsView>::New();
cmdTimeEvent->SetCallbackFunction(this, &QmitkImageStatisticsView::OnTimeChanged);
// It is sufficient to add the observer to the axial render window since the GeometryTimeEvent
// is always triggered by all views.
m_TimeObserverTag = renderWindow->GetQmitkRenderWindow("axial")->
GetSliceNavigationController()->
AddObserver(mitk::SliceNavigationController::GeometryTimeEvent(NULL, 0), cmdTimeEvent);
}
if (m_DataNodeSelectionChanged)
{
if (this->IsCurrentSelectionValid())
{
this->SelectionChanged(this->GetCurrentSelection());
}
else
{
this->SelectionChanged(this->GetDataManagerSelection());
}
m_DataNodeSelectionChanged = false;
}
}
void QmitkRegionGrowingView::CreateQtPartControl( QWidget *parent )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls.setupUi( parent );
connect( m_Controls.buttonPerformImageProcessing, SIGNAL(clicked()), this, SLOT(DoImageProcessing()) );
//! [cpp-createqtpartcontrol]
// create a QmitkPointListWidget and add it to the widget created from .ui file
m_PointListWidget = new QmitkPointListWidget();
m_Controls.verticalLayout->addWidget(m_PointListWidget, 1);
// retrieve a possibly existing IRenderWindowPart
if (mitk::IRenderWindowPart* renderWindowPart = GetRenderWindowPart())
{
// let the point set widget know about the render window part (crosshair updates)
RenderWindowPartActivated(renderWindowPart);
}
// create a new DataNode containing a PointSet with some interaction
m_PointSet = mitk::PointSet::New();
mitk::DataNode::Pointer pointSetNode = mitk::DataNode::New();
pointSetNode->SetData( m_PointSet );
pointSetNode->SetName("seed points for region growing");
pointSetNode->SetProperty("helper object", mitk::BoolProperty::New(true) );
pointSetNode->SetProperty("layer", mitk::IntProperty::New(1024) );
// add the pointset to the data storage (for rendering and access by other modules)
GetDataStorage()->Add( pointSetNode );
// tell the GUI widget about the point set
m_PointListWidget->SetPointSetNode( pointSetNode );
//! [cpp-createqtpartcontrol]
}
void QmitkSemanticRelationsView::OpenInEditor(const mitk::DataNode* dataNode)
{
auto renderWindowPart = GetRenderWindowPart();
if (nullptr == renderWindowPart)
{
renderWindowPart = GetRenderWindowPart(mitk::WorkbenchUtil::IRenderWindowPartStrategy::BRING_TO_FRONT | mitk::WorkbenchUtil::IRenderWindowPartStrategy::OPEN);
if (nullptr == renderWindowPart)
{
// no render window available
return;
}
}
auto image = dynamic_cast<mitk::Image*>(dataNode->GetData());
if (nullptr != image)
{
mitk::RenderingManager::GetInstance()->InitializeViews(image->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
}
}
void QmitkMatchPointRegistrationEvaluator::OnSliceChanged()
{
mitk::Point3D currentSelectedPosition = GetRenderWindowPart()->GetSelectedPosition(NULL);
unsigned int currentSelectedTimeStep = GetRenderWindowPart()->GetTimeNavigationController()->GetTime()->GetPos();
if (m_currentSelectedPosition != currentSelectedPosition
|| m_currentSelectedTimeStep != currentSelectedTimeStep
|| m_selectedNodeTime > m_currentPositionTime)
{
//the current position has been changed or the selected node has been changed since the last position validation -> check position
m_currentSelectedPosition = currentSelectedPosition;
m_currentSelectedTimeStep = currentSelectedTimeStep;
m_currentPositionTime.Modified();
if (this->m_selectedEvalNode.IsNotNull())
{
this->m_selectedEvalNode->SetProperty(mitk::nodeProp_RegEvalCurrentPosition, mitk::GenericProperty<mitk::Point3D>::New(currentSelectedPosition));
}
}
}
void QmitkDicomInspectorView::ValidateAndSetCurrentPosition()
{
mitk::Point3D currentSelectedPosition = GetRenderWindowPart()->GetSelectedPosition(NULL);
unsigned int currentSelectedTimeStep = GetRenderWindowPart()->GetTimeNavigationController()->GetTime()->GetPos();
if (m_currentSelectedPosition != currentSelectedPosition
|| m_currentSelectedTimeStep != currentSelectedTimeStep
|| m_selectedNodeTime > m_currentPositionTime)
{
//the current position has been changed or the selected node has been changed since the last position validation -> check position
m_currentSelectedPosition = currentSelectedPosition;
m_currentSelectedTimeStep = currentSelectedTimeStep;
m_currentPositionTime.Modified();
m_validSelectedPosition = false;
if (m_currentSelectedData.IsNull())
{
return;
}
mitk::BaseGeometry::Pointer geometry = m_currentSelectedData->GetTimeGeometry()->GetGeometryForTimeStep(
m_currentSelectedTimeStep);
// check for invalid time step
if (geometry.IsNull())
{
geometry = m_currentSelectedData->GetTimeGeometry()->GetGeometryForTimeStep(0);
}
if (geometry.IsNull())
{
return;
}
m_validSelectedPosition = geometry->IsInside(m_currentSelectedPosition);
itk::Index<3> index;
geometry->WorldToIndex(m_currentSelectedPosition, index);
m_currentSelectedZSlice = index[2];
}
}
void QmitkDicomInspectorView::CreateQtPartControl(QWidget* parent)
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls.setupUi(parent);
m_Controls.labelNode->setText(QString("select node..."));
m_Controls.labelTime->setText(QString(""));
m_Controls.labelSlice->setText(QString(""));
mitk::IRenderWindowPart* renderWindowPart = GetRenderWindowPart();
RenderWindowPartActivated(renderWindowPart);
}
void QmitkSemanticRelationsView::JumpToPosition(const mitk::DataNode* dataNode)
{
if (nullptr == dataNode)
{
return;
}
mitk::LabelSetImage* labelSetImage = dynamic_cast<mitk::LabelSetImage*>(dataNode->GetData());
if (nullptr == labelSetImage)
{
return;
}
unsigned int activeLayer = labelSetImage->GetActiveLayer();
mitk::Label* activeLabel = labelSetImage->GetActiveLabel(activeLayer);
labelSetImage->UpdateCenterOfMass(activeLabel->GetValue(), activeLayer);
const mitk::Point3D& centerPosition = activeLabel->GetCenterOfMassCoordinates();
if (centerPosition.GetVnlVector().max_value() > 0.0)
{
auto renderWindowPart = GetRenderWindowPart();
if (nullptr == renderWindowPart)
{
renderWindowPart = GetRenderWindowPart(mitk::WorkbenchUtil::IRenderWindowPartStrategy::BRING_TO_FRONT | mitk::WorkbenchUtil::IRenderWindowPartStrategy::OPEN);
if (nullptr == renderWindowPart)
{
// no render window available
return;
}
}
auto segmentation = dynamic_cast<mitk::LabelSetImage*>(dataNode->GetData());
if (nullptr != segmentation)
{
renderWindowPart->SetSelectedPosition(centerPosition);
mitk::RenderingManager::GetInstance()->InitializeViews(segmentation->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
}
}
}
void QmitkImageStatisticsView::Hidden()
{
m_Visible = false;
// The slice navigation controller observer is removed here instead of in the destructor.
// If it was called in the destructor, the application would freeze because the view's
// destructor gets called after the render windows have been destructed.
if ( m_TimeObserverTag != NULL )
{
mitk::IRenderWindowPart* renderWindow = GetRenderWindowPart();
if (renderWindow)
{
renderWindow->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->
RemoveObserver( m_TimeObserverTag );
}
m_TimeObserverTag = NULL;
}
}
void QmitkSemanticRelationsView::CreateQtPartControl(QWidget* parent)
{
// create GUI widgets
m_Controls.setupUi(parent);
m_LesionInfoWidget = new QmitkLesionInfoWidget(GetDataStorage(), parent);
m_Controls.gridLayout->addWidget(m_LesionInfoWidget);
m_PatientTableInspector = new QmitkPatientTableInspector(parent);
m_PatientTableInspector->SetDataStorage(GetDataStorage());
m_Controls.gridLayout->addWidget(m_PatientTableInspector);
QGridLayout* dndDataNodeWidgetLayout = new QGridLayout;
dndDataNodeWidgetLayout->addWidget(m_PatientTableInspector, 0, 0);
dndDataNodeWidgetLayout->setContentsMargins(0, 0, 0, 0);
m_DnDDataNodeWidget = new QmitkDnDDataNodeWidget(parent);
m_DnDDataNodeWidget->setLayout(dndDataNodeWidgetLayout);
m_Controls.gridLayout->addWidget(m_DnDDataNodeWidget);
m_ContextMenu = new QmitkSemanticRelationsContextMenu(GetSite(), m_PatientTableInspector);
m_ContextMenu->SetDataStorage(GetDataStorage());
mitk::IRenderWindowPart* renderWindowPart = GetRenderWindowPart();
if (nullptr != renderWindowPart)
{
RenderWindowPartActivated(renderWindowPart);
}
SetUpConnections();
const auto& allCaseIDs = mitk::RelationStorage::GetAllCaseIDs();
for (const auto& caseID : allCaseIDs)
{
AddToComboBox(caseID);
}
}
void QmitkSegmentationView::CreateQtPartControl(QWidget* parent)
{
// setup the basic GUI of this view
m_Parent = parent;
m_Controls = new Ui::QmitkSegmentationControls;
m_Controls->setupUi(parent);
m_Controls->patImageSelector->SetDataStorage(GetDataStorage());
m_Controls->patImageSelector->SetPredicate(m_IsAPatientImagePredicate);
UpdateWarningLabel(tr("Please load an image"));
if (m_Controls->patImageSelector->GetSelectedNode().IsNotNull())
{
UpdateWarningLabel(tr("Select or create a new segmentation"));
}
m_Controls->segImageSelector->SetDataStorage(GetDataStorage());
m_Controls->segImageSelector->SetPredicate(m_IsASegmentationImagePredicate);
if (m_Controls->segImageSelector->GetSelectedNode().IsNotNull())
{
UpdateWarningLabel("");
}
mitk::ToolManager* toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
assert(toolManager);
toolManager->SetDataStorage(*(GetDataStorage()));
toolManager->InitializeTools();
// all part of open source MITK
m_Controls->m_ManualToolSelectionBox2D->setEnabled(true);
m_Controls->m_ManualToolSelectionBox2D->SetGenerateAccelerators(true);
m_Controls->m_ManualToolSelectionBox2D->SetToolGUIArea( m_Controls->m_ManualToolGUIContainer2D );
m_Controls->m_ManualToolSelectionBox2D->SetDisplayedToolGroups(tr("Add Subtract Correction Paint Wipe 'Region Growing' Fill Erase 'Live Wire' '2D Fast Marching'").toStdString());
m_Controls->m_ManualToolSelectionBox2D->SetLayoutColumns(3);
m_Controls->m_ManualToolSelectionBox2D->SetEnabledMode( QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible );
connect( m_Controls->m_ManualToolSelectionBox2D, SIGNAL(ToolSelected(int)), this, SLOT(OnManualTool2DSelected(int)) );
//setup 3D Tools
m_Controls->m_ManualToolSelectionBox3D->setEnabled(true);
m_Controls->m_ManualToolSelectionBox3D->SetGenerateAccelerators(true);
m_Controls->m_ManualToolSelectionBox3D->SetToolGUIArea( m_Controls->m_ManualToolGUIContainer3D );
//specify tools to be added to 3D Tool area
m_Controls->m_ManualToolSelectionBox3D->SetDisplayedToolGroups(tr("Threshold 'UL Threshold' Otsu 'Fast Marching 3D' 'Region Growing 3D' Watershed Picking").toStdString());
m_Controls->m_ManualToolSelectionBox3D->SetLayoutColumns(3);
m_Controls->m_ManualToolSelectionBox3D->SetEnabledMode( QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible );
//Hide 3D selection box, show 2D selection box
m_Controls->m_ManualToolSelectionBox3D->hide();
m_Controls->m_ManualToolSelectionBox2D->show();
// update the list of segmentations
toolManager->NewNodesGenerated += mitk::MessageDelegate<QmitkSegmentationView>(this, &QmitkSegmentationView::NewNodesGenerated);
// update the list of segmentations
toolManager->NewNodeObjectsGenerated += mitk::MessageDelegate1<QmitkSegmentationView, mitk::ToolManager::DataVectorType*>(this, &QmitkSegmentationView::NewNodeObjectsGenerated);
// create signal/slot connections
connect(m_Controls->patImageSelector, SIGNAL(OnSelectionChanged(const mitk::DataNode*)), this, SLOT(OnPatientComboBoxSelectionChanged(const mitk::DataNode*)));
connect(m_Controls->segImageSelector, SIGNAL(OnSelectionChanged(const mitk::DataNode*)), this, SLOT(OnSegmentationComboBoxSelectionChanged(const mitk::DataNode*)));
connect( m_Controls->btnNewSegmentation, SIGNAL(clicked()), this, SLOT(CreateNewSegmentation()) );
// connect( m_Controls->CreateSegmentationFromSurface, SIGNAL(clicked()), this, SLOT(CreateSegmentationFromSurface()) );
// connect( m_Controls->widgetStack, SIGNAL(currentChanged(int)), this, SLOT(ToolboxStackPageChanged(int)) );
connect( m_Controls->tabWidgetSegmentationTools, SIGNAL(currentChanged(int)), this, SLOT(OnTabWidgetChanged(int)));
// connect(m_Controls->MaskSurfaces, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
// this, SLOT( OnSurfaceSelectionChanged( ) ) );
connect(m_Controls->m_SlicesInterpolator, SIGNAL(SignalShowMarkerNodes(bool)), this, SLOT(OnShowMarkerNodes(bool)));
// m_Controls->MaskSurfaces->SetDataStorage(this->GetDataStorage());
// m_Controls->MaskSurfaces->SetPredicate(mitk::NodePredicateDataType::New("Surface"));
mitk::DataStorage::SetOfObjects::ConstPointer patientImages = GetDataStorage()->GetSubset(m_IsAPatientImagePredicate);
if (!patientImages->empty())
{
OnSelectionChanged(*patientImages->begin());
}
// set callback function for already existing nodes (images & segmentations)
mitk::DataStorage::SetOfObjects::ConstPointer allImages = GetDataStorage()->GetSubset(m_IsOfTypeImagePredicate);
for (mitk::DataStorage::SetOfObjects::const_iterator iter = allImages->begin(); iter != allImages->end(); ++iter)
{
mitk::DataNode* node = *iter;
itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
command->SetCallbackFunction(this, &QmitkSegmentationView::OnVisiblePropertyChanged);
m_WorkingDataObserverTags.insert(std::pair<mitk::DataNode*, unsigned long>(node, node->GetProperty("visible")->AddObserver(itk::ModifiedEvent(), command)));
itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command2 = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
command2->SetCallbackFunction(this, &QmitkSegmentationView::OnBinaryPropertyChanged);
m_BinaryPropertyObserverTags.insert(std::pair<mitk::DataNode*, unsigned long>(node, node->GetProperty("binary")->AddObserver(itk::ModifiedEvent(), command2)));
}
itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
command->SetCallbackFunction(this, &QmitkSegmentationView::RenderingManagerReinitialized);
m_RenderingManagerObserverTag = mitk::RenderingManager::GetInstance()->AddObserver(mitk::RenderingManagerViewsInitializedEvent(), command);
InitToolManagerSelection(m_Controls->patImageSelector->GetSelectedNode(), m_Controls->segImageSelector->GetSelectedNode());
m_RenderWindowPart = GetRenderWindowPart();
if (m_RenderWindowPart)
{
RenderWindowPartActivated(m_RenderWindowPart);
}
}
void QmitkSegmentationView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
{
if (nodes.size() != 0)
{
std::string markerName = "Position";
unsigned int numberOfNodes = nodes.size();
std::string nodeName = nodes.at(0)->GetName();
if ((numberOfNodes == 1) && (nodeName.find(markerName) == 0))
{
OnContourMarkerSelected(nodes.at(0));
return;
}
}
if (m_AutoSelectionEnabled)
{
if (nodes.size() == 0 && m_Controls->patImageSelector->GetSelectedNode().IsNull())
{
SetToolManagerSelection(nullptr, nullptr);
}
else if (nodes.size() == 1)
{
mitk::DataNode::Pointer selectedNode = nodes.at(0);
if (selectedNode.IsNull())
{
return;
}
mitk::Image::Pointer selectedImage = dynamic_cast<mitk::Image*>(selectedNode->GetData());
if (selectedImage.IsNull())
{
SetToolManagerSelection(nullptr, nullptr);
return;
}
if (m_IsASegmentationImagePredicate->CheckNode(selectedNode))
{
// set all nodes to invisible
mitk::DataStorage::SetOfObjects::ConstPointer allImages = GetDataStorage()->GetSubset(m_IsOfTypeImagePredicate);
for (mitk::DataStorage::SetOfObjects::const_iterator iter = allImages->begin(); iter != allImages->end(); ++iter)
{
(*iter)->SetVisibility(false);
}
// if a segmentation is selected find a possible patient image
mitk::DataStorage::SetOfObjects::ConstPointer sources = GetDataStorage()->GetSources(selectedNode, m_IsAPatientImagePredicate);
mitk::DataNode::Pointer refNode;
if (sources->Size() != 0)
{
// found one or more sources - use the first one
refNode = sources->ElementAt(0);
refNode->SetVisibility(true);
selectedNode->SetVisibility(true);
SetToolManagerSelection(refNode, selectedNode);
}
else
{
// did not find a source / patient image, check all images and compare geometry
mitk::DataStorage::SetOfObjects::ConstPointer possiblePatientImages = GetDataStorage()->GetSubset(m_IsAPatientImagePredicate);
for (mitk::DataStorage::SetOfObjects::ConstIterator iter = possiblePatientImages->Begin(); iter != possiblePatientImages->End(); ++iter)
{
refNode = iter->Value();
if (CheckForSameGeometry(selectedNode, iter->Value()))
{
refNode->SetVisibility(true);
selectedNode->SetVisibility(true);
SetToolManagerSelection(refNode, selectedNode);
// doing this we can assure that the segmentation is always visible if the segmentation and the patient image are at the
// same level in the data manager
int layer(10);
refNode->GetIntProperty("layer", layer);
layer++;
selectedNode->SetProperty("layer", mitk::IntProperty::New(layer));
return;
}
}
// did not find a source / patient image with the same geometry
SetToolManagerSelection(nullptr, selectedNode);
}
mitk::RenderingManager::GetInstance()->InitializeViews(selectedNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
}
else
{
if (mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetReferenceData(0) != selectedNode)
{
SetToolManagerSelection(selectedNode, nullptr);
// may be a bug in the selection services. A node which is deselected will be passed as selected node to the OnSelectionChanged function
mitk::IRenderWindowPart* renderWindowPart = GetRenderWindowPart();
if (renderWindowPart && !selectedNode->IsVisible(renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer()))
{
selectedNode->SetVisibility(true);
}
UpdateWarningLabel(tr("The selected patient image does not match with the selected segmentation!"));
SetToolSelectionBoxesEnabled(false);
}
}
}
if (m_Controls->lblSegmentationWarnings->isVisible()) // "RenderingManagerReinitialized()" caused a warning. we do not need to go any further
{
return;
}
RenderingManagerReinitialized();
}
}
