diff --git a/Modules/QtWidgets/include/QmitkMultiWidgetLayoutManager.h b/Modules/QtWidgets/include/QmitkMultiWidgetLayoutManager.h
index 0c5b2dd6a1..2a39a28bf1 100644
--- a/Modules/QtWidgets/include/QmitkMultiWidgetLayoutManager.h
+++ b/Modules/QtWidgets/include/QmitkMultiWidgetLayoutManager.h
@@ -1,94 +1,94 @@
/*===================================================================
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 QMITKMULTIWIDGETLAYOUTMANAGER_H
#define QMITKMULTIWIDGETLAYOUTMANAGER_H
#include "MitkQtWidgetsExports.h"
#include <QObject>
class QmitkAbstractMultiWidget;
class QmitkRenderWindowWidget;
/**
* @brief
*
*
*/
class MITKQTWIDGETS_EXPORT QmitkMultiWidgetLayoutManager : public QObject
{
Q_OBJECT
public:
enum class LayoutDesign
{
DEFAULT = 0,
ALL_2D_TOP_3D_BOTTOM,
ALL_2D_LEFT_3D_RIGHT,
ONE_BIG,
ONLY_2D_HORIZONTAL,
ONLY_2D_VERTICAL,
ONE_TOP_3D_BOTTOM,
ONE_LEFT_3D_RIGHT,
ALL_HORIZONTAL,
ALL_VERTICAL,
REMOVE_ONE,
NONE
};
QmitkMultiWidgetLayoutManager(QmitkAbstractMultiWidget* multiwidget);
/**
* @brief This function is called by render window widgets. Given a specific
* layout design the layout of the multi widget data member is set with this method.
*/
- void OnLayoutDesignChanged(LayoutDesign layoutDesign);
+ void SetLayoutDesign(LayoutDesign layoutDesign);
/**
* @brief Allow setting the current render window widget without relying on the sending object.
*
- * Calling 'OnLayoutDesignChanged' will overwrite the current render window widget but using the public
- * layout setter the current render window widget cna be defined using the function.
+ * Calling 'SetLayoutDesign' will overwrite the current render window widget but using the public
+ * layout setter the current render window widget can be defined using the function.
* This is necessary for layouts that work with a specific selected render window widget.
*/
void SetCurrentRenderWindowWidget(QmitkRenderWindowWidget* renderWindowWidget);
void SetDefaultLayout();
void SetAll2DTop3DBottomLayout();
void SetAll2DLeft3DRightLayout();
void SetOneBigLayout();
void SetOnly2DHorizontalLayout();
void SetOnly2DVerticalLayout();
void SetOneTop3DBottomLayout();
void SetOneLeft3DRightLayout();
void SetAllHorizontalLayout();
void SetAllVerticalLayout();
void RemoveOneLayout();
private:
QmitkAbstractMultiWidget* m_MultiWidget;
QmitkRenderWindowWidget* m_CurrentRenderWindowWidget;
};
#endif // QMITKMULTIWIDGETLAYOUTMANAGER_H
diff --git a/Modules/QtWidgets/src/QmitkMultiWidgetLayoutManager.cpp b/Modules/QtWidgets/src/QmitkMultiWidgetLayoutManager.cpp
index aa20567644..6d4ed1ef36 100644
--- a/Modules/QtWidgets/src/QmitkMultiWidgetLayoutManager.cpp
+++ b/Modules/QtWidgets/src/QmitkMultiWidgetLayoutManager.cpp
@@ -1,541 +1,541 @@
/*===================================================================
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 "QmitkMultiWidgetLayoutManager.h"
#include <mitkLogMacros.h>
#include <QmitkAbstractMultiWidget.h>
#include <QmitkRenderWindow.h>
#include <QmitkRenderWindowWidget.h>
// qt
#include <QHBoxLayout>
#include <QSPlitter>
QmitkMultiWidgetLayoutManager::QmitkMultiWidgetLayoutManager(QmitkAbstractMultiWidget* multiwidget)
: QObject(multiwidget)
, m_MultiWidget(multiwidget)
, m_CurrentRenderWindowWidget(nullptr)
{
// nothing here
}
-void QmitkMultiWidgetLayoutManager::OnLayoutDesignChanged(LayoutDesign layoutDesign)
+void QmitkMultiWidgetLayoutManager::SetLayoutDesign(LayoutDesign layoutDesign)
{
if (nullptr == m_MultiWidget)
{
return;
}
// retrieve the render window name from the sending render window
auto renderWindow = dynamic_cast<QmitkRenderWindow*>(QObject::sender());
m_CurrentRenderWindowWidget = m_MultiWidget->GetRenderWindowWidget(renderWindow).get();
switch (layoutDesign)
{
case LayoutDesign::DEFAULT:
{
SetDefaultLayout();
break;
}
case LayoutDesign::ALL_2D_TOP_3D_BOTTOM:
{
SetAll2DTop3DBottomLayout();
break;
}
case LayoutDesign::ALL_2D_LEFT_3D_RIGHT:
{
SetAll2DLeft3DRightLayout();
break;
}
case LayoutDesign::ONE_BIG:
{
SetOneBigLayout();
break;
}
case LayoutDesign::ONLY_2D_HORIZONTAL:
{
SetOnly2DHorizontalLayout();
break;
}
case LayoutDesign::ONLY_2D_VERTICAL:
{
SetOnly2DVerticalLayout();
break;
}
case LayoutDesign::ONE_TOP_3D_BOTTOM:
{
SetOneTop3DBottomLayout();
break;
}
case LayoutDesign::ONE_LEFT_3D_RIGHT:
{
SetOneLeft3DRightLayout();
break;
}
case LayoutDesign::ALL_HORIZONTAL:
{
SetAllHorizontalLayout();
break;
}
case LayoutDesign::ALL_VERTICAL:
{
SetAllVerticalLayout();
break;
}
case LayoutDesign::REMOVE_ONE:
{
RemoveOneLayout();
break;
}
};
}
void QmitkMultiWidgetLayoutManager::SetCurrentRenderWindowWidget(QmitkRenderWindowWidget* renderWindowWidget)
{
m_CurrentRenderWindowWidget = renderWindowWidget;
}
void QmitkMultiWidgetLayoutManager::SetDefaultLayout()
{
MITK_INFO << "Set default layout" << std::endl;
m_MultiWidget->ActivateMenuWidget(false);
delete m_MultiWidget->layout();
auto hBoxLayout = new QHBoxLayout(m_MultiWidget);
hBoxLayout->setContentsMargins(0, 0, 0, 0);
m_MultiWidget->setLayout(hBoxLayout);
hBoxLayout->setMargin(0);
auto mainSplit = new QSplitter(Qt::Vertical, m_MultiWidget);
hBoxLayout->addWidget(mainSplit);
QList<int> splitterSizeRow;
for (int row = 0; row < m_MultiWidget->GetRowCount(); ++row)
{
splitterSizeRow.push_back(1000);
QList<int> splitterSizeColumn;
auto splitter = new QSplitter(mainSplit);
for (int column = 0; column < m_MultiWidget->GetColumnCount(); ++column)
{
splitterSizeColumn.push_back(1000);
auto renderWindowWidget = m_MultiWidget->GetRenderWindowWidget(row, column);
splitter->addWidget(renderWindowWidget.get());
renderWindowWidget->show();
}
splitter->setSizes(splitterSizeColumn);
}
mainSplit->setSizes(splitterSizeRow);
m_MultiWidget->ActivateMenuWidget(true);
auto allRenderWindows = m_MultiWidget->GetRenderWindows();
for (auto& renderWindow : allRenderWindows)
{
renderWindow->LayoutDesignListChanged(LayoutDesign::DEFAULT);
}
}
void QmitkMultiWidgetLayoutManager::SetAll2DTop3DBottomLayout()
{
MITK_INFO << "Set all 2D top and 3D bottom layout" << std::endl;
m_MultiWidget->ActivateMenuWidget(false);
delete m_MultiWidget->layout();
auto hBoxLayout = new QHBoxLayout(m_MultiWidget);
hBoxLayout->setContentsMargins(0, 0, 0, 0);
m_MultiWidget->setLayout(hBoxLayout);
hBoxLayout->setMargin(0);
auto mainSplit = new QSplitter(Qt::Vertical, m_MultiWidget);
hBoxLayout->addWidget(mainSplit);
auto subSplit2D = new QSplitter(mainSplit);
QList<int> splitterSize;
auto all2DRenderWindowWidgets = m_MultiWidget->Get2DRenderWindowWidgets();
for (const auto& renderWindowWidget : all2DRenderWindowWidgets)
{
subSplit2D->addWidget(renderWindowWidget.second.get());
renderWindowWidget.second->show();
splitterSize.push_back(1000);
}
subSplit2D->setSizes(splitterSize);
auto subSplit3D = new QSplitter(mainSplit);
splitterSize.clear();
auto all3DRenderWindowWidgets = m_MultiWidget->Get3DRenderWindowWidgets();
for (const auto& renderWindowWidget : all3DRenderWindowWidgets)
{
subSplit3D->addWidget(renderWindowWidget.second.get());
renderWindowWidget.second->show();
splitterSize.push_back(1000);
}
subSplit3D->setSizes(splitterSize);
// set size for main splitter
splitterSize.clear();
splitterSize.push_back(600);
splitterSize.push_back(1000);
mainSplit->setSizes(splitterSize);
m_MultiWidget->ActivateMenuWidget(true);
auto allRenderWindows = m_MultiWidget->GetRenderWindows();
for (auto& renderWindow : allRenderWindows)
{
renderWindow->LayoutDesignListChanged(LayoutDesign::ALL_2D_TOP_3D_BOTTOM);
}
}
void QmitkMultiWidgetLayoutManager::SetAll2DLeft3DRightLayout()
{
MITK_INFO << "Set all 2D left and 3D right layout" << std::endl;
m_MultiWidget->ActivateMenuWidget(false);
delete m_MultiWidget->layout();
auto hBoxLayout = new QHBoxLayout(m_MultiWidget);
hBoxLayout->setContentsMargins(0, 0, 0, 0);
m_MultiWidget->setLayout(hBoxLayout);
hBoxLayout->setMargin(0);
auto mainSplit = new QSplitter(m_MultiWidget);
hBoxLayout->addWidget(mainSplit);
auto subSplit2D = new QSplitter(Qt::Vertical, mainSplit);
QList<int> splitterSize;
auto all2DRenderWindowWidgets = m_MultiWidget->Get2DRenderWindowWidgets();
for (const auto& renderWindowWidget : all2DRenderWindowWidgets)
{
subSplit2D->addWidget(renderWindowWidget.second.get());
renderWindowWidget.second->show();
splitterSize.push_back(1000);
}
subSplit2D->setSizes(splitterSize);
auto subSplit3D = new QSplitter( mainSplit);
splitterSize.clear();
auto all3DRenderWindowWidgets = m_MultiWidget->Get3DRenderWindowWidgets();
for (const auto& renderWindowWidget : all3DRenderWindowWidgets)
{
subSplit3D->addWidget(renderWindowWidget.second.get());
renderWindowWidget.second->show();
splitterSize.push_back(1000);
}
subSplit3D->setSizes(splitterSize);
// set size for main splitter
splitterSize.clear();
splitterSize.push_back(600);
splitterSize.push_back(1000);
mainSplit->setSizes(splitterSize);
m_MultiWidget->ActivateMenuWidget(true);
auto allRenderWindows = m_MultiWidget->GetRenderWindows();
for (auto& renderWindow : allRenderWindows)
{
renderWindow->LayoutDesignListChanged(LayoutDesign::ALL_2D_LEFT_3D_RIGHT);
}
}
void QmitkMultiWidgetLayoutManager::SetOneBigLayout()
{
MITK_INFO << "Set single 2D layout" << std::endl;
m_MultiWidget->ActivateMenuWidget(false);
delete m_MultiWidget->layout();
auto hBoxLayout = new QHBoxLayout(m_MultiWidget);
hBoxLayout->setContentsMargins(0, 0, 0, 0);
m_MultiWidget->setLayout(hBoxLayout);
hBoxLayout->setMargin(0);
auto mainSplit = new QSplitter(m_MultiWidget);
hBoxLayout->addWidget(mainSplit);
mainSplit->addWidget(m_CurrentRenderWindowWidget);
m_CurrentRenderWindowWidget->show();
m_MultiWidget->ActivateMenuWidget(true);
auto allRenderWindows = m_MultiWidget->GetRenderWindows();
for (auto& renderWindow : allRenderWindows)
{
renderWindow->LayoutDesignListChanged(LayoutDesign::ONE_BIG);
}
}
void QmitkMultiWidgetLayoutManager::SetOnly2DHorizontalLayout()
{
MITK_INFO << "Set only 2D layout" << std::endl;
m_MultiWidget->ActivateMenuWidget(false);
delete m_MultiWidget->layout();
auto hBoxLayout = new QHBoxLayout(m_MultiWidget);
hBoxLayout->setContentsMargins(0, 0, 0, 0);
m_MultiWidget->setLayout(hBoxLayout);
hBoxLayout->setMargin(0);
auto mainSplit = new QSplitter(m_MultiWidget);
hBoxLayout->addWidget(mainSplit);
QList<int> splitterSize;
auto all2DRenderWindowWidgets = m_MultiWidget->Get2DRenderWindowWidgets();
for (const auto& renderWindowWidget : all2DRenderWindowWidgets)
{
mainSplit->addWidget(renderWindowWidget.second.get());
renderWindowWidget.second->show();
splitterSize.push_back(1000);
}
mainSplit->setSizes(splitterSize);
m_MultiWidget->ActivateMenuWidget(true);
auto allRenderWindows = m_MultiWidget->GetRenderWindows();
for (auto& renderWindow : allRenderWindows)
{
renderWindow->LayoutDesignListChanged(LayoutDesign::ONLY_2D_HORIZONTAL);
}
}
void QmitkMultiWidgetLayoutManager::SetOnly2DVerticalLayout()
{
MITK_INFO << "Set only 2D layout" << std::endl;
m_MultiWidget->ActivateMenuWidget(false);
delete m_MultiWidget->layout();
auto hBoxLayout = new QHBoxLayout(m_MultiWidget);
hBoxLayout->setContentsMargins(0, 0, 0, 0);
m_MultiWidget->setLayout(hBoxLayout);
hBoxLayout->setMargin(0);
auto mainSplit = new QSplitter(Qt::Vertical, m_MultiWidget);
hBoxLayout->addWidget(mainSplit);
QList<int> splitterSize;
auto all2DRenderWindowWidgets = m_MultiWidget->Get2DRenderWindowWidgets();
for (const auto& renderWindowWidget : all2DRenderWindowWidgets)
{
mainSplit->addWidget(renderWindowWidget.second.get());
renderWindowWidget.second->show();
splitterSize.push_back(1000);
}
mainSplit->setSizes(splitterSize);
m_MultiWidget->ActivateMenuWidget(true);
auto allRenderWindows = m_MultiWidget->GetRenderWindows();
for (auto& renderWindow : allRenderWindows)
{
renderWindow->LayoutDesignListChanged(LayoutDesign::ONLY_2D_VERTICAL);
}
}
void QmitkMultiWidgetLayoutManager::SetOneTop3DBottomLayout()
{
MITK_INFO << "Set one 2D top and 3D bottom layout" << std::endl;
m_MultiWidget->ActivateMenuWidget(false);
delete m_MultiWidget->layout();
auto hBoxLayout = new QHBoxLayout(m_MultiWidget);
hBoxLayout->setContentsMargins(0, 0, 0, 0);
m_MultiWidget->setLayout(hBoxLayout);
hBoxLayout->setMargin(0);
auto mainSplit = new QSplitter(Qt::Vertical, m_MultiWidget);
hBoxLayout->addWidget(mainSplit);
mainSplit->addWidget(m_CurrentRenderWindowWidget);
m_CurrentRenderWindowWidget->show();
auto subSplit3D = new QSplitter(mainSplit);
QList<int> splitterSize;
auto all3DRenderWindowWidgets = m_MultiWidget->Get3DRenderWindowWidgets();
for (const auto& renderWindowWidget : all3DRenderWindowWidgets)
{
subSplit3D->addWidget(renderWindowWidget.second.get());
renderWindowWidget.second->show();
splitterSize.push_back(1000);
}
subSplit3D->setSizes(splitterSize);
// set size for main splitter
splitterSize.clear();
splitterSize.push_back(1000);
splitterSize.push_back(1000);
mainSplit->setSizes(splitterSize);
m_MultiWidget->ActivateMenuWidget(true);
auto allRenderWindows = m_MultiWidget->GetRenderWindows();
for (auto& renderWindow : allRenderWindows)
{
renderWindow->LayoutDesignListChanged(LayoutDesign::ONE_TOP_3D_BOTTOM);
}
}
void QmitkMultiWidgetLayoutManager::SetOneLeft3DRightLayout()
{
MITK_INFO << "Set one 2D left and 3D right layout" << std::endl;
m_MultiWidget->ActivateMenuWidget(false);
delete m_MultiWidget->layout();
auto hBoxLayout = new QHBoxLayout(m_MultiWidget);
hBoxLayout->setContentsMargins(0, 0, 0, 0);
m_MultiWidget->setLayout(hBoxLayout);
hBoxLayout->setMargin(0);
auto mainSplit = new QSplitter(m_MultiWidget);
hBoxLayout->addWidget(mainSplit);
mainSplit->addWidget(m_CurrentRenderWindowWidget);
m_CurrentRenderWindowWidget->show();
auto subSplit3D = new QSplitter(Qt::Vertical, mainSplit);
QList<int> splitterSize;
auto all3DRenderWindowWidgets = m_MultiWidget->Get3DRenderWindowWidgets();
for (const auto& renderWindowWidget : all3DRenderWindowWidgets)
{
subSplit3D->addWidget(renderWindowWidget.second.get());
renderWindowWidget.second->show();
splitterSize.push_back(1000);
}
subSplit3D->setSizes(splitterSize);
// set size for main splitter
splitterSize.clear();
splitterSize.push_back(1000);
splitterSize.push_back(1000);
mainSplit->setSizes(splitterSize);
m_MultiWidget->ActivateMenuWidget(true);
auto allRenderWindows = m_MultiWidget->GetRenderWindows();
for (auto& renderWindow : allRenderWindows)
{
renderWindow->LayoutDesignListChanged(LayoutDesign::ONE_LEFT_3D_RIGHT);
}
}
void QmitkMultiWidgetLayoutManager::SetAllHorizontalLayout()
{
MITK_INFO << "Set default layout" << std::endl;
m_MultiWidget->ActivateMenuWidget(false);
delete m_MultiWidget->layout();
auto hBoxLayout = new QHBoxLayout(m_MultiWidget);
hBoxLayout->setContentsMargins(0, 0, 0, 0);
m_MultiWidget->setLayout(hBoxLayout);
hBoxLayout->setMargin(0);
auto mainSplit = new QSplitter(m_MultiWidget);
hBoxLayout->addWidget(mainSplit);
QList<int> splitterSize;
auto allRenderWindowWidgets = m_MultiWidget->GetRenderWindowWidgets();
for (const auto& renderWindowWidget : allRenderWindowWidgets)
{
if (nullptr != renderWindowWidget.second)
{
mainSplit->addWidget(renderWindowWidget.second.get());
renderWindowWidget.second->show();
splitterSize.push_back(1000);
}
}
// set size for main splitter
mainSplit->setSizes(splitterSize);
m_MultiWidget->ActivateMenuWidget(true);
auto allRenderWindows = m_MultiWidget->GetRenderWindows();
for (auto& renderWindow : allRenderWindows)
{
renderWindow->LayoutDesignListChanged(LayoutDesign::ALL_HORIZONTAL);
}
}
void QmitkMultiWidgetLayoutManager::SetAllVerticalLayout()
{
MITK_INFO << "Set all vertical" << std::endl;
m_MultiWidget->ActivateMenuWidget(false);
delete m_MultiWidget->layout();
auto hBoxLayout = new QHBoxLayout(m_MultiWidget);
hBoxLayout->setContentsMargins(0, 0, 0, 0);
m_MultiWidget->setLayout(hBoxLayout);
hBoxLayout->setMargin(0);
auto mainSplit = new QSplitter(Qt::Vertical, m_MultiWidget);
hBoxLayout->addWidget(mainSplit);
QList<int> splitterSize;
auto allRenderWindowWidgets = m_MultiWidget->GetRenderWindowWidgets();
for (const auto& renderWindowWidget : allRenderWindowWidgets)
{
mainSplit->addWidget(renderWindowWidget.second.get());
renderWindowWidget.second->show();
splitterSize.push_back(1000);
}
// set size for splitter
mainSplit->setSizes(splitterSize);
m_MultiWidget->ActivateMenuWidget(true);
auto allRenderWindows = m_MultiWidget->GetRenderWindows();
for (auto& renderWindow : allRenderWindows)
{
renderWindow->LayoutDesignListChanged(LayoutDesign::ALL_VERTICAL);
}
}
void QmitkMultiWidgetLayoutManager::RemoveOneLayout()
{
MITK_INFO << "Remove single render window" << std::endl;
m_MultiWidget->ActivateMenuWidget(false);
m_CurrentRenderWindowWidget->hide();
m_MultiWidget->ActivateMenuWidget(true);
auto allRenderWindows = m_MultiWidget->GetRenderWindows();
for (auto& renderWindow : allRenderWindows)
{
renderWindow->LayoutDesignListChanged(LayoutDesign::NONE);
}
}
diff --git a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
index 01b70b8eb5..6c4c5dc73f 100644
--- a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
@@ -1,256 +1,256 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical Image Computing.
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 "QmitkMxNMultiWidget.h"
#include "QmitkRenderWindowWidget.h"
// qt
#include <QGridLayout>
QmitkMxNMultiWidget::QmitkMxNMultiWidget(QWidget* parent,
Qt::WindowFlags f/* = 0*/,
mitk::RenderingManager* renderingManager/* = nullptr*/,
mitk::BaseRenderer::RenderingMode::Type renderingMode/* = mitk::BaseRenderer::RenderingMode::Standard*/,
const QString& multiWidgetName/* = "mxnmulti"*/)
: QmitkAbstractMultiWidget(parent, f, renderingManager, renderingMode, multiWidgetName)
, m_CrosshairVisibility(false)
{
// nothing here
}
void QmitkMxNMultiWidget::InitializeMultiWidget()
{
SetLayout(1, 1);
ActivateMenuWidget(true);
}
void QmitkMxNMultiWidget::MultiWidgetOpened()
{
SetCrosshairVisibility(true);
}
void QmitkMxNMultiWidget::MultiWidgetClosed()
{
SetCrosshairVisibility(false);
}
QmitkRenderWindow* QmitkMxNMultiWidget::GetRenderWindow(const QString& widgetName) const
{
if ("axial" == widgetName || "sagittal" == widgetName || "coronal" == widgetName || "3d" == widgetName)
{
return GetActiveRenderWindowWidget()->GetRenderWindow();
}
return QmitkAbstractMultiWidget::GetRenderWindow(widgetName);
}
QmitkRenderWindow* QmitkMxNMultiWidget::GetRenderWindow(const mitk::BaseRenderer::ViewDirection& viewDirection) const
{
// currently no mapping between view directions and render windows
// simply return the currently active render window
return GetActiveRenderWindowWidget()->GetRenderWindow();
}
void QmitkMxNMultiWidget::SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget)
{
auto currentActiveRenderWindowWidget = GetActiveRenderWindowWidget();
if (currentActiveRenderWindowWidget == activeRenderWindowWidget)
{
return;
}
// reset the decoration color of the previously active render window widget
if (nullptr != currentActiveRenderWindowWidget)
{
auto decorationColor = currentActiveRenderWindowWidget->GetDecorationColor();
QColor hexColor(decorationColor[0] * 255, decorationColor[1] * 255, decorationColor[2] * 255);
currentActiveRenderWindowWidget->setStyleSheet("border: 2px solid " + hexColor.name(QColor::HexRgb));
}
// set the new decoration color of the currently active render window widget
if (nullptr != activeRenderWindowWidget)
{
activeRenderWindowWidget->setStyleSheet("border: 2px solid #FF6464");
}
QmitkAbstractMultiWidget::SetActiveRenderWindowWidget(activeRenderWindowWidget);
}
void QmitkMxNMultiWidget::SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName)
{
RenderWindowWidgetPointer renderWindowWidget;
if (widgetName.isNull())
{
renderWindowWidget = GetActiveRenderWindowWidget();
}
else
{
renderWindowWidget = GetRenderWindowWidget(widgetName);
}
if (nullptr != renderWindowWidget)
{
renderWindowWidget->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
renderWindowWidget->RequestUpdate();
return;
}
MITK_ERROR << "Position can not be set for an unknown render window widget.";
}
const mitk::Point3D QmitkMxNMultiWidget::GetSelectedPosition(const QString& /*widgetName*/) const
{
// see T26208
return mitk::Point3D();
}
void QmitkMxNMultiWidget::SetCrosshairVisibility(bool activate)
{
auto renderWindowWidgets = GetRenderWindowWidgets();
for (const auto& renderWindowWidget : renderWindowWidgets)
{
renderWindowWidget.second->ActivateCrosshair(activate);
}
m_CrosshairVisibility = activate;
}
void QmitkMxNMultiWidget::ResetCrosshair()
{
auto dataStorage = GetDataStorage();
if (nullptr == dataStorage)
{
return;
}
auto renderingManager = GetRenderingManager();
if (nullptr == renderingManager)
{
return;
}
renderingManager->InitializeViewsByBoundingObjects(dataStorage);
SetWidgetPlaneMode(mitk::InteractionSchemeSwitcher::MITKStandard);
}
void QmitkMxNMultiWidget::SetWidgetPlaneMode(int userMode)
{
MITK_DEBUG << "Changing crosshair mode to " << userMode;
switch (userMode)
{
case 0:
SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKStandard);
break;
case 1:
SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKRotationUncoupled);
break;
case 2:
SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKRotationCoupled);
break;
case 3:
SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKSwivel);
break;
}
}
//////////////////////////////////////////////////////////////////////////
// PUBLIC SLOTS
// MOUSE EVENTS
//////////////////////////////////////////////////////////////////////////
void QmitkMxNMultiWidget::wheelEvent(QWheelEvent* e)
{
emit WheelMoved(e);
}
void QmitkMxNMultiWidget::mousePressEvent(QMouseEvent* e)
{
if (QEvent::MouseButtonPress != e->type())
{
return;
}
auto renderWindowWidget = dynamic_cast<QmitkRenderWindowWidget*>(this->sender());
if (nullptr == renderWindowWidget)
{
return;
}
auto renderWindowWidgetPointer = GetRenderWindowWidget(renderWindowWidget->GetWidgetName());
SetActiveRenderWindowWidget(renderWindowWidgetPointer);
}
void QmitkMxNMultiWidget::moveEvent(QMoveEvent* e)
{
QWidget::moveEvent(e);
// it is necessary to readjust the position of the overlays as the MultiWidget has moved
// unfortunately it's not done by QmitkRenderWindow::moveEvent -> must be done here
emit Moved();
}
//////////////////////////////////////////////////////////////////////////
// PRIVATE
//////////////////////////////////////////////////////////////////////////
void QmitkMxNMultiWidget::SetLayoutImpl()
{
int requiredRenderWindowWidgets = GetRowCount() * GetColumnCount();
int existingRenderWindowWidgets = GetRenderWindowWidgets().size();
int difference = requiredRenderWindowWidgets - existingRenderWindowWidgets;
while (0 < difference)
{
// more render window widgets needed
CreateRenderWindowWidget();
--difference;
}
while (0 > difference)
{
// less render window widgets needed
RemoveRenderWindowWidget();
++difference;
}
auto firstRenderWindowWidget = GetFirstRenderWindowWidget();
if (nullptr != firstRenderWindowWidget)
{
SetActiveRenderWindowWidget(firstRenderWindowWidget);
}
- GetMultiWidgetLayoutManager()->OnLayoutDesignChanged(QmitkMultiWidgetLayoutManager::LayoutDesign::DEFAULT);
+ GetMultiWidgetLayoutManager()->SetLayoutDesign(QmitkMultiWidgetLayoutManager::LayoutDesign::DEFAULT);
}
void QmitkMxNMultiWidget::CreateRenderWindowWidget()
{
// create the render window widget and connect signal / slot
QString renderWindowWidgetName = GetNameFromIndex(GetNumberOfRenderWindowWidgets());
RenderWindowWidgetPointer renderWindowWidget = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage(), GetRenderingManager());
renderWindowWidget->SetCornerAnnotationText(renderWindowWidgetName.toStdString());
connect(renderWindowWidget.get(), &QmitkRenderWindowWidget::MouseEvent, this, &QmitkMxNMultiWidget::mousePressEvent);
AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget);
auto renderWindow = renderWindowWidget->GetRenderWindow();
auto layoutManager = GetMultiWidgetLayoutManager();
- connect(renderWindow, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::OnLayoutDesignChanged);
+ connect(renderWindow, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
connect(renderWindow, &QmitkRenderWindow::ResetView, this, &QmitkMxNMultiWidget::ResetCrosshair);
connect(renderWindow, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkMxNMultiWidget::SetCrosshairVisibility);
connect(renderWindow, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkMxNMultiWidget::SetWidgetPlaneMode);
}
diff --git a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
index 42ec2824b4..87ca55e6bb 100644
--- a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
@@ -1,808 +1,808 @@
/*===================================================================
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.
===================================================================*/
#define SMW_INFO MITK_INFO("widget.stdmulti")
#include "QmitkStdMultiWidget.h"
#include "QmitkRenderWindowWidget.h"
// mitk core
#include <mitkCameraController.h>
#include <mitkImage.h>
#include <mitkImagePixelReadAccessor.h>
#include <mitkInteractionConst.h>
#include <mitkLine.h>
#include <mitkNodePredicateBase.h>
#include <mitkNodePredicateDataType.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
#include <mitkPixelTypeMultiplex.h>
#include <mitkPlaneGeometryDataMapper2D.h>
#include <mitkPointSet.h>
#include <mitkProperties.h>
#include <mitkStatusBar.h>
#include <mitkVtkLayerController.h>
// qt
#include <QList>
#include <QMouseEvent>
#include <QTimer>
// vtk
#include <vtkSmartPointer.h>
// c++
#include <iomanip>
QmitkStdMultiWidget::QmitkStdMultiWidget(QWidget *parent,
Qt::WindowFlags f/* = 0*/,
mitk::RenderingManager *renderingManager/* = nullptr*/,
mitk::BaseRenderer::RenderingMode::Type renderingMode/* = mitk::BaseRenderer::RenderingMode::Standard*/,
const QString &name/* = "stdmulti"*/)
: QmitkAbstractMultiWidget(parent, f, renderingManager, renderingMode, name)
, m_TimeNavigationController(nullptr)
, m_PendingCrosshairPositionEvent(false)
{
m_TimeNavigationController = GetRenderingManager()->GetTimeNavigationController();
}
QmitkStdMultiWidget::~QmitkStdMultiWidget()
{
m_TimeNavigationController->Disconnect(GetRenderWindow1()->GetSliceNavigationController());
m_TimeNavigationController->Disconnect(GetRenderWindow2()->GetSliceNavigationController());
m_TimeNavigationController->Disconnect(GetRenderWindow3()->GetSliceNavigationController());
m_TimeNavigationController->Disconnect(GetRenderWindow4()->GetSliceNavigationController());
}
void QmitkStdMultiWidget::InitializeMultiWidget()
{
// yellow is default color for widget4
m_DecorationColorWidget4[0] = 1.0f;
m_DecorationColorWidget4[1] = 1.0f;
m_DecorationColorWidget4[2] = 0.0f;
SetLayout(2, 2);
// transfer colors in WorldGeometry-Nodes of the associated Renderer
mitk::IntProperty::Pointer layer;
// of widget 1
m_PlaneNode1 =
mitk::BaseRenderer::GetInstance(GetRenderWindow1()->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
m_PlaneNode1->SetColor(GetDecorationColor(0));
layer = mitk::IntProperty::New(1000);
m_PlaneNode1->SetProperty("layer", layer);
// of widget 2
m_PlaneNode2 =
mitk::BaseRenderer::GetInstance(GetRenderWindow2()->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
m_PlaneNode2->SetColor(GetDecorationColor(1));
layer = mitk::IntProperty::New(1000);
m_PlaneNode2->SetProperty("layer", layer);
// of widget 3
m_PlaneNode3 =
mitk::BaseRenderer::GetInstance(GetRenderWindow3()->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
m_PlaneNode3->SetColor(GetDecorationColor(2));
layer = mitk::IntProperty::New(1000);
m_PlaneNode3->SetProperty("layer", layer);
// the parent node
m_ParentNodeForGeometryPlanes =
mitk::BaseRenderer::GetInstance(GetRenderWindow4()->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
layer = mitk::IntProperty::New(1000);
m_ParentNodeForGeometryPlanes->SetProperty("layer", layer);
AddDisplayPlaneSubTree();
}
QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow(const QString& widgetName) const
{
if ("axial" == widgetName)
{
return GetRenderWindow1();
}
if ("sagittal" == widgetName)
{
return GetRenderWindow2();
}
if ("coronal" == widgetName)
{
return GetRenderWindow3();
}
if ("3d" == widgetName)
{
return GetRenderWindow4();
}
return QmitkAbstractMultiWidget::GetRenderWindow(widgetName);
}
QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow(const mitk::BaseRenderer::ViewDirection& viewDirection) const
{
return GetRenderWindow(static_cast<unsigned int>(viewDirection));
}
void QmitkStdMultiWidget::SetSelectedPosition(const mitk::Point3D& newPosition, const QString& /*widgetName*/)
{
GetRenderWindow1()->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
GetRenderWindow2()->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
GetRenderWindow3()->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
RequestUpdateAll();
}
const mitk::Point3D QmitkStdMultiWidget::GetSelectedPosition(const QString& /*widgetName*/) const
{
const mitk::PlaneGeometry* plane1 = GetRenderWindow1()->GetSliceNavigationController()->GetCurrentPlaneGeometry();
const mitk::PlaneGeometry* plane2 = GetRenderWindow2()->GetSliceNavigationController()->GetCurrentPlaneGeometry();
const mitk::PlaneGeometry* plane3 = GetRenderWindow3()->GetSliceNavigationController()->GetCurrentPlaneGeometry();
mitk::Line3D line;
if ((plane1 != nullptr) && (plane2 != nullptr)
&& (plane1->IntersectionLine(plane2, line)))
{
mitk::Point3D point;
if ((plane3 != nullptr) && (plane3->IntersectionPoint(line, point)))
{
return point;
}
}
return mitk::Point3D();
}
void QmitkStdMultiWidget::SetCrosshairVisibility(bool visible)
{
if (m_PlaneNode1.IsNotNull())
{
m_PlaneNode1->SetVisibility(visible);
}
if (m_PlaneNode2.IsNotNull())
{
m_PlaneNode2->SetVisibility(visible);
}
if (m_PlaneNode3.IsNotNull())
{
m_PlaneNode3->SetVisibility(visible);
}
RequestUpdateAll();
}
bool QmitkStdMultiWidget::GetCrosshairVisibility() const
{
bool crosshairVisibility = true;
if (m_PlaneNode1.IsNotNull())
{
bool visibilityProperty = false;
m_PlaneNode1->GetVisibility(visibilityProperty, nullptr);
crosshairVisibility &= visibilityProperty;
}
if (m_PlaneNode2.IsNotNull())
{
bool visibilityProperty = false;
crosshairVisibility &= m_PlaneNode2->GetVisibility(visibilityProperty, nullptr);
crosshairVisibility &= visibilityProperty;
}
if (m_PlaneNode3.IsNotNull())
{
bool visibilityProperty = false;
crosshairVisibility &= m_PlaneNode3->GetVisibility(visibilityProperty, nullptr);
crosshairVisibility &= visibilityProperty;
}
return crosshairVisibility;
}
void QmitkStdMultiWidget::ResetCrosshair()
{
auto dataStorage = GetDataStorage();
if (nullptr == dataStorage)
{
return;
}
GetRenderingManager()->InitializeViewsByBoundingObjects(dataStorage);
SetWidgetPlaneMode(mitk::InteractionSchemeSwitcher::MITKStandard);
}
void QmitkStdMultiWidget::SetWidgetPlaneMode(int userMode)
{
MITK_DEBUG << "Changing crosshair mode to " << userMode;
switch (userMode)
{
case 0:
SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKStandard);
break;
case 1:
SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKRotationUncoupled);
break;
case 2:
SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKRotationCoupled);
break;
case 3:
SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKSwivel);
break;
}
}
mitk::SliceNavigationController* QmitkStdMultiWidget::GetTimeNavigationController()
{
return m_TimeNavigationController;
}
void QmitkStdMultiWidget::AddPlanesToDataStorage()
{
auto dataStorage = GetDataStorage();
if (nullptr == dataStorage)
{
return;
}
if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull()
&& m_PlaneNode3.IsNotNull() && m_ParentNodeForGeometryPlanes.IsNotNull())
{
dataStorage->Add(m_ParentNodeForGeometryPlanes);
dataStorage->Add(m_PlaneNode1, m_ParentNodeForGeometryPlanes);
dataStorage->Add(m_PlaneNode2, m_ParentNodeForGeometryPlanes);
dataStorage->Add(m_PlaneNode3, m_ParentNodeForGeometryPlanes);
}
}
void QmitkStdMultiWidget::RemovePlanesFromDataStorage()
{
auto dataStorage = GetDataStorage();
if (nullptr == dataStorage)
{
return;
}
if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull()
&& m_PlaneNode3.IsNotNull() && m_ParentNodeForGeometryPlanes.IsNotNull())
{
dataStorage->Remove(m_PlaneNode1);
dataStorage->Remove(m_PlaneNode2);
dataStorage->Remove(m_PlaneNode3);
dataStorage->Remove(m_ParentNodeForGeometryPlanes);
}
}
void QmitkStdMultiWidget::HandleCrosshairPositionEvent()
{
if (!m_PendingCrosshairPositionEvent)
{
m_PendingCrosshairPositionEvent = true;
QTimer::singleShot(0, this, SLOT(HandleCrosshairPositionEventDelayed()));
}
}
QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow(unsigned int number) const
{
switch (number)
{
case 0:
return GetRenderWindow1();
case 1:
return GetRenderWindow2();
case 2:
return GetRenderWindow3();
case 3:
return GetRenderWindow4();
default:
MITK_ERROR << "Requested unknown render window";
break;
}
return nullptr;
}
QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow1() const
{
return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(0, 0));
}
QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow2() const
{
return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(0, 1));
}
QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow3() const
{
return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(1, 0));
}
QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow4() const
{
return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(1, 1));
}
mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane1() const
{
return m_PlaneNode1;
}
mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane2() const
{
return m_PlaneNode2;
}
mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane3() const
{
return m_PlaneNode3;
}
mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane(unsigned number) const
{
switch (number)
{
case 1:
return m_PlaneNode1;
case 2:
return m_PlaneNode2;
case 3:
return m_PlaneNode3;
default:
MITK_ERROR << "Requested unknown render window";
break;
}
return nullptr;
}
void QmitkStdMultiWidget::SetDecorationColor(unsigned int widgetNumber, mitk::Color color)
{
switch (widgetNumber)
{
case 0:
if (m_PlaneNode1.IsNotNull())
{
m_PlaneNode1->SetColor(color);
}
break;
case 1:
if (m_PlaneNode2.IsNotNull())
{
m_PlaneNode2->SetColor(color);
}
break;
case 2:
if (m_PlaneNode3.IsNotNull())
{
m_PlaneNode3->SetColor(color);
}
break;
case 3:
m_DecorationColorWidget4 = color;
break;
default:
MITK_ERROR << "Decoration color for unknown widget!";
break;
}
}
mitk::Color QmitkStdMultiWidget::GetDecorationColor(unsigned int widgetNumber)
{
// The implementation looks a bit messy here, but it avoids
// synchronization of the color of the geometry nodes and an
// internal member here.
// Default colors were chosen for decent visibility.
// Feel free to change your preferences in the workbench.
float tmp[3] = { 0.0f, 0.0f, 0.0f };
switch (widgetNumber)
{
case 0:
{
if (m_PlaneNode1.IsNotNull())
{
if (m_PlaneNode1->GetColor(tmp))
{
return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode1->GetProperty("color"))->GetColor();
}
}
float red[3] = { 0.753f, 0.0f, 0.0f }; // This is #C00000 in hex
return mitk::Color(red);
}
case 1:
{
if (m_PlaneNode2.IsNotNull())
{
if (m_PlaneNode2->GetColor(tmp))
{
return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode2->GetProperty("color"))->GetColor();
}
}
float green[3] = { 0.0f, 0.69f, 0.0f }; // This is #00B000 in hex
return mitk::Color(green);
}
case 2:
{
if (m_PlaneNode3.IsNotNull())
{
if (m_PlaneNode3->GetColor(tmp))
{
return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode3->GetProperty("color"))->GetColor();
}
}
float blue[3] = { 0.0, 0.502f, 1.0f }; // This is #0080FF in hex
return mitk::Color(blue);
}
case 3:
{
return m_DecorationColorWidget4;
}
default:
MITK_ERROR << "Decoration color for unknown widget!";
float black[3] = { 0.0f, 0.0f, 0.0f };
return mitk::Color(black);
}
}
void QmitkStdMultiWidget::mousePressEvent(QMouseEvent* e)
{
if (QEvent::MouseButtonPress != e->type())
{
return;
}
auto renderWindowWidget = dynamic_cast<QmitkRenderWindowWidget*>(this->sender());
if (nullptr == renderWindowWidget)
{
return;
}
auto renderWindowWidgetPointer = GetRenderWindowWidget(renderWindowWidget->GetWidgetName());
SetActiveRenderWindowWidget(renderWindowWidgetPointer);
}
void QmitkStdMultiWidget::moveEvent(QMoveEvent* e)
{
QWidget::moveEvent(e);
// it is necessary to readjust the position of the Annotation as the StdMultiWidget has moved
// unfortunately it's not done by QmitkRenderWindow::moveEvent -> must be done here
emit Moved();
}
void QmitkStdMultiWidget::wheelEvent(QWheelEvent* e)
{
emit WheelMoved(e);
}
void QmitkStdMultiWidget::HandleCrosshairPositionEventDelayed()
{
auto dataStorage = GetDataStorage();
if (nullptr == dataStorage)
{
return;
}
m_PendingCrosshairPositionEvent = false;
// find image with highest layer
mitk::TNodePredicateDataType<mitk::Image>::Pointer isImageData = mitk::TNodePredicateDataType<mitk::Image>::New();
mitk::DataStorage::SetOfObjects::ConstPointer nodes = dataStorage->GetSubset(isImageData).GetPointer();
mitk::Point3D crosshairPos = GetSelectedPosition("");
mitk::BaseRenderer* baseRenderer = GetRenderWindow1()->GetSliceNavigationController()->GetRenderer();
auto globalCurrentTimePoint = baseRenderer->GetTime();
mitk::DataNode::Pointer node = mitk::FindTopmostVisibleNode(nodes, crosshairPos, globalCurrentTimePoint, baseRenderer);
mitk::DataNode::Pointer topSourceNode;
mitk::Image::Pointer image;
bool isBinary = false;
int component = 0;
if (node.IsNotNull())
{
node->GetBoolProperty("binary", isBinary);
if (isBinary)
{
mitk::DataStorage::SetOfObjects::ConstPointer sourcenodes = dataStorage->GetSources(node, nullptr, true);
if (!sourcenodes->empty())
{
topSourceNode = mitk::FindTopmostVisibleNode(sourcenodes, crosshairPos, globalCurrentTimePoint, baseRenderer);
}
if (topSourceNode.IsNotNull())
{
image = dynamic_cast<mitk::Image *>(topSourceNode->GetData());
topSourceNode->GetIntProperty("Image.Displayed Component", component);
}
else
{
image = dynamic_cast<mitk::Image *>(node->GetData());
node->GetIntProperty("Image.Displayed Component", component);
}
}
else
{
image = dynamic_cast<mitk::Image *>(node->GetData());
node->GetIntProperty("Image.Displayed Component", component);
}
}
std::string statusText;
std::stringstream stream;
itk::Index<3> p;
unsigned int timestep = baseRenderer->GetTimeStep();
if (image.IsNotNull() && (image->GetTimeSteps() > timestep))
{
image->GetGeometry()->WorldToIndex(crosshairPos, p);
stream.precision(2);
stream << "Position: <" << std::fixed << crosshairPos[0] << ", " << std::fixed << crosshairPos[1] << ", "
<< std::fixed << crosshairPos[2] << "> mm";
stream << "; Index: <" << p[0] << ", " << p[1] << ", " << p[2] << "> ";
mitk::ScalarType pixelValue;
mitkPixelTypeMultiplex5(mitk::FastSinglePixelAccess,
image->GetChannelDescriptor().GetPixelType(),
image,
image->GetVolumeData(image->GetTimeGeometry()->TimePointToTimeStep(globalCurrentTimePoint)),
p,
pixelValue,
component);
if (fabs(pixelValue) > 1000000 || fabs(pixelValue) < 0.01)
{
stream << "; Time: " << globalCurrentTimePoint << " ms; Pixelvalue: " << std::scientific << pixelValue << " ";
}
else
{
stream << "; Time: " << globalCurrentTimePoint << " ms; Pixelvalue: " << pixelValue << " ";
}
}
else
{
stream << "No image information at this position!";
}
statusText = stream.str();
mitk::StatusBar::GetInstance()->DisplayGreyValueText(statusText.c_str());
}
void QmitkStdMultiWidget::Fit()
{
vtkSmartPointer<vtkRenderer> vtkrenderer;
vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow1()->GetRenderWindow())->GetVtkRenderer();
if (nullptr != vtkrenderer)
{
vtkrenderer->ResetCamera();
}
vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow2()->GetRenderWindow())->GetVtkRenderer();
if (nullptr != vtkrenderer)
{
vtkrenderer->ResetCamera();
}
vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow3()->GetRenderWindow())->GetVtkRenderer();
if (nullptr != vtkrenderer)
{
vtkrenderer->ResetCamera();
}
vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow4()->GetRenderWindow())->GetVtkRenderer();
if (nullptr != vtkrenderer)
{
vtkrenderer->ResetCamera();
}
mitk::BaseRenderer::GetInstance(GetRenderWindow1()->GetRenderWindow())->GetCameraController()->Fit();
mitk::BaseRenderer::GetInstance(GetRenderWindow2()->GetRenderWindow())->GetCameraController()->Fit();
mitk::BaseRenderer::GetInstance(GetRenderWindow3()->GetRenderWindow())->GetCameraController()->Fit();
mitk::BaseRenderer::GetInstance(GetRenderWindow4()->GetRenderWindow())->GetCameraController()->Fit();
int w = vtkObject::GetGlobalWarningDisplay();
vtkObject::GlobalWarningDisplayOff();
vtkObject::SetGlobalWarningDisplay(w);
}
void QmitkStdMultiWidget::AddDisplayPlaneSubTree()
{
// add the displayed planes of the multiwidget to a node to which the subtree
// @a planesSubTree points ...
mitk::PlaneGeometryDataMapper2D::Pointer mapper;
// ... of widget 1
mitk::BaseRenderer* renderer1 = mitk::BaseRenderer::GetInstance(GetRenderWindow1()->GetRenderWindow());
m_PlaneNode1 = renderer1->GetCurrentWorldPlaneGeometryNode();
m_PlaneNode1->SetProperty("visible", mitk::BoolProperty::New(true));
m_PlaneNode1->SetProperty("name", mitk::StringProperty::New(std::string(renderer1->GetName()) + ".plane"));
m_PlaneNode1->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_PlaneNode1->SetProperty("helper object", mitk::BoolProperty::New(true));
mapper = mitk::PlaneGeometryDataMapper2D::New();
m_PlaneNode1->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
// ... of widget 2
mitk::BaseRenderer* renderer2 = mitk::BaseRenderer::GetInstance(GetRenderWindow2()->GetRenderWindow());
m_PlaneNode2 = renderer2->GetCurrentWorldPlaneGeometryNode();
m_PlaneNode2->SetProperty("visible", mitk::BoolProperty::New(true));
m_PlaneNode2->SetProperty("name", mitk::StringProperty::New(std::string(renderer2->GetName()) + ".plane"));
m_PlaneNode2->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_PlaneNode2->SetProperty("helper object", mitk::BoolProperty::New(true));
mapper = mitk::PlaneGeometryDataMapper2D::New();
m_PlaneNode2->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
// ... of widget 3
mitk::BaseRenderer *renderer3 = mitk::BaseRenderer::GetInstance(GetRenderWindow3()->GetRenderWindow());
m_PlaneNode3 = renderer3->GetCurrentWorldPlaneGeometryNode();
m_PlaneNode3->SetProperty("visible", mitk::BoolProperty::New(true));
m_PlaneNode3->SetProperty("name", mitk::StringProperty::New(std::string(renderer3->GetName()) + ".plane"));
m_PlaneNode3->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_PlaneNode3->SetProperty("helper object", mitk::BoolProperty::New(true));
mapper = mitk::PlaneGeometryDataMapper2D::New();
m_PlaneNode3->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
m_ParentNodeForGeometryPlanes = mitk::DataNode::New();
m_ParentNodeForGeometryPlanes->SetProperty("name", mitk::StringProperty::New("Widgets"));
m_ParentNodeForGeometryPlanes->SetProperty("helper object", mitk::BoolProperty::New(true));
}
void QmitkStdMultiWidget::EnsureDisplayContainsPoint(mitk::BaseRenderer *renderer, const mitk::Point3D &p)
{
mitk::Point2D pointOnDisplay;
renderer->WorldToDisplay(p, pointOnDisplay);
if (pointOnDisplay[0] < renderer->GetVtkRenderer()->GetOrigin()[0] ||
pointOnDisplay[1] < renderer->GetVtkRenderer()->GetOrigin()[1] ||
pointOnDisplay[0] > renderer->GetVtkRenderer()->GetOrigin()[0] + renderer->GetViewportSize()[0] ||
pointOnDisplay[1] > renderer->GetVtkRenderer()->GetOrigin()[1] + renderer->GetViewportSize()[1])
{
mitk::Point2D pointOnPlane;
renderer->GetCurrentWorldPlaneGeometry()->Map(p, pointOnPlane);
renderer->GetCameraController()->MoveCameraToPoint(pointOnPlane);
}
}
void QmitkStdMultiWidget::SetWidgetPlaneVisibility(const char *widgetName, bool visible, mitk::BaseRenderer *renderer)
{
auto dataStorage = GetDataStorage();
if (nullptr != dataStorage)
{
mitk::DataNode* dataNode = dataStorage->GetNamedNode(widgetName);
if (dataNode != nullptr)
{
dataNode->SetVisibility(visible, renderer);
}
}
}
void QmitkStdMultiWidget::SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer)
{
if (m_PlaneNode1.IsNotNull())
{
m_PlaneNode1->SetVisibility(visible, renderer);
}
if (m_PlaneNode2.IsNotNull())
{
m_PlaneNode2->SetVisibility(visible, renderer);
}
if (m_PlaneNode3.IsNotNull())
{
m_PlaneNode3->SetVisibility(visible, renderer);
}
GetRenderingManager()->RequestUpdateAll();
}
//////////////////////////////////////////////////////////////////////////
// PRIVATE
//////////////////////////////////////////////////////////////////////////
void QmitkStdMultiWidget::SetLayoutImpl()
{
CreateRenderWindowWidgets();
- GetMultiWidgetLayoutManager()->OnLayoutDesignChanged(QmitkMultiWidgetLayoutManager::LayoutDesign::DEFAULT);
+ GetMultiWidgetLayoutManager()->SetLayoutDesign(QmitkMultiWidgetLayoutManager::LayoutDesign::DEFAULT);
// Initialize views as axial, sagittal, coronal to all data objects in DataStorage
auto geo = GetDataStorage()->ComputeBoundingGeometry3D(GetDataStorage()->GetAll());
GetRenderingManager()->InitializeViews(geo);
}
void QmitkStdMultiWidget::CreateRenderWindowWidgets()
{
// create axial render window (widget)
QString renderWindowWidgetName = GetNameFromIndex(0, 0);
RenderWindowWidgetPointer renderWindowWidget1 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage(), GetRenderingManager());
auto renderWindow1 = renderWindowWidget1->GetRenderWindow();
renderWindow1->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
renderWindowWidget1->SetDecorationColor(GetDecorationColor(0));
renderWindowWidget1->SetCornerAnnotationText("Axial");
renderWindowWidget1->GetRenderWindow()->SetLayoutIndex(ViewDirection::AXIAL);
AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget1);
// create sagittal render window (widget)
renderWindowWidgetName = GetNameFromIndex(0, 1);
RenderWindowWidgetPointer renderWindowWidget2 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage(), GetRenderingManager());
auto renderWindow2 = renderWindowWidget2->GetRenderWindow();
renderWindow2->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
renderWindowWidget2->SetDecorationColor(GetDecorationColor(1));
renderWindowWidget2->setStyleSheet("border: 0px");
renderWindowWidget2->SetCornerAnnotationText("Sagittal");
renderWindowWidget2->GetRenderWindow()->SetLayoutIndex(ViewDirection::SAGITTAL);
AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget2);
// create coronal render window (widget)
renderWindowWidgetName = GetNameFromIndex(1, 0);
RenderWindowWidgetPointer renderWindowWidget3 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage(), GetRenderingManager());
auto renderWindow3 = renderWindowWidget3->GetRenderWindow();
renderWindow3->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal);
renderWindowWidget3->SetDecorationColor(GetDecorationColor(2));
renderWindowWidget3->SetCornerAnnotationText("Coronal");
renderWindowWidget3->GetRenderWindow()->SetLayoutIndex(ViewDirection::CORONAL);
AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget3);
// create 3D render window (widget)
renderWindowWidgetName = GetNameFromIndex(1, 1);
RenderWindowWidgetPointer renderWindowWidget4 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage(), GetRenderingManager());
auto renderWindow4 = renderWindowWidget4->GetRenderWindow();
renderWindow4->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Original);
renderWindowWidget4->SetDecorationColor(GetDecorationColor(3));
renderWindowWidget4->SetCornerAnnotationText("3D");
renderWindowWidget4->GetRenderWindow()->SetLayoutIndex(ViewDirection::THREE_D);
mitk::BaseRenderer::GetInstance(renderWindowWidget4->GetRenderWindow()->GetRenderWindow())->SetMapperID(mitk::BaseRenderer::Standard3D);
AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget4);
SetActiveRenderWindowWidget(renderWindowWidget1);
// connect to the "time navigation controller": send time via sliceNavigationControllers
m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow1->GetSliceNavigationController(), false);
m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow2->GetSliceNavigationController(), false);
m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow3->GetSliceNavigationController(), false);
m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow4->GetSliceNavigationController(), false);
renderWindow1->GetSliceNavigationController()->ConnectGeometrySendEvent(
mitk::BaseRenderer::GetInstance(renderWindow4->GetRenderWindow()));
// reverse connection between sliceNavigationControllers and timeNavigationController
renderWindow1->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
renderWindow2->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
renderWindow3->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
//renderWindow4->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
auto layoutManager = GetMultiWidgetLayoutManager();
connect(renderWindowWidget1.get(), &QmitkRenderWindowWidget::MouseEvent, this, &QmitkStdMultiWidget::mousePressEvent);
connect(renderWindow1, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
connect(renderWindow1, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
connect(renderWindow1, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
- connect(renderWindow1, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::OnLayoutDesignChanged);
+ connect(renderWindow1, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
connect(renderWindowWidget2.get(), &QmitkRenderWindowWidget::MouseEvent, this, &QmitkStdMultiWidget::mousePressEvent);
connect(renderWindow2, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
connect(renderWindow2, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
connect(renderWindow2, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
- connect(renderWindow2, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::OnLayoutDesignChanged);
+ connect(renderWindow2, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
connect(renderWindowWidget3.get(), &QmitkRenderWindowWidget::MouseEvent, this, &QmitkStdMultiWidget::mousePressEvent);
connect(renderWindow3, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
connect(renderWindow3, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
connect(renderWindow3, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
- connect(renderWindow3, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::OnLayoutDesignChanged);
+ connect(renderWindow3, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
connect(renderWindowWidget4.get(), &QmitkRenderWindowWidget::MouseEvent, this, &QmitkStdMultiWidget::mousePressEvent);
connect(renderWindow4, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
connect(renderWindow4, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
connect(renderWindow4, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
- connect(renderWindow4, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::OnLayoutDesignChanged);
+ connect(renderWindow4, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
}