diff --git a/Modules/QtWidgets/include/QmitkStdMultiWidget.h b/Modules/QtWidgets/include/QmitkStdMultiWidget.h
index cb7b47fc42..da5b5340a9 100644
--- a/Modules/QtWidgets/include/QmitkStdMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkStdMultiWidget.h
@@ -1,429 +1,433 @@
/*===================================================================
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 QmitkStdMultiWidget_h
#define QmitkStdMultiWidget_h
#include "MitkQtWidgetsExports.h"
#include <mitkDataStorage.h>
#include <mitkLogoAnnotation.h>
#include <mitkMouseModeSwitcher.h>
#include <QFrame>
#include <qsplitter.h>
#include <qwidget.h>
#include <QmitkLevelWindowWidget.h>
#include <QmitkRenderWindow.h>
#include <mitkBaseRenderer.h>
class QHBoxLayout;
class QVBoxLayout;
class QGridLayout;
class QSpacerItem;
class QmitkLevelWindowWidget;
class QmitkRenderWindow;
class vtkCornerAnnotation;
class vtkMitkRectangleProp;
namespace mitk
{
class RenderingManager;
}
/// \ingroup QmitkModule
class MITKQTWIDGETS_EXPORT QmitkStdMultiWidget : public QWidget
{
Q_OBJECT
public:
QmitkStdMultiWidget(
QWidget *parent = 0,
Qt::WindowFlags f = 0,
mitk::RenderingManager *renderingManager = 0,
mitk::BaseRenderer::RenderingMode::Type renderingMode = mitk::BaseRenderer::RenderingMode::Standard,
const QString &name = "stdmulti");
virtual ~QmitkStdMultiWidget();
mitk::SliceNavigationController *GetTimeNavigationController();
void RequestUpdate();
void ForceImmediateUpdate();
mitk::MouseModeSwitcher *GetMouseModeSwitcher();
QmitkRenderWindow *GetRenderWindow1() const;
QmitkRenderWindow *GetRenderWindow2() const;
QmitkRenderWindow *GetRenderWindow3() const;
QmitkRenderWindow *GetRenderWindow4() const;
const mitk::Point3D GetCrossPosition() const;
void EnablePositionTracking();
void DisablePositionTracking();
int GetLayout() const;
bool GetGradientBackgroundFlag() const;
/*!
\brief Access node of widget plane 1
\return DataNode holding widget plane 1
*/
mitk::DataNode::Pointer GetWidgetPlane1();
/*!
\brief Access node of widget plane 2
\return DataNode holding widget plane 2
*/
mitk::DataNode::Pointer GetWidgetPlane2();
/*!
\brief Access node of widget plane 3
\return DataNode holding widget plane 3
*/
mitk::DataNode::Pointer GetWidgetPlane3();
/*!
\brief Convenience method to access node of widget planes
\param id number of widget plane to be returned
\return DataNode holding widget plane 3
*/
mitk::DataNode::Pointer GetWidgetPlane(int id);
bool IsColoredRectanglesEnabled() const;
bool IsDepartmentLogoEnabled() const;
void InitializeWidget();
/// called when the StdMultiWidget is closed to remove the 3 widget planes and the helper node from the DataStorage
void RemovePlanesFromDataStorage();
void AddPlanesToDataStorage();
void SetDataStorage(mitk::DataStorage *ds);
/** \brief Listener to the CrosshairPositionEvent
Ensures the CrosshairPositionEvent is handled only once and at the end of the Qt-Event loop
*/
void HandleCrosshairPositionEvent();
/// activate Menu Widget. true: activated, false: deactivated
void ActivateMenuWidget(bool state);
bool IsMenuWidgetEnabled() const;
void SetCornerAnnotationVisibility(bool visibility);
bool IsCornerAnnotationVisible(void) const;
protected:
void UpdateAllWidgets();
void HideAllWidgetToolbars();
mitk::DataNode::Pointer GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes);
public slots:
/// Receives the signal from HandleCrosshairPositionEvent, executes the StatusBar update
void HandleCrosshairPositionEventDelayed();
void changeLayoutTo2DImagesUp();
void changeLayoutTo2DImagesLeft();
void changeLayoutToDefault();
void changeLayoutToBig3D();
void changeLayoutToWidget1();
void changeLayoutToWidget2();
void changeLayoutToWidget3();
void changeLayoutToRowWidget3And4();
void changeLayoutToColumnWidget3And4();
void changeLayoutToRowWidgetSmall3andBig4();
void changeLayoutToSmallUpperWidget2Big3and4();
void changeLayoutTo2x2Dand3DWidget();
void changeLayoutToLeft2Dand3DRight2D();
- void changeLayoutTo2DUpAnd3DDown();
+ /** Changes the layout to one 2D window up and a 3D window down.
+ * The 2D window can be defined by its id (1-3). If MITK default
+ * settings were not changed, 1 is axial, 2 is sagittal and 3 is coronal.
+ */
+ void changeLayoutTo2DUpAnd3DDown(unsigned int id2Dwindow = 2);
void Fit();
void InitPositionTracking();
void AddDisplayPlaneSubTree();
void EnableStandardLevelWindow();
void DisableStandardLevelWindow();
bool InitializeStandardViews(const mitk::Geometry3D *geometry);
void wheelEvent(QWheelEvent *e) override;
void mousePressEvent(QMouseEvent *e) override;
void moveEvent(QMoveEvent *e) override;
void EnsureDisplayContainsPoint(mitk::BaseRenderer *renderer, const mitk::Point3D &p);
void MoveCrossToPosition(const mitk::Point3D &newPosition);
// void EnableNavigationControllerEventListening();
// void DisableNavigationControllerEventListening();
void EnableGradientBackground();
void DisableGradientBackground();
void EnableDepartmentLogo();
void DisableDepartmentLogo();
void EnableColoredRectangles();
void DisableColoredRectangles();
void SetWidgetPlaneVisibility(const char *widgetName, bool visible, mitk::BaseRenderer *renderer = NULL);
void SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer = NULL);
void SetWidgetPlanesLocked(bool locked);
void SetWidgetPlanesRotationLocked(bool locked);
void SetWidgetPlanesRotationLinked(bool link);
void SetWidgetPlaneMode(int mode);
void SetGradientBackgroundColors(const mitk::Color &upper, const mitk::Color &lower);
void SetDepartmentLogoPath(const char *path);
void SetWidgetPlaneModeToSlicing(bool activate);
void SetWidgetPlaneModeToRotation(bool activate);
void SetWidgetPlaneModeToSwivel(bool activate);
void OnLayoutDesignChanged(int layoutDesignIndex);
void ResetCrosshair();
signals:
void LeftMouseClicked(mitk::Point3D pointValue);
void WheelMoved(QWheelEvent *);
void WidgetPlanesRotationLinked(bool);
void WidgetPlanesRotationEnabled(bool);
void ViewsInitialized();
void WidgetPlaneModeSlicing(bool);
void WidgetPlaneModeRotation(bool);
void WidgetPlaneModeSwivel(bool);
void WidgetPlaneModeChange(int);
void WidgetNotifyNewCrossHairMode(int);
void Moved();
public:
/** Define RenderWindow (public)*/
QmitkRenderWindow *mitkWidget1;
QmitkRenderWindow *mitkWidget2;
QmitkRenderWindow *mitkWidget3;
QmitkRenderWindow *mitkWidget4;
QmitkLevelWindowWidget *levelWindowWidget;
/********************************/
enum
{
PLANE_MODE_SLICING = 0,
PLANE_MODE_ROTATION,
PLANE_MODE_SWIVEL
};
enum
{
LAYOUT_DEFAULT = 0,
LAYOUT_2D_IMAGES_UP,
LAYOUT_2D_IMAGES_LEFT,
LAYOUT_BIG_3D,
LAYOUT_WIDGET1,
LAYOUT_WIDGET2,
LAYOUT_WIDGET3,
LAYOUT_2X_2D_AND_3D_WIDGET,
LAYOUT_ROW_WIDGET_3_AND_4,
LAYOUT_COLUMN_WIDGET_3_AND_4,
LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4,
LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4,
LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET,
LAYOUT_2D_UP_AND_3D_DOWN
};
enum
{
AXIAL,
SAGITTAL,
CORONAL,
THREE_D
};
/**
* @brief SetCornerAnnotation Create a corner annotation for a widget.
* @param text The text of the annotation.
* @param color The color.
* @param widgetNumber The widget (0-3).
*/
void SetDecorationProperties(std::string text, mitk::Color color, int widgetNumber);
/**
* @brief GetRenderWindow convinience method to get a widget.
* @param number of the widget (0-3)
* @return The renderwindow widget.
*/
QmitkRenderWindow *GetRenderWindow(unsigned int number);
/**
* @brief SetGradientBackgroundColorForRenderWindow background for a widget.
*
* If two different input colors are, a gradient background is generated.
*
* @param upper Upper color of the gradient background.
* @param lower Lower color of the gradient background.
* @param widgetNumber The widget (0-3).
*/
void SetGradientBackgroundColorForRenderWindow(const mitk::Color &upper,
const mitk::Color &lower,
unsigned int widgetNumber);
/**
* @brief GetDecorationColorForWidget Get the color for annotation, crosshair and rectangle.
* @param widgetNumber Number of the renderwindow (0-3).
* @return Color in mitk format.
*/
mitk::Color GetDecorationColor(unsigned int widgetNumber);
/**
* @brief SetDecorationColor Set the color of the decoration of the 4 widgets.
*
* This is used to color the frame of the renderwindow and the corner annatation.
* For the first 3 widgets, this color is a property of the helper object nodes
* which contain the respective plane geometry. For widget 4, this is a member,
* since there is no data node for this widget.
*/
void SetDecorationColor(unsigned int widgetNumber, mitk::Color color);
/**
* @brief GetCornerAnnotationText Getter for corner annotation text.
* @param widgetNumber the widget number (0-3).
* @return The text in the corner annotation.
*/
std::string GetCornerAnnotationText(unsigned int widgetNumber);
/**
* @brief GetGradientColors Getter for gradientbackground colors.
* @param widgetNumber the widget number (0-3).
* @return A pair of colors. First: upper, second: lower.
*/
std::pair<mitk::Color, mitk::Color> GetGradientColors(unsigned int widgetNumber);
protected:
QHBoxLayout *QmitkStdMultiWidgetLayout;
int m_Layout;
int m_PlaneMode;
mitk::RenderingManager *m_RenderingManager;
mitk::LogoAnnotation::Pointer m_LogoRendering;
bool m_GradientBackgroundFlag;
mitk::MouseModeSwitcher::Pointer m_MouseModeSwitcher;
mitk::SliceNavigationController *m_TimeNavigationController;
mitk::DataStorage::Pointer m_DataStorage;
/**
* @brief m_PlaneNode1 the 3 helper objects which contain the plane geometry.
*/
mitk::DataNode::Pointer m_PlaneNode1;
mitk::DataNode::Pointer m_PlaneNode2;
mitk::DataNode::Pointer m_PlaneNode3;
/**
* @brief m_ParentNodeForGeometryPlanes This helper object is added to the datastorage
* and contains the 3 planes for displaying the image geometry (crosshair and 3D planes).
*/
mitk::DataNode::Pointer m_ParentNodeForGeometryPlanes;
/**
* @brief m_DecorationColorWidget4 color for annotation and rectangle of widget 4.
*
* For other widgets1-3, the color is a property of the respective data node.
* There is no node for widget 4, hence, we need an extra member.
*/
mitk::Color m_DecorationColorWidget4;
/**
* @brief m_GradientBackgroundColors Contains the colors of the gradient background.
*
*/
std::pair<mitk::Color, mitk::Color> m_GradientBackgroundColors[4];
QSplitter *m_MainSplit;
QSplitter *m_LayoutSplit;
QSplitter *m_SubSplit1;
QSplitter *m_SubSplit2;
QWidget *mitkWidget1Container;
QWidget *mitkWidget2Container;
QWidget *mitkWidget3Container;
QWidget *mitkWidget4Container;
vtkSmartPointer<vtkCornerAnnotation> m_CornerAnnotations[4];
vtkSmartPointer<vtkMitkRectangleProp> m_RectangleProps[4];
bool m_PendingCrosshairPositionEvent;
bool m_CrosshairNavigationEnabled;
/**
* @brief CreateCornerAnnotation helper method to create a corner annotation.
* @param text of the annotation.
* @param color of the annotation.
* @return the complete CornerAnnotation.
*/
vtkSmartPointer<vtkCornerAnnotation> CreateCornerAnnotation(std::string text, mitk::Color color);
/**
* @brief FillGradientBackgroundWithBlack Internal helper method to initialize the
* gradient background colors with black.
*/
void FillGradientBackgroundWithBlack();
};
#endif /*QmitkStdMultiWidget_h*/
diff --git a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
index 500968e857..795b03dfce 100644
--- a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
@@ -1,2021 +1,2056 @@
/*===================================================================
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 <QGridLayout>
#include <QHBoxLayout>
#include <QList>
#include <QMouseEvent>
#include <QTimer>
#include <QVBoxLayout>
#include <qsplitter.h>
#include "mitkImagePixelReadAccessor.h"
#include "mitkPixelTypeMultiplex.h"
#include <mitkManualPlacementAnnotationRenderer.h>
#include <mitkCameraController.h>
#include <mitkDataStorage.h>
#include <mitkImage.h>
#include <mitkInteractionConst.h>
#include <mitkLine.h>
#include <mitkNodePredicateBase.h>
#include <mitkNodePredicateDataType.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
#include <mitkPlaneGeometryDataMapper2D.h>
#include <mitkPointSet.h>
#include <mitkProperties.h>
#include <mitkStatusBar.h>
#include <mitkVtkLayerController.h>
#include <vtkCornerAnnotation.h>
#include <vtkMitkRectangleProp.h>
#include <vtkTextProperty.h>
#include <iomanip>
QmitkStdMultiWidget::QmitkStdMultiWidget(QWidget *parent,
Qt::WindowFlags f,
mitk::RenderingManager *renderingManager,
mitk::BaseRenderer::RenderingMode::Type renderingMode,
const QString &name)
: QWidget(parent, f),
mitkWidget1(NULL),
mitkWidget2(NULL),
mitkWidget3(NULL),
mitkWidget4(NULL),
levelWindowWidget(NULL),
QmitkStdMultiWidgetLayout(NULL),
m_Layout(LAYOUT_DEFAULT),
m_PlaneMode(PLANE_MODE_SLICING),
m_RenderingManager(renderingManager),
m_GradientBackgroundFlag(true),
m_TimeNavigationController(NULL),
m_MainSplit(NULL),
m_LayoutSplit(NULL),
m_SubSplit1(NULL),
m_SubSplit2(NULL),
mitkWidget1Container(NULL),
mitkWidget2Container(NULL),
mitkWidget3Container(NULL),
mitkWidget4Container(NULL),
m_PendingCrosshairPositionEvent(false),
m_CrosshairNavigationEnabled(false)
{
/******************************************************
* Use the global RenderingManager if none was specified
* ****************************************************/
if (m_RenderingManager == NULL)
{
m_RenderingManager = mitk::RenderingManager::GetInstance();
}
m_TimeNavigationController = m_RenderingManager->GetTimeNavigationController();
/*******************************/
// Create Widget manually
/*******************************/
// create Layouts
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
QmitkStdMultiWidgetLayout->setContentsMargins(0, 0, 0, 0);
// Set Layout to widget
this->setLayout(QmitkStdMultiWidgetLayout);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
m_MainSplit->addWidget(m_LayoutSplit);
// create m_SubSplit1 and m_SubSplit2
m_SubSplit1 = new QSplitter(m_LayoutSplit);
m_SubSplit2 = new QSplitter(m_LayoutSplit);
// creae Widget Container
mitkWidget1Container = new QWidget(m_SubSplit1);
mitkWidget2Container = new QWidget(m_SubSplit1);
mitkWidget3Container = new QWidget(m_SubSplit2);
mitkWidget4Container = new QWidget(m_SubSplit2);
mitkWidget1Container->setContentsMargins(0, 0, 0, 0);
mitkWidget2Container->setContentsMargins(0, 0, 0, 0);
mitkWidget3Container->setContentsMargins(0, 0, 0, 0);
mitkWidget4Container->setContentsMargins(0, 0, 0, 0);
// create Widget Layout
QHBoxLayout *mitkWidgetLayout1 = new QHBoxLayout(mitkWidget1Container);
QHBoxLayout *mitkWidgetLayout2 = new QHBoxLayout(mitkWidget2Container);
QHBoxLayout *mitkWidgetLayout3 = new QHBoxLayout(mitkWidget3Container);
QHBoxLayout *mitkWidgetLayout4 = new QHBoxLayout(mitkWidget4Container);
m_CornerAnnotations[0] = vtkSmartPointer<vtkCornerAnnotation>::New();
m_CornerAnnotations[1] = vtkSmartPointer<vtkCornerAnnotation>::New();
m_CornerAnnotations[2] = vtkSmartPointer<vtkCornerAnnotation>::New();
m_CornerAnnotations[3] = vtkSmartPointer<vtkCornerAnnotation>::New();
m_RectangleProps[0] = vtkSmartPointer<vtkMitkRectangleProp>::New();
m_RectangleProps[1] = vtkSmartPointer<vtkMitkRectangleProp>::New();
m_RectangleProps[2] = vtkSmartPointer<vtkMitkRectangleProp>::New();
m_RectangleProps[3] = vtkSmartPointer<vtkMitkRectangleProp>::New();
mitkWidgetLayout1->setMargin(0);
mitkWidgetLayout2->setMargin(0);
mitkWidgetLayout3->setMargin(0);
mitkWidgetLayout4->setMargin(0);
// set Layout to Widget Container
mitkWidget1Container->setLayout(mitkWidgetLayout1);
mitkWidget2Container->setLayout(mitkWidgetLayout2);
mitkWidget3Container->setLayout(mitkWidgetLayout3);
mitkWidget4Container->setLayout(mitkWidgetLayout4);
// set SizePolicy
mitkWidget1Container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
mitkWidget2Container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
mitkWidget3Container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
mitkWidget4Container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
// insert Widget Container into the splitters
m_SubSplit1->addWidget(mitkWidget1Container);
m_SubSplit1->addWidget(mitkWidget2Container);
m_SubSplit2->addWidget(mitkWidget3Container);
m_SubSplit2->addWidget(mitkWidget4Container);
// Create RenderWindows 1
mitkWidget1 = new QmitkRenderWindow(mitkWidget1Container, name + ".widget1", NULL, m_RenderingManager, renderingMode);
mitkWidget1->SetLayoutIndex(AXIAL);
mitkWidgetLayout1->addWidget(mitkWidget1);
// Create RenderWindows 2
mitkWidget2 = new QmitkRenderWindow(mitkWidget2Container, name + ".widget2", NULL, m_RenderingManager, renderingMode);
mitkWidget2->setEnabled(true);
mitkWidget2->SetLayoutIndex(SAGITTAL);
mitkWidgetLayout2->addWidget(mitkWidget2);
// Create RenderWindows 3
mitkWidget3 = new QmitkRenderWindow(mitkWidget3Container, name + ".widget3", NULL, m_RenderingManager, renderingMode);
mitkWidget3->SetLayoutIndex(CORONAL);
mitkWidgetLayout3->addWidget(mitkWidget3);
// Create RenderWindows 4
mitkWidget4 = new QmitkRenderWindow(mitkWidget4Container, name + ".widget4", NULL, m_RenderingManager, renderingMode);
mitkWidget4->SetLayoutIndex(THREE_D);
mitkWidgetLayout4->addWidget(mitkWidget4);
// create SignalSlot Connection
connect(mitkWidget1, SIGNAL(SignalLayoutDesignChanged(int)), this, SLOT(OnLayoutDesignChanged(int)));
connect(mitkWidget1, SIGNAL(ResetView()), this, SLOT(ResetCrosshair()));
connect(mitkWidget1, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int)));
connect(this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget1, SLOT(OnWidgetPlaneModeChanged(int)));
connect(mitkWidget2, SIGNAL(SignalLayoutDesignChanged(int)), this, SLOT(OnLayoutDesignChanged(int)));
connect(mitkWidget2, SIGNAL(ResetView()), this, SLOT(ResetCrosshair()));
connect(mitkWidget2, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int)));
connect(this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget2, SLOT(OnWidgetPlaneModeChanged(int)));
connect(mitkWidget3, SIGNAL(SignalLayoutDesignChanged(int)), this, SLOT(OnLayoutDesignChanged(int)));
connect(mitkWidget3, SIGNAL(ResetView()), this, SLOT(ResetCrosshair()));
connect(mitkWidget3, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int)));
connect(this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget3, SLOT(OnWidgetPlaneModeChanged(int)));
connect(mitkWidget4, SIGNAL(SignalLayoutDesignChanged(int)), this, SLOT(OnLayoutDesignChanged(int)));
connect(mitkWidget4, SIGNAL(ResetView()), this, SLOT(ResetCrosshair()));
connect(mitkWidget4, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int)));
connect(this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget4, SLOT(OnWidgetPlaneModeChanged(int)));
// Create Level Window Widget
levelWindowWidget = new QmitkLevelWindowWidget(m_MainSplit); // this
levelWindowWidget->setObjectName(QString::fromUtf8("levelWindowWidget"));
QSizePolicy sizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
sizePolicy.setHorizontalStretch(0);
sizePolicy.setVerticalStretch(0);
sizePolicy.setHeightForWidth(levelWindowWidget->sizePolicy().hasHeightForWidth());
levelWindowWidget->setSizePolicy(sizePolicy);
levelWindowWidget->setMaximumWidth(50);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// show mainSplitt and add to Layout
m_MainSplit->show();
// resize Image.
this->resize(QSize(364, 477).expandedTo(minimumSizeHint()));
// Initialize the widgets.
this->InitializeWidget();
// Activate Widget Menu
this->ActivateMenuWidget(true);
}
void QmitkStdMultiWidget::InitializeWidget()
{
// Make all black and overwrite renderwindow 4
this->FillGradientBackgroundWithBlack();
// This is #191919 in hex
float tmp1[3] = {0.098f, 0.098f, 0.098f};
// This is #7F7F7F in hex
float tmp2[3] = {0.498f, 0.498f, 0.498f};
m_GradientBackgroundColors[3] = std::make_pair(mitk::Color(tmp1), mitk::Color(tmp2));
// Yellow is default color for widget4
m_DecorationColorWidget4[0] = 1.0f;
m_DecorationColorWidget4[1] = 1.0f;
m_DecorationColorWidget4[2] = 0.0f;
// transfer colors in WorldGeometry-Nodes of the associated Renderer
mitk::IntProperty::Pointer layer;
// of widget 1
m_PlaneNode1 = mitk::BaseRenderer::GetInstance(mitkWidget1->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(mitkWidget2->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(mitkWidget3->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(mitkWidget4->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
layer = mitk::IntProperty::New(1000);
m_ParentNodeForGeometryPlanes->SetProperty("layer", layer);
mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetMapperID(mitk::BaseRenderer::Standard3D);
// Set plane mode (slicing/rotation behavior) to slicing (default)
m_PlaneMode = PLANE_MODE_SLICING;
// Set default view directions for SNCs
mitkWidget1->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
mitkWidget2->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
mitkWidget3->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal);
mitkWidget4->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Original);
SetDecorationProperties("Axial", GetDecorationColor(0), 0);
SetDecorationProperties("Sagittal", GetDecorationColor(1), 1);
SetDecorationProperties("Coronal", GetDecorationColor(2), 2);
SetDecorationProperties("3D", GetDecorationColor(3), 3);
// connect to the "time navigation controller": send time via sliceNavigationControllers
m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget1->GetSliceNavigationController(), false);
m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget2->GetSliceNavigationController(), false);
m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget3->GetSliceNavigationController(), false);
m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget4->GetSliceNavigationController(), false);
mitkWidget1->GetSliceNavigationController()->ConnectGeometrySendEvent(
mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
// reverse connection between sliceNavigationControllers and m_TimeNavigationController
mitkWidget1->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
mitkWidget2->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
mitkWidget3->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
// mitkWidget4->GetSliceNavigationController()
// ->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
m_MouseModeSwitcher = mitk::MouseModeSwitcher::New();
// setup the department logo rendering
m_LogoRendering = mitk::LogoAnnotation::New();
mitk::BaseRenderer::Pointer renderer4 = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow());
m_LogoRendering->SetOpacity(0.5);
mitk::Point2D offset;
offset.Fill(0.03);
m_LogoRendering->SetOffsetVector(offset);
m_LogoRendering->SetRelativeSize(0.15);
m_LogoRendering->SetCornerPosition(1);
m_LogoRendering->SetLogoImagePath("DefaultLogo");
mitk::ManualPlacementAnnotationRenderer::AddAnnotation(m_LogoRendering.GetPointer(), renderer4);
}
void QmitkStdMultiWidget::FillGradientBackgroundWithBlack()
{
// We have 4 widgets and ...
for (unsigned int i = 0; i < 4; ++i)
{
float black[3] = {0.0f, 0.0f, 0.0f};
m_GradientBackgroundColors[i] = std::make_pair(mitk::Color(black), mitk::Color(black));
}
}
std::pair<mitk::Color, mitk::Color> QmitkStdMultiWidget::GetGradientColors(unsigned int widgetNumber)
{
if (widgetNumber > 3)
{
MITK_ERROR << "Decoration color for unknown widget!";
float black[3] = {0.0f, 0.0f, 0.0f};
return std::make_pair(mitk::Color(black), mitk::Color(black));
}
return m_GradientBackgroundColors[widgetNumber];
}
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 visibitliy.
// 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);
}
}
std::string QmitkStdMultiWidget::GetCornerAnnotationText(unsigned int widgetNumber)
{
if (widgetNumber > 3)
{
MITK_ERROR << "Decoration color for unknown widget!";
return std::string("");
}
return std::string(m_CornerAnnotations[widgetNumber]->GetText(0));
}
QmitkStdMultiWidget::~QmitkStdMultiWidget()
{
DisablePositionTracking();
// DisableNavigationControllerEventListening();
m_TimeNavigationController->Disconnect(mitkWidget1->GetSliceNavigationController());
m_TimeNavigationController->Disconnect(mitkWidget2->GetSliceNavigationController());
m_TimeNavigationController->Disconnect(mitkWidget3->GetSliceNavigationController());
m_TimeNavigationController->Disconnect(mitkWidget4->GetSliceNavigationController());
}
void QmitkStdMultiWidget::RemovePlanesFromDataStorage()
{
if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull() && m_PlaneNode3.IsNotNull() &&
m_ParentNodeForGeometryPlanes.IsNotNull())
{
if (m_DataStorage.IsNotNull())
{
m_DataStorage->Remove(m_PlaneNode1);
m_DataStorage->Remove(m_PlaneNode2);
m_DataStorage->Remove(m_PlaneNode3);
m_DataStorage->Remove(m_ParentNodeForGeometryPlanes);
}
}
}
void QmitkStdMultiWidget::AddPlanesToDataStorage()
{
if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull() && m_PlaneNode3.IsNotNull() &&
m_ParentNodeForGeometryPlanes.IsNotNull())
{
if (m_DataStorage.IsNotNull())
{
m_DataStorage->Add(m_ParentNodeForGeometryPlanes);
m_DataStorage->Add(m_PlaneNode1, m_ParentNodeForGeometryPlanes);
m_DataStorage->Add(m_PlaneNode2, m_ParentNodeForGeometryPlanes);
m_DataStorage->Add(m_PlaneNode3, m_ParentNodeForGeometryPlanes);
}
}
}
void QmitkStdMultiWidget::changeLayoutTo2DImagesUp()
{
SMW_INFO << "changing layout to 2D images up... " << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// Set Layout to widget
this->setLayout(QmitkStdMultiWidgetLayout);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
m_MainSplit->addWidget(m_LayoutSplit);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// create m_SubSplit1 and m_SubSplit2
m_SubSplit1 = new QSplitter(m_LayoutSplit);
m_SubSplit2 = new QSplitter(m_LayoutSplit);
// insert Widget Container into splitter top
m_SubSplit1->addWidget(mitkWidget1Container);
m_SubSplit1->addWidget(mitkWidget2Container);
m_SubSplit1->addWidget(mitkWidget3Container);
// set SplitterSize for splitter top
QList<int> splitterSize;
splitterSize.push_back(1000);
splitterSize.push_back(1000);
splitterSize.push_back(1000);
m_SubSplit1->setSizes(splitterSize);
// insert Widget Container into splitter bottom
m_SubSplit2->addWidget(mitkWidget4Container);
// set SplitterSize for splitter m_LayoutSplit
splitterSize.clear();
splitterSize.push_back(400);
splitterSize.push_back(1000);
m_LayoutSplit->setSizes(splitterSize);
// show mainSplitt
m_MainSplit->show();
// show Widget if hidden
if (mitkWidget1->isHidden())
mitkWidget1->show();
if (mitkWidget2->isHidden())
mitkWidget2->show();
if (mitkWidget3->isHidden())
mitkWidget3->show();
if (mitkWidget4->isHidden())
mitkWidget4->show();
// Change Layout Name
m_Layout = LAYOUT_2D_IMAGES_UP;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_2D_IMAGES_UP);
mitkWidget2->LayoutDesignListChanged(LAYOUT_2D_IMAGES_UP);
mitkWidget3->LayoutDesignListChanged(LAYOUT_2D_IMAGES_UP);
mitkWidget4->LayoutDesignListChanged(LAYOUT_2D_IMAGES_UP);
// update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutTo2DImagesLeft()
{
SMW_INFO << "changing layout to 2D images left... " << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter(m_MainSplit);
m_MainSplit->addWidget(m_LayoutSplit);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// create m_SubSplit1 and m_SubSplit2
m_SubSplit1 = new QSplitter(Qt::Vertical, m_LayoutSplit);
m_SubSplit2 = new QSplitter(m_LayoutSplit);
// insert Widget into the splitters
m_SubSplit1->addWidget(mitkWidget1Container);
m_SubSplit1->addWidget(mitkWidget2Container);
m_SubSplit1->addWidget(mitkWidget3Container);
// set splitterSize of SubSplit1
QList<int> splitterSize;
splitterSize.push_back(1000);
splitterSize.push_back(1000);
splitterSize.push_back(1000);
m_SubSplit1->setSizes(splitterSize);
m_SubSplit2->addWidget(mitkWidget4Container);
// set splitterSize of Layout Split
splitterSize.clear();
splitterSize.push_back(400);
splitterSize.push_back(1000);
m_LayoutSplit->setSizes(splitterSize);
// show mainSplitt and add to Layout
m_MainSplit->show();
// show Widget if hidden
if (mitkWidget1->isHidden())
mitkWidget1->show();
if (mitkWidget2->isHidden())
mitkWidget2->show();
if (mitkWidget3->isHidden())
mitkWidget3->show();
if (mitkWidget4->isHidden())
mitkWidget4->show();
// update Layout Name
m_Layout = LAYOUT_2D_IMAGES_LEFT;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_2D_IMAGES_LEFT);
mitkWidget2->LayoutDesignListChanged(LAYOUT_2D_IMAGES_LEFT);
mitkWidget3->LayoutDesignListChanged(LAYOUT_2D_IMAGES_LEFT);
mitkWidget4->LayoutDesignListChanged(LAYOUT_2D_IMAGES_LEFT);
// update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::SetDecorationProperties(std::string text, mitk::Color color, int widgetNumber)
{
if (widgetNumber > 3)
{
MITK_ERROR << "Unknown render window for annotation.";
return;
}
vtkRenderer *renderer = this->GetRenderWindow(widgetNumber)->GetRenderer()->GetVtkRenderer();
if (!renderer)
return;
vtkSmartPointer<vtkCornerAnnotation> annotation = m_CornerAnnotations[widgetNumber];
annotation->SetText(0, text.c_str());
annotation->SetMaximumFontSize(12);
annotation->GetTextProperty()->SetColor(color[0], color[1], color[2]);
if (!renderer->HasViewProp(annotation))
{
renderer->AddViewProp(annotation);
}
vtkSmartPointer<vtkMitkRectangleProp> frame = m_RectangleProps[widgetNumber];
frame->SetColor(color[0], color[1], color[2]);
if (!renderer->HasViewProp(frame))
{
renderer->AddViewProp(frame);
}
}
void QmitkStdMultiWidget::SetCornerAnnotationVisibility(bool visibility)
{
for (int i = 0; i < 4; ++i)
{
m_CornerAnnotations[i]->SetVisibility(visibility);
}
}
bool QmitkStdMultiWidget::IsCornerAnnotationVisible(void) const
{
return m_CornerAnnotations[0]->GetVisibility() > 0;
}
QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow(unsigned int number)
{
switch (number)
{
case 0:
return this->GetRenderWindow1();
case 1:
return this->GetRenderWindow2();
case 2:
return this->GetRenderWindow3();
case 3:
return this->GetRenderWindow4();
default:
MITK_ERROR << "Requested unknown render window";
break;
}
return NULL;
}
void QmitkStdMultiWidget::changeLayoutToDefault()
{
SMW_INFO << "changing layout to default... " << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
m_MainSplit->addWidget(m_LayoutSplit);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// create m_SubSplit1 and m_SubSplit2
m_SubSplit1 = new QSplitter(m_LayoutSplit);
m_SubSplit2 = new QSplitter(m_LayoutSplit);
// insert Widget container into the splitters
m_SubSplit1->addWidget(mitkWidget1Container);
m_SubSplit1->addWidget(mitkWidget2Container);
m_SubSplit2->addWidget(mitkWidget3Container);
m_SubSplit2->addWidget(mitkWidget4Container);
// set splitter Size
QList<int> splitterSize;
splitterSize.push_back(1000);
splitterSize.push_back(1000);
m_SubSplit1->setSizes(splitterSize);
m_SubSplit2->setSizes(splitterSize);
m_LayoutSplit->setSizes(splitterSize);
// show mainSplitt and add to Layout
m_MainSplit->show();
// show Widget if hidden
if (mitkWidget1->isHidden())
mitkWidget1->show();
if (mitkWidget2->isHidden())
mitkWidget2->show();
if (mitkWidget3->isHidden())
mitkWidget3->show();
if (mitkWidget4->isHidden())
mitkWidget4->show();
m_Layout = LAYOUT_DEFAULT;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_DEFAULT);
mitkWidget2->LayoutDesignListChanged(LAYOUT_DEFAULT);
mitkWidget3->LayoutDesignListChanged(LAYOUT_DEFAULT);
mitkWidget4->LayoutDesignListChanged(LAYOUT_DEFAULT);
// update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutToBig3D()
{
SMW_INFO << "changing layout to big 3D ..." << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// add widget Splitter to main Splitter
m_MainSplit->addWidget(mitkWidget4Container);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// show mainSplitt and add to Layout
m_MainSplit->show();
// show/hide Widgets
mitkWidget1->hide();
mitkWidget2->hide();
mitkWidget3->hide();
if (mitkWidget4->isHidden())
mitkWidget4->show();
m_Layout = LAYOUT_BIG_3D;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_BIG_3D);
mitkWidget2->LayoutDesignListChanged(LAYOUT_BIG_3D);
mitkWidget3->LayoutDesignListChanged(LAYOUT_BIG_3D);
mitkWidget4->LayoutDesignListChanged(LAYOUT_BIG_3D);
// update Alle Widgets
this->UpdateAllWidgets();
mitk::RenderingManager::GetInstance()->SetRenderWindowFocus(mitkWidget4->GetVtkRenderWindow());
}
void QmitkStdMultiWidget::changeLayoutToWidget1()
{
SMW_INFO << "changing layout to big Widget1 ..." << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// add widget Splitter to main Splitter
m_MainSplit->addWidget(mitkWidget1Container);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// show mainSplitt and add to Layout
m_MainSplit->show();
// show/hide Widgets
if (mitkWidget1->isHidden())
mitkWidget1->show();
mitkWidget2->hide();
mitkWidget3->hide();
mitkWidget4->hide();
m_Layout = LAYOUT_WIDGET1;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_WIDGET1);
mitkWidget2->LayoutDesignListChanged(LAYOUT_WIDGET1);
mitkWidget3->LayoutDesignListChanged(LAYOUT_WIDGET1);
mitkWidget4->LayoutDesignListChanged(LAYOUT_WIDGET1);
// update Alle Widgets
this->UpdateAllWidgets();
mitk::RenderingManager::GetInstance()->SetRenderWindowFocus(mitkWidget1->GetVtkRenderWindow());
}
void QmitkStdMultiWidget::changeLayoutToWidget2()
{
SMW_INFO << "changing layout to big Widget2 ..." << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// add widget Splitter to main Splitter
m_MainSplit->addWidget(mitkWidget2Container);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// show mainSplitt and add to Layout
m_MainSplit->show();
// show/hide Widgets
mitkWidget1->hide();
if (mitkWidget2->isHidden())
mitkWidget2->show();
mitkWidget3->hide();
mitkWidget4->hide();
m_Layout = LAYOUT_WIDGET2;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_WIDGET2);
mitkWidget2->LayoutDesignListChanged(LAYOUT_WIDGET2);
mitkWidget3->LayoutDesignListChanged(LAYOUT_WIDGET2);
mitkWidget4->LayoutDesignListChanged(LAYOUT_WIDGET2);
// update Alle Widgets
this->UpdateAllWidgets();
mitk::RenderingManager::GetInstance()->SetRenderWindowFocus(mitkWidget2->GetVtkRenderWindow());
}
void QmitkStdMultiWidget::changeLayoutToWidget3()
{
SMW_INFO << "changing layout to big Widget3 ..." << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// add widget Splitter to main Splitter
m_MainSplit->addWidget(mitkWidget3Container);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// show mainSplitt and add to Layout
m_MainSplit->show();
// show/hide Widgets
mitkWidget1->hide();
mitkWidget2->hide();
if (mitkWidget3->isHidden())
mitkWidget3->show();
mitkWidget4->hide();
m_Layout = LAYOUT_WIDGET3;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_WIDGET3);
mitkWidget2->LayoutDesignListChanged(LAYOUT_WIDGET3);
mitkWidget3->LayoutDesignListChanged(LAYOUT_WIDGET3);
mitkWidget4->LayoutDesignListChanged(LAYOUT_WIDGET3);
// update Alle Widgets
this->UpdateAllWidgets();
mitk::RenderingManager::GetInstance()->SetRenderWindowFocus(mitkWidget3->GetVtkRenderWindow());
}
void QmitkStdMultiWidget::changeLayoutToRowWidget3And4()
{
SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
m_MainSplit->addWidget(m_LayoutSplit);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// add Widgets to splitter
m_LayoutSplit->addWidget(mitkWidget3Container);
m_LayoutSplit->addWidget(mitkWidget4Container);
// set Splitter Size
QList<int> splitterSize;
splitterSize.push_back(1000);
splitterSize.push_back(1000);
m_LayoutSplit->setSizes(splitterSize);
// show mainSplitt and add to Layout
m_MainSplit->show();
// show/hide Widgets
mitkWidget1->hide();
mitkWidget2->hide();
if (mitkWidget3->isHidden())
mitkWidget3->show();
if (mitkWidget4->isHidden())
mitkWidget4->show();
m_Layout = LAYOUT_ROW_WIDGET_3_AND_4;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_ROW_WIDGET_3_AND_4);
mitkWidget2->LayoutDesignListChanged(LAYOUT_ROW_WIDGET_3_AND_4);
mitkWidget3->LayoutDesignListChanged(LAYOUT_ROW_WIDGET_3_AND_4);
mitkWidget4->LayoutDesignListChanged(LAYOUT_ROW_WIDGET_3_AND_4);
// update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutToColumnWidget3And4()
{
SMW_INFO << "changing layout to Widget3 and 4 in one Column..." << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter(m_MainSplit);
m_MainSplit->addWidget(m_LayoutSplit);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// add Widgets to splitter
m_LayoutSplit->addWidget(mitkWidget3Container);
m_LayoutSplit->addWidget(mitkWidget4Container);
// set SplitterSize
QList<int> splitterSize;
splitterSize.push_back(1000);
splitterSize.push_back(1000);
m_LayoutSplit->setSizes(splitterSize);
// show mainSplitt and add to Layout
m_MainSplit->show();
// show/hide Widgets
mitkWidget1->hide();
mitkWidget2->hide();
if (mitkWidget3->isHidden())
mitkWidget3->show();
if (mitkWidget4->isHidden())
mitkWidget4->show();
m_Layout = LAYOUT_COLUMN_WIDGET_3_AND_4;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_COLUMN_WIDGET_3_AND_4);
mitkWidget2->LayoutDesignListChanged(LAYOUT_COLUMN_WIDGET_3_AND_4);
mitkWidget3->LayoutDesignListChanged(LAYOUT_COLUMN_WIDGET_3_AND_4);
mitkWidget4->LayoutDesignListChanged(LAYOUT_COLUMN_WIDGET_3_AND_4);
// update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutToRowWidgetSmall3andBig4()
{
SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
this->changeLayoutToRowWidget3And4();
m_Layout = LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4;
}
void QmitkStdMultiWidget::changeLayoutToSmallUpperWidget2Big3and4()
{
SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
m_MainSplit->addWidget(m_LayoutSplit);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// create m_SubSplit1 and m_SubSplit2
m_SubSplit1 = new QSplitter(Qt::Vertical, m_LayoutSplit);
m_SubSplit2 = new QSplitter(m_LayoutSplit);
// insert Widget into the splitters
m_SubSplit1->addWidget(mitkWidget2Container);
m_SubSplit2->addWidget(mitkWidget3Container);
m_SubSplit2->addWidget(mitkWidget4Container);
// set Splitter Size
QList<int> splitterSize;
splitterSize.push_back(1000);
splitterSize.push_back(1000);
m_SubSplit2->setSizes(splitterSize);
splitterSize.clear();
splitterSize.push_back(500);
splitterSize.push_back(1000);
m_LayoutSplit->setSizes(splitterSize);
// show mainSplitt
m_MainSplit->show();
// show Widget if hidden
mitkWidget1->hide();
if (mitkWidget2->isHidden())
mitkWidget2->show();
if (mitkWidget3->isHidden())
mitkWidget3->show();
if (mitkWidget4->isHidden())
mitkWidget4->show();
m_Layout = LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4);
mitkWidget2->LayoutDesignListChanged(LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4);
mitkWidget3->LayoutDesignListChanged(LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4);
mitkWidget4->LayoutDesignListChanged(LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4);
// update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutTo2x2Dand3DWidget()
{
SMW_INFO << "changing layout to 2 x 2D and 3D Widget" << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter(m_MainSplit);
m_MainSplit->addWidget(m_LayoutSplit);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// create m_SubSplit1 and m_SubSplit2
m_SubSplit1 = new QSplitter(Qt::Vertical, m_LayoutSplit);
m_SubSplit2 = new QSplitter(m_LayoutSplit);
// add Widgets to splitter
m_SubSplit1->addWidget(mitkWidget1Container);
m_SubSplit1->addWidget(mitkWidget2Container);
m_SubSplit2->addWidget(mitkWidget4Container);
// set Splitter Size
QList<int> splitterSize;
splitterSize.push_back(1000);
splitterSize.push_back(1000);
m_SubSplit1->setSizes(splitterSize);
m_LayoutSplit->setSizes(splitterSize);
// show mainSplitt and add to Layout
m_MainSplit->show();
// show/hide Widgets
if (mitkWidget1->isHidden())
mitkWidget1->show();
if (mitkWidget2->isHidden())
mitkWidget2->show();
mitkWidget3->hide();
if (mitkWidget4->isHidden())
mitkWidget4->show();
m_Layout = LAYOUT_2X_2D_AND_3D_WIDGET;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_2X_2D_AND_3D_WIDGET);
mitkWidget2->LayoutDesignListChanged(LAYOUT_2X_2D_AND_3D_WIDGET);
mitkWidget3->LayoutDesignListChanged(LAYOUT_2X_2D_AND_3D_WIDGET);
mitkWidget4->LayoutDesignListChanged(LAYOUT_2X_2D_AND_3D_WIDGET);
// update Alle Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::changeLayoutToLeft2Dand3DRight2D()
{
SMW_INFO << "changing layout to 2D and 3D left, 2D right Widget" << std::endl;
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter(m_MainSplit);
m_MainSplit->addWidget(m_LayoutSplit);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// create m_SubSplit1 and m_SubSplit2
m_SubSplit1 = new QSplitter(Qt::Vertical, m_LayoutSplit);
m_SubSplit2 = new QSplitter(m_LayoutSplit);
// add Widgets to splitter
m_SubSplit1->addWidget(mitkWidget1Container);
m_SubSplit1->addWidget(mitkWidget4Container);
m_SubSplit2->addWidget(mitkWidget2Container);
// set Splitter Size
QList<int> splitterSize;
splitterSize.push_back(1000);
splitterSize.push_back(1000);
m_SubSplit1->setSizes(splitterSize);
m_LayoutSplit->setSizes(splitterSize);
// show mainSplitt and add to Layout
m_MainSplit->show();
// show/hide Widgets
if (mitkWidget1->isHidden())
mitkWidget1->show();
if (mitkWidget2->isHidden())
mitkWidget2->show();
mitkWidget3->hide();
if (mitkWidget4->isHidden())
mitkWidget4->show();
m_Layout = LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET);
mitkWidget2->LayoutDesignListChanged(LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET);
mitkWidget3->LayoutDesignListChanged(LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET);
mitkWidget4->LayoutDesignListChanged(LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET);
// update Alle Widgets
this->UpdateAllWidgets();
}
-void QmitkStdMultiWidget::changeLayoutTo2DUpAnd3DDown()
+void QmitkStdMultiWidget::changeLayoutTo2DUpAnd3DDown(unsigned int id2Dwindow)
{
SMW_INFO << "changing layout to 2D up and 3D down" << std::endl;
+ if (id2Dwindow < 1 || id2Dwindow > 3)
+ {
+ MITK_WARN << "Only 2D render window IDs 1,2 or 3 are valid. Got ID " << id2Dwindow << ". " << "Using default ID 2 instead.";
+ id2Dwindow = 2;
+ }
// Hide all Menu Widgets
this->HideAllWidgetToolbars();
delete QmitkStdMultiWidgetLayout;
// create Main Layout
QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
// Set Layout to widget
this->setLayout(QmitkStdMultiWidgetLayout);
// create main splitter
m_MainSplit = new QSplitter(this);
QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
// create m_LayoutSplit and add to the mainSplit
m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
m_MainSplit->addWidget(m_LayoutSplit);
// add LevelWindow Widget to mainSplitter
m_MainSplit->addWidget(levelWindowWidget);
// create m_SubSplit1 and m_SubSplit2
m_SubSplit1 = new QSplitter(m_LayoutSplit);
m_SubSplit2 = new QSplitter(m_LayoutSplit);
// insert Widget Container into splitter top
- m_SubSplit1->addWidget(mitkWidget1Container);
+ switch (id2Dwindow)
+ {
+ case 1:
+ m_SubSplit1->addWidget(mitkWidget1Container);
+ break;
+ case 2:
+ m_SubSplit1->addWidget(mitkWidget2Container);
+ break;
+ case 3:
+ m_SubSplit1->addWidget(mitkWidget3Container);
+ break;
+ }
// set SplitterSize for splitter top
QList<int> splitterSize;
// insert Widget Container into splitter bottom
m_SubSplit2->addWidget(mitkWidget4Container);
// set SplitterSize for splitter m_LayoutSplit
splitterSize.clear();
splitterSize.push_back(700);
splitterSize.push_back(700);
m_LayoutSplit->setSizes(splitterSize);
// show mainSplitt
m_MainSplit->show();
// show/hide Widgets
- if (mitkWidget1->isHidden())
- mitkWidget1->show();
- mitkWidget2->hide();
- mitkWidget3->hide();
+ switch (id2Dwindow)
+ {
+ case 1:
+ if (mitkWidget1->isHidden())
+ mitkWidget1->show();
+ mitkWidget2->hide();
+ mitkWidget3->hide();
+ break;
+ case 2:
+ if (mitkWidget2->isHidden())
+ mitkWidget2->show();
+ mitkWidget1->hide();
+ mitkWidget3->hide();
+ break;
+ case 3:
+ if (mitkWidget3->isHidden())
+ mitkWidget3->show();
+ mitkWidget1->hide();
+ mitkWidget2->hide();
+ break;
+ }
+
+ //always show 3D widget
if (mitkWidget4->isHidden())
mitkWidget4->show();
m_Layout = LAYOUT_2D_UP_AND_3D_DOWN;
// update Layout Design List
mitkWidget1->LayoutDesignListChanged(LAYOUT_2D_UP_AND_3D_DOWN);
mitkWidget2->LayoutDesignListChanged(LAYOUT_2D_UP_AND_3D_DOWN);
mitkWidget3->LayoutDesignListChanged(LAYOUT_2D_UP_AND_3D_DOWN);
mitkWidget4->LayoutDesignListChanged(LAYOUT_2D_UP_AND_3D_DOWN);
// update all Widgets
this->UpdateAllWidgets();
}
void QmitkStdMultiWidget::SetDataStorage(mitk::DataStorage *ds)
{
if (ds == m_DataStorage)
{
return;
}
mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->SetDataStorage(ds);
mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->SetDataStorage(ds);
mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->SetDataStorage(ds);
mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetDataStorage(ds);
m_DataStorage = ds;
}
void QmitkStdMultiWidget::Fit()
{
vtkSmartPointer<vtkRenderer> vtkrenderer;
vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetVtkRenderer();
if (vtkrenderer != NULL)
vtkrenderer->ResetCamera();
vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetVtkRenderer();
if (vtkrenderer != NULL)
vtkrenderer->ResetCamera();
vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetVtkRenderer();
if (vtkrenderer != NULL)
vtkrenderer->ResetCamera();
vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetVtkRenderer();
if (vtkrenderer != NULL)
vtkrenderer->ResetCamera();
mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetCameraController()->Fit();
mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetCameraController()->Fit();
mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetCameraController()->Fit();
mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetCameraController()->Fit();
int w = vtkObject::GetGlobalWarningDisplay();
vtkObject::GlobalWarningDisplayOff();
vtkObject::SetGlobalWarningDisplay(w);
}
void QmitkStdMultiWidget::InitPositionTracking()
{
// TODO POSITIONTRACKER
}
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(mitkWidget1->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(mitkWidget2->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(mitkWidget3->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));
}
mitk::SliceNavigationController *QmitkStdMultiWidget::GetTimeNavigationController()
{
return m_TimeNavigationController;
}
void QmitkStdMultiWidget::EnableStandardLevelWindow()
{
levelWindowWidget->disconnect(this);
levelWindowWidget->SetDataStorage(mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetDataStorage());
levelWindowWidget->show();
}
void QmitkStdMultiWidget::DisableStandardLevelWindow()
{
levelWindowWidget->disconnect(this);
levelWindowWidget->hide();
}
// CAUTION: Legacy code for enabling Qt-signal-controlled view initialization.
// Use RenderingManager::InitializeViews() instead.
bool QmitkStdMultiWidget::InitializeStandardViews(const mitk::Geometry3D *geometry)
{
return m_RenderingManager->InitializeViews(geometry);
}
void QmitkStdMultiWidget::RequestUpdate()
{
m_RenderingManager->RequestUpdate(mitkWidget1->GetRenderWindow());
m_RenderingManager->RequestUpdate(mitkWidget2->GetRenderWindow());
m_RenderingManager->RequestUpdate(mitkWidget3->GetRenderWindow());
m_RenderingManager->RequestUpdate(mitkWidget4->GetRenderWindow());
}
void QmitkStdMultiWidget::ForceImmediateUpdate()
{
m_RenderingManager->ForceImmediateUpdate(mitkWidget1->GetRenderWindow());
m_RenderingManager->ForceImmediateUpdate(mitkWidget2->GetRenderWindow());
m_RenderingManager->ForceImmediateUpdate(mitkWidget3->GetRenderWindow());
m_RenderingManager->ForceImmediateUpdate(mitkWidget4->GetRenderWindow());
}
void QmitkStdMultiWidget::wheelEvent(QWheelEvent *e)
{
emit WheelMoved(e);
}
void QmitkStdMultiWidget::mousePressEvent(QMouseEvent *e)
{
}
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();
}
QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow1() const
{
return mitkWidget1;
}
QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow2() const
{
return mitkWidget2;
}
QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow3() const
{
return mitkWidget3;
}
QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow4() const
{
return mitkWidget4;
}
const mitk::Point3D QmitkStdMultiWidget::GetCrossPosition() const
{
const mitk::PlaneGeometry *plane1 = mitkWidget1->GetSliceNavigationController()->GetCurrentPlaneGeometry();
const mitk::PlaneGeometry *plane2 = mitkWidget2->GetSliceNavigationController()->GetCurrentPlaneGeometry();
const mitk::PlaneGeometry *plane3 = mitkWidget3->GetSliceNavigationController()->GetCurrentPlaneGeometry();
mitk::Line3D line;
if ((plane1 != NULL) && (plane2 != NULL) && (plane1->IntersectionLine(plane2, line)))
{
mitk::Point3D point;
if ((plane3 != NULL) && (plane3->IntersectionPoint(line, point)))
{
return point;
}
}
// TODO BUG POSITIONTRACKER;
mitk::Point3D p;
return p;
// return m_LastLeftClickPositionSupplier->GetCurrentPoint();
}
void QmitkStdMultiWidget::EnablePositionTracking()
{
}
void QmitkStdMultiWidget::DisablePositionTracking()
{
}
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::MoveCrossToPosition(const mitk::Point3D &newPosition)
{
mitkWidget1->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
mitkWidget2->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
mitkWidget3->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
m_RenderingManager->RequestUpdateAll();
}
void QmitkStdMultiWidget::HandleCrosshairPositionEvent()
{
if (!m_PendingCrosshairPositionEvent)
{
m_PendingCrosshairPositionEvent = true;
QTimer::singleShot(0, this, SLOT(HandleCrosshairPositionEventDelayed()));
}
}
mitk::DataNode::Pointer QmitkStdMultiWidget::GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes)
{
mitk::Point3D crosshairPos = this->GetCrossPosition();
mitk::DataNode::Pointer node;
int maxlayer = -32768;
if (nodes.IsNotNull())
{
mitk::BaseRenderer *baseRenderer = this->mitkWidget1->GetSliceNavigationController()->GetRenderer();
// find node with largest layer, that is the node shown on top in the render window
for (unsigned int x = 0; x < nodes->size(); x++)
{
if ((nodes->at(x)->GetData()->GetGeometry() != NULL) &&
nodes->at(x)->GetData()->GetGeometry()->IsInside(crosshairPos))
{
int layer = 0;
if (!(nodes->at(x)->GetIntProperty("layer", layer)))
continue;
if (layer > maxlayer)
{
if (static_cast<mitk::DataNode::Pointer>(nodes->at(x))->IsVisible(baseRenderer))
{
node = nodes->at(x);
maxlayer = layer;
}
}
}
}
}
return node;
}
void QmitkStdMultiWidget::HandleCrosshairPositionEventDelayed()
{
m_PendingCrosshairPositionEvent = false;
// find image with highest layer
mitk::TNodePredicateDataType<mitk::Image>::Pointer isImageData = mitk::TNodePredicateDataType<mitk::Image>::New();
mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->m_DataStorage->GetSubset(isImageData).GetPointer();
mitk::DataNode::Pointer node;
mitk::DataNode::Pointer topSourceNode;
mitk::Image::Pointer image;
bool isBinary = false;
node = this->GetTopLayerNode(nodes);
int component = 0;
if (node.IsNotNull())
{
node->GetBoolProperty("binary", isBinary);
if (isBinary)
{
mitk::DataStorage::SetOfObjects::ConstPointer sourcenodes = m_DataStorage->GetSources(node, NULL, true);
if (!sourcenodes->empty())
{
topSourceNode = this->GetTopLayerNode(sourcenodes);
}
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);
}
}
mitk::Point3D crosshairPos = this->GetCrossPosition();
std::string statusText;
std::stringstream stream;
itk::Index<3> p;
mitk::BaseRenderer *baseRenderer = this->mitkWidget1->GetSliceNavigationController()->GetRenderer();
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(baseRenderer->GetTimeStep()),
p,
pixelValue,
component);
if (fabs(pixelValue) > 1000000 || fabs(pixelValue) < 0.01)
{
stream << "; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: " << std::scientific << pixelValue << " ";
}
else
{
stream << "; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: " << pixelValue << " ";
}
}
else
{
stream << "No image information at this position!";
}
statusText = stream.str();
mitk::StatusBar::GetInstance()->DisplayGreyValueText(statusText.c_str());
}
int QmitkStdMultiWidget::GetLayout() const
{
return m_Layout;
}
bool QmitkStdMultiWidget::GetGradientBackgroundFlag() const
{
return m_GradientBackgroundFlag;
}
void QmitkStdMultiWidget::EnableGradientBackground()
{
// gradient background is by default only in widget 4, otherwise
// interferences between 2D rendering and VTK rendering may occur.
for (unsigned int i = 0; i < 4; ++i)
{
GetRenderWindow(i)->GetRenderer()->GetVtkRenderer()->GradientBackgroundOn();
}
m_GradientBackgroundFlag = true;
}
void QmitkStdMultiWidget::DisableGradientBackground()
{
for (unsigned int i = 0; i < 4; ++i)
{
GetRenderWindow(i)->GetRenderer()->GetVtkRenderer()->GradientBackgroundOff();
}
m_GradientBackgroundFlag = false;
}
void QmitkStdMultiWidget::EnableDepartmentLogo()
{
m_LogoRendering->SetVisibility(true);
RequestUpdate();
}
void QmitkStdMultiWidget::DisableDepartmentLogo()
{
m_LogoRendering->SetVisibility(false);
RequestUpdate();
}
bool QmitkStdMultiWidget::IsDepartmentLogoEnabled() const
{
return m_LogoRendering->IsVisible();
}
void QmitkStdMultiWidget::SetWidgetPlaneVisibility(const char *widgetName, bool visible, mitk::BaseRenderer *renderer)
{
if (m_DataStorage.IsNotNull())
{
mitk::DataNode *n = m_DataStorage->GetNamedNode(widgetName);
if (n != NULL)
n->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);
}
m_RenderingManager->RequestUpdateAll();
}
void QmitkStdMultiWidget::SetWidgetPlanesLocked(bool locked)
{
// do your job and lock or unlock slices.
GetRenderWindow1()->GetSliceNavigationController()->SetSliceLocked(locked);
GetRenderWindow2()->GetSliceNavigationController()->SetSliceLocked(locked);
GetRenderWindow3()->GetSliceNavigationController()->SetSliceLocked(locked);
}
void QmitkStdMultiWidget::SetWidgetPlanesRotationLocked(bool locked)
{
// do your job and lock or unlock slices.
GetRenderWindow1()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
GetRenderWindow2()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
GetRenderWindow3()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
}
void QmitkStdMultiWidget::SetWidgetPlanesRotationLinked(bool link)
{
emit WidgetPlanesRotationLinked(link);
}
void QmitkStdMultiWidget::SetWidgetPlaneMode(int userMode)
{
MITK_DEBUG << "Changing crosshair mode to " << userMode;
emit WidgetNotifyNewCrossHairMode(userMode);
// Convert user interface mode to actual mode
{
switch (userMode)
{
case 0:
m_MouseModeSwitcher->SetInteractionScheme(mitk::MouseModeSwitcher::InteractionScheme::MITK);
break;
case 1:
m_MouseModeSwitcher->SetInteractionScheme(mitk::MouseModeSwitcher::InteractionScheme::ROTATION);
break;
case 2:
m_MouseModeSwitcher->SetInteractionScheme(mitk::MouseModeSwitcher::InteractionScheme::ROTATIONLINKED);
break;
case 3:
m_MouseModeSwitcher->SetInteractionScheme(mitk::MouseModeSwitcher::InteractionScheme::SWIVEL);
break;
}
}
}
void QmitkStdMultiWidget::SetGradientBackgroundColorForRenderWindow(const mitk::Color &upper,
const mitk::Color &lower,
unsigned int widgetNumber)
{
if (widgetNumber > 3)
{
MITK_ERROR << "Gradientbackground for unknown widget!";
return;
}
m_GradientBackgroundColors[widgetNumber].first = upper;
m_GradientBackgroundColors[widgetNumber].second = lower;
vtkRenderer *renderer = GetRenderWindow(widgetNumber)->GetRenderer()->GetVtkRenderer();
renderer->SetBackground2(upper[0], upper[1], upper[2]);
renderer->SetBackground(lower[0], lower[1], lower[2]);
m_GradientBackgroundFlag = true;
}
void QmitkStdMultiWidget::SetGradientBackgroundColors(const mitk::Color &upper, const mitk::Color &lower)
{
for (unsigned int i = 0; i < 4; ++i)
{
vtkRenderer *renderer = GetRenderWindow(i)->GetRenderer()->GetVtkRenderer();
renderer->SetBackground2(upper[0], upper[1], upper[2]);
renderer->SetBackground(lower[0], lower[1], lower[2]);
}
m_GradientBackgroundFlag = true;
}
void QmitkStdMultiWidget::SetDepartmentLogoPath(const char *path)
{
m_LogoRendering->SetLogoImagePath(path);
mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow());
m_LogoRendering->Update(renderer);
RequestUpdate();
}
void QmitkStdMultiWidget::SetWidgetPlaneModeToSlicing(bool activate)
{
if (activate)
{
this->SetWidgetPlaneMode(PLANE_MODE_SLICING);
}
}
void QmitkStdMultiWidget::SetWidgetPlaneModeToRotation(bool activate)
{
if (activate)
{
this->SetWidgetPlaneMode(PLANE_MODE_ROTATION);
}
}
void QmitkStdMultiWidget::SetWidgetPlaneModeToSwivel(bool activate)
{
if (activate)
{
this->SetWidgetPlaneMode(PLANE_MODE_SWIVEL);
}
}
void QmitkStdMultiWidget::OnLayoutDesignChanged(int layoutDesignIndex)
{
switch (layoutDesignIndex)
{
case LAYOUT_DEFAULT:
{
this->changeLayoutToDefault();
break;
}
case LAYOUT_2D_IMAGES_UP:
{
this->changeLayoutTo2DImagesUp();
break;
}
case LAYOUT_2D_IMAGES_LEFT:
{
this->changeLayoutTo2DImagesLeft();
break;
}
case LAYOUT_BIG_3D:
{
this->changeLayoutToBig3D();
break;
}
case LAYOUT_WIDGET1:
{
this->changeLayoutToWidget1();
break;
}
case LAYOUT_WIDGET2:
{
this->changeLayoutToWidget2();
break;
}
case LAYOUT_WIDGET3:
{
this->changeLayoutToWidget3();
break;
}
case LAYOUT_2X_2D_AND_3D_WIDGET:
{
this->changeLayoutTo2x2Dand3DWidget();
break;
}
case LAYOUT_ROW_WIDGET_3_AND_4:
{
this->changeLayoutToRowWidget3And4();
break;
}
case LAYOUT_COLUMN_WIDGET_3_AND_4:
{
this->changeLayoutToColumnWidget3And4();
break;
}
case LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4:
{
this->changeLayoutToRowWidgetSmall3andBig4();
break;
}
case LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4:
{
this->changeLayoutToSmallUpperWidget2Big3and4();
break;
}
case LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET:
{
this->changeLayoutToLeft2Dand3DRight2D();
break;
}
};
}
void QmitkStdMultiWidget::UpdateAllWidgets()
{
mitkWidget1->resize(mitkWidget1Container->frameSize().width() - 1, mitkWidget1Container->frameSize().height());
mitkWidget1->resize(mitkWidget1Container->frameSize().width(), mitkWidget1Container->frameSize().height());
mitkWidget2->resize(mitkWidget2Container->frameSize().width() - 1, mitkWidget2Container->frameSize().height());
mitkWidget2->resize(mitkWidget2Container->frameSize().width(), mitkWidget2Container->frameSize().height());
mitkWidget3->resize(mitkWidget3Container->frameSize().width() - 1, mitkWidget3Container->frameSize().height());
mitkWidget3->resize(mitkWidget3Container->frameSize().width(), mitkWidget3Container->frameSize().height());
mitkWidget4->resize(mitkWidget4Container->frameSize().width() - 1, mitkWidget4Container->frameSize().height());
mitkWidget4->resize(mitkWidget4Container->frameSize().width(), mitkWidget4Container->frameSize().height());
}
void QmitkStdMultiWidget::HideAllWidgetToolbars()
{
mitkWidget1->HideRenderWindowMenu();
mitkWidget2->HideRenderWindowMenu();
mitkWidget3->HideRenderWindowMenu();
mitkWidget4->HideRenderWindowMenu();
}
void QmitkStdMultiWidget::ActivateMenuWidget(bool state)
{
mitkWidget1->ActivateMenuWidget(state, this);
mitkWidget2->ActivateMenuWidget(state, this);
mitkWidget3->ActivateMenuWidget(state, this);
mitkWidget4->ActivateMenuWidget(state, this);
}
bool QmitkStdMultiWidget::IsMenuWidgetEnabled() const
{
return mitkWidget1->GetActivateMenuWidgetFlag();
}
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;
}
}
void QmitkStdMultiWidget::ResetCrosshair()
{
if (m_DataStorage.IsNotNull())
{
m_RenderingManager->InitializeViewsByBoundingObjects(m_DataStorage);
// m_RenderingManager->InitializeViews( m_DataStorage->ComputeVisibleBoundingGeometry3D() );
// reset interactor to normal slicing
this->SetWidgetPlaneMode(PLANE_MODE_SLICING);
}
}
void QmitkStdMultiWidget::EnableColoredRectangles()
{
m_RectangleProps[0]->SetVisibility(1);
m_RectangleProps[1]->SetVisibility(1);
m_RectangleProps[2]->SetVisibility(1);
m_RectangleProps[3]->SetVisibility(1);
}
void QmitkStdMultiWidget::DisableColoredRectangles()
{
m_RectangleProps[0]->SetVisibility(0);
m_RectangleProps[1]->SetVisibility(0);
m_RectangleProps[2]->SetVisibility(0);
m_RectangleProps[3]->SetVisibility(0);
}
bool QmitkStdMultiWidget::IsColoredRectanglesEnabled() const
{
return m_RectangleProps[0]->GetVisibility() > 0;
}
mitk::MouseModeSwitcher *QmitkStdMultiWidget::GetMouseModeSwitcher()
{
return m_MouseModeSwitcher;
}
mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane1()
{
return this->m_PlaneNode1;
}
mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane2()
{
return this->m_PlaneNode2;
}
mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane3()
{
return this->m_PlaneNode3;
}
mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane(int id)
{
switch (id)
{
case 1:
return this->m_PlaneNode1;
break;
case 2:
return this->m_PlaneNode2;
break;
case 3:
return this->m_PlaneNode3;
break;
default:
return NULL;
}
}
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.cpp
index 98ccf1c6a4..08ffa76525 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.cpp
@@ -1,713 +1,738 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "USNavigationMarkerPlacement.h"
#include "ui_USNavigationMarkerPlacement.h"
#include "NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.h"
#include "NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.h"
#include "NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.h"
#include "NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.h"
#include "NavigationStepWidgets/QmitkUSNavigationStepTumourSelection.h"
#include "NavigationStepWidgets/QmitkUSNavigationStepZoneMarking.h"
#include "SettingsWidgets/QmitkUSNavigationCombinedSettingsWidget.h"
#include "mitkIRenderingManager.h"
#include "mitkNodeDisplacementFilter.h"
#include "mitkUSCombinedModality.h"
#include <mitkIOUtil.h>
#include "IO/mitkUSNavigationExperimentLogging.h"
#include "IO/mitkUSNavigationStepTimer.h"
#include <QDateTime>
#include <QDir>
#include <QInputDialog>
#include <QMessageBox>
#include <QSignalMapper>
#include <QTimer>
#include "QmitkRenderWindow.h"
#include "QmitkStdMultiWidget.h"
#include "QmitkStdMultiWidgetEditor.h"
#include "mitkLayoutAnnotationRenderer.h"
// scene serialization
#include <mitkConvert2Dto3DImageFilter.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
#include <mitkSceneIO.h>
#include <mitkSurface.h>
const std::string USNavigationMarkerPlacement::VIEW_ID = "org.mitk.views.usmarkerplacement";
const char *USNavigationMarkerPlacement::DATANAME_TUMOUR = "Tumour";
const char *USNavigationMarkerPlacement::DATANAME_TARGETSURFACE = "Target Surface";
const char *USNavigationMarkerPlacement::DATANAME_ZONES = "Zones";
const char *USNavigationMarkerPlacement::DATANAME_TARGETS = "Targets";
const char *USNavigationMarkerPlacement::DATANAME_TARGETS_PATHS = "Target Paths";
const char *USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS = "Reached Targets";
USNavigationMarkerPlacement::USNavigationMarkerPlacement()
: m_UpdateTimer(new QTimer(this)),
m_ImageAndNavigationDataLoggingTimer(new QTimer(this)),
m_StdMultiWidget(0),
m_ReinitAlreadyDone(false),
m_IsExperimentRunning(false),
m_NavigationStepTimer(mitk::USNavigationStepTimer::New()),
m_ExperimentLogging(mitk::USNavigationExperimentLogging::New()),
m_AblationZonesDisplacementFilter(mitk::NodeDisplacementFilter::New()),
m_IconRunning(QPixmap(":/USNavigation/record.png")),
m_IconNotRunning(QPixmap(":/USNavigation/record-gray.png")),
m_USImageLoggingFilter(mitk::USImageLoggingFilter::New()),
m_NavigationDataRecorder(mitk::NavigationDataRecorder::New()),
m_SceneNumber(1),
m_WarnOverlay(mitk::TextAnnotation2D::New()),
m_ListenerDeviceChanged(this, &USNavigationMarkerPlacement::OnCombinedModalityPropertyChanged),
m_NeedleIndex(0),
m_MarkerIndex(1),
ui(new Ui::USNavigationMarkerPlacement)
{
connect(m_UpdateTimer, SIGNAL(timeout()), this, SLOT(OnTimeout()));
connect(
m_ImageAndNavigationDataLoggingTimer, SIGNAL(timeout()), this, SLOT(OnImageAndNavigationDataLoggingTimeout()));
// scale running (and not running) icon the specific height
m_IconRunning = m_IconRunning.scaledToHeight(20, Qt::SmoothTransformation);
m_IconNotRunning = m_IconNotRunning.scaledToHeight(20, Qt::SmoothTransformation);
// set prefix for experiment logging (only keys with this prefix are taken
// into consideration
m_ExperimentLogging->SetKeyPrefix("USNavigation::");
m_UpdateTimer->start(33); // every 33 Milliseconds = 30 Frames/Second
}
USNavigationMarkerPlacement::~USNavigationMarkerPlacement()
{
+ this->OnResetStandardLayout();
+
// make sure that the experiment got finished before destructing the object
if (m_IsExperimentRunning)
{
this->OnFinishExperiment();
}
// remove listener for ultrasound device changes
if (m_CombinedModality.IsNotNull() && m_CombinedModality->GetUltrasoundDevice().IsNotNull())
{
m_CombinedModality->GetUltrasoundDevice()->RemovePropertyChangedListener(m_ListenerDeviceChanged);
}
delete ui;
}
void USNavigationMarkerPlacement::OnChangeAblationZone(int id, int newSize)
{
if ((m_AblationZonesVector.size() < id) || (id < 0))
{
return;
}
MITK_INFO << "Ablation Zone " << id << " changed, new size: " << newSize;
// create a vtk sphere with given radius
vtkSphereSource *vtkData = vtkSphereSource::New();
vtkData->SetRadius(newSize / 2);
vtkData->SetCenter(0, 0, 0);
vtkData->SetPhiResolution(20);
vtkData->SetThetaResolution(20);
vtkData->Update();
mitk::Surface::Pointer zoneSurface = dynamic_cast<mitk::Surface *>(m_AblationZonesVector.at(id)->GetData());
zoneSurface->SetVtkPolyData(vtkData->GetOutput());
vtkData->Delete();
}
void USNavigationMarkerPlacement::OnAddAblationZone(int size)
{
m_AblationZonesDisplacementFilter->SetInitialReferencePose(
m_CombinedModality->GetNavigationDataSource()->GetOutput(m_MarkerIndex));
mitk::DataNode::Pointer NewAblationZone = mitk::DataNode::New();
mitk::Point3D origin = m_CombinedModality->GetNavigationDataSource()->GetOutput(m_NeedleIndex)->GetPosition();
MITK_INFO("USNavigationLogging") << "Ablation Zone Added, initial size: " << size << ", origin: " << origin;
mitk::Surface::Pointer zone = mitk::Surface::New();
// create a vtk sphere with given radius
vtkSphereSource *vtkData = vtkSphereSource::New();
vtkData->SetRadius(size / 2);
vtkData->SetCenter(0, 0, 0);
vtkData->SetPhiResolution(20);
vtkData->SetThetaResolution(20);
vtkData->Update();
zone->SetVtkPolyData(vtkData->GetOutput());
vtkData->Delete();
// set vtk sphere and origin to data node (origin must be set
// again, because of the new sphere set as data)
NewAblationZone->SetData(zone);
NewAblationZone->GetData()->GetGeometry()->SetOrigin(origin);
mitk::Color SphereColor = mitk::Color();
// default color
SphereColor[0] = 102;
SphereColor[1] = 0;
SphereColor[2] = 204;
NewAblationZone->SetColor(SphereColor);
NewAblationZone->SetOpacity(0.3);
// set name of zone
std::stringstream name;
name << "Ablation Zone" << m_AblationZonesVector.size();
NewAblationZone->SetName(name.str());
// add zone to filter
m_AblationZonesDisplacementFilter->AddNode(NewAblationZone);
m_AblationZonesVector.push_back(NewAblationZone);
this->GetDataStorage()->Add(NewAblationZone);
}
void USNavigationMarkerPlacement::CreateQtPartControl(QWidget *parent)
{
m_Parent = parent;
ui->setupUi(parent);
connect(ui->navigationProcessWidget,
SIGNAL(SignalCombinedModalityChanged(itk::SmartPointer<mitk::USCombinedModality>)),
this,
SLOT(OnCombinedModalityChanged(itk::SmartPointer<mitk::USCombinedModality>)));
connect(ui->navigationProcessWidget,
SIGNAL(SignalSettingsChanged(itk::SmartPointer<mitk::DataNode>)),
this,
SLOT(OnSettingsChanged(itk::SmartPointer<mitk::DataNode>)));
connect(ui->navigationProcessWidget,
SIGNAL(SignalActiveNavigationStepChanged(int)),
this,
SLOT(OnActiveNavigationStepChanged(int)));
connect(ui->startExperimentButton, SIGNAL(clicked()), this, SLOT(OnStartExperiment()));
connect(ui->finishExperimentButton, SIGNAL(clicked()), this, SLOT(OnFinishExperiment()));
+ connect(ui->m_enableNavigationLayout, SIGNAL(clicked()), this, SLOT(OnChangeLayoutClicked()));
connect(ui->navigationProcessWidget,
SIGNAL(SignalIntermediateResult(const itk::SmartPointer<mitk::DataNode>)),
this,
SLOT(OnIntermediateResultProduced(const itk::SmartPointer<mitk::DataNode>)));
ui->navigationProcessWidget->SetDataStorage(this->GetDataStorage());
// indicate that no experiment is running at start
ui->runningLabel->setPixmap(m_IconNotRunning);
ui->navigationProcessWidget->SetSettingsWidget(new QmitkUSNavigationCombinedSettingsWidget(m_Parent));
}
void USNavigationMarkerPlacement::OnCombinedModalityPropertyChanged(const std::string &key, const std::string &)
{
if (key == mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DEPTH)
{
m_ReinitAlreadyDone = false;
this->ReinitOnImage();
if (m_CombinedModality.IsNotNull() && !m_CombinedModality->GetIsCalibratedForCurrentStatus())
{
mitk::LayoutAnnotationRenderer::AddAnnotation(
m_WarnOverlay.GetPointer(), "stdmulti.widget1", mitk::LayoutAnnotationRenderer::TopLeft);
MITK_WARN << "No calibration available for the selected ultrasound image depth.";
}
}
}
void USNavigationMarkerPlacement::SetFocus()
{
this->ReinitOnImage();
}
void USNavigationMarkerPlacement::OnTimeout()
{
if (!m_StdMultiWidget)
{
+ OnEnableNavigationLayout();
+ this->CreateOverlays();
+ }
+
+ if (m_CombinedModality.IsNotNull() &&
+ !this->m_CombinedModality->GetIsFreezed()) // if the combined modality is freezed: do nothing
+ {
+ ui->navigationProcessWidget->UpdateNavigationProgress();
+ m_AblationZonesDisplacementFilter->Update();
+
+ // update the 3D window only every fourth time to speed up the rendering (at least in 2D)
+ this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS);
+
+ // make sure that a reinit was performed on the image
+ this->ReinitOnImage();
+ }
+}
+
+void USNavigationMarkerPlacement::OnEnableNavigationLayout()
+{
+ MITK_INFO << "Navigation Layout";
// try to get the standard multi widget if it couldn't be got before
mitk::IRenderWindowPart *renderWindow = this->GetRenderWindowPart();
QmitkStdMultiWidgetEditor *multiWidgetEditor = dynamic_cast<QmitkStdMultiWidgetEditor *>(renderWindow);
// if there is a standard multi widget now, disable the level window and
// change the layout to 2D up and 3d down
if (multiWidgetEditor)
{
m_StdMultiWidget = multiWidgetEditor->GetStdMultiWidget();
if (m_StdMultiWidget)
{
m_StdMultiWidget->DisableStandardLevelWindow();
m_StdMultiWidget->changeLayoutTo2DUpAnd3DDown();
+ this->GetDataStorage()->GetNamedNode("stdmulti.widget1.plane")->SetVisibility(false);
+ this->GetDataStorage()->GetNamedNode("stdmulti.widget3.plane")->SetVisibility(false);
}
}
+}
- this->CreateOverlays();
- }
-
- if (m_CombinedModality.IsNotNull() &&
- !this->m_CombinedModality->GetIsFreezed()) // if the combined modality is freezed: do nothing
- {
- ui->navigationProcessWidget->UpdateNavigationProgress();
- m_AblationZonesDisplacementFilter->Update();
-
- // update the 3D window only every fourth time to speed up the rendering (at least in 2D)
- this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS);
+void USNavigationMarkerPlacement::OnResetStandardLayout()
+{
+ MITK_INFO << "Resetting Layout";
+ //reset render windows
+ this->GetDataStorage()->GetNamedNode("stdmulti.widget1.plane")->SetVisibility(true);
+ this->GetDataStorage()->GetNamedNode("stdmulti.widget3.plane")->SetVisibility(true);
+ m_StdMultiWidget->changeLayoutToDefault();
+}
- // make sure that a reinit was performed on the image
- this->ReinitOnImage();
- }
+void USNavigationMarkerPlacement::OnChangeLayoutClicked()
+{
+ if (ui->m_enableNavigationLayout->isChecked()) OnEnableNavigationLayout();
+ else OnResetStandardLayout();
}
void USNavigationMarkerPlacement::OnImageAndNavigationDataLoggingTimeout()
{
// update filter for logging navigation data and ultrasound images
if (m_CombinedModality.IsNotNull())
{
m_NavigationDataRecorder->Update();
// get last messages for logging filer and store them
std::vector<std::string> messages = m_LoggingBackend.GetNavigationMessages();
std::string composedMessage = "";
for (int i = 0; i < messages.size(); i++)
{
composedMessage += messages.at(i);
}
m_USImageLoggingFilter->AddMessageToCurrentImage(composedMessage);
m_LoggingBackend.ClearNavigationMessages();
// update logging filter
m_USImageLoggingFilter->Update();
}
}
void USNavigationMarkerPlacement::OnStartExperiment()
{
// get name for the experiment by a QInputDialog
bool ok;
if (m_ExperimentName.isEmpty())
{ // default: current date
m_ExperimentName = QString::number(QDateTime::currentDateTime().date().year()) + "_" +
QString::number(QDateTime::currentDateTime().date().month()) + "_" +
QString::number(QDateTime::currentDateTime().date().day()) + "_experiment_" +
QString::number(QDateTime::currentDateTime().time().hour()) + "." +
QString::number(QDateTime::currentDateTime().time().minute());
}
m_ExperimentName = QInputDialog::getText(
m_Parent, QString("Experiment Name"), QString("Name of the Experiment"), QLineEdit::Normal, m_ExperimentName, &ok);
MITK_INFO("USNavigationLogging") << "Experiment started: " << m_ExperimentName.toStdString();
if (ok && !m_ExperimentName.isEmpty())
{
// display error message and call the function recursivly if a directory
// with the given name already exists
QDir experimentResultsDir(m_ResultsDirectory + QDir::separator() + m_ExperimentName);
if (experimentResultsDir.exists())
{
QMessageBox::critical(
m_Parent, "Results Directory Exists", "The result directory already exists.\nPlease choose an other name.");
this->OnStartExperiment();
}
else
{
QDir(m_ResultsDirectory).mkdir(m_ExperimentName);
m_ExperimentResultsSubDirectory = m_ResultsDirectory + QDir::separator() + m_ExperimentName;
// experiment is running now
ui->runningLabel->setPixmap(m_IconRunning);
ui->navigationProcessWidget->EnableInteraction(true);
// (re)start timer for navigation step durations
m_NavigationStepTimer->Reset();
m_NavigationStepTimer->SetOutputFileName(
QString(m_ExperimentResultsSubDirectory + QDir::separator() + QString("durations.cvs")).toStdString());
m_NavigationStepTimer->SetActiveIndex(0, m_NavigationSteps.at(0)->GetTitle().toStdString());
ui->finishExperimentButton->setEnabled(true);
ui->startExperimentButton->setDisabled(true);
// initialize and register logging backend
QString loggingFilename = m_ExperimentResultsSubDirectory + QDir::separator() + "logging.txt";
m_LoggingBackend.SetOutputFileName(loggingFilename.toStdString());
mbilog::RegisterBackend(&m_LoggingBackend);
// initialize and start navigation data recorder form xml recording
m_NavigationDataRecorder->StartRecording();
m_IsExperimentRunning = true;
m_ImageAndNavigationDataLoggingTimer->start(1000);
// (re)start experiment logging and set output file name
m_ExperimentLogging->Reset();
m_ExperimentLogging->SetFileName(
QString(m_ExperimentResultsSubDirectory + QDir::separator() + "experiment-logging.xml").toStdString());
}
}
}
void USNavigationMarkerPlacement::OnFinishExperiment()
{
this->WaitCursorOn();
MITK_INFO("USNavigationLogging") << "Experiment finished!";
MITK_INFO("USNavigationLogging")
<< "Position/Orientation of needle tip: "
<< (dynamic_cast<mitk::NavigationData *>(m_CombinedModality->GetTrackingDevice()->GetOutput(0)))->GetPosition();
MITK_INFO("USNavigationLogging")
<< "Position of target: " << m_TargetNodeDisplacementFilter->GetRawDisplacementNavigationData(0)->GetPosition();
MITK_INFO("USNavigationLogging") << "Total duration: " << m_NavigationStepTimer->GetTotalDuration();
ui->navigationProcessWidget->FinishCurrentNavigationStep();
m_ImageAndNavigationDataLoggingTimer->stop();
ui->runningLabel->setPixmap(m_IconNotRunning);
ui->navigationProcessWidget->EnableInteraction(false);
m_NavigationStepTimer->Stop();
// make sure that the navigation process will be start from beginning at the
// next experiment
ui->navigationProcessWidget->ResetNavigationProcess();
ui->finishExperimentButton->setDisabled(true);
ui->startExperimentButton->setEnabled(true);
MITK_INFO("USNavigationLogging") << "Writing logging data to " << m_ExperimentResultsSubDirectory.toStdString();
// save ultrasound images to the file system
QDir(m_ExperimentResultsSubDirectory).mkdir("ImageStream");
m_USImageLoggingFilter->Update();
m_USImageLoggingFilter->SetImageFilesExtension(".jpg");
m_USImageLoggingFilter->SaveImages(
QString(m_ExperimentResultsSubDirectory + QDir::separator() + "ImageStream" + QDir::separator()).toStdString());
m_USImageLoggingFilter = mitk::USImageLoggingFilter::New();
m_NavigationDataRecorder->StopRecording();
// Write data to csv and xml file
mitk::IOUtil::SaveBaseData(
m_NavigationDataRecorder->GetNavigationDataSet(),
(QString(m_ExperimentResultsSubDirectory + QDir::separator() + "navigation-data.xml").toStdString().c_str()));
mitk::IOUtil::SaveBaseData(
m_NavigationDataRecorder->GetNavigationDataSet(),
(QString(m_ExperimentResultsSubDirectory + QDir::separator() + "navigation-data.csv").toStdString().c_str()));
// write logged navigation data messages to separate file
std::stringstream csvNavigationMessagesFilename;
csvNavigationMessagesFilename << m_ExperimentResultsSubDirectory.toStdString() << QDir::separator().toLatin1()
<< "CSVNavigationMessagesLogFile.csv";
MITK_INFO("USNavigationLogging") << "Writing logged navigation messages to separate csv file: "
<< csvNavigationMessagesFilename.str();
m_LoggingBackend.WriteCSVFileWithNavigationMessages(csvNavigationMessagesFilename.str());
mbilog::UnregisterBackend(&m_LoggingBackend);
m_IsExperimentRunning = false;
m_ImageAndNavigationDataLoggingTimer->stop();
m_CombinedModality = 0;
// reset scene number for next experiment
m_SceneNumber = 1;
this->WaitCursorOff();
MITK_INFO("USNavigationLogging") << "Finished!";
}
void USNavigationMarkerPlacement::OnCombinedModalityChanged(
itk::SmartPointer<mitk::USCombinedModality> combinedModality)
{
// remove old listener for ultrasound device changes
if (m_CombinedModality.IsNotNull() && m_CombinedModality->GetUltrasoundDevice().IsNotNull())
{
m_CombinedModality->GetUltrasoundDevice()->RemovePropertyChangedListener(m_ListenerDeviceChanged);
}
m_CombinedModality = combinedModality;
m_ReinitAlreadyDone = false;
// add a listener for ultrasound device changes
if (m_CombinedModality.IsNotNull() && m_CombinedModality->GetUltrasoundDevice().IsNotNull())
{
m_CombinedModality->GetUltrasoundDevice()->AddPropertyChangedListener(m_ListenerDeviceChanged);
}
// update navigation data recorder for using the new combined modality
mitk::NavigationDataSource::Pointer navigationDataSource = combinedModality->GetNavigationDataSource();
m_NavigationDataRecorder->ConnectTo(navigationDataSource);
m_NavigationDataRecorder->ResetRecording();
// TODO check for correct connection
// for (unsigned int n = 0; n < navigationDataSource->GetNumberOfIndexedOutputs(); ++n)
// {
// m_NavigationDataRecorder->AddNavigationData(navigationDataSource->GetOutput(n));
// }
// update ultrasound image logging filter for using the new combined modality
mitk::USDevice::Pointer ultrasoundImageSource = combinedModality->GetUltrasoundDevice();
for (unsigned int n = 0; n < ultrasoundImageSource->GetNumberOfIndexedOutputs(); ++n)
{
m_USImageLoggingFilter->SetInput(n, ultrasoundImageSource->GetOutput(n));
}
// update ablation zone filter for using the new combined modality
for (unsigned int n = 0; n < navigationDataSource->GetNumberOfIndexedOutputs(); ++n)
{
m_AblationZonesDisplacementFilter->SetInput(n, navigationDataSource->GetOutput(n));
}
m_AblationZonesDisplacementFilter->SelectInput(m_MarkerIndex);
// make sure that a reinit is done for the new images
this->ReinitOnImage();
}
void USNavigationMarkerPlacement::OnSettingsChanged(itk::SmartPointer<mitk::DataNode> settings)
{
std::string applicationName;
if (!settings->GetStringProperty("settings.application", applicationName))
{
// set default application if the string property is not available
applicationName = "Marker Placement";
}
// create navigation step widgets according to the selected application
if (applicationName != m_CurrentApplicationName)
{
m_CurrentApplicationName = applicationName;
QmitkUSNavigationProcessWidget::NavigationStepVector navigationSteps;
if (applicationName == "Punction")
{
QmitkUSNavigationStepCombinedModality *stepCombinedModality = new QmitkUSNavigationStepCombinedModality(m_Parent);
QmitkUSNavigationStepTumourSelection *stepTumourSelection = new QmitkUSNavigationStepTumourSelection(m_Parent);
stepTumourSelection->SetTargetSelectionOptional(true);
m_TargetNodeDisplacementFilter = stepTumourSelection->GetTumourNodeDisplacementFilter();
QmitkUSNavigationStepZoneMarking *stepZoneMarking = new QmitkUSNavigationStepZoneMarking(m_Parent);
QmitkUSNavigationStepPunctuationIntervention *stepIntervention =
new QmitkUSNavigationStepPunctuationIntervention(m_Parent);
connect(stepIntervention, SIGNAL(AddAblationZoneClicked(int)), this, SLOT(OnAddAblationZone(int)));
connect(stepIntervention, SIGNAL(AblationZoneChanged(int, int)), this, SLOT(OnChangeAblationZone(int, int)));
m_NavigationStepNames = std::vector<QString>();
navigationSteps.push_back(stepCombinedModality);
m_NavigationStepNames.push_back("Combined Modality Initialization");
navigationSteps.push_back(stepTumourSelection);
m_NavigationStepNames.push_back("Target Selection");
navigationSteps.push_back(stepZoneMarking);
m_NavigationStepNames.push_back("Critical Structure Marking");
navigationSteps.push_back(stepIntervention);
m_NavigationStepNames.push_back("Intervention");
}
else if (applicationName == "Marker Placement")
{
QmitkUSNavigationStepCombinedModality *stepCombinedModality = new QmitkUSNavigationStepCombinedModality(m_Parent);
QmitkUSNavigationStepTumourSelection *stepTumourSelection = new QmitkUSNavigationStepTumourSelection(m_Parent);
m_TargetNodeDisplacementFilter = stepTumourSelection->GetTumourNodeDisplacementFilter();
QmitkUSNavigationStepZoneMarking *stepZoneMarking = new QmitkUSNavigationStepZoneMarking(m_Parent);
QmitkUSNavigationStepPlacementPlanning *stepPlacementPlanning =
new QmitkUSNavigationStepPlacementPlanning(m_Parent);
QmitkUSNavigationStepMarkerIntervention *stepMarkerIntervention =
new QmitkUSNavigationStepMarkerIntervention(m_Parent);
m_NavigationStepNames = std::vector<QString>();
navigationSteps.push_back(stepCombinedModality);
m_NavigationStepNames.push_back("Combined Modality Initialization");
navigationSteps.push_back(stepTumourSelection);
m_NavigationStepNames.push_back("Target Selection");
navigationSteps.push_back(stepZoneMarking);
m_NavigationStepNames.push_back("Critical Structure Marking");
navigationSteps.push_back(stepPlacementPlanning);
m_NavigationStepNames.push_back("Placement Planning");
navigationSteps.push_back(stepMarkerIntervention);
m_NavigationStepNames.push_back("Marker Intervention");
}
// set navigation step widgets to the process widget
ui->navigationProcessWidget->SetNavigationSteps(navigationSteps);
for (QmitkUSNavigationProcessWidget::NavigationStepIterator it = m_NavigationSteps.begin();
it != m_NavigationSteps.end();
++it)
{
delete *it;
}
m_NavigationSteps.clear();
m_NavigationSteps = navigationSteps;
}
// initialize gui according to the experiment mode setting
bool experimentMode = false;
settings->GetBoolProperty("settings.experiment-mode", experimentMode);
ui->startExperimentButton->setVisible(experimentMode);
ui->finishExperimentButton->setVisible(experimentMode);
ui->runningLabel->setVisible(experimentMode);
if (experimentMode && !m_IsExperimentRunning)
{
ui->navigationProcessWidget->ResetNavigationProcess();
ui->navigationProcessWidget->EnableInteraction(false);
ui->runningLabel->setPixmap(m_IconNotRunning);
}
else if (!experimentMode)
{
if (m_IsExperimentRunning)
{
this->OnFinishExperiment();
}
ui->navigationProcessWidget->EnableInteraction(true);
}
// get the results directory from the settings and use home directory if
// there is no results directory configured
std::string resultsDirectory;
if (settings->GetStringProperty("settings.experiment-results-directory", resultsDirectory))
{
m_ResultsDirectory = QString::fromStdString(resultsDirectory);
}
else
{
m_ResultsDirectory = QDir::homePath();
}
// make sure that the results directory exists
QDir resultsDirectoryQDir = QDir(m_ResultsDirectory);
if (!resultsDirectoryQDir.exists())
{
resultsDirectoryQDir.mkpath(m_ResultsDirectory);
}
MITK_INFO << "Results Directory: " << m_ResultsDirectory.toStdString();
}
void USNavigationMarkerPlacement::OnActiveNavigationStepChanged(int index)
{
// update navigation step timer each time the active navigation step changes
m_NavigationStepTimer->SetActiveIndex(index, m_NavigationSteps.at(index)->GetTitle().toStdString());
if (m_NavigationStepNames.size() <= index)
{
MITK_INFO("USNavigationLogging") << "Someting went wrong: unknown navigation step!";
}
else
{
MITK_INFO("USNavigationLogging") << "Navigation step finished/changed, next step: "
<< this->m_NavigationStepNames.at(index).toStdString()
<< "; duration until now: " << m_NavigationStepTimer->GetTotalDuration();
}
}
void USNavigationMarkerPlacement::OnIntermediateResultProduced(const itk::SmartPointer<mitk::DataNode> resultsNode)
{
// intermediate results only matter during an experiment
if (!m_IsExperimentRunning)
{
return;
}
this->WaitCursorOn();
// set results node to the experiment logging (for saving contents to the
// file system)
m_ExperimentLogging->SetResult(resultsNode);
std::string resultsName;
if (!resultsNode->GetName(resultsName))
{
MITK_WARN << "Could not get name of current results node.";
return;
}
// save the mitk scene
std::string scenefile = QString(m_ExperimentResultsSubDirectory + QDir::separator() +
QString("Scene %1 - ").arg(m_SceneNumber++, 2, 10, QChar('0')) +
QString::fromStdString(resultsName).replace(":", "_") + ".mitk")
.toStdString();
MITK_INFO << "Saving Scene File: " << scenefile;
mitk::SceneIO::Pointer sceneIO = mitk::SceneIO::New();
mitk::NodePredicateNot::Pointer isNotHelperObject =
mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(true)));
mitk::DataStorage::SetOfObjects::ConstPointer nodesToBeSaved = this->GetDataStorage()->GetSubset(isNotHelperObject);
this->Convert2DImagesTo3D(nodesToBeSaved);
sceneIO->SaveScene(nodesToBeSaved, this->GetDataStorage(), scenefile);
this->WaitCursorOff();
}
void USNavigationMarkerPlacement::ReinitOnImage()
{
if (!m_ReinitAlreadyDone && m_CombinedModality.IsNotNull())
{
// make sure that the output is already calibrated correctly
// (if the zoom level was changed recently)
m_CombinedModality->Modified();
m_CombinedModality->Update();
mitk::Image::Pointer image = m_CombinedModality->GetOutput();
if (image.IsNotNull() && image->IsInitialized())
{
// make a reinit on the ultrasound image
mitk::IRenderWindowPart *renderWindow = this->GetRenderWindowPart();
if (renderWindow != NULL && image->GetTimeGeometry()->IsValid())
{
renderWindow->GetRenderingManager()->InitializeViews(
image->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
renderWindow->GetRenderingManager()->RequestUpdateAll();
}
this->RequestRenderWindowUpdate();
m_ReinitAlreadyDone = true;
}
}
}
void USNavigationMarkerPlacement::Convert2DImagesTo3D(mitk::DataStorage::SetOfObjects::ConstPointer nodes)
{
for (mitk::DataStorage::SetOfObjects::ConstIterator it = nodes->Begin(); it != nodes->End(); ++it)
{
if (it->Value()->GetData() && strcmp(it->Value()->GetData()->GetNameOfClass(), "Image") == 0)
{
// convert image to 3d image if it is 2d at the moment
mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(it->Value()->GetData());
if (image.IsNotNull() && image->GetDimension() == 2 && !image->GetGeometry()->Is2DConvertable())
{
mitk::Convert2Dto3DImageFilter::Pointer convert2DTo3DImageFilter = mitk::Convert2Dto3DImageFilter::New();
convert2DTo3DImageFilter->SetInput(image);
convert2DTo3DImageFilter->Update();
it->Value()->SetData(convert2DTo3DImageFilter->GetOutput());
}
}
}
}
void USNavigationMarkerPlacement::CreateOverlays()
{
// initialize warning overlay (and do not display it, yet)
m_WarnOverlay->SetText("Warning: No calibration available for current depth.");
// set position and font size for the text overlay
// (nonesense postition as a layouter is used, but it ignored
// the overlay without setting a position here)
mitk::Point2D overlayPosition;
overlayPosition.SetElement(0, -50.0f);
overlayPosition.SetElement(1, -50.0f);
m_WarnOverlay->SetPosition2D(overlayPosition);
m_WarnOverlay->SetFontSize(22);
m_WarnOverlay->SetColor(1, 0, 0); // overlay should be red
}
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.h b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.h
index f43ddf3e90..11d3791b81 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.h
@@ -1,190 +1,196 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef USNAVIGATIONMARKERPLACEMENT_H
#define USNAVIGATIONMARKERPLACEMENT_H
#include <QmitkAbstractView.h>
#include "IO/mitkUSNavigationLoggingBackend.h"
#include "Widgets/QmitkUSNavigationProcessWidget.h"
#include "mitkNavigationDataRecorder.h"
#include "mitkNodeDisplacementFilter.h"
#include "mitkUSImageLoggingFilter.h"
#include <mitkMessage.h>
#include <mitkTextAnnotation2D.h>
#include <mitkUSCombinedModality.h>
namespace itk
{
template <class T>
class SmartPointer;
}
namespace mitk
{
class USNavigationStepTimer;
class USNavigationExperimentLogging;
}
namespace Ui
{
class USNavigationMarkerPlacement;
}
class QmitkUSAbstractNavigationStep;
class QmitkStdMultiWidget;
class QTimer;
class QSignalMapper;
/**
* \brief View for navigated marker placement using the combined modality.
* This view utilizes the QmitkUSNavigationProcessWidget to do the navigation
* process. It can be switched between widgets for marker placement and widgets
* for punctuation.
*
* An experiment mode allows for logging results, durations and the ultrasound
* images.
*/
class USNavigationMarkerPlacement : public QmitkAbstractView
{
Q_OBJECT
protected slots:
/**
* \brief Called periodically to update the rendering.
* The standard multi widget is changed to fit the navigation process once it
* is available and a reinit on the ultrasound image is done for a new image
* node.
*/
void OnTimeout();
/**
* \brief Called periodically during an experiment for logging the ultrasound images.
*/
void OnImageAndNavigationDataLoggingTimeout();
/**
* \brief Initializes anything neccessary for an experiment.
* The user is asked for a directory for storing the results and the logging
* is started.
*/
void OnStartExperiment();
/**
* \brief Stops logging and saves everything to the file system.
*/
void OnFinishExperiment();
void OnCombinedModalityChanged(itk::SmartPointer<mitk::USCombinedModality>);
/**
* \brief Switches the navigation step widgets if the navigation application was changed.
*/
void OnSettingsChanged(itk::SmartPointer<mitk::DataNode>);
/**
* \brief Updates the timer for the navigation steps durations every time the active navigation step changes.
*/
void OnActiveNavigationStepChanged(int);
/**
* \brief The data node is given to the experiment logging and scene is saved to the file system.
*/
void OnIntermediateResultProduced(const itk::SmartPointer<mitk::DataNode>);
void OnAddAblationZone(int size);
+ void OnEnableNavigationLayout();
+
+ void OnResetStandardLayout();
+
+ void OnChangeLayoutClicked();
+
void OnChangeAblationZone(int id, int newSize);
public:
static const char *DATANAME_TUMOUR;
static const char *DATANAME_TARGETSURFACE;
static const char *DATANAME_ZONES;
static const char *DATANAME_TARGETS;
static const char *DATANAME_TARGETS_PATHS;
static const char *DATANAME_REACHED_TARGETS;
explicit USNavigationMarkerPlacement();
- ~USNavigationMarkerPlacement();
+ virtual ~USNavigationMarkerPlacement();
virtual void CreateQtPartControl(QWidget *parent);
static const std::string VIEW_ID;
void OnCombinedModalityPropertyChanged(const std::string &, const std::string &);
protected:
/**
* \brief A reinit on the ultrasound image is performed every time the view gets the focus.
*/
virtual void SetFocus();
/**
* \brief Helper function which performs a reinit on the ultrasound image.
*/
void ReinitOnImage();
/**
* \brief Helper function for being able to serialize the 2d ultrasound image.
*/
void Convert2DImagesTo3D(mitk::DataStorage::SetOfObjects::ConstPointer nodes);
void CreateOverlays();
QWidget *m_Parent;
QmitkUSNavigationProcessWidget::NavigationStepVector m_NavigationSteps;
QTimer *m_UpdateTimer;
QTimer *m_ImageAndNavigationDataLoggingTimer;
QmitkStdMultiWidget *m_StdMultiWidget;
itk::SmartPointer<mitk::USCombinedModality> m_CombinedModality;
bool m_ReinitAlreadyDone;
bool m_IsExperimentRunning;
std::string m_CurrentApplicationName;
itk::SmartPointer<mitk::USNavigationStepTimer> m_NavigationStepTimer;
itk::SmartPointer<mitk::USNavigationExperimentLogging> m_ExperimentLogging;
QPixmap m_IconRunning;
QPixmap m_IconNotRunning;
QString m_ResultsDirectory;
QString m_ExperimentName;
QString m_ExperimentResultsSubDirectory;
std::vector<QString>
m_NavigationStepNames; // stores the names of the navigation steps which are currently used (for logging purposes)
mitk::USNavigationLoggingBackend m_LoggingBackend;
mitk::USImageLoggingFilter::Pointer m_USImageLoggingFilter;
mitk::NavigationDataRecorder::Pointer m_NavigationDataRecorder; // records navigation data files
mitk::NodeDisplacementFilter::Pointer m_TargetNodeDisplacementFilter;
mitk::NodeDisplacementFilter::Pointer m_AblationZonesDisplacementFilter;
std::vector<mitk::DataNode::Pointer> m_AblationZonesVector;
int m_NeedleIndex;
int m_MarkerIndex;
int m_SceneNumber;
itk::SmartPointer<mitk::TextAnnotation2D> m_WarnOverlay;
private:
mitk::MessageDelegate2<USNavigationMarkerPlacement, const std::string &, const std::string &> m_ListenerDeviceChanged;
Ui::USNavigationMarkerPlacement *ui;
};
#endif // USNAVIGATIONMARKERPLACEMENT_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.ui b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.ui
index be5cde1399..eb816e0225 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.ui
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.ui
@@ -1,83 +1,102 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>USNavigationMarkerPlacement</class>
<widget class="QWidget" name="USNavigationMarkerPlacement">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>400</width>
<height>146</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<property name="spacing">
<number>0</number>
</property>
- <property name="margin">
+ <property name="leftMargin">
+ <number>0</number>
+ </property>
+ <property name="topMargin">
+ <number>0</number>
+ </property>
+ <property name="rightMargin">
+ <number>0</number>
+ </property>
+ <property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QmitkUSNavigationProcessWidget" name="navigationProcessWidget" native="true"/>
</item>
<item>
<widget class="Line" name="line">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
</widget>
</item>
+ <item>
+ <widget class="QCheckBox" name="m_enableNavigationLayout">
+ <property name="text">
+ <string>Enable Navigation Render Window Layout</string>
+ </property>
+ <property name="checked">
+ <bool>true</bool>
+ </property>
+ </widget>
+ </item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<widget class="QPushButton" name="startExperimentButton">
<property name="text">
<string>Start New Experiment</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="finishExperimentButton">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>Finish Experiment</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="runningLabel">
<property name="maximumSize">
<size>
<width>20</width>
<height>20</height>
</size>
</property>
<property name="text">
<string/>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
<customwidgets>
<customwidget>
<class>QmitkUSNavigationProcessWidget</class>
<extends>QWidget</extends>
<header>src/internal/Widgets/QmitkUSNavigationProcessWidget.h</header>
<container>1</container>
</customwidget>
</customwidgets>
<resources/>
<connections/>
<slots>
<slot>OnStartExperiment()</slot>
<slot>OnFinishExperiment()</slot>
</slots>
</ui>