diff --git a/Applications/Workbench/target_libraries.cmake b/Applications/Workbench/target_libraries.cmake
index 454061bdda..d88d280b30 100644
--- a/Applications/Workbench/target_libraries.cmake
+++ b/Applications/Workbench/target_libraries.cmake
@@ -1,9 +1,8 @@
# A list of plug-in targets which should be automatically enabled
# (or be available in external projects) for this application.
set(target_libraries
org_blueberry_ui_qt
- org_blueberry_ui_qt_help
org_mitk_gui_qt_extapplication
)
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/PluginList.cmake b/Plugins/PluginList.cmake
index 4cdec681c8..c2701b02e4 100644
--- a/Plugins/PluginList.cmake
+++ b/Plugins/PluginList.cmake
@@ -1,85 +1,85 @@
# Plug-ins must be ordered according to their dependencies
set(MITK_PLUGINS
org.blueberry.core.runtime:ON
org.blueberry.core.expressions:OFF
org.blueberry.core.commands:OFF
org.blueberry.core.jobs:OFF
org.blueberry.ui.qt:OFF
- org.blueberry.ui.qt.help:OFF
+ org.blueberry.ui.qt.help:ON
org.blueberry.ui.qt.log:ON
org.blueberry.ui.qt.objectinspector:OFF
#org.blueberry.test:ON
#org.blueberry.uitest:ON
#Testing/org.blueberry.core.runtime.tests:ON
#Testing/org.blueberry.osgi.tests:ON
org.mitk.core.services:ON
org.mitk.gui.common:ON
org.mitk.planarfigure:ON
org.mitk.core.ext:OFF
org.mitk.core.jobs:OFF
org.mitk.diffusionimaging:OFF
org.mitk.simulation:OFF
org.mitk.gui.qt.application:ON
org.mitk.gui.qt.coreapplication:OFF
org.mitk.gui.qt.ext:OFF
org.mitk.gui.qt.extapplication:OFF
org.mitk.gui.qt.common:ON
org.mitk.gui.qt.stdmultiwidgeteditor:ON
org.mitk.gui.qt.common.legacy:OFF
org.mitk.gui.qt.cmdlinemodules:OFF
org.mitk.gui.qt.diffusionimagingapp:OFF
org.mitk.gui.qt.datamanager:ON
org.mitk.gui.qt.datamanagerlight:OFF
org.mitk.gui.qt.properties:ON
org.mitk.gui.qt.basicimageprocessing:OFF
org.mitk.gui.qt.dicom:OFF
org.mitk.gui.qt.dicominspector:OFF
org.mitk.gui.qt.diffusionimaging:OFF
org.mitk.gui.qt.dosevisualization:OFF
org.mitk.gui.qt.geometrytools:OFF
org.mitk.gui.qt.igtexamples:OFF
org.mitk.gui.qt.igttracking:OFF
org.mitk.gui.qt.openigtlink:OFF
org.mitk.gui.qt.imagecropper:OFF
org.mitk.gui.qt.imagenavigator:ON
org.mitk.gui.qt.viewnavigator:OFF
org.mitk.gui.qt.materialeditor:OFF
org.mitk.gui.qt.measurementtoolbox:OFF
org.mitk.gui.qt.moviemaker:OFF
org.mitk.gui.qt.pointsetinteraction:OFF
org.mitk.gui.qt.pointsetinteractionmultispectrum:OFF
org.mitk.gui.qt.python:OFF
org.mitk.gui.qt.registration:OFF
org.mitk.gui.qt.remeshing:OFF
org.mitk.gui.qt.segmentation:OFF
org.mitk.gui.qt.simulation:OFF
org.mitk.gui.qt.aicpregistration:OFF
org.mitk.gui.qt.toftutorial:OFF
org.mitk.gui.qt.tofutil:OFF
org.mitk.gui.qt.tubegraph:OFF
org.mitk.gui.qt.ugvisualization:OFF
org.mitk.gui.qt.ultrasound:OFF
org.mitk.gui.qt.volumevisualization:OFF
org.mitk.gui.qt.eventrecorder:OFF
org.mitk.gui.qt.xnat:OFF
org.mitk.gui.qt.igt.app.echotrack:OFF
org.mitk.gui.qt.spectrocamrecorder:OFF
org.mitk.gui.qt.classificationsegmentation:OFF
org.mitk.gui.qt.overlaymanager:OFF
org.mitk.gui.qt.multilabelsegmentation:ON
org.mitk.matchpoint.core.helper:OFF
org.mitk.gui.qt.matchpoint.algorithm.browser:OFF
org.mitk.gui.qt.matchpoint.algorithm.control:OFF
org.mitk.gui.qt.matchpoint.algorithm.batch:OFF
org.mitk.gui.qt.matchpoint.mapper:OFF
org.mitk.gui.qt.matchpoint.framereg:OFF
org.mitk.gui.qt.matchpoint.visualizer:OFF
org.mitk.gui.qt.matchpoint.evaluator:OFF
org.mitk.gui.qt.matchpoint.manipulator:OFF
)
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/QmitkUSNavigationPerspective.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/QmitkUSNavigationPerspective.cpp
index 2afe6176cc..70ba385845 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/QmitkUSNavigationPerspective.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/QmitkUSNavigationPerspective.cpp
@@ -1,36 +1,42 @@
/*===================================================================
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 "QmitkUSNavigationPerspective.h"
QmitkUSNavigationPerspective::QmitkUSNavigationPerspective()
{
}
void QmitkUSNavigationPerspective::CreateInitialLayout (berry::IPageLayout::Pointer layout)
{
// place navigation plugin on the right side (not closable)
- layout->AddStandaloneView("org.mitk.views.usmarkerplacement", false, berry::IPageLayout::RIGHT, 0.8f, layout->GetEditorArea());
+ layout->AddStandaloneView("org.mitk.views.usmarkerplacement", false, berry::IPageLayout::RIGHT, 0.75f, layout->GetEditorArea());
// place tracking toolbox and ultrasound support on the left into a folder
// layout (closeable)
+ layout->AddStandaloneView("org.mitk.views.ultrasoundsupport", false, berry::IPageLayout::LEFT, 0.3f, layout->GetEditorArea());
+ layout->AddStandaloneView("org.mitk.views.mitkigttrackingtoolbox", false, berry::IPageLayout::BOTTOM, 0.9f, "org.mitk.views.ultrasoundsupport");
+
+ /*
berry::IFolderLayout::Pointer leftFolder = layout->CreateFolder("left", berry::IPageLayout::LEFT, 0.3f, layout->GetEditorArea());
+ leftFolder->AddStandaloneView("org.mitk.views.ultrasoundsupport", false, berry::IPageLayout::LEFT, 0.8f, layout->GetEditorArea());
leftFolder->AddView("org.mitk.views.mitkigttrackingtoolbox");
leftFolder->AddView("org.mitk.views.ultrasoundsupport");
layout->GetViewLayout("org.mitk.views.mitkigttrackingtoolbox")->SetCloseable(false);
layout->GetViewLayout("org.mitk.views.ultrasoundsupport")->SetCloseable(false);
+ */
}
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..ee3b26d0d7 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,691 @@
/*===================================================================
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 "NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.h"
+#include "NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.h"
+#include "NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.h"
#include "SettingsWidgets/QmitkUSNavigationCombinedSettingsWidget.h"
#include "mitkIRenderingManager.h"
#include "mitkNodeDisplacementFilter.h"
#include "mitkUSCombinedModality.h"
+#include "mitkOverlay2DLayouter.h"
#include <mitkIOUtil.h>
-#include "IO/mitkUSNavigationExperimentLogging.h"
#include "IO/mitkUSNavigationStepTimer.h"
+#include "IO/mitkUSNavigationExperimentLogging.h"
-#include <QDateTime>
-#include <QDir>
+#include <QTimer>
+#include <QSignalMapper>
#include <QInputDialog>
+#include <QDir>
#include <QMessageBox>
-#include <QSignalMapper>
-#include <QTimer>
+#include <QDateTime>
#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>
+#include <mitkNodePredicateNot.h>
+#include <mitkNodePredicateProperty.h>
+#include <mitkConvert2Dto3DImageFilter.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";
+const char* USNavigationMarkerPlacement::DATANAME_TUMOUR = "Tumour";
+const char* USNavigationMarkerPlacement::DATANAME_TARGETSURFACE = "Target Surface";
+const char* USNavigationMarkerPlacement::DATANAME_ZONES = "Zones";
+const char* USNavigationMarkerPlacement::DATANAME_TARGETS = "Targets";
+const char* USNavigationMarkerPlacement::DATANAME_TARGETS_PATHS = "Target Paths";
+const char* USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS = "Reached Targets";
USNavigationMarkerPlacement::USNavigationMarkerPlacement()
: m_UpdateTimer(new QTimer(this)),
m_ImageAndNavigationDataLoggingTimer(new QTimer(this)),
m_StdMultiWidget(0),
m_ReinitAlreadyDone(false),
m_IsExperimentRunning(false),
m_NavigationStepTimer(mitk::USNavigationStepTimer::New()),
m_ExperimentLogging(mitk::USNavigationExperimentLogging::New()),
m_AblationZonesDisplacementFilter(mitk::NodeDisplacementFilter::New()),
m_IconRunning(QPixmap(":/USNavigation/record.png")),
m_IconNotRunning(QPixmap(":/USNavigation/record-gray.png")),
m_USImageLoggingFilter(mitk::USImageLoggingFilter::New()),
m_NavigationDataRecorder(mitk::NavigationDataRecorder::New()),
m_SceneNumber(1),
m_WarnOverlay(mitk::TextAnnotation2D::New()),
m_ListenerDeviceChanged(this, &USNavigationMarkerPlacement::OnCombinedModalityPropertyChanged),
m_NeedleIndex(0),
m_MarkerIndex(1),
ui(new Ui::USNavigationMarkerPlacement)
{
connect(m_UpdateTimer, SIGNAL(timeout()), this, SLOT(OnTimeout()));
- connect(
- m_ImageAndNavigationDataLoggingTimer, SIGNAL(timeout()), this, SLOT(OnImageAndNavigationDataLoggingTimeout()));
+ connect(m_ImageAndNavigationDataLoggingTimer, SIGNAL(timeout()), this, SLOT(OnImageAndNavigationDataLoggingTimeout()));
// scale running (and not running) icon the specific height
m_IconRunning = m_IconRunning.scaledToHeight(20, Qt::SmoothTransformation);
m_IconNotRunning = m_IconNotRunning.scaledToHeight(20, Qt::SmoothTransformation);
// set prefix for experiment logging (only keys with this prefix are taken
// into consideration
m_ExperimentLogging->SetKeyPrefix("USNavigation::");
- m_UpdateTimer->start(33); // every 33 Milliseconds = 30 Frames/Second
+ m_UpdateTimer->start(33); //every 33 Milliseconds = 30 Frames/Second
}
USNavigationMarkerPlacement::~USNavigationMarkerPlacement()
{
// make sure that the experiment got finished before destructing the object
- if (m_IsExperimentRunning)
- {
- this->OnFinishExperiment();
- }
+ if (m_IsExperimentRunning) { this->OnFinishExperiment(); }
// remove listener for ultrasound device changes
if (m_CombinedModality.IsNotNull() && m_CombinedModality->GetUltrasoundDevice().IsNotNull())
{
m_CombinedModality->GetUltrasoundDevice()->RemovePropertyChangedListener(m_ListenerDeviceChanged);
}
delete ui;
}
void USNavigationMarkerPlacement::OnChangeAblationZone(int id, int newSize)
{
- if ((m_AblationZonesVector.size() < id) || (id < 0))
- {
- return;
- }
+ if ((m_AblationZonesVector.size() < id) || (id < 0)) { return; }
MITK_INFO << "Ablation Zone " << id << " changed, new size: " << newSize;
// create a vtk sphere with given radius
vtkSphereSource *vtkData = vtkSphereSource::New();
vtkData->SetRadius(newSize / 2);
vtkData->SetCenter(0, 0, 0);
vtkData->SetPhiResolution(20);
vtkData->SetThetaResolution(20);
vtkData->Update();
- mitk::Surface::Pointer zoneSurface = dynamic_cast<mitk::Surface *>(m_AblationZonesVector.at(id)->GetData());
+ 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));
+ m_AblationZonesDisplacementFilter->SetInitialReferencePose(m_CombinedModality->GetNavigationDataSource()->GetOutput(m_MarkerIndex));
mitk::DataNode::Pointer NewAblationZone = mitk::DataNode::New();
mitk::Point3D origin = m_CombinedModality->GetNavigationDataSource()->GetOutput(m_NeedleIndex)->GetPosition();
MITK_INFO("USNavigationLogging") << "Ablation Zone Added, initial size: " << size << ", origin: " << origin;
mitk::Surface::Pointer zone = mitk::Surface::New();
// create a vtk sphere with given radius
vtkSphereSource *vtkData = vtkSphereSource::New();
vtkData->SetRadius(size / 2);
vtkData->SetCenter(0, 0, 0);
vtkData->SetPhiResolution(20);
vtkData->SetThetaResolution(20);
vtkData->Update();
zone->SetVtkPolyData(vtkData->GetOutput());
vtkData->Delete();
// set vtk sphere and origin to data node (origin must be set
// again, because of the new sphere set as data)
NewAblationZone->SetData(zone);
NewAblationZone->GetData()->GetGeometry()->SetOrigin(origin);
mitk::Color SphereColor = mitk::Color();
- // default color
+ //default color
SphereColor[0] = 102;
SphereColor[1] = 0;
SphereColor[2] = 204;
NewAblationZone->SetColor(SphereColor);
NewAblationZone->SetOpacity(0.3);
// set name of zone
std::stringstream name;
name << "Ablation Zone" << m_AblationZonesVector.size();
NewAblationZone->SetName(name.str());
// add zone to filter
m_AblationZonesDisplacementFilter->AddNode(NewAblationZone);
m_AblationZonesVector.push_back(NewAblationZone);
this->GetDataStorage()->Add(NewAblationZone);
}
void USNavigationMarkerPlacement::CreateQtPartControl(QWidget *parent)
{
m_Parent = parent;
ui->setupUi(parent);
connect(ui->navigationProcessWidget,
- SIGNAL(SignalCombinedModalityChanged(itk::SmartPointer<mitk::USCombinedModality>)),
- this,
- SLOT(OnCombinedModalityChanged(itk::SmartPointer<mitk::USCombinedModality>)));
+ 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>)));
+ 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->navigationProcessWidget, SIGNAL(SignalActiveNavigationStepChanged(int)),
+ this, SLOT(OnActiveNavigationStepChanged(int)));
connect(ui->startExperimentButton, SIGNAL(clicked()), this, SLOT(OnStartExperiment()));
connect(ui->finishExperimentButton, SIGNAL(clicked()), this, SLOT(OnFinishExperiment()));
- connect(ui->navigationProcessWidget,
- SIGNAL(SignalIntermediateResult(const itk::SmartPointer<mitk::DataNode>)),
- this,
- SLOT(OnIntermediateResultProduced(const itk::SmartPointer<mitk::DataNode>)));
+ 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 &)
+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)
{
// try to get the standard multi widget if it couldn't be got before
- mitk::IRenderWindowPart *renderWindow = this->GetRenderWindowPart();
+ mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart();
- QmitkStdMultiWidgetEditor *multiWidgetEditor = dynamic_cast<QmitkStdMultiWidgetEditor *>(renderWindow);
+ 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->CreateOverlays();
}
- if (m_CombinedModality.IsNotNull() &&
- !this->m_CombinedModality->GetIsFreezed()) // if the combined modality is freezed: do nothing
+ if (m_CombinedModality.IsNotNull() && !this->m_CombinedModality->GetIsFreezed()) //if the combined modality is freezed: do nothing
{
ui->navigationProcessWidget->UpdateNavigationProgress();
m_AblationZonesDisplacementFilter->Update();
- // update the 3D window only every fourth time to speed up the rendering (at least in 2D)
+ //update the 3D window only every fourth time to speed up the rendering (at least in 2D)
this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS);
// make sure that a reinit was performed on the image
this->ReinitOnImage();
}
}
void USNavigationMarkerPlacement::OnImageAndNavigationDataLoggingTimeout()
{
// update filter for logging navigation data and ultrasound images
if (m_CombinedModality.IsNotNull())
{
m_NavigationDataRecorder->Update();
- // get last messages for logging filer and store them
+ //get last messages for logging filer and store them
std::vector<std::string> messages = m_LoggingBackend.GetNavigationMessages();
std::string composedMessage = "";
- for (int i = 0; i < messages.size(); i++)
- {
- composedMessage += messages.at(i);
- }
+ for (int i = 0; i < messages.size(); i++) { composedMessage += messages.at(i); }
m_USImageLoggingFilter->AddMessageToCurrentImage(composedMessage);
m_LoggingBackend.ClearNavigationMessages();
- // update logging filter
+ //update logging filter
m_USImageLoggingFilter->Update();
}
}
void USNavigationMarkerPlacement::OnStartExperiment()
{
// get name for the experiment by a QInputDialog
bool ok;
if (m_ExperimentName.isEmpty())
- { // default: current date
- m_ExperimentName = QString::number(QDateTime::currentDateTime().date().year()) + "_" +
- QString::number(QDateTime::currentDateTime().date().month()) + "_" +
- QString::number(QDateTime::currentDateTime().date().day()) + "_experiment_" +
- QString::number(QDateTime::currentDateTime().time().hour()) + "." +
- QString::number(QDateTime::currentDateTime().time().minute());
+ { //default: current date
+ m_ExperimentName = QString::number(QDateTime::currentDateTime().date().year()) + "_"
+ + QString::number(QDateTime::currentDateTime().date().month()) + "_"
+ + QString::number(QDateTime::currentDateTime().date().day()) + "_experiment_"
+ + QString::number(QDateTime::currentDateTime().time().hour()) + "."
+ + QString::number(QDateTime::currentDateTime().time().minute());
}
- m_ExperimentName = QInputDialog::getText(
- m_Parent, QString("Experiment Name"), QString("Name of the Experiment"), QLineEdit::Normal, m_ExperimentName, &ok);
+ m_ExperimentName = QInputDialog::getText(m_Parent, QString("Experiment Name"), QString("Name of the Experiment"), QLineEdit::Normal, m_ExperimentName, &ok);
MITK_INFO("USNavigationLogging") << "Experiment started: " << m_ExperimentName.toStdString();
if (ok && !m_ExperimentName.isEmpty())
{
// display error message and call the function recursivly if a directory
// with the given name already exists
QDir experimentResultsDir(m_ResultsDirectory + QDir::separator() + m_ExperimentName);
if (experimentResultsDir.exists())
{
- QMessageBox::critical(
- m_Parent, "Results Directory Exists", "The result directory already exists.\nPlease choose an other name.");
+ QMessageBox::critical(m_Parent, "Results Directory Exists", "The result directory already exists.\nPlease choose an other name.");
this->OnStartExperiment();
}
else
{
QDir(m_ResultsDirectory).mkdir(m_ExperimentName);
m_ExperimentResultsSubDirectory = m_ResultsDirectory + QDir::separator() + m_ExperimentName;
// experiment is running now
ui->runningLabel->setPixmap(m_IconRunning);
ui->navigationProcessWidget->EnableInteraction(true);
// (re)start timer for navigation step durations
m_NavigationStepTimer->Reset();
- m_NavigationStepTimer->SetOutputFileName(
- QString(m_ExperimentResultsSubDirectory + QDir::separator() + QString("durations.cvs")).toStdString());
+ m_NavigationStepTimer->SetOutputFileName(QString(m_ExperimentResultsSubDirectory + QDir::separator()
+ + QString("durations.cvs")).toStdString());
m_NavigationStepTimer->SetActiveIndex(0, m_NavigationSteps.at(0)->GetTitle().toStdString());
ui->finishExperimentButton->setEnabled(true);
ui->startExperimentButton->setDisabled(true);
// initialize and register logging backend
QString loggingFilename = m_ExperimentResultsSubDirectory + QDir::separator() + "logging.txt";
m_LoggingBackend.SetOutputFileName(loggingFilename.toStdString());
mbilog::RegisterBackend(&m_LoggingBackend);
// initialize and start navigation data recorder form xml recording
m_NavigationDataRecorder->StartRecording();
m_IsExperimentRunning = true;
m_ImageAndNavigationDataLoggingTimer->start(1000);
// (re)start experiment logging and set output file name
m_ExperimentLogging->Reset();
- m_ExperimentLogging->SetFileName(
- QString(m_ExperimentResultsSubDirectory + QDir::separator() + "experiment-logging.xml").toStdString());
+ m_ExperimentLogging->SetFileName(QString(m_ExperimentResultsSubDirectory + QDir::separator() + "experiment-logging.xml").toStdString());
}
}
}
void USNavigationMarkerPlacement::OnFinishExperiment()
{
this->WaitCursorOn();
MITK_INFO("USNavigationLogging") << "Experiment finished!";
- MITK_INFO("USNavigationLogging")
- << "Position/Orientation of needle tip: "
- << (dynamic_cast<mitk::NavigationData *>(m_CombinedModality->GetTrackingDevice()->GetOutput(0)))->GetPosition();
- MITK_INFO("USNavigationLogging")
- << "Position of target: " << m_TargetNodeDisplacementFilter->GetRawDisplacementNavigationData(0)->GetPosition();
+ MITK_INFO("USNavigationLogging") << "Position/Orientation of needle tip: " << (dynamic_cast<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->SaveImages(QString(m_ExperimentResultsSubDirectory + QDir::separator() + "ImageStream" + QDir::separator()).toStdString());
m_USImageLoggingFilter = mitk::USImageLoggingFilter::New();
m_NavigationDataRecorder->StopRecording();
// Write data to csv and xml file
- mitk::IOUtil::SaveBaseData(
- m_NavigationDataRecorder->GetNavigationDataSet(),
- (QString(m_ExperimentResultsSubDirectory + QDir::separator() + "navigation-data.xml").toStdString().c_str()));
- mitk::IOUtil::SaveBaseData(
- m_NavigationDataRecorder->GetNavigationDataSet(),
- (QString(m_ExperimentResultsSubDirectory + QDir::separator() + "navigation-data.csv").toStdString().c_str()));
-
- // write logged navigation data messages to separate file
+ mitk::IOUtil::SaveBaseData(m_NavigationDataRecorder->GetNavigationDataSet(), (QString(m_ExperimentResultsSubDirectory + QDir::separator() + "navigation-data.xml").toStdString().c_str()));
+ mitk::IOUtil::SaveBaseData(m_NavigationDataRecorder->GetNavigationDataSet(), (QString(m_ExperimentResultsSubDirectory + QDir::separator() + "navigation-data.csv").toStdString().c_str()));
+
+ //write logged navigation data messages to separate file
std::stringstream csvNavigationMessagesFilename;
- csvNavigationMessagesFilename << m_ExperimentResultsSubDirectory.toStdString() << QDir::separator().toLatin1()
- << "CSVNavigationMessagesLogFile.csv";
- MITK_INFO("USNavigationLogging") << "Writing logged navigation messages to separate csv file: "
- << csvNavigationMessagesFilename.str();
+ csvNavigationMessagesFilename << m_ExperimentResultsSubDirectory.toStdString() << QDir::separator().toLatin1() << "CSVNavigationMessagesLogFile.csv";
+ MITK_INFO("USNavigationLogging") << "Writing logged navigation messages to separate csv file: " << csvNavigationMessagesFilename.str();
m_LoggingBackend.WriteCSVFileWithNavigationMessages(csvNavigationMessagesFilename.str());
mbilog::UnregisterBackend(&m_LoggingBackend);
m_IsExperimentRunning = false;
m_ImageAndNavigationDataLoggingTimer->stop();
m_CombinedModality = 0;
// reset scene number for next experiment
m_SceneNumber = 1;
this->WaitCursorOff();
MITK_INFO("USNavigationLogging") << "Finished!";
}
-void USNavigationMarkerPlacement::OnCombinedModalityChanged(
- itk::SmartPointer<mitk::USCombinedModality> combinedModality)
+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);
+ QmitkUSNavigationStepCombinedModality* stepCombinedModality =
+ new QmitkUSNavigationStepCombinedModality(m_Parent);
+ QmitkUSNavigationStepTumourSelection* stepTumourSelection =
+ new QmitkUSNavigationStepTumourSelection(m_Parent);
stepTumourSelection->SetTargetSelectionOptional(true);
m_TargetNodeDisplacementFilter = stepTumourSelection->GetTumourNodeDisplacementFilter();
- QmitkUSNavigationStepZoneMarking *stepZoneMarking = new QmitkUSNavigationStepZoneMarking(m_Parent);
- QmitkUSNavigationStepPunctuationIntervention *stepIntervention =
+ QmitkUSNavigationStepZoneMarking* stepZoneMarking =
+ new QmitkUSNavigationStepZoneMarking(m_Parent);
+ QmitkUSNavigationStepPunctuationIntervention* stepIntervention =
new QmitkUSNavigationStepPunctuationIntervention(m_Parent);
connect(stepIntervention, SIGNAL(AddAblationZoneClicked(int)), this, SLOT(OnAddAblationZone(int)));
connect(stepIntervention, SIGNAL(AblationZoneChanged(int, int)), this, SLOT(OnChangeAblationZone(int, int)));
m_NavigationStepNames = std::vector<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);
+ QmitkUSNavigationStepCombinedModality* stepCombinedModality =
+ new QmitkUSNavigationStepCombinedModality(m_Parent);
+ QmitkUSNavigationStepTumourSelection* stepTumourSelection =
+ new QmitkUSNavigationStepTumourSelection(m_Parent);
m_TargetNodeDisplacementFilter = stepTumourSelection->GetTumourNodeDisplacementFilter();
- QmitkUSNavigationStepZoneMarking *stepZoneMarking = new QmitkUSNavigationStepZoneMarking(m_Parent);
- QmitkUSNavigationStepPlacementPlanning *stepPlacementPlanning =
+ QmitkUSNavigationStepZoneMarking* stepZoneMarking =
+ new QmitkUSNavigationStepZoneMarking(m_Parent);
+ QmitkUSNavigationStepPlacementPlanning* stepPlacementPlanning =
new QmitkUSNavigationStepPlacementPlanning(m_Parent);
- QmitkUSNavigationStepMarkerIntervention *stepMarkerIntervention =
+ QmitkUSNavigationStepMarkerIntervention* stepMarkerIntervention =
new QmitkUSNavigationStepMarkerIntervention(m_Parent);
m_NavigationStepNames = std::vector<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)
+ it != m_NavigationSteps.end(); ++it)
{
delete *it;
}
m_NavigationSteps.clear();
m_NavigationSteps = navigationSteps;
}
// initialize gui according to the experiment mode setting
bool experimentMode = false;
settings->GetBoolProperty("settings.experiment-mode", experimentMode);
ui->startExperimentButton->setVisible(experimentMode);
ui->finishExperimentButton->setVisible(experimentMode);
ui->runningLabel->setVisible(experimentMode);
if (experimentMode && !m_IsExperimentRunning)
{
ui->navigationProcessWidget->ResetNavigationProcess();
ui->navigationProcessWidget->EnableInteraction(false);
ui->runningLabel->setPixmap(m_IconNotRunning);
}
else if (!experimentMode)
{
- if (m_IsExperimentRunning)
- {
- this->OnFinishExperiment();
- }
+ if (m_IsExperimentRunning) { this->OnFinishExperiment(); }
ui->navigationProcessWidget->EnableInteraction(true);
}
// get the results directory from the settings and use home directory if
// there is no results directory configured
std::string resultsDirectory;
if (settings->GetStringProperty("settings.experiment-results-directory", resultsDirectory))
{
m_ResultsDirectory = QString::fromStdString(resultsDirectory);
}
else
{
m_ResultsDirectory = QDir::homePath();
}
// make sure that the results directory exists
QDir resultsDirectoryQDir = QDir(m_ResultsDirectory);
if (!resultsDirectoryQDir.exists())
{
resultsDirectoryQDir.mkpath(m_ResultsDirectory);
}
MITK_INFO << "Results Directory: " << m_ResultsDirectory.toStdString();
}
void USNavigationMarkerPlacement::OnActiveNavigationStepChanged(int index)
{
// update navigation step timer each time the active navigation step changes
m_NavigationStepTimer->SetActiveIndex(index, m_NavigationSteps.at(index)->GetTitle().toStdString());
- if (m_NavigationStepNames.size() <= index)
- {
- MITK_INFO("USNavigationLogging") << "Someting went wrong: unknown navigation step!";
- }
- else
- {
- MITK_INFO("USNavigationLogging") << "Navigation step finished/changed, next step: "
- << this->m_NavigationStepNames.at(index).toStdString()
- << "; duration until now: " << m_NavigationStepTimer->GetTotalDuration();
- }
+ if (m_NavigationStepNames.size() <= index) { MITK_INFO("USNavigationLogging") << "Someting went wrong: unknown navigation step!"; }
+ else { MITK_INFO("USNavigationLogging") << "Navigation step finished/changed, next step: " << this->m_NavigationStepNames.at(index).toStdString() << "; duration until now: " << m_NavigationStepTimer->GetTotalDuration(); }
}
void USNavigationMarkerPlacement::OnIntermediateResultProduced(const itk::SmartPointer<mitk::DataNode> resultsNode)
{
// intermediate results only matter during an experiment
- if (!m_IsExperimentRunning)
- {
- return;
- }
+ if (!m_IsExperimentRunning) { return; }
this->WaitCursorOn();
// set results node to the experiment logging (for saving contents to the
// file system)
m_ExperimentLogging->SetResult(resultsNode);
std::string resultsName;
if (!resultsNode->GetName(resultsName))
{
MITK_WARN << "Could not get name of current results node.";
return;
}
// save the mitk scene
- std::string scenefile = QString(m_ExperimentResultsSubDirectory + QDir::separator() +
- QString("Scene %1 - ").arg(m_SceneNumber++, 2, 10, QChar('0')) +
- QString::fromStdString(resultsName).replace(":", "_") + ".mitk")
- .toStdString();
+ std::string scenefile = QString(m_ExperimentResultsSubDirectory + QDir::separator()
+ + QString("Scene %1 - ").arg(m_SceneNumber++, 2, 10, QChar('0'))
+ + QString::fromStdString(resultsName).replace(":", "_") + ".mitk").toStdString();
MITK_INFO << "Saving Scene File: " << scenefile;
mitk::SceneIO::Pointer sceneIO = mitk::SceneIO::New();
mitk::NodePredicateNot::Pointer isNotHelperObject =
mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(true)));
mitk::DataStorage::SetOfObjects::ConstPointer nodesToBeSaved = this->GetDataStorage()->GetSubset(isNotHelperObject);
this->Convert2DImagesTo3D(nodesToBeSaved);
sceneIO->SaveScene(nodesToBeSaved, this->GetDataStorage(), scenefile);
this->WaitCursorOff();
}
void USNavigationMarkerPlacement::ReinitOnImage()
{
if (!m_ReinitAlreadyDone && m_CombinedModality.IsNotNull())
{
// make sure that the output is already calibrated correctly
// (if the zoom level was changed recently)
m_CombinedModality->Modified();
m_CombinedModality->Update();
mitk::Image::Pointer image = m_CombinedModality->GetOutput();
if (image.IsNotNull() && image->IsInitialized())
{
// make a reinit on the ultrasound image
- mitk::IRenderWindowPart *renderWindow = this->GetRenderWindowPart();
+ mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart();
if (renderWindow != NULL && image->GetTimeGeometry()->IsValid())
{
renderWindow->GetRenderingManager()->InitializeViews(
image->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
renderWindow->GetRenderingManager()->RequestUpdateAll();
}
this->RequestRenderWindowUpdate();
m_ReinitAlreadyDone = true;
}
}
}
void USNavigationMarkerPlacement::Convert2DImagesTo3D(mitk::DataStorage::SetOfObjects::ConstPointer nodes)
{
- for (mitk::DataStorage::SetOfObjects::ConstIterator it = nodes->Begin(); it != nodes->End(); ++it)
+ for (mitk::DataStorage::SetOfObjects::ConstIterator it = nodes->Begin();
+ it != nodes->End(); ++it)
{
if (it->Value()->GetData() && strcmp(it->Value()->GetData()->GetNameOfClass(), "Image") == 0)
{
// convert image to 3d image if it is 2d at the moment
- mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(it->Value()->GetData());
- if (image.IsNotNull() && image->GetDimension() == 2 && !image->GetGeometry()->Is2DConvertable())
+ 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
+
+ mitk::BaseRenderer* renderer = mitk::BaseRenderer::GetByName("stdmulti.widget1");
+ if (renderer)
+ {
+ m_OverlayManager = renderer->GetOverlayManager();
+
+ //add layouter if it doesn't exist yet
+ if (!m_OverlayManager->GetLayouter(renderer, mitk::Overlay2DLayouter::STANDARD_2D_TOP()))
+ {
+ m_OverlayManager->AddLayouter(mitk::Overlay2DLayouter::CreateLayouter(mitk::Overlay2DLayouter::STANDARD_2D_TOP(), renderer).GetPointer());
+ }
+
+ /* causes a crash when closing the view and opening it again, so deactivated at the moment TODO!!
+ //set layouter to warn overlay
+ m_OverlayManager->SetLayouter(m_WarnOverlay.GetPointer(), mitk::Overlay2DLayouter::STANDARD_2D_TOP(), renderer);
+ */
+ }
}
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.h b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.h
index 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>
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
index 749aabdb59..f0476ee894 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
@@ -1,1451 +1,1482 @@
/*===================================================================
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.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkMITKIGTTrackingToolboxView.h"
#include "QmitkTrackingDeviceConfigurationWidget.h"
#include "QmitkStdMultiWidget.h"
// Qt
#include <QMessageBox>
#include <QSettings>
#include <qfiledialog.h>
// MITK
#include <mitkNavigationToolStorageDeserializer.h>
#include <mitkTrackingDeviceSourceConfigurator.h>
#include <mitkTrackingVolumeGenerator.h>
#include <mitkNDITrackingDevice.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
#include <mitkNavigationToolStorageSerializer.h>
#include <mitkProgressBar.h>
#include <mitkIOUtil.h>
#include <mitkLog.h>
#include <usModule.h>
#include <mitkTrackingDeviceTypeCollection.h>
#include <mitkUnspecifiedTrackingTypeInformation.h>
#include "mitkNDIAuroraTypeInformation.h"
// vtk
#include <vtkSphereSource.h>
//for exceptions
#include <mitkIGTException.h>
#include <mitkIGTIOException.h>
//for Microservice
#include "mitkPluginActivator.h"
#include <usModuleContext.h>
#include <usGetModuleContext.h>
#include "usServiceReference.h"
const std::string QmitkMITKIGTTrackingToolboxView::VIEW_ID = "org.mitk.views.mitkigttrackingtoolbox";
QmitkMITKIGTTrackingToolboxView::QmitkMITKIGTTrackingToolboxView()
: QmitkFunctionality()
, m_Controls(nullptr)
, m_MultiWidget(nullptr)
, m_DeviceTypeCollection(nullptr)
{
m_TrackingLoggingTimer = new QTimer(this);
m_TrackingRenderTimer = new QTimer(this);
m_TimeoutTimer = new QTimer(this);
m_tracking = false;
m_connected = false;
m_logging = false;
m_loggedFrames = 0;
+ m_SimpleModeEnabled = false;
//create filename for autosaving of tool storage
QString loggingPathWithoutFilename = QString(mitk::LoggingBackend::GetLogFile().c_str());
if (!loggingPathWithoutFilename.isEmpty()) //if there already is a path for the MITK logging file use this one
{
//extract path from path+filename (if someone knows a better way to do this feel free to change it)
int lengthOfFilename = QFileInfo(QString::fromStdString(mitk::LoggingBackend::GetLogFile())).fileName().size();
loggingPathWithoutFilename.resize(loggingPathWithoutFilename.size() - lengthOfFilename);
m_AutoSaveFilename = loggingPathWithoutFilename + "TrackingToolboxAutoSave.IGTToolStorage";
}
else //if not: use a temporary path from IOUtil
{
m_AutoSaveFilename = QString(mitk::IOUtil::GetTempPath().c_str()) + "TrackingToolboxAutoSave.IGTToolStorage";
}
MITK_INFO("IGT Tracking Toolbox") << "Filename for auto saving of IGT ToolStorages: " << m_AutoSaveFilename.toStdString();
//! [Thread 1]
//initialize worker thread
m_WorkerThread = new QThread();
m_Worker = new QmitkMITKIGTTrackingToolboxViewWorker();
//! [Thread 1]
ctkPluginContext* pluginContext = mitk::PluginActivator::GetContext();
if (pluginContext)
{
QString interfaceName = QString::fromStdString(us_service_interface_iid<mitk::TrackingDeviceTypeCollection>());
QList<ctkServiceReference> serviceReference = pluginContext->getServiceReferences(interfaceName);
if (serviceReference.size() > 0)
{
m_DeviceTypeServiceReference = serviceReference.at(0);
const ctkServiceReference& r = serviceReference.at(0);
m_DeviceTypeCollection = pluginContext->getService<mitk::TrackingDeviceTypeCollection>(r);
}
else
{
MITK_INFO << "No Tracking Device Collection!";
}
}
}
QmitkMITKIGTTrackingToolboxView::~QmitkMITKIGTTrackingToolboxView()
{
this->StoreUISettings();
m_TrackingLoggingTimer->stop();
m_TrackingRenderTimer->stop();
m_TimeoutTimer->stop();
delete m_TrackingLoggingTimer;
delete m_TrackingRenderTimer;
delete m_TimeoutTimer;
try
{
//! [Thread 2]
// wait for thread to finish
m_WorkerThread->terminate();
m_WorkerThread->wait();
//clean up worker thread
if (m_WorkerThread) { delete m_WorkerThread; }
if (m_Worker) { delete m_Worker; }
//! [Thread 2]
//remove the tracking volume
this->GetDataStorage()->Remove(m_TrackingVolumeNode);
//unregister microservices
if (m_toolStorage) { m_toolStorage->UnRegisterMicroservice(); }
if (m_TrackingDeviceSource) { m_TrackingDeviceSource->UnRegisterMicroservice(); }
if (m_IGTLMessageProvider.IsNotNull()){ m_IGTLMessageProvider->UnRegisterMicroservice(); }
}
catch (std::exception& e) { MITK_WARN << "Unexpected exception during clean up of tracking toolbox view: " << e.what(); }
catch (...) { MITK_WARN << "Unexpected unknown error during clean up of tracking toolbox view!"; }
//store tool storage and UI settings for persistence
this->AutoSaveToolStorage();
this->StoreUISettings();
m_DeviceTypeCollection = nullptr;
mitk::PluginActivator::GetContext()->ungetService(m_DeviceTypeServiceReference);
}
void QmitkMITKIGTTrackingToolboxView::CreateQtPartControl(QWidget *parent)
{
// build up qt view, unless already done
if (!m_Controls)
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkMITKIGTTrackingToolboxViewControls;
m_Controls->setupUi(parent);
//create connections
connect(m_Controls->m_LoadTools, SIGNAL(clicked()), this, SLOT(OnLoadTools()));
connect(m_Controls->m_ConnectDisconnectButton, SIGNAL(clicked()), this, SLOT(OnConnectDisconnect()));
connect(m_Controls->m_StartStopTrackingButton, SIGNAL(clicked()), this, SLOT(OnStartStopTracking()));
+ connect(m_Controls->m_ConnectSimpleMode, SIGNAL(clicked()), this, SLOT(OnConnectDisconnect()));
+ connect(m_Controls->m_StartTrackingSimpleMode, SIGNAL(clicked()), this, SLOT(OnStartStopTracking()));
connect(m_Controls->m_FreezeUnfreezeTrackingButton, SIGNAL(clicked()), this, SLOT(OnFreezeUnfreezeTracking()));
connect(m_TrackingLoggingTimer, SIGNAL(timeout()), this, SLOT(UpdateLoggingTrackingTimer()));
connect(m_TrackingRenderTimer, SIGNAL(timeout()), this, SLOT(UpdateRenderTrackingTimer()));
connect(m_TimeoutTimer, SIGNAL(timeout()), this, SLOT(OnTimeOut()));
connect(m_Controls->m_ChooseFile, SIGNAL(clicked()), this, SLOT(OnChooseFileClicked()));
connect(m_Controls->m_StartLogging, SIGNAL(clicked()), this, SLOT(StartLogging()));
connect(m_Controls->m_StopLogging, SIGNAL(clicked()), this, SLOT(StopLogging()));
connect(m_Controls->m_VolumeSelectionBox, SIGNAL(currentIndexChanged(QString)), this, SLOT(OnTrackingVolumeChanged(QString)));
connect(m_Controls->m_ShowTrackingVolume, SIGNAL(clicked()), this, SLOT(OnShowTrackingVolumeChanged()));
connect(m_Controls->m_AutoDetectTools, SIGNAL(clicked()), this, SLOT(OnAutoDetectTools()));
connect(m_Controls->m_ResetTools, SIGNAL(clicked()), this, SLOT(OnResetTools()));
connect(m_Controls->m_AddSingleTool, SIGNAL(clicked()), this, SLOT(OnAddSingleTool()));
connect(m_Controls->m_NavigationToolCreationWidget, SIGNAL(NavigationToolFinished()), this, SLOT(OnAddSingleToolFinished()));
connect(m_Controls->m_NavigationToolCreationWidget, SIGNAL(Canceled()), this, SLOT(OnAddSingleToolCanceled()));
connect(m_Controls->m_csvFormat, SIGNAL(clicked()), this, SLOT(OnToggleFileExtension()));
connect(m_Controls->m_xmlFormat, SIGNAL(clicked()), this, SLOT(OnToggleFileExtension()));
connect(m_Controls->m_UseDifferentUpdateRates, SIGNAL(clicked()), this, SLOT(OnToggleDifferentUpdateRates()));
connect(m_Controls->m_RenderUpdateRate, SIGNAL(valueChanged(int)), this, SLOT(OnChangeRenderUpdateRate()));
connect(m_Controls->m_DisableAllTimers, SIGNAL(stateChanged(int)), this, SLOT(EnableDisableTimerButtons(int)));
+ connect(m_Controls->m_advancedUI, SIGNAL(clicked()), this, SLOT(OnToggleAdvancedSimpleMode()));
+ connect(m_Controls->m_simpleUI, SIGNAL(clicked()), this, SLOT(OnToggleAdvancedSimpleMode()));
//connections for the tracking device configuration widget
connect(m_Controls->m_configurationWidget, SIGNAL(TrackingDeviceSelectionChanged()), this, SLOT(OnTrackingDeviceChanged()));
//! [Thread 3]
//connect worker thread
connect(m_Worker, SIGNAL(AutoDetectToolsFinished(bool, QString)), this, SLOT(OnAutoDetectToolsFinished(bool, QString)));
connect(m_Worker, SIGNAL(ConnectDeviceFinished(bool, QString)), this, SLOT(OnConnectFinished(bool, QString)));
connect(m_Worker, SIGNAL(StartTrackingFinished(bool, QString)), this, SLOT(OnStartTrackingFinished(bool, QString)));
connect(m_Worker, SIGNAL(StopTrackingFinished(bool, QString)), this, SLOT(OnStopTrackingFinished(bool, QString)));
connect(m_Worker, SIGNAL(DisconnectDeviceFinished(bool, QString)), this, SLOT(OnDisconnectFinished(bool, QString)));
connect(m_WorkerThread, SIGNAL(started()), m_Worker, SLOT(ThreadFunc()));
//move the worker to the thread
m_Worker->moveToThread(m_WorkerThread);
//! [Thread 3]
//initialize widgets
m_Controls->m_TrackingToolsStatusWidget->SetShowPositions(true);
m_Controls->m_TrackingToolsStatusWidget->SetTextAlignment(Qt::AlignLeft);
+ m_Controls->m_simpleWidget->setVisible(false);
//initialize tracking volume node
m_TrackingVolumeNode = mitk::DataNode::New();
m_TrackingVolumeNode->SetName("TrackingVolume");
m_TrackingVolumeNode->SetBoolProperty("Backface Culling", true);
mitk::Color red;
red.SetRed(1);
m_TrackingVolumeNode->SetColor(red);
//initialize buttons
m_Controls->m_AutoDetectTools->setVisible(false); //only visible if tracking device is Aurora
m_Controls->m_StartStopTrackingButton->setEnabled(false);
+ m_Controls->m_StartTrackingSimpleMode->setEnabled(false);
m_Controls->m_FreezeUnfreezeTrackingButton->setEnabled(false);
//initialize warning labels
m_Controls->m_renderWarningLabel->setVisible(false);
m_Controls->m_TrackingFrozenLabel->setVisible(false);
//Update List of available models for selected tool.
std::vector<mitk::TrackingDeviceData> Compatibles;
if ((m_Controls == NULL) || //check all these stuff for NULL, latterly this causes crashes from time to time
(m_Controls->m_configurationWidget == NULL) ||
(m_Controls->m_configurationWidget->GetTrackingDevice().IsNull()))
{
MITK_ERROR << "Couldn't get current tracking device or an object is NULL, something went wrong!";
return;
}
else
{
Compatibles = m_DeviceTypeCollection->GetDeviceDataForLine(m_Controls->m_configurationWidget->GetTrackingDevice()->GetType());
}
m_Controls->m_VolumeSelectionBox->clear();
for (std::size_t i = 0; i < Compatibles.size(); i++)
{
m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
}
//initialize tool storage
m_toolStorage = mitk::NavigationToolStorage::New(GetDataStorage());
m_toolStorage->SetName("TrackingToolbox Default Storage");
m_toolStorage->RegisterAsMicroservice("no tracking device");
//set home directory as default path for logfile
m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(QDir::homePath()) + QDir::separator() + "logfile.csv");
//tracking device may be changed already by the persistence of the
//QmitkTrackingDeciveConfigurationWidget
this->OnTrackingDeviceChanged();
this->LoadUISettings();
//add tracking volume node only to data storage
this->GetDataStorage()->Add(m_TrackingVolumeNode);
if (!m_Controls->m_ShowTrackingVolume->isChecked()) m_TrackingVolumeNode->SetOpacity(0.0);
else m_TrackingVolumeNode->SetOpacity(0.25);
//Update List of available models for selected tool.
m_Controls->m_VolumeSelectionBox->clear();
for (std::size_t i = 0; i < Compatibles.size(); i++)
{
m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
}
}
}
void QmitkMITKIGTTrackingToolboxView::StdMultiWidgetAvailable(QmitkStdMultiWidget &stdMultiWidget)
{
m_MultiWidget = &stdMultiWidget;
}
void QmitkMITKIGTTrackingToolboxView::StdMultiWidgetNotAvailable()
{
m_MultiWidget = NULL;
}
void QmitkMITKIGTTrackingToolboxView::OnLoadTools()
{
//read in filename
QString filename = QFileDialog::getOpenFileName(NULL, tr("Open Tool Storage"), "/", tr("Tool Storage Files (*.IGTToolStorage)"));
if (filename.isNull()) return;
//read tool storage from disk
std::string errorMessage = "";
mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(GetDataStorage());
// try-catch block for exceptions
try
{
this->ReplaceCurrentToolStorage(myDeserializer->Deserialize(filename.toStdString()), filename.toStdString());
}
catch (mitk::IGTException)
{
std::string errormessage = "Error during loading the tool storage file. Please only load tool storage files created with the NavigationToolManager view.";
QMessageBox::warning(NULL, "Tool Storage Loading Error", errormessage.c_str());
return;
}
if (m_toolStorage->isEmpty())
{
errorMessage = myDeserializer->GetErrorMessage();
MessageBox(errorMessage);
return;
}
//update label
UpdateToolStorageLabel(filename);
//update tool preview
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
//save filename for persistent storage
m_ToolStorageFilename = filename;
}
void QmitkMITKIGTTrackingToolboxView::OnResetTools()
{
this->ReplaceCurrentToolStorage(mitk::NavigationToolStorage::New(GetDataStorage()), "TrackingToolbox Default Storage");
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
QString toolLabel = QString("<none>");
m_Controls->m_toolLabel->setText(toolLabel);
m_ToolStorageFilename = "";
}
void QmitkMITKIGTTrackingToolboxView::OnStartStopTracking()
{
if (!m_connected)
{
MITK_WARN << "Can't start tracking if no device is connected. Aborting";
return;
}
if (m_tracking) { OnStopTracking(); }
else { OnStartTracking(); }
}
void QmitkMITKIGTTrackingToolboxView::OnFreezeUnfreezeTracking()
{
if (m_Controls->m_FreezeUnfreezeTrackingButton->text() == "Freeze Tracking")
{
m_TrackingDeviceSource->Freeze();
m_Controls->m_FreezeUnfreezeTrackingButton->setText("Unfreeze Tracking");
m_Controls->m_TrackingFrozenLabel->setVisible(true);
}
else if (m_Controls->m_FreezeUnfreezeTrackingButton->text() == "Unfreeze Tracking")
{
m_TrackingDeviceSource->UnFreeze();
m_Controls->m_FreezeUnfreezeTrackingButton->setText("Freeze Tracking");
m_Controls->m_TrackingFrozenLabel->setVisible(false);
}
}
void QmitkMITKIGTTrackingToolboxView::OnConnectDisconnect()
{
if (m_connected) { OnDisconnect(); }
else { OnConnect(); }
}
void QmitkMITKIGTTrackingToolboxView::OnConnect()
{
MITK_INFO << "Connect Clicked";
//check if everything is ready to start tracking
if (this->m_toolStorage.IsNull())
{
MessageBox("Error: No Tools Loaded Yet!");
return;
}
else if (this->m_toolStorage->GetToolCount() == 0)
{
MessageBox("Error: No Way To Track Without Tools!");
return;
}
//parse tracking device data
mitk::TrackingDeviceData data = mitk::UnspecifiedTrackingTypeInformation::GetDeviceDataUnspecified();
QString qstr = m_Controls->m_VolumeSelectionBox->currentText();
if ((!qstr.isNull()) || (!qstr.isEmpty())) {
std::string str = qstr.toStdString();
data = m_DeviceTypeCollection->GetDeviceDataByName(str); //Data will be set later, after device generation
}
//! [Thread 4]
//initialize worker thread
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eConnectDevice);
m_Worker->SetTrackingDevice(this->m_Controls->m_configurationWidget->GetTrackingDevice());
m_Worker->SetInverseMode(m_Controls->m_InverseMode->isChecked());
m_Worker->SetNavigationToolStorage(this->m_toolStorage);
m_Worker->SetTrackingDeviceData(data);
//start worker thread
m_WorkerThread->start();
//! [Thread 4]
//disable buttons
this->m_Controls->m_MainWidget->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::EnableDisableTimerButtons(int enable)
{
bool enableBool = enable;
m_Controls->m_UpdateRateOptionsGroupBox->setEnabled(!enableBool);
m_Controls->m_renderWarningLabel->setVisible(enableBool);
}
void QmitkMITKIGTTrackingToolboxView::OnConnectFinished(bool success, QString errorMessage)
{
m_WorkerThread->quit();
m_WorkerThread->wait();
//enable buttons
this->m_Controls->m_MainWidget->setEnabled(true);
if (!success)
{
MITK_WARN << errorMessage.toStdString();
MessageBox(errorMessage.toStdString());
return;
}
//! [Thread 6]
//get data from worker thread
m_TrackingDeviceSource = m_Worker->GetTrackingDeviceSource();
m_TrackingDeviceData = m_Worker->GetTrackingDeviceData();
m_ToolVisualizationFilter = m_Worker->GetToolVisualizationFilter();
//! [Thread 6]
//enable/disable Buttons
DisableOptionsButtons();
DisableTrackingConfigurationButtons();
m_Controls->m_TrackingControlLabel->setText("Status: connected");
m_Controls->m_ConnectDisconnectButton->setText("Disconnect");
+ m_Controls->m_ConnectSimpleMode->setText("Disconnect");
m_Controls->m_StartStopTrackingButton->setEnabled(true);
+ m_Controls->m_StartTrackingSimpleMode->setEnabled(true);
m_connected = true;
}
void QmitkMITKIGTTrackingToolboxView::OnDisconnect()
{
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eDisconnectDevice);
m_WorkerThread->start();
m_Controls->m_MainWidget->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::OnDisconnectFinished(bool success, QString errorMessage)
{
m_WorkerThread->quit();
m_WorkerThread->wait();
m_Controls->m_MainWidget->setEnabled(true);
if (!success)
{
MITK_WARN << errorMessage.toStdString();
MessageBox(errorMessage.toStdString());
return;
}
//enable/disable Buttons
m_Controls->m_StartStopTrackingButton->setEnabled(false);
+ m_Controls->m_StartTrackingSimpleMode->setEnabled(false);
EnableOptionsButtons();
EnableTrackingConfigurationButtons();
m_Controls->m_TrackingControlLabel->setText("Status: disconnected");
m_Controls->m_ConnectDisconnectButton->setText("Connect");
+ m_Controls->m_ConnectSimpleMode->setText("Connect");
m_Controls->m_FreezeUnfreezeTrackingButton->setText("Freeze Tracking");
m_Controls->m_TrackingFrozenLabel->setVisible(false);
m_connected = false;
}
void QmitkMITKIGTTrackingToolboxView::OnStartTracking()
{
//show tracking volume
this->OnTrackingVolumeChanged(m_Controls->m_VolumeSelectionBox->currentText());
//Reset the view to a defined start. Do it here and not in OnStartTrackingFinished, to give other tracking devices the chance to reset the view to a different direction.
this->GlobalReinit();
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eStartTracking);
m_WorkerThread->start();
this->m_Controls->m_MainWidget->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::OnStartTrackingFinished(bool success, QString errorMessage)
{
//! [Thread 5]
m_WorkerThread->quit();
m_WorkerThread->wait();
//! [Thread 5]
this->m_Controls->m_MainWidget->setEnabled(true);
if (!success)
{
MessageBox(errorMessage.toStdString());
MITK_WARN << errorMessage.toStdString();
return;
}
if (!(m_Controls->m_DisableAllTimers->isChecked()))
{
if (m_Controls->m_UseDifferentUpdateRates->isChecked())
{
if (m_Controls->m_RenderUpdateRate->value() != 0)
m_TrackingRenderTimer->start(1000 / (m_Controls->m_RenderUpdateRate->value()));
m_TrackingLoggingTimer->start(1000 / (m_Controls->m_LogUpdateRate->value()));
}
else
{
m_TrackingRenderTimer->start(1000 / (m_Controls->m_UpdateRate->value()));
m_TrackingLoggingTimer->start(1000 / (m_Controls->m_UpdateRate->value()));
}
}
m_Controls->m_TrackingControlLabel->setText("Status: tracking");
//connect the tool visualization widget
for (std::size_t i = 0; i < m_TrackingDeviceSource->GetNumberOfOutputs(); i++)
{
m_Controls->m_TrackingToolsStatusWidget->AddNavigationData(m_TrackingDeviceSource->GetOutput(i));
}
m_Controls->m_TrackingToolsStatusWidget->ShowStatusLabels();
if (m_Controls->m_ShowToolQuaternions->isChecked()) { m_Controls->m_TrackingToolsStatusWidget->SetShowQuaternions(true); }
else { m_Controls->m_TrackingToolsStatusWidget->SetShowQuaternions(false); }
//if activated enable open IGT link microservice
if (m_Controls->m_EnableOpenIGTLinkMicroService->isChecked())
{
//create convertion filter
m_IGTLConversionFilter = mitk::NavigationDataToIGTLMessageFilter::New();
m_IGTLConversionFilter->SetName("IGT Tracking Toolbox");
m_IGTLConversionFilter->ConnectTo(m_ToolVisualizationFilter);
m_IGTLConversionFilter->SetOperationMode(mitk::NavigationDataToIGTLMessageFilter::ModeSendTDataMsg);
m_IGTLConversionFilter->RegisterAsMicroservice();
//create server and message provider
m_IGTLServer = mitk::IGTLServer::New(false);
m_IGTLServer->SetName("Tracking Toolbox IGTL Server");
m_IGTLMessageProvider = mitk::IGTLMessageProvider::New();
m_IGTLMessageProvider->SetIGTLDevice(m_IGTLServer);
m_IGTLMessageProvider->RegisterAsMicroservice();
}
m_tracking = true;
m_Controls->m_ConnectDisconnectButton->setEnabled(false);
m_Controls->m_StartStopTrackingButton->setText("Stop Tracking");
+ m_Controls->m_StartTrackingSimpleMode->setText("Stop\nTracking");
m_Controls->m_FreezeUnfreezeTrackingButton->setEnabled(true);
}
void QmitkMITKIGTTrackingToolboxView::OnStopTracking()
{
if (!m_tracking) return;
m_TrackingRenderTimer->stop();
m_TrackingLoggingTimer->stop();
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eStopTracking);
m_WorkerThread->start();
m_Controls->m_MainWidget->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::OnStopTrackingFinished(bool success, QString errorMessage)
{
m_WorkerThread->quit();
m_WorkerThread->wait();
m_Controls->m_MainWidget->setEnabled(true);
if (!success)
{
MessageBox(errorMessage.toStdString());
MITK_WARN << errorMessage.toStdString();
return;
}
m_Controls->m_TrackingControlLabel->setText("Status: connected");
if (m_logging) StopLogging();
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
m_tracking = false;
m_Controls->m_StartStopTrackingButton->setText("Start Tracking");
+ m_Controls->m_StartTrackingSimpleMode->setText("Start\nTracking");
m_Controls->m_ConnectDisconnectButton->setEnabled(true);
m_Controls->m_FreezeUnfreezeTrackingButton->setEnabled(false);
//unregister open IGT link micro service
if (m_Controls->m_EnableOpenIGTLinkMicroService->isChecked())
{
m_IGTLConversionFilter->UnRegisterMicroservice();
m_IGTLMessageProvider->UnRegisterMicroservice();
}
}
void QmitkMITKIGTTrackingToolboxView::OnTrackingDeviceChanged()
{
mitk::TrackingDeviceType Type;
if (m_Controls->m_configurationWidget->GetTrackingDevice().IsNotNull())
{
Type = m_Controls->m_configurationWidget->GetTrackingDevice()->GetType();
//enable controls because device is valid
m_Controls->m_TrackingToolsGoupBox->setEnabled(true);
m_Controls->m_TrackingControlsGroupBox->setEnabled(true);
}
else
{
Type = mitk::UnspecifiedTrackingTypeInformation::GetTrackingDeviceName();
MessageBox("Error: This tracking device is not included in this project. Please make sure that the device is installed and activated in your MITK build.");
m_Controls->m_TrackingToolsGoupBox->setEnabled(false);
m_Controls->m_TrackingControlsGroupBox->setEnabled(false);
return;
}
// Code to enable/disable device specific buttons
if (m_Controls->m_configurationWidget->GetTrackingDevice()->AutoDetectToolsAvailable())
{ m_Controls->m_AutoDetectTools->setVisible(true); }
else
{ m_Controls->m_AutoDetectTools->setVisible(false); }
if (Type == mitk::NDIAuroraTypeInformation::GetTrackingDeviceName()) //Aurora
{ m_Controls->m_AddSingleTool->setEnabled(false);}
else //other trackers
{ m_Controls->m_AddSingleTool->setEnabled(true); }
// Code to select appropriate tracking volume for current type
std::vector<mitk::TrackingDeviceData> Compatibles = m_DeviceTypeCollection->GetDeviceDataForLine(Type);
m_Controls->m_VolumeSelectionBox->clear();
for (std::size_t i = 0; i < Compatibles.size(); i++)
{
m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
}
}
void QmitkMITKIGTTrackingToolboxView::OnTrackingVolumeChanged(QString qstr)
{
if (qstr.isNull()) return;
if (qstr.isEmpty()) return;
mitk::TrackingVolumeGenerator::Pointer volumeGenerator = mitk::TrackingVolumeGenerator::New();
std::string str = qstr.toStdString();
mitk::TrackingDeviceData data = m_DeviceTypeCollection->GetDeviceDataByName(str);
m_TrackingDeviceData = data;
volumeGenerator->SetTrackingDeviceData(data);
volumeGenerator->Update();
mitk::Surface::Pointer volumeSurface = volumeGenerator->GetOutput();
m_TrackingVolumeNode->SetData(volumeSurface);
if (!m_Controls->m_ShowTrackingVolume->isChecked()) m_TrackingVolumeNode->SetOpacity(0.0);
else m_TrackingVolumeNode->SetOpacity(0.25);
GlobalReinit();
}
void QmitkMITKIGTTrackingToolboxView::OnShowTrackingVolumeChanged()
{
if (m_Controls->m_ShowTrackingVolume->isChecked())
{
OnTrackingVolumeChanged(m_Controls->m_VolumeSelectionBox->currentText());
m_TrackingVolumeNode->SetOpacity(0.25);
}
else
{
m_TrackingVolumeNode->SetOpacity(0.0);
}
}
void QmitkMITKIGTTrackingToolboxView::OnAutoDetectTools()
{
if (m_Controls->m_configurationWidget->GetTrackingDevice()->AutoDetectToolsAvailable())
{
DisableTrackingConfigurationButtons();
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eAutoDetectTools);
m_Worker->SetTrackingDevice(m_Controls->m_configurationWidget->GetTrackingDevice().GetPointer());
m_Worker->SetDataStorage(this->GetDataStorage());
m_WorkerThread->start();
m_TimeoutTimer->start(5000);
//disable controls until worker thread is finished
this->m_Controls->m_MainWidget->setEnabled(false);
}
}
void QmitkMITKIGTTrackingToolboxView::OnAutoDetectToolsFinished(bool success, QString errorMessage)
{
m_TimeoutTimer->stop();
m_WorkerThread->quit();
m_WorkerThread->wait();
//enable controls again
this->m_Controls->m_MainWidget->setEnabled(true);
EnableTrackingConfigurationButtons();
if (!success)
{
MITK_WARN << errorMessage.toStdString();
MessageBox(errorMessage.toStdString());
EnableTrackingConfigurationButtons();
return;
}
mitk::NavigationToolStorage::Pointer autoDetectedStorage = m_Worker->GetNavigationToolStorage();
//save detected tools
this->ReplaceCurrentToolStorage(autoDetectedStorage, "Autodetected NDI Aurora Storage");
//auto save the new storage to hard disc (for persistence)
AutoSaveToolStorage();
//update label
QString toolLabel = QString("Loaded Tools: ") + QString::number(m_toolStorage->GetToolCount()) + " Tools (Auto Detected)";
m_Controls->m_toolLabel->setText(toolLabel);
//update tool preview
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
EnableTrackingConfigurationButtons();
//print a logging message about the detected tools
switch (m_toolStorage->GetToolCount())
{
case 0:
MITK_INFO("IGT Tracking Toolbox") << "Found no tools. Empty ToolStorage was autosaved to " << m_ToolStorageFilename.toStdString();
break;
case 1:
MITK_INFO("IGT Tracking Toolbox") << "Found one tool. ToolStorage was autosaved to " << m_ToolStorageFilename.toStdString();
break;
default:
MITK_INFO("IGT Tracking Toolbox") << "Found " << m_toolStorage->GetToolCount() << " tools. ToolStorage was autosaved to " << m_ToolStorageFilename.toStdString();
}
}
void QmitkMITKIGTTrackingToolboxView::MessageBox(std::string s)
{
QMessageBox msgBox;
msgBox.setText(s.c_str());
msgBox.exec();
}
void QmitkMITKIGTTrackingToolboxView::UpdateRenderTrackingTimer()
{
//update filter
m_ToolVisualizationFilter->Update();
MITK_DEBUG << "Number of outputs ToolVisualizationFilter: " << m_ToolVisualizationFilter->GetNumberOfIndexedOutputs();
MITK_DEBUG << "Number of inputs ToolVisualizationFilter: " << m_ToolVisualizationFilter->GetNumberOfIndexedInputs();
//update tool colors to show tool status
for (unsigned int i = 0; i < m_ToolVisualizationFilter->GetNumberOfIndexedOutputs(); i++)
{
mitk::NavigationData::Pointer currentTool = m_ToolVisualizationFilter->GetOutput(i);
if (currentTool->IsDataValid())
{
this->m_toolStorage->GetTool(i)->GetDataNode()->SetColor(mitk::IGTColor_VALID);
}
else
{
this->m_toolStorage->GetTool(i)->GetDataNode()->SetColor(mitk::IGTColor_WARNING);
}
}
//refresh view and status widget
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
m_Controls->m_TrackingToolsStatusWidget->Refresh();
//code to better isolate bug 17713, could be removed when bug 17713 is fixed
static int i = 0;
static mitk::Point3D lastPositionTool1 = m_ToolVisualizationFilter->GetOutput(0)->GetPosition();
static itk::TimeStamp lastTimeStamp = m_ToolVisualizationFilter->GetOutput(0)->GetTimeStamp();
i++;
//every 20 frames: check if tracking is frozen
if (i > 20)
{
i = 0;
if (m_ToolVisualizationFilter->GetOutput(0)->IsDataValid())
{
if (mitk::Equal(lastPositionTool1, m_ToolVisualizationFilter->GetOutput(0)->GetPosition(), 0.000000001, false)
&& m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() != "Da Vinci")
{
MITK_WARN << "Seems as tracking (of at least tool 1) is frozen which means that bug 17713 occurred. Restart tracking might help.";
//display further information to find the bug
MITK_WARN << "Timestamp of current navigation data: " << m_ToolVisualizationFilter->GetOutput(0)->GetTimeStamp();
MITK_WARN << "Timestamp of last navigation data (which holds the same values): " << lastTimeStamp;
}
lastPositionTool1 = m_ToolVisualizationFilter->GetOutput(0)->GetPosition();
lastTimeStamp = m_ToolVisualizationFilter->GetOutput(0)->GetTimeStamp();
}
}
}
void QmitkMITKIGTTrackingToolboxView::UpdateLoggingTrackingTimer()
{
//update logging
if (m_logging)
{
this->m_loggingFilter->Update();
m_loggedFrames = this->m_loggingFilter->GetNumberOfRecordedSteps();
this->m_Controls->m_LoggedFramesLabel->setText("Logged Frames: " + QString::number(m_loggedFrames));
//check if logging stopped automatically
if ((m_loggedFrames > 1) && (!m_loggingFilter->GetRecording())){ StopLogging(); }
}
//refresh status widget
m_Controls->m_TrackingToolsStatusWidget->Refresh();
}
void QmitkMITKIGTTrackingToolboxView::OnChooseFileClicked()
{
QDir currentPath = QFileInfo(m_Controls->m_LoggingFileName->text()).dir();
// if no path was selected (QDir would select current working dir then) or the
// selected path does not exist -> use home directory
if (currentPath == QDir() || !currentPath.exists())
{
currentPath = QDir(QDir::homePath());
}
QString filename = QFileDialog::getSaveFileName(NULL, tr("Choose Logging File"), currentPath.absolutePath(), "*.*");
if (filename == "") return;
this->m_Controls->m_LoggingFileName->setText(filename);
this->OnToggleFileExtension();
}
// bug-16470: toggle file extension after clicking on radio button
void QmitkMITKIGTTrackingToolboxView::OnToggleFileExtension()
{
QString currentInputText = this->m_Controls->m_LoggingFileName->text();
QString currentFile = QFileInfo(currentInputText).baseName();
QDir currentPath = QFileInfo(currentInputText).dir();
if (currentFile.isEmpty())
{
currentFile = "logfile";
}
// Setting currentPath to default home path when currentPath is empty or it does not exist
if (currentPath == QDir() || !currentPath.exists())
{
currentPath = QDir::homePath();
}
// check if csv radio button is clicked
if (this->m_Controls->m_csvFormat->isChecked())
{
// you needn't add a seperator to the input text when currentpath is the rootpath
if (currentPath.isRoot())
{
this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + currentFile + ".csv");
}
else
{
this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + QDir::separator() + currentFile + ".csv");
}
}
// check if xml radio button is clicked
else if (this->m_Controls->m_xmlFormat->isChecked())
{
// you needn't add a seperator to the input text when currentpath is the rootpath
if (currentPath.isRoot())
{
this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + currentFile + ".xml");
}
else
{
this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + QDir::separator() + currentFile + ".xml");
}
}
}
+void QmitkMITKIGTTrackingToolboxView::OnToggleAdvancedSimpleMode()
+{
+ if (m_SimpleModeEnabled)
+ {
+ m_Controls->m_simpleWidget->setVisible(false);
+ m_Controls->m_MainWidget->setVisible(true);
+ m_Controls->m_simpleUI->setChecked(false);
+ m_SimpleModeEnabled = false;
+ }
+ else
+ {
+ m_Controls->m_simpleWidget->setVisible(true);
+ m_Controls->m_MainWidget->setVisible(false);
+ m_SimpleModeEnabled = true;
+ }
+}
+
void QmitkMITKIGTTrackingToolboxView::OnToggleDifferentUpdateRates()
{
if (m_Controls->m_UseDifferentUpdateRates->isChecked())
{
if (m_Controls->m_RenderUpdateRate->value() == 0)
m_Controls->m_renderWarningLabel->setVisible(true);
else
m_Controls->m_renderWarningLabel->setVisible(false);
m_Controls->m_UpdateRate->setEnabled(false);
m_Controls->m_OptionsUpdateRateLabel->setEnabled(false);
m_Controls->m_RenderUpdateRate->setEnabled(true);
m_Controls->m_OptionsRenderUpdateRateLabel->setEnabled(true);
m_Controls->m_LogUpdateRate->setEnabled(true);
m_Controls->m_OptionsLogUpdateRateLabel->setEnabled(true);
}
else
{
m_Controls->m_renderWarningLabel->setVisible(false);
m_Controls->m_UpdateRate->setEnabled(true);
m_Controls->m_OptionsUpdateRateLabel->setEnabled(true);
m_Controls->m_RenderUpdateRate->setEnabled(false);
m_Controls->m_OptionsRenderUpdateRateLabel->setEnabled(false);
m_Controls->m_LogUpdateRate->setEnabled(false);
m_Controls->m_OptionsLogUpdateRateLabel->setEnabled(false);
}
}
void QmitkMITKIGTTrackingToolboxView::OnChangeRenderUpdateRate()
{
if (m_Controls->m_RenderUpdateRate->value() == 0)
m_Controls->m_renderWarningLabel->setVisible(true);
else
m_Controls->m_renderWarningLabel->setVisible(false);
}
void QmitkMITKIGTTrackingToolboxView::StartLogging()
{
if (m_ToolVisualizationFilter.IsNull())
{
MessageBox("Cannot activate logging without a connected device. Configure and connect a tracking device first.");
return;
}
if (!m_logging)
{
//initialize logging filter
m_loggingFilter = mitk::NavigationDataRecorder::New();
m_loggingFilter->ConnectTo(m_ToolVisualizationFilter);
if (m_Controls->m_LoggingLimit->isChecked()){ m_loggingFilter->SetRecordCountLimit(m_Controls->m_LoggedFramesLimit->value()); }
//start filter with try-catch block for exceptions
try
{
m_loggingFilter->StartRecording();
}
catch (mitk::IGTException)
{
std::string errormessage = "Error during start recording. Recorder already started recording?";
QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
m_loggingFilter->StopRecording();
return;
}
//update labels / logging variables
this->m_Controls->m_LoggingLabel->setText("Logging ON");
this->m_Controls->m_LoggedFramesLabel->setText("Logged Frames: 0");
m_loggedFrames = 0;
m_logging = true;
DisableLoggingButtons();
}
}
void QmitkMITKIGTTrackingToolboxView::StopLogging()
{
if (m_logging)
{
//stop logging
m_loggingFilter->StopRecording();
m_logging = false;
//update GUI
this->m_Controls->m_LoggingLabel->setText("Logging OFF");
EnableLoggingButtons();
//write the results to a file
if (m_Controls->m_csvFormat->isChecked())
{
mitk::IOUtil::SaveBaseData(m_loggingFilter->GetNavigationDataSet(), this->m_Controls->m_LoggingFileName->text().toStdString());
}
else if (m_Controls->m_xmlFormat->isChecked())
{
mitk::IOUtil::SaveBaseData(m_loggingFilter->GetNavigationDataSet(), this->m_Controls->m_LoggingFileName->text().toStdString());
}
}
}
void QmitkMITKIGTTrackingToolboxView::OnAddSingleTool()
{
QString Identifier = "Tool#";
QString Name = "NewTool";
if (m_toolStorage.IsNotNull()) {
Identifier += QString::number(m_toolStorage->GetToolCount());
Name += QString::number(m_toolStorage->GetToolCount());
}
else {
Identifier += "0";
Name += "0";
}
m_Controls->m_NavigationToolCreationWidget->Initialize(GetDataStorage(), Identifier.toStdString(), Name.toStdString());
m_Controls->m_NavigationToolCreationWidget->SetTrackingDeviceType(m_Controls->m_configurationWidget->GetTrackingDevice()->GetType(), false);
m_Controls->m_TrackingToolsWidget->setCurrentIndex(1);
//disable tracking volume during tool editing
lastTrackingVolumeState = m_Controls->m_ShowTrackingVolume->isChecked();
if (lastTrackingVolumeState) m_Controls->m_ShowTrackingVolume->click();
GlobalReinit();
}
void QmitkMITKIGTTrackingToolboxView::OnAddSingleToolFinished()
{
m_Controls->m_TrackingToolsWidget->setCurrentIndex(0);
if (this->m_toolStorage.IsNull())
{
//this shouldn't happen!
MITK_WARN << "No ToolStorage available, cannot add tool, aborting!";
return;
}
m_toolStorage->AddTool(m_Controls->m_NavigationToolCreationWidget->GetCreatedTool());
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
m_Controls->m_toolLabel->setText("<manually added>");
//auto save current storage for persistence
MITK_INFO << "Auto saving manually added tools for persistence.";
AutoSaveToolStorage();
//enable tracking volume again
if (lastTrackingVolumeState) m_Controls->m_ShowTrackingVolume->click();
GlobalReinit();
}
void QmitkMITKIGTTrackingToolboxView::OnAddSingleToolCanceled()
{
m_Controls->m_TrackingToolsWidget->setCurrentIndex(0);
//enable tracking volume again
if (lastTrackingVolumeState) m_Controls->m_ShowTrackingVolume->click();
GlobalReinit();
}
void QmitkMITKIGTTrackingToolboxView::GlobalReinit()
{
// get all nodes that have not set "includeInBoundingBox" to false
mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false)));
mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
// calculate bounding geometry of these nodes
mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
// initialize the views to the bounding geometry
mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
}
void QmitkMITKIGTTrackingToolboxView::DisableLoggingButtons()
{
m_Controls->m_StartLogging->setEnabled(false);
m_Controls->m_LoggingFileName->setEnabled(false);
m_Controls->m_ChooseFile->setEnabled(false);
m_Controls->m_LoggingLimit->setEnabled(false);
m_Controls->m_LoggedFramesLimit->setEnabled(false);
m_Controls->m_csvFormat->setEnabled(false);
m_Controls->m_xmlFormat->setEnabled(false);
m_Controls->m_StopLogging->setEnabled(true);
}
void QmitkMITKIGTTrackingToolboxView::EnableLoggingButtons()
{
m_Controls->m_StartLogging->setEnabled(true);
m_Controls->m_LoggingFileName->setEnabled(true);
m_Controls->m_ChooseFile->setEnabled(true);
m_Controls->m_LoggingLimit->setEnabled(true);
m_Controls->m_LoggedFramesLimit->setEnabled(true);
m_Controls->m_csvFormat->setEnabled(true);
m_Controls->m_xmlFormat->setEnabled(true);
m_Controls->m_StopLogging->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::DisableOptionsButtons()
{
m_Controls->m_ShowTrackingVolume->setEnabled(false);
m_Controls->m_UseDifferentUpdateRates->setEnabled(false);
m_Controls->m_UpdateRate->setEnabled(false);
m_Controls->m_OptionsUpdateRateLabel->setEnabled(false);
m_Controls->m_RenderUpdateRate->setEnabled(false);
m_Controls->m_OptionsRenderUpdateRateLabel->setEnabled(false);
m_Controls->m_LogUpdateRate->setEnabled(false);
m_Controls->m_OptionsLogUpdateRateLabel->setEnabled(false);
m_Controls->m_DisableAllTimers->setEnabled(false);
m_Controls->m_OtherOptionsGroupBox->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::EnableOptionsButtons()
{
m_Controls->m_ShowTrackingVolume->setEnabled(true);
m_Controls->m_UseDifferentUpdateRates->setEnabled(true);
m_Controls->m_DisableAllTimers->setEnabled(true);
m_Controls->m_OtherOptionsGroupBox->setEnabled(true);
OnToggleDifferentUpdateRates();
}
void QmitkMITKIGTTrackingToolboxView::EnableTrackingControls()
{
m_Controls->m_TrackingControlsGroupBox->setEnabled(true);
}
void QmitkMITKIGTTrackingToolboxView::DisableTrackingControls()
{
m_Controls->m_TrackingControlsGroupBox->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::EnableTrackingConfigurationButtons()
{
m_Controls->m_AutoDetectTools->setEnabled(true);
if (m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() != mitk::NDIAuroraTypeInformation::GetTrackingDeviceName()) m_Controls->m_AddSingleTool->setEnabled(true);
m_Controls->m_LoadTools->setEnabled(true);
m_Controls->m_ResetTools->setEnabled(true);
}
void QmitkMITKIGTTrackingToolboxView::DisableTrackingConfigurationButtons()
{
m_Controls->m_AutoDetectTools->setEnabled(false);
if (m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() != mitk::NDIAuroraTypeInformation::GetTrackingDeviceName()) m_Controls->m_AddSingleTool->setEnabled(false);
m_Controls->m_LoadTools->setEnabled(false);
m_Controls->m_ResetTools->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::ReplaceCurrentToolStorage(mitk::NavigationToolStorage::Pointer newStorage, std::string newStorageName)
{
//first: get rid of the old one
//don't reset if there is no tool storage. BugFix #17793
if (m_toolStorage.IsNotNull()){
m_toolStorage->UnLockStorage(); //only to be sure...
m_toolStorage->UnRegisterMicroservice();
m_toolStorage = nullptr;
}
//now: replace by the new one
m_toolStorage = newStorage;
m_toolStorage->SetName(newStorageName);
m_toolStorage->RegisterAsMicroservice("no tracking device");
}
void QmitkMITKIGTTrackingToolboxView::OnTimeOut()
{
m_WorkerThread->terminate();
m_WorkerThread->wait();
m_TimeoutTimer->stop();
}
//! [StoreUISettings]
void QmitkMITKIGTTrackingToolboxView::StoreUISettings()
{
// persistence service does not directly work in plugins for now
// -> using QSettings
QSettings settings;
settings.beginGroup(QString::fromStdString(VIEW_ID));
-
+ MITK_INFO << "Store UI settings";
// set the values of some widgets and attrbutes to the QSettings
settings.setValue("ShowTrackingVolume", QVariant(m_Controls->m_ShowTrackingVolume->isChecked()));
settings.setValue("toolStorageFilename", QVariant(m_ToolStorageFilename));
settings.setValue("VolumeSelectionBox", QVariant(m_Controls->m_VolumeSelectionBox->currentIndex()));
+ settings.setValue("SimpleModeEnabled", QVariant(m_SimpleModeEnabled));
settings.endGroup();
}
//! [StoreUISettings]
//! [LoadUISettings]
void QmitkMITKIGTTrackingToolboxView::LoadUISettings()
{
// persistence service does not directly work in plugins for now
// -> using QSettings
QSettings settings;
settings.beginGroup(QString::fromStdString(VIEW_ID));
// set some widgets and attributes by the values from the QSettings
m_Controls->m_ShowTrackingVolume->setChecked(settings.value("ShowTrackingVolume", true).toBool());
m_Controls->m_VolumeSelectionBox->setCurrentIndex(settings.value("VolumeSelectionBox", 0).toInt());
m_ToolStorageFilename = settings.value("toolStorageFilename", QVariant("")).toString();
-
+ if (settings.value("SimpleModeEnabled", false).toBool()) { this->OnToggleAdvancedSimpleMode(); }
settings.endGroup();
//! [LoadUISettings]
//! [LoadToolStorage]
// try to deserialize the tool storage from the given tool storage file name
if (!m_ToolStorageFilename.isEmpty())
{
// try-catch block for exceptions
try
{
mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(GetDataStorage());
m_toolStorage->UnRegisterMicroservice();
m_toolStorage = myDeserializer->Deserialize(m_ToolStorageFilename.toStdString());
m_toolStorage->RegisterAsMicroservice("no tracking device");
//update label
UpdateToolStorageLabel(m_ToolStorageFilename);
//update tool preview
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
}
catch (mitk::IGTException)
{
MITK_WARN("QmitkMITKIGTTrackingToolBoxView") << "Error during restoring tools. Problems with file (" << m_ToolStorageFilename.toStdString() << "), please check the file?";
this->OnResetTools(); //if there where errors reset the tool storage to avoid problems later on
}
}
//! [LoadToolStorage]
}
void QmitkMITKIGTTrackingToolboxView::UpdateToolStorageLabel(QString pathOfLoadedStorage)
{
QFileInfo myPath(pathOfLoadedStorage); //use this to seperate filename from path
QString toolLabel = myPath.fileName();
if (toolLabel.size() > 45) //if the tool storage name is to long trimm the string
{
toolLabel.resize(40);
toolLabel += "[...]";
}
m_Controls->m_toolLabel->setText(toolLabel);
}
void QmitkMITKIGTTrackingToolboxView::AutoSaveToolStorage()
{
m_ToolStorageFilename = m_AutoSaveFilename;
mitk::NavigationToolStorageSerializer::Pointer mySerializer = mitk::NavigationToolStorageSerializer::New();
mySerializer->Serialize(m_ToolStorageFilename.toStdString(), m_toolStorage);
}
void QmitkMITKIGTTrackingToolboxViewWorker::SetWorkerMethod(WorkerMethod w)
{
m_WorkerMethod = w;
}
void QmitkMITKIGTTrackingToolboxViewWorker::SetTrackingDevice(mitk::TrackingDevice::Pointer t)
{
m_TrackingDevice = t;
}
void QmitkMITKIGTTrackingToolboxViewWorker::SetDataStorage(mitk::DataStorage::Pointer d)
{
m_DataStorage = d;
}
void QmitkMITKIGTTrackingToolboxViewWorker::SetInverseMode(bool mode)
{
m_InverseMode = mode;
}
void QmitkMITKIGTTrackingToolboxViewWorker::SetTrackingDeviceData(mitk::TrackingDeviceData d)
{
m_TrackingDeviceData = d;
}
void QmitkMITKIGTTrackingToolboxViewWorker::SetNavigationToolStorage(mitk::NavigationToolStorage::Pointer n)
{
m_NavigationToolStorage = n;
}
//! [Thread 7]
void QmitkMITKIGTTrackingToolboxViewWorker::ThreadFunc()
{
switch (m_WorkerMethod)
{
case eAutoDetectTools:
this->AutoDetectTools();
break;
case eConnectDevice:
this->ConnectDevice();
break;
case eStartTracking:
this->StartTracking();
break;
case eStopTracking:
this->StopTracking();
break;
case eDisconnectDevice:
this->DisconnectDevice();
break;
default:
MITK_WARN << "Undefined worker method was set ... something went wrong!";
break;
}
}
//! [Thread 7]
void QmitkMITKIGTTrackingToolboxViewWorker::AutoDetectTools()
{
mitk::ProgressBar::GetInstance()->AddStepsToDo(2);
mitk::NavigationToolStorage::Pointer autoDetectedStorage = mitk::NavigationToolStorage::New(m_DataStorage);
try
{
mitk::NavigationToolStorage::Pointer tempStorage = m_TrackingDevice->AutoDetectTools();
mitk::ProgressBar::GetInstance()->Progress();
for (int i = 0; i < tempStorage->GetToolCount(); i++) { autoDetectedStorage->AddTool(tempStorage->GetTool(i)); }
}
catch (mitk::Exception& e)
{
MITK_WARN << e.GetDescription();
mitk::ProgressBar::GetInstance()->Progress(2);
emit AutoDetectToolsFinished(false, e.GetDescription());
return;
}
m_NavigationToolStorage = autoDetectedStorage;
mitk::ProgressBar::GetInstance()->Progress();
emit AutoDetectToolsFinished(true, "");
mitk::ProgressBar::GetInstance()->Progress(2);
}
void QmitkMITKIGTTrackingToolboxViewWorker::ConnectDevice()
{
std::string message = "";
mitk::ProgressBar::GetInstance()->AddStepsToDo(10);
//build the IGT pipeline
mitk::TrackingDevice::Pointer trackingDevice = m_TrackingDevice;
trackingDevice->SetData(m_TrackingDeviceData);
//set device to rotation mode transposed becaus we are working with VNL style quaternions
if (m_InverseMode)
{
trackingDevice->SetRotationMode(mitk::TrackingDevice::RotationTransposed);
}
//Get Tracking Volume Data
mitk::TrackingDeviceData data = m_TrackingDeviceData;
mitk::ProgressBar::GetInstance()->Progress();
//Create Navigation Data Source with the factory class
mitk::TrackingDeviceSourceConfigurator::Pointer myTrackingDeviceSourceFactory = mitk::TrackingDeviceSourceConfigurator::New(m_NavigationToolStorage, trackingDevice);
m_TrackingDeviceSource = myTrackingDeviceSourceFactory->CreateTrackingDeviceSource(m_ToolVisualizationFilter);
mitk::ProgressBar::GetInstance()->Progress();
if (m_TrackingDeviceSource.IsNull())
{
message = std::string("Cannot connect to device: ") + myTrackingDeviceSourceFactory->GetErrorMessage();
emit ConnectDeviceFinished(false, QString(message.c_str()));
return;
}
//set filter to rotation mode transposed becaus we are working with VNL style quaternions
if (m_InverseMode)
m_ToolVisualizationFilter->SetRotationMode(mitk::NavigationDataObjectVisualizationFilter::RotationTransposed);
//First check if the created object is valid
if (m_TrackingDeviceSource.IsNull())
{
message = myTrackingDeviceSourceFactory->GetErrorMessage();
emit ConnectDeviceFinished(false, QString(message.c_str()));
return;
}
MITK_INFO << "Number of tools: " << m_TrackingDeviceSource->GetNumberOfOutputs();
mitk::ProgressBar::GetInstance()->Progress();
//The tools are maybe reordered after initialization, e.g. in case of auto-detected tools of NDI Aurora
mitk::NavigationToolStorage::Pointer toolsInNewOrder = myTrackingDeviceSourceFactory->GetUpdatedNavigationToolStorage();
if ((toolsInNewOrder.IsNotNull()) && (toolsInNewOrder->GetToolCount() > 0))
{
//so delete the old tools in wrong order and add them in the right order
//we cannot simply replace the tool storage because the new storage is
//not correctly initialized with the right data storage
/*
m_NavigationToolStorage->DeleteAllTools();
for (int i=0; i < toolsInNewOrder->GetToolCount(); i++) {m_NavigationToolStorage->AddTool(toolsInNewOrder->GetTool(i));}
This was replaced and thereby fixed Bug 18318 DeleteAllTools() is not Threadsafe!
*/
for (int i = 0; i < toolsInNewOrder->GetToolCount(); i++)
{
m_NavigationToolStorage->AssignToolNumber(toolsInNewOrder->GetTool(i)->GetIdentifier(), i);
}
}
mitk::ProgressBar::GetInstance()->Progress();
//connect to device
try
{
m_TrackingDeviceSource->Connect();
mitk::ProgressBar::GetInstance()->Progress();
//Microservice registration:
m_TrackingDeviceSource->RegisterAsMicroservice();
m_NavigationToolStorage->UnRegisterMicroservice();
m_NavigationToolStorage->RegisterAsMicroservice(m_TrackingDeviceSource->GetMicroserviceID());
m_NavigationToolStorage->LockStorage();
}
catch (...) //todo: change to mitk::IGTException
{
message = "Error on connecting the tracking device.";
emit ConnectDeviceFinished(false, QString(message.c_str()));
return;
}
emit ConnectDeviceFinished(true, QString(message.c_str()));
mitk::ProgressBar::GetInstance()->Progress(10);
}
void QmitkMITKIGTTrackingToolboxViewWorker::StartTracking()
{
QString errorMessage = "";
try
{
m_TrackingDeviceSource->StartTracking();
}
catch (...) //todo: change to mitk::IGTException
{
errorMessage += "Error while starting the tracking device!";
emit StartTrackingFinished(false, errorMessage);
return;
}
//remember the original colors of the tools
m_OriginalColors = std::map<mitk::DataNode::Pointer, mitk::Color>();
for (int i = 0; i < this->m_NavigationToolStorage->GetToolCount(); i++)
{
mitk::DataNode::Pointer currentToolNode = m_NavigationToolStorage->GetTool(i)->GetDataNode();
float c[3];
currentToolNode->GetColor(c);
mitk::Color color;
color.SetRed(c[0]);
color.SetGreen(c[1]);
color.SetBlue(c[2]);
m_OriginalColors[currentToolNode] = color;
}
emit StartTrackingFinished(true, errorMessage);
}
void QmitkMITKIGTTrackingToolboxViewWorker::StopTracking()
{
//stop tracking
try
{
m_TrackingDeviceSource->StopTracking();
}
catch (mitk::Exception& e)
{
emit StopTrackingFinished(false, e.GetDescription());
}
//restore the original colors of the tools
for (int i = 0; i < this->m_NavigationToolStorage->GetToolCount(); i++)
{
mitk::DataNode::Pointer currentToolNode = m_NavigationToolStorage->GetTool(i)->GetDataNode();
if (m_OriginalColors.find(currentToolNode) == m_OriginalColors.end())
{
MITK_WARN << "Cannot restore original color of tool " << m_NavigationToolStorage->GetTool(i)->GetToolName();
}
else
{
currentToolNode->SetColor(m_OriginalColors[currentToolNode]);
}
}
//emit signal
emit StopTrackingFinished(true, "");
}
void QmitkMITKIGTTrackingToolboxViewWorker::DisconnectDevice()
{
try
{
if (m_TrackingDeviceSource->IsTracking()) { m_TrackingDeviceSource->StopTracking(); }
m_TrackingDeviceSource->Disconnect();
m_TrackingDeviceSource->UnRegisterMicroservice();
m_NavigationToolStorage->UnLockStorage();
}
catch (mitk::Exception& e)
{
emit DisconnectDeviceFinished(false, e.GetDescription());
}
emit DisconnectDeviceFinished(true, "");
}
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.h b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.h
index 406dcfafd6..e9376fd998 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.h
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.h
@@ -1,306 +1,308 @@
/*===================================================================
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 QmitkMITKIGTTrackingToolboxView_h
#define QmitkMITKIGTTrackingToolboxView_h
#include <berryISelectionListener.h>
#include <QmitkFunctionality.h>
#include "ui_QmitkMITKIGTTrackingToolboxViewControls.h"
//mitk headers
#include <mitkNavigationToolStorage.h>
#include <mitkTrackingDeviceSource.h>
#include <mitkNavigationDataObjectVisualizationFilter.h>
#include <mitkNavigationDataRecorder.h>
#include <mitkNavigationDataToIGTLMessageFilter.h>
#include <mitkIGTLServer.h>
#include <mitkIGTLMessageProvider.h>
//QT headers
#include <QTimer>
class QmitkMITKIGTTrackingToolboxViewWorker;
/*!
\brief QmitkMITKIGTTrackingToolboxView
This is the view of the bundle IGT Tracking Toolbox. The IGT Tracking Toolbox can be used to access tracking devices with MITK-IGT. The Tracking Toolbox can be used to log tracking data in XML or CSV format for measurement purposes. The Tracking Toolbox further allows for visualization of tools with given surfaces in combination with the NaviagtionToolManager.
\sa QmitkFunctionality
\ingroup Functionalities
*/
class QmitkMITKIGTTrackingToolboxView : public QmitkFunctionality
{
// this is needed for all Qt objects that should have a Qt meta-object
// (everything that derives from QObject and wants to have signal/slots)
Q_OBJECT
public:
static const std::string VIEW_ID;
QmitkMITKIGTTrackingToolboxView();
virtual ~QmitkMITKIGTTrackingToolboxView();
virtual void CreateQtPartControl(QWidget *parent) override;
virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget) override;
virtual void StdMultiWidgetNotAvailable() override;
protected slots:
/** @brief changes name of the filename when switching fileextension by radio button */
void OnToggleFileExtension();
/** @brief This slot is called if the user wants to load a new tool file. A new window opens where the user can choose a file. If the chosen file is
corrupt or not valid the user gets an error message. If the file was loaded successfully the tools are show in the tool status widget. */
void OnLoadTools();
/** Starts tracking if tracking is stopped / stops tracking if tracking is started. */
void OnStartStopTracking();
/** Connects the device if it is disconnected / disconnects the device if it is connected. */
void OnConnectDisconnect();
/** Freezes the device if it is not frozen / unfreezes the device if it is frozen. */
void OnFreezeUnfreezeTracking();
/** @brief This slot connects to the device. In status "connected" configuration of the device is disabled. */
void OnConnect();
/** @brief This slot disconnects from the device. */
void OnDisconnect();
/** @brief This slot tries to start tracking with the current device. If start tracking fails the user gets an error message and tracking stays off.*/
void OnStartTracking();
/** @brief This slot stops tracking. If tracking is not strated it does nothing.*/
void OnStopTracking();
/** @brief This slot is called if the user want's to choose a file name for logging. A new windows to navigate through the file system and choose
a file opens.*/
void OnChooseFileClicked();
/** @brief This slot starts logging. Logging is only possible if a device is tracking. If not the logging mechanism start when the start tracking
is called.*/
void StartLogging();
/** @brief This slot stops logging. If logging is not running it does nothing.*/
void StopLogging();
/** @brief This slot enables / disables UI elements depending on the tracking device after a device is changed.*/
void OnTrackingDeviceChanged();
/** @brief This slot selects the Tracking Volume appropriate for a given model */
void OnTrackingVolumeChanged(QString qstr);
/** @brief Shows or hides the tracking volume according to the checkboxe's state */
void OnShowTrackingVolumeChanged();
/** @brief This slot auto detects tools of a NDI Aurora tracking device. If tools where found they will be stored internally as a tool storage.
The user is also asked if he wants to save this tool storage to load it later. Only call it if a Aurora device was configured because other
devices don't support auto detection.*/
void OnAutoDetectTools();
/** @brief Slot for tracking timer. The timer updates the IGT pipline and also the logging filter if logging is activated.*/
void UpdateRenderTrackingTimer();
void UpdateLoggingTrackingTimer();
/** @brief Slot for showing the rendering disabled warning label*/
void OnChangeRenderUpdateRate();
/** @brief Resets the Tracking Tools: this means all tools are removed. */
void OnResetTools();
/** @brief Opens a dialog where a new navigation tool can be created. */
void OnAddSingleTool();
/** @brief This slot is called if the user finishes the creation of a new tool. */
void OnAddSingleToolFinished();
/** @brief This slot is called if the user cancels the creation of a new tool. */
void OnAddSingleToolCanceled();
void OnTimeOut();
protected slots:
//help slots for enable/disable buttons
void DisableLoggingButtons();
void EnableLoggingButtons();
void DisableOptionsButtons();
void EnableOptionsButtons();
void EnableTrackingConfigurationButtons();
void DisableTrackingConfigurationButtons();
void EnableTrackingControls();
void DisableTrackingControls();
void EnableDisableTimerButtons(int enable);
-
+ void OnToggleAdvancedSimpleMode();
void OnToggleDifferentUpdateRates();
//slots for worker thread
void OnAutoDetectToolsFinished(bool success, QString errorMessage);
void OnConnectFinished(bool success, QString errorMessage);
void OnStartTrackingFinished(bool success, QString errorMessage);
void OnStopTrackingFinished(bool success, QString errorMessage);
void OnDisconnectFinished(bool success, QString errorMessage);
protected:
Ui::QmitkMITKIGTTrackingToolboxViewControls* m_Controls;
QmitkStdMultiWidget* m_MultiWidget;
bool m_tracking; ///> bool which is true if tracking is running, false if not
bool m_connected; ///> bool that is true when a tracking device is connected
bool m_logging; ///> bool which is true if logging is running, false if not
int m_loggedFrames; ///> stores the current number of logged frames if logging is on
mitk::NavigationToolStorage::Pointer m_toolStorage; ///>stores the loaded tools
mitk::DataNode::Pointer m_TrackingVolumeNode; ///>holds the data node of the tracking volume if volume is visualized
bool lastTrackingVolumeState; ///>temporary holds the state of the tracking volume (activated/not activated) during some methods
QString m_ToolStorageFilename; ///>stores the filename of the current tool storage
QString m_AutoSaveFilename; ///>a filename for auto saving tools if no m_ToolStorageFilename was given by the user
/** @brief Shows a message box with the text given as parameter. */
void MessageBox(std::string s);
/** @brief reinits the view globally. */
void GlobalReinit();
//members for the filter pipeline
mitk::TrackingDeviceSource::Pointer m_TrackingDeviceSource; ///> member for the source of the IGT pipeline
mitk::TrackingDeviceData m_TrackingDeviceData; ///> stores the tracking device data as long as this is not handled by the tracking device configuration widget
mitk::NavigationDataObjectVisualizationFilter::Pointer m_ToolVisualizationFilter; ///> holds the tool visualization filter (second filter of the IGT pipeline)
mitk::NavigationDataRecorder::Pointer m_loggingFilter; ///> holds the logging filter if logging is on (third filter of the IGT pipeline)
//members for open IGT link server
mitk::NavigationDataToIGTLMessageFilter::Pointer m_IGTLConversionFilter; ///> Converts the navigation data as open IGT link message and makes this filter available as microservice
mitk::IGTLServer::Pointer m_IGTLServer;
mitk::IGTLMessageProvider::Pointer m_IGTLMessageProvider;
/** @brief This timer updates the IGT pipline and also the logging filter if logging is activated.*/
QTimer* m_TrackingRenderTimer;
QTimer* m_TrackingLoggingTimer;
QTimer* m_TimeoutTimer;
+ bool m_SimpleModeEnabled; ///>Stores if simple UI mode is enabled
+
/** Replaces the current navigation tool storage which is stored in m_toolStorage.
* Basically handles the microservice stuff: unregisteres the old storage, then
* replaces the storage and registers the new one.
*/
void ReplaceCurrentToolStorage(mitk::NavigationToolStorage::Pointer newStorage, std::string newStorageName);
/**
* \brief Stores the properties of some QWidgets (and the tool storage file name) to QSettings.
*/
void StoreUISettings();
/**
* \brief Loads the properties of some QWidgets (and the tool storage file name) from QSettings.
*/
void LoadUISettings();
/**
* Help method for updating the tool label
*/
void UpdateToolStorageLabel(QString pathOfLoadedStorage);
/**
* Auto saves the current tool storage to a temporary file. This ist used for persistence.
*/
void AutoSaveToolStorage();
//members for worker thread
QThread* m_WorkerThread;
QmitkMITKIGTTrackingToolboxViewWorker* m_Worker;
private:
ctkServiceReference m_DeviceTypeServiceReference;
mitk::TrackingDeviceTypeCollection* m_DeviceTypeCollection;
};
/**
* Worker thread class for this view.
*/
class QmitkMITKIGTTrackingToolboxViewWorker : public QObject
{
Q_OBJECT
public:
enum WorkerMethod{
eAutoDetectTools = 0,
eConnectDevice = 1,
eStartTracking = 2,
eStopTracking = 3,
eDisconnectDevice = 4
};
void SetWorkerMethod(WorkerMethod w);
void SetTrackingDevice(mitk::TrackingDevice::Pointer t);
void SetDataStorage(mitk::DataStorage::Pointer d);
void SetInverseMode(bool mode);
void SetTrackingDeviceData(mitk::TrackingDeviceData d);
void SetNavigationToolStorage(mitk::NavigationToolStorage::Pointer n);
itkGetMacro(NavigationToolStorage,mitk::NavigationToolStorage::Pointer);
itkGetMacro(TrackingDeviceSource,mitk::TrackingDeviceSource::Pointer);
itkGetMacro(TrackingDeviceData,mitk::TrackingDeviceData);
itkGetMacro(ToolVisualizationFilter,mitk::NavigationDataObjectVisualizationFilter::Pointer);
public slots:
void ThreadFunc();
signals:
void AutoDetectToolsFinished(bool success, QString errorMessage);
void ConnectDeviceFinished(bool success, QString errorMessage);
void StartTrackingFinished(bool success, QString errorMessage);
void StopTrackingFinished(bool success, QString errorMessage);
void DisconnectDeviceFinished(bool success, QString errorMessage);
protected:
mitk::TrackingDevice::Pointer m_TrackingDevice;
WorkerMethod m_WorkerMethod;
mitk::DataStorage::Pointer m_DataStorage;
mitk::NavigationToolStorage::Pointer m_NavigationToolStorage;
//members for the filter pipeline which is created in the worker thread during ConnectDevice()
mitk::TrackingDeviceSource::Pointer m_TrackingDeviceSource; ///> member for the source of the IGT pipeline
mitk::TrackingDeviceData m_TrackingDeviceData; ///> stores the tracking device data as long as this is not handled by the tracking device configuration widget
mitk::NavigationDataObjectVisualizationFilter::Pointer m_ToolVisualizationFilter; ///> holds the tool visualization filter (second filter of the IGT pipeline)
//members some internal flags
bool m_InverseMode; //flag that is true when the inverse mode is enabled
//stores the original colors of the tracking tools
std::map<mitk::DataNode::Pointer,mitk::Color> m_OriginalColors;
//internal methods
void AutoDetectTools();
void ConnectDevice();
void StartTracking();
void StopTracking();
void DisconnectDevice();
};
#endif // _QMITKMITKIGTTRACKINGTOOLBOXVIEW_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewControls.ui b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewControls.ui
index ecad7c0c5b..80774c501b 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewControls.ui
@@ -1,805 +1,889 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>QmitkMITKIGTTrackingToolboxViewControls</class>
<widget class="QWidget" name="QmitkMITKIGTTrackingToolboxViewControls">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>370</width>
- <height>1009</height>
+ <height>747</height>
</rect>
</property>
<property name="minimumSize">
<size>
<width>0</width>
<height>0</height>
</size>
</property>
<property name="windowTitle">
<string>QmitkTemplate</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_3">
<item>
<widget class="QTabWidget" name="m_MainWidget">
<property name="currentIndex">
<number>0</number>
</property>
<widget class="QWidget" name="tab">
<attribute name="title">
<string>Tracking</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout_9">
<item>
<widget class="QGroupBox" name="groupBox_3">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="minimumSize">
<size>
<width>0</width>
<height>0</height>
</size>
</property>
<property name="maximumSize">
<size>
<width>16777215</width>
<height>280</height>
</size>
</property>
<property name="title">
<string/>
</property>
<layout class="QVBoxLayout" name="verticalLayout_4">
<item>
<widget class="QmitkTrackingDeviceConfigurationWidget" name="m_configurationWidget" native="true">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="m_TrackingToolsGoupBox">
<property name="title">
<string/>
</property>
<layout class="QVBoxLayout" name="verticalLayout_5">
<item>
<widget class="QLabel" name="label_2">
<property name="font">
<font>
<pointsize>6</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd">
<html><head><meta name="qrichtext" content="1" /><style type="text/css">
p, li { white-space: pre-wrap; }
</style></head><body style=" font-family:'MS Shell Dlg 2'; font-size:7.8pt; font-weight:400; font-style:normal;">
<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-size:10pt; font-weight:600;">Tracking Tools</span></p></body></html></string>
</property>
</widget>
</item>
<item>
<widget class="QStackedWidget" name="m_TrackingToolsWidget">
<property name="lineWidth">
<number>0</number>
</property>
<property name="currentIndex">
<number>0</number>
</property>
<widget class="QWidget" name="page">
<layout class="QVBoxLayout" name="verticalLayout_11">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_3">
<item>
<widget class="QLabel" name="label_4">
<property name="text">
<string>ToolStorage:</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="m_toolLabel">
<property name="text">
<string><none></string>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
</layout>
</item>
<item>
<widget class="QmitkToolTrackingStatusWidget" name="m_TrackingToolsStatusWidget" native="true">
<property name="minimumSize">
<size>
<width>200</width>
<height>80</height>
</size>
</property>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_9">
<item>
<spacer name="horizontalSpacer_7">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>13</width>
<height>49</height>
</size>
</property>
</spacer>
</item>
<item>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QPushButton" name="m_AutoDetectTools">
<property name="minimumSize">
<size>
<width>120</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Auto Detection</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="m_AddSingleTool">
<property name="minimumSize">
<size>
<width>120</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Add Single Tool</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="m_LoadTools">
<property name="minimumSize">
<size>
<width>120</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Load Tool Storage</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="m_ResetTools">
<property name="minimumSize">
<size>
<width>120</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Reset</string>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</item>
</layout>
</widget>
<widget class="QWidget" name="page_2">
<layout class="QVBoxLayout" name="verticalLayout_10">
<item>
<widget class="QmitkNavigationToolCreationWidget" name="m_NavigationToolCreationWidget" native="true"/>
</item>
</layout>
</widget>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="m_TrackingControlsGroupBox">
<property name="title">
<string/>
</property>
<layout class="QVBoxLayout" name="verticalLayout_2">
<item>
<widget class="QLabel" name="label_3">
<property name="text">
<string><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd">
<html><head><meta name="qrichtext" content="1" /><style type="text/css">
p, li { white-space: pre-wrap; }
</style></head><body style=" font-family:'MS Shell Dlg 2'; font-size:7.8pt; font-weight:400; font-style:normal;">
<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-size:10pt; font-weight:600;">Tracking Control</span></p></body></html></string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="m_TrackingControlLabel">
<property name="text">
<string>Status: disconnected</string>
</property>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<spacer name="horizontalSpacer_11">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QPushButton" name="m_ConnectDisconnectButton">
<property name="minimumSize">
<size>
<width>142</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Connect</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_2">
<item>
<spacer name="horizontalSpacer_2">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QPushButton" name="m_StartStopTrackingButton">
<property name="minimumSize">
<size>
<width>142</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Start Tracking</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_11">
<item>
<spacer name="horizontalSpacer_9">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QLabel" name="m_TrackingFrozenLabel">
<property name="text">
<string><html><head/><body><p><span style=" color:#ff0000;">Tracking Frozen!</span></p></body></html></string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="m_FreezeUnfreezeTrackingButton">
<property name="enabled">
<bool>true</bool>
</property>
<property name="minimumSize">
<size>
<width>142</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Freeze Tracking</string>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
</item>
<item>
<spacer name="verticalSpacer">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
<widget class="QWidget" name="tab_2">
<attribute name="title">
<string>Options</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout_13">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_12">
<item>
<widget class="QCheckBox" name="m_DisableAllTimers">
<property name="text">
<string>Disable All Timers</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="m_renderWarningLabel">
<property name="enabled">
<bool>true</bool>
</property>
<property name="text">
<string><html><head/><body><p align="right"><span style=" color:#ff0000;">Rendering Disabled!</span></p></body></html></string>
</property>
<property name="textFormat">
<enum>Qt::AutoText</enum>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QGroupBox" name="m_UpdateRateOptionsGroupBox">
<property name="title">
<string>Update Rate Options</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_14">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_6">
<item>
<widget class="QLabel" name="m_OptionsUpdateRateLabel">
<property name="text">
<string>Update Rate [per second]</string>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer_5">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QSpinBox" name="m_UpdateRate">
<property name="maximum">
<number>100</number>
</property>
<property name="value">
<number>10</number>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QCheckBox" name="m_UseDifferentUpdateRates">
<property name="text">
<string>Use different Render and Log Update Rates</string>
</property>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_8" stretch="0,0,0">
<item>
<widget class="QLabel" name="m_OptionsRenderUpdateRateLabel">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>Render Update Rate [fps]</string>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer_3">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QSpinBox" name="m_RenderUpdateRate">
<property name="enabled">
<bool>false</bool>
</property>
<property name="minimum">
<number>0</number>
</property>
<property name="maximum">
<number>100</number>
</property>
<property name="value">
<number>10</number>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_10">
<item>
<widget class="QLabel" name="m_OptionsLogUpdateRateLabel">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>Log Update Rate [per second]</string>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer_8">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QSpinBox" name="m_LogUpdateRate">
<property name="enabled">
<bool>false</bool>
</property>
<property name="minimum">
<number>1</number>
</property>
<property name="maximum">
<number>120</number>
</property>
<property name="singleStep">
<number>10</number>
</property>
<property name="value">
<number>60</number>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="groupBox">
<property name="title">
<string>Tracking Volume Options</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_7">
<item>
<widget class="QCheckBox" name="m_ShowTrackingVolume">
<property name="enabled">
<bool>true</bool>
</property>
<property name="text">
<string>Show Tracking Volume</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label_5">
<property name="text">
<string>Select Model:</string>
</property>
</widget>
</item>
<item>
<widget class="QComboBox" name="m_VolumeSelectionBox"/>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="m_OtherOptionsGroupBox">
<property name="title">
<string>Other Options</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_12">
<item>
<widget class="QCheckBox" name="m_ShowToolQuaternions">
<property name="text">
<string>Show Tool Quaternions</string>
</property>
</widget>
</item>
<item>
<widget class="QCheckBox" name="m_EnableOpenIGTLinkMicroService">
<property name="text">
<string>Enable Open IGT Link MicroService</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
+ <item>
+ <widget class="QCheckBox" name="m_simpleUI">
+ <property name="text">
+ <string>Simple UI</string>
+ </property>
+ </widget>
+ </item>
<item>
<widget class="QLabel" name="label_6">
<property name="text">
<string>Caution, only for backward compatibility:</string>
</property>
</widget>
</item>
<item>
<widget class="QCheckBox" name="m_InverseMode">
<property name="text">
<string>Inverse mode (Quaternions are stored inverse)</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<spacer name="verticalSpacer_3">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>600</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
<widget class="QWidget" name="tab_3">
<attribute name="title">
<string>Logging</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout_8">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_4">
<item>
<widget class="QLabel" name="label">
<property name="text">
<string>Filename:</string>
</property>
</widget>
</item>
<item>
<widget class="QLineEdit" name="m_LoggingFileName"/>
</item>
<item>
<widget class="QPushButton" name="m_ChooseFile">
<property name="text">
<string>Choose File</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_7">
<item>
<widget class="QCheckBox" name="m_LoggingLimit">
<property name="text">
<string>Limit Number Of Logged Frames:</string>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer_6">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QSpinBox" name="m_LoggedFramesLimit">
<property name="minimum">
<number>1</number>
</property>
<property name="maximum">
<number>9999</number>
</property>
<property name="value">
<number>300</number>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QRadioButton" name="m_csvFormat">
<property name="text">
<string>CSV format</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QRadioButton" name="m_xmlFormat">
<property name="text">
<string>XML format</string>
</property>
</widget>
</item>
<item>
<widget class="QGroupBox" name="groupBox_4">
<property name="title">
<string>Logging Status</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_6">
<item>
<widget class="QLabel" name="m_LoggingLabel">
<property name="text">
<string>Logging OFF</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="m_LoggedFramesLabel">
<property name="text">
<string>Logged Frames: 0</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_5">
<item>
<spacer name="horizontalSpacer_4">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QPushButton" name="m_StartLogging">
<property name="text">
<string>Start Logging</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="m_StopLogging">
<property name="text">
<string>Stop Logging</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<spacer name="verticalSpacer_2">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
</widget>
</item>
+ <item>
+ <widget class="QWidget" name="m_simpleWidget" native="true">
+ <layout class="QHBoxLayout" name="horizontalLayout_13">
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout_25">
+ <item>
+ <widget class="QPushButton" name="m_ConnectSimpleMode">
+ <property name="minimumSize">
+ <size>
+ <width>70</width>
+ <height>50</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>Connect</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QPushButton" name="m_StartTrackingSimpleMode">
+ <property name="minimumSize">
+ <size>
+ <width>70</width>
+ <height>50</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>Start
+Tracking</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <spacer name="horizontalSpacer_21">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QPushButton" name="m_advancedUI">
+ <property name="minimumSize">
+ <size>
+ <width>70</width>
+ <height>50</height>
+ </size>
+ </property>
+ <property name="text">
+ <string>Advanced
+Mode</string>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
+ </layout>
+ </widget>
+ </item>
+ <item>
+ <spacer name="verticalSpacer_4">
+ <property name="orientation">
+ <enum>Qt::Vertical</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>20</width>
+ <height>40</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
</layout>
</widget>
<layoutdefault spacing="6" margin="11"/>
<customwidgets>
<customwidget>
<class>QmitkTrackingDeviceConfigurationWidget</class>
<extends>QWidget</extends>
<header>QmitkTrackingDeviceConfigurationWidget.h</header>
<container>1</container>
</customwidget>
<customwidget>
<class>QmitkToolTrackingStatusWidget</class>
<extends>QWidget</extends>
<header>QmitkToolTrackingStatusWidget.h</header>
<container>1</container>
</customwidget>
<customwidget>
<class>QmitkNavigationToolCreationWidget</class>
<extends>QWidget</extends>
<header>QmitkNavigationToolCreationWidget.h</header>
<container>1</container>
</customwidget>
</customwidgets>
<resources/>
<connections/>
</ui>