diff --git a/Modules/IGT/Algorithms/mitkNeedleProjectionFilter.cpp b/Modules/IGT/Algorithms/mitkNeedleProjectionFilter.cpp
index 2ca8c463cd..6854335767 100644
--- a/Modules/IGT/Algorithms/mitkNeedleProjectionFilter.cpp
+++ b/Modules/IGT/Algorithms/mitkNeedleProjectionFilter.cpp
@@ -1,198 +1,198 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // MITK
 #include "mitkNeedleProjectionFilter.h"
 #include <mitkPlaneGeometry.h>
 // Vermutung - wird nicht ben�tigt: #include "mitkUSCombinedModality.h"
 
 // VTK
 #include <vtkPlane.h>
 
 mitk::NeedleProjectionFilter::NeedleProjectionFilter()
   : m_Projection(mitk::PointSet::New()),
   m_OriginalPoints(mitk::PointSet::New()),
-  m_SelectedInput(-1),
-  m_ShowToolAxis(false)
+  m_ShowToolAxis(false),
+  m_SelectedInput(-1)
 {
   // Tool Coordinates:x axis is chosen as default axis when no axis is specified
 
   MITK_DEBUG << "Constructor called";
 
   mitk::Point3D toolAxis;
   mitk::FillVector3D(toolAxis, 1, 0, 0);
   m_ToolAxis = toolAxis;
   InitializeOriginalPoints(toolAxis, m_ShowToolAxis);
 
   MITK_DEBUG << "orginal point 0 set constructor" << m_OriginalPoints->GetPoint(0);
   MITK_DEBUG << "orginal point 1 set constructor" << m_OriginalPoints->GetPoint(1);
 }
 
 void mitk::NeedleProjectionFilter::InitializeOriginalPoints(mitk::Point3D toolAxis, bool showToolAxis)
 {
   m_OriginalPoints = mitk::PointSet::New();
 
   mitk::Point3D projectionPoint;
   projectionPoint.SetElement(0, toolAxis.GetElement(0) * 400);
   projectionPoint.SetElement(1, toolAxis.GetElement(1) * 400);
   projectionPoint.SetElement(2, toolAxis.GetElement(2) * 400);
   m_OriginalPoints->InsertPoint(projectionPoint);
 
   mitk::Point3D toolOrigin;
   toolOrigin.SetElement(0, 0);
   toolOrigin.SetElement(1, 0);
   toolOrigin.SetElement(2, 0);
   m_OriginalPoints->InsertPoint(toolOrigin);
 
   if (showToolAxis)
   {
     mitk::Point3D axisPoint;
     axisPoint.SetElement(0, toolAxis.GetElement(0) * -400);
     axisPoint.SetElement(1, toolAxis.GetElement(1) * -400);
     axisPoint.SetElement(2, toolAxis.GetElement(2) * -400);
     m_OriginalPoints->InsertPoint(axisPoint);
   }
 
 }
 
 void mitk::NeedleProjectionFilter::ShowToolAxis(bool enabled)
 {
   m_ShowToolAxis = enabled;
   InitializeOriginalPoints(m_ToolAxis,m_ShowToolAxis);
 }
 
 void mitk::NeedleProjectionFilter::SetToolAxisForFilter(mitk::Point3D point)
 {
   m_ToolAxis = point;
   InitializeOriginalPoints(m_ToolAxis, m_ShowToolAxis);
 
   MITK_DEBUG << "orginal point 1 set mutator" << m_OriginalPoints->GetPoint(1);
   MITK_DEBUG << "orginal point 0 set mutator" << m_OriginalPoints->GetPoint(0);
 }
 
 mitk::NeedleProjectionFilter::~NeedleProjectionFilter()
 {
 }
 
 void mitk::NeedleProjectionFilter::SelectInput(int i)
 {
   if (i < 0) mitkThrow() << "Negative Input selected in NeedleProjectionFilter";
   if (! (static_cast<unsigned int>(i) < this->GetInputs().size())) mitkThrow() << "Selected input index is larger than actual number of inputs in NeedleProjectionFilter";
   m_SelectedInput = i;
 }
 
 void mitk::NeedleProjectionFilter::GenerateData()
 {
   // copy the navigation data from the inputs to the outputs
   mitk::NavigationDataPassThroughFilter::GenerateData();
 
   // If no reference has been set yet, warn and abort
   if (m_SelectedInput == -1)
   {
     MITK_INFO << "No input has been selected in NeedleProjection Filter. Only forwarding NavigationData...";
     return;
   }
 
   // Cancel, if selected tool is currently not being tracked
   if (! GetInput(m_SelectedInput)->IsDataValid()) return;
 
   // Outputs have been updated, now to calculate the Projection
   // 1) Generate Pseudo-Geometry for Input
   mitk::AffineTransform3D::Pointer refTrans = this->NavigationDataToTransform(this->GetInput(m_SelectedInput));
   mitk::Geometry3D::Pointer refGeom = this->TransformToGeometry(refTrans);
 
   // 2) Transform Original Pointset
   m_OriginalPoints->SetGeometry(refGeom);
   // Update Projection (We do not clone, since we want to keep properties alive)
   m_Projection->SetPoint(0, m_OriginalPoints->GetPoint(0));
   m_Projection->SetPoint(1, m_OriginalPoints->GetPoint(1));
   if (m_ShowToolAxis) { m_Projection->SetPoint(2, m_OriginalPoints->GetPoint(2)); }
 
   // 3a) If no target Plane has been set, then leave it at that
   if (this->m_TargetPlane.IsNull())
     return;
 
   // 3b) else, calculate intersection with plane
   mitk::PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
   plane->SetIndexToWorldTransform(m_TargetPlane);
   //plane->TransferItkToVtkTransform(); //included in SetIndexToWorldTransform
 
   double t;
   double x[3];
   // Points that define the needle vector
   double p1[3] = {m_OriginalPoints->GetPoint(0)[0], m_OriginalPoints->GetPoint(0)[1], m_OriginalPoints->GetPoint(0)[2]};
   double p2[3] = {m_OriginalPoints->GetPoint(1)[0], m_OriginalPoints->GetPoint(1)[1], m_OriginalPoints->GetPoint(1)[2]};
   // Center of image plane and it's normal
   double center[3] = {plane->GetCenter()[0], plane->GetCenter()[1], plane->GetCenter()[2]};
   double normal[3] = {plane->GetNormal()[0], plane->GetNormal()[1], plane->GetNormal()[2]};
 
   vtkPlane::IntersectWithLine(p1, p2, normal, center, t, x);
 
   // change (cut) needle path only if the needle points to the image plane;
   // otherwise the needle path direction would be changed pointing to the image plane
   if ( t >= 0 )
   {
     // Convert vtk to itk
     mitk::Point3D intersection;
     intersection[0] = x[0];
     intersection[1] = x[1];
     intersection[2] = x[2];
 
     // Replace distant point with image intersection
     m_Projection->SetPoint(0, intersection);
 
   }
 }
 
 mitk::AffineTransform3D::Pointer mitk::NeedleProjectionFilter::NavigationDataToTransform(const mitk::NavigationData * nd)
 {
   mitk::AffineTransform3D::Pointer affineTransform = mitk::AffineTransform3D::New();
   affineTransform->SetIdentity();
 
   //calculate the transform from the quaternions
   static itk::QuaternionRigidTransform<double>::Pointer quatTransform = itk::QuaternionRigidTransform<double>::New();
 
   mitk::NavigationData::OrientationType orientation = nd->GetOrientation();
   // convert mitk::ScalarType quaternion to double quaternion because of itk bug
   vnl_quaternion<double> doubleQuaternion(orientation.x(), orientation.y(), orientation.z(), orientation.r());
   quatTransform->SetIdentity();
   quatTransform->SetRotation(doubleQuaternion);
   quatTransform->Modified();
 
   /* because of an itk bug, the transform can not be calculated with float data type.
   To use it in the mitk geometry classes, it has to be transfered to mitk::ScalarType which is float */
   static AffineTransform3D::MatrixType m;
   mitk::TransferMatrix(quatTransform->GetMatrix(), m);
   affineTransform->SetMatrix(m);
 
   /*set the offset by convert from itkPoint to itkVector and setting offset of transform*/
   mitk::Vector3D pos;
   pos.SetVnlVector(nd->GetPosition().GetVnlVector());
   affineTransform->SetOffset(pos);
 
   affineTransform->Modified();
   return affineTransform;
 }
 
 mitk::Geometry3D::Pointer mitk::NeedleProjectionFilter::TransformToGeometry(mitk::AffineTransform3D::Pointer transform){
   mitk::Geometry3D::Pointer g3d = mitk::Geometry3D::New();
   mitk::ScalarType scale[] = {1.0, 1.0, 1.0};
   g3d->SetSpacing(scale);
   g3d->SetIndexToWorldTransform(transform);
   //g3d->TransferItkToVtkTransform(); // update VTK Transform for rendering too //included in SetIndexToWorldTransform
   g3d->Modified();
   return g3d;
 }
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTNavigationToolManagerView.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTNavigationToolManagerView.cpp
index 1db19eb558..8de72cb732 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTNavigationToolManagerView.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTNavigationToolManagerView.cpp
@@ -1,78 +1,78 @@
 /*===================================================================
 
 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 "QmitkMITKIGTNavigationToolManagerView.h"
 
 // MITK
 #include <usGetModuleContext.h>
 
 // Qt
 #include <QMessageBox>
 
 const std::string QmitkMITKIGTNavigationToolManagerView::VIEW_ID = "org.mitk.views.mitkigtnavigationtoolmanager";
 
 QmitkMITKIGTNavigationToolManagerView::QmitkMITKIGTNavigationToolManagerView()
   : QmitkAbstractView()
   , m_Controls(0)
 {
 }
 
 QmitkMITKIGTNavigationToolManagerView::~QmitkMITKIGTNavigationToolManagerView()
 {
   for (auto storage : m_AllStoragesHandledByThisWidget)
     storage->UnRegisterMicroservice();
 }
 
 void QmitkMITKIGTNavigationToolManagerView::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::QmitkMITKIGTNavigationToolManagerViewControls;
     m_Controls->setupUi(parent);
     connect((QObject*)(m_Controls->m_toolManagerWidget), SIGNAL(NewStorageAdded(mitk::NavigationToolStorage::Pointer, std::string)), this, SLOT(NewStorageByWidget(mitk::NavigationToolStorage::Pointer, std::string)));
     connect((QObject*)(m_Controls->m_ToolStorageListWidget), SIGNAL(NavigationToolStorageSelected(mitk::NavigationToolStorage::Pointer)), this, SLOT(ToolStorageSelected(mitk::NavigationToolStorage::Pointer)));
   }
   m_Controls->m_toolManagerWidget->Initialize(this->GetDataStorage());
 }
 
 void QmitkMITKIGTNavigationToolManagerView::SetFocus()
 {
   m_Controls->m_ToolStorageListWidget->setFocus();
 }
 
-void QmitkMITKIGTNavigationToolManagerView::NewStorageByWidget(mitk::NavigationToolStorage::Pointer storage, std::string storageName)
+void QmitkMITKIGTNavigationToolManagerView::NewStorageByWidget(mitk::NavigationToolStorage::Pointer storage)
 {
   storage->RegisterAsMicroservice();
   m_AllStoragesHandledByThisWidget.push_back(storage);
 }
 
 void QmitkMITKIGTNavigationToolManagerView::ToolStorageSelected(mitk::NavigationToolStorage::Pointer storage)
 {
   if (storage.IsNull()) //no storage selected
   {
     //reset everything
     return;
   }
 
   this->m_Controls->m_toolManagerWidget->LoadStorage(storage);
 }
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTNavigationToolManagerView.h b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTNavigationToolManagerView.h
index c9fff653b4..b84f1edce6 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTNavigationToolManagerView.h
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTNavigationToolManagerView.h
@@ -1,63 +1,63 @@
 /*===================================================================
 
 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 QmitkMITKIGTNavigationToolManagerView_h
 #define QmitkMITKIGTNavigationToolManagerView_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 #include <usServiceReference.h>
 
 #include "ui_QmitkMITKIGTNavigationToolManagerViewControls.h"
 
 /*!
   \brief QmitkMITKIGTNavigationToolManagerView
 
   \warning  This application module is not yet documented. Use "svn blame/praise/annotate" and ask the author to provide basic documentation.
 
   */
 class QmitkMITKIGTNavigationToolManagerView : public QmitkAbstractView
 {
   // 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;
 
   QmitkMITKIGTNavigationToolManagerView();
   virtual ~QmitkMITKIGTNavigationToolManagerView();
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
   virtual void SetFocus() override;
 
   protected slots:
 
-  void NewStorageByWidget(mitk::NavigationToolStorage::Pointer storage, std::string);
+  void NewStorageByWidget(mitk::NavigationToolStorage::Pointer storage);
   void ToolStorageSelected(mitk::NavigationToolStorage::Pointer);
 
 protected:
 
   Ui::QmitkMITKIGTNavigationToolManagerViewControls* m_Controls;
 
   /** Someone needs to hold the smart pointers of new storages, otherwise the objects will be lost although they are listed as microservice. */
   std::vector<mitk::NavigationToolStorage::Pointer> m_AllStoragesHandledByThisWidget;
 };
 
 #endif // _QMITKMITKIGTNAVIGATIONTOOLMANAGERVIEW_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
index 24edfec12a..ec17ff1d2e 100644
--- a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
+++ b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
@@ -1,530 +1,530 @@
 /*===================================================================
 
 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 <mitkIRenderingManager.h>
 #include <mitkIRenderWindowPart.h>
 #include <mitkILinkedRenderWindowPart.h>
 
 // Qmitk
 #include "QmitkToFUtilView.h"
 
 // Qt
 #include <QMessageBox>
 #include <QString>
 #include <qmessagebox.h>
 #include <qfiledialog.h>
 #include <qcombobox.h>
 
 // MITK
 #include <mitkBaseRenderer.h>
 #include <mitkToFDistanceImageToPointSetFilter.h>
 #include <mitkTransferFunction.h>
 #include <mitkTransferFunctionProperty.h>
 #include <mitkToFDeviceFactoryManager.h>
 #include <mitkToFCameraDevice.h>
 #include <mitkCameraIntrinsicsProperty.h>
 #include <mitkSmartPointerProperty.h>
 #include <mitkRenderingModeProperty.h>
 #include <mitkVtkScalarModeProperty.h>
 
 // VTK
 #include <vtkCamera.h>
 #include <vtkPointData.h>
 #include <vtkPolyData.h>
 
 // ITK
 #include <itkCommand.h>
 #include <itksys/SystemTools.hxx>
 
 const std::string QmitkToFUtilView::VIEW_ID = "org.mitk.views.tofutil";
 
 //Constructor
 QmitkToFUtilView::QmitkToFUtilView()
   : QmitkAbstractView()
   , m_Controls(nullptr)
+  , m_Framerateoutput(false)
   , m_MitkDistanceImage(nullptr), m_MitkAmplitudeImage(nullptr), m_MitkIntensityImage(nullptr), m_Surface(nullptr)
   , m_DistanceImageNode(nullptr), m_AmplitudeImageNode(nullptr), m_IntensityImageNode(nullptr), m_RGBImageNode(nullptr), m_SurfaceNode(nullptr)
   , m_ToFImageRecorder(nullptr), m_ToFImageGrabber(nullptr), m_ToFDistanceImageToSurfaceFilter(nullptr), m_ToFCompositeFilter(nullptr)
   , m_2DDisplayCount(0)
   , m_RealTimeClock(nullptr)
   , m_StepsForFramerate(100)
   , m_2DTimeBefore(0.0)
   , m_2DTimeAfter(0.0)
   , m_CameraIntrinsics(nullptr)
-  , m_Framerateoutput(false)
 {
   this->m_Frametimer = new QTimer(this);
 
   this->m_ToFDistanceImageToSurfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
   this->m_ToFCompositeFilter = mitk::ToFCompositeFilter::New();
   this->m_ToFImageRecorder = mitk::ToFImageRecorder::New();
 }
 
 //Destructor, specifically calling OnToFCameraStopped() and OnToFCammeraDiconnected()
 QmitkToFUtilView::~QmitkToFUtilView()
 {
   OnToFCameraStopped();
   OnToFCameraDisconnected();
 }
 
 //Createing the PartControl Signal-Slot principal
 void QmitkToFUtilView::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::QmitkToFUtilViewControls;
     m_Controls->setupUi( parent );
 
     //Looking for Input and Defining reaction
     connect(m_Frametimer, SIGNAL(timeout()), this, SLOT(OnUpdateCamera()));
 
     connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(KinectAcquisitionModeChanged()), this, SLOT(OnKinectAcquisitionModeChanged()) ); // Todo in Widget2
     connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraConnected()), this, SLOT(OnToFCameraConnected()) );
     connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraDisconnected()), this, SLOT(OnToFCameraDisconnected()) );
     connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(ToFCameraStarted()), this, SLOT(OnToFCameraStarted()) );
     connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(ToFCameraStopped()), this, SLOT(OnToFCameraStopped()) );
     connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(RecordingStarted()), this, SLOT(OnToFCameraStopped()) );
     connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(RecordingStopped()), this, SLOT(OnToFCameraStarted()) );
 }
 }
 
 //SetFocus-Method -> actually seting Focus to the Recorder
 void QmitkToFUtilView::SetFocus()
 {
   m_Controls->m_ToFRecorderWidget->setFocus();
 }
 
 //Activated-Method->Generating RenderWindow
 void QmitkToFUtilView::Activated()
 {
   //get the current RenderWindowPart or open a new one if there is none
   if (this->GetRenderWindowPart(OPEN))
   {
     mitk::ILinkedRenderWindowPart* linkedRenderWindowPart = dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart());
     if (linkedRenderWindowPart == 0)
     {
       MITK_ERROR << "No linked render window part avaiable!!!";
     }
     else
     {
       linkedRenderWindowPart->EnableSlicingPlanes(false);
     }
     GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SliceLockedOn();
     GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SliceLockedOn();
     GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SliceLockedOn();
 
     mitk::RenderingManager::GetInstance()->InitializeViews();
 
     this->UseToFVisibilitySettings(true);
 
     if (this->m_ToFCompositeFilter)
     {
       m_Controls->m_ToFCompositeFilterWidget->SetToFCompositeFilter(this->m_ToFCompositeFilter);
     }
     if (this->GetDataStorage())
     {
       m_Controls->m_ToFCompositeFilterWidget->SetDataStorage(this->GetDataStorage());
     }
 
     if (this->m_ToFImageGrabber.IsNull())
     {
       m_Controls->m_ToFRecorderWidget->setEnabled(false);
       m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
       m_Controls->m_ToFCompositeFilterWidget->setEnabled(false);
       m_Controls->m_ToFMeasurementWidget->setEnabled(false);
       m_Controls->m_ToFSurfaceGenerationWidget->setEnabled(false);
     }
   }
 }
 
 //ZomnnieView-Method -> Resetting GUI to default. Why not just QmitkToFUtilView()?!
 void QmitkToFUtilView::ActivatedZombieView(berry::IWorkbenchPartReference::Pointer /*zombieView*/)
 {
   ResetGUIToDefault();
 }
 
 void QmitkToFUtilView::Deactivated()
 {
 }
 
 void QmitkToFUtilView::Visible()
 {
 }
 
 //Reset of the ToFUtilView
 void QmitkToFUtilView::Hidden()
 {
   ResetGUIToDefault();
 }
 
 void QmitkToFUtilView::OnToFCameraConnected()
 {
   MITK_DEBUG <<"OnToFCameraConnected";
   this->m_2DDisplayCount = 0;
 
   this->m_ToFImageGrabber = m_Controls->m_ToFConnectionWidget->GetToFImageGrabber();
 
   // initialize surface generation
   this->m_ToFDistanceImageToSurfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
 
   // initialize ToFImageRecorder and ToFRecorderWidget
   this->m_ToFImageRecorder = mitk::ToFImageRecorder::New();
   this->m_ToFImageRecorder->SetCameraDevice(this->m_ToFImageGrabber->GetCameraDevice());
   m_Controls->m_ToFRecorderWidget->SetParameter(this->m_ToFImageGrabber, this->m_ToFImageRecorder);
   m_Controls->m_ToFRecorderWidget->setEnabled(true);
   m_Controls->m_ToFRecorderWidget->ResetGUIToInitial();
   m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
 
   // initialize ToFCompositeFilterWidget
   this->m_ToFCompositeFilter = mitk::ToFCompositeFilter::New();
   if (this->m_ToFCompositeFilter)
   {
     m_Controls->m_ToFCompositeFilterWidget->SetToFCompositeFilter(this->m_ToFCompositeFilter);
   }
   if (this->GetDataStorage())
   {
     m_Controls->m_ToFCompositeFilterWidget->SetDataStorage(this->GetDataStorage());
   }
 
   if ( this->GetRenderWindowPart() )
     // initialize measurement widget
     m_Controls->m_ToFMeasurementWidget->InitializeWidget(this->GetRenderWindowPart()->GetQmitkRenderWindows(),this->GetDataStorage(), this->m_ToFDistanceImageToSurfaceFilter->GetCameraIntrinsics());
   else
     MITK_WARN << "No render window part available!!! MeasurementWidget will not work.";
 
   this->m_RealTimeClock = mitk::RealTimeClock::New();
   this->m_2DTimeBefore = this->m_RealTimeClock->GetCurrentStamp();
 
   this->RequestRenderWindowUpdate();
 }
 
 void QmitkToFUtilView::ResetGUIToDefault()
 {
   if(this->GetRenderWindowPart())
   {
     mitk::ILinkedRenderWindowPart* linkedRenderWindowPart = dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart());
     if(linkedRenderWindowPart == 0)
     {
       MITK_ERROR << "No linked render window part avaiable!!!";
     }
     else
     {
       linkedRenderWindowPart->EnableSlicingPlanes(true);
     }
     GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetSliceNavigationController()->SliceLockedOff();
     GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
     GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController()->SliceLockedOff();
     GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal);
     GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetSliceNavigationController()->SliceLockedOff();
 
     this->UseToFVisibilitySettings(false);
 
     //global reinit
     mitk::RenderingManager::GetInstance()->InitializeViews();
     this->RequestRenderWindowUpdate();
   }
 }
 
 void QmitkToFUtilView::OnToFCameraDisconnected()
 {
   this->GetDataStorage()->Remove(m_DistanceImageNode);
   if(m_RGBImageNode)
     this->GetDataStorage()->Remove(m_RGBImageNode);
   if(m_AmplitudeImageNode)
     this->GetDataStorage()->Remove(m_AmplitudeImageNode);
   if(m_IntensityImageNode)
     this->GetDataStorage()->Remove(m_IntensityImageNode);
   if(m_SurfaceNode)
     this->GetDataStorage()->Remove(m_SurfaceNode);
 
   m_Controls->m_ToFRecorderWidget->OnStop();
   m_Controls->m_ToFRecorderWidget->setEnabled(false);
   m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
   m_Controls->m_ToFMeasurementWidget->setEnabled(false);
   m_Controls->m_ToFSurfaceGenerationWidget->setEnabled(false);
   //clean up measurement widget
   m_Controls->m_ToFMeasurementWidget->CleanUpWidget();
 }
 
 void QmitkToFUtilView::OnKinectAcquisitionModeChanged()
 {
   if (m_ToFCompositeFilter.IsNotNull()&&m_ToFImageGrabber.IsNotNull())
   {
     if (m_SelectedCamera.contains("Kinect"))
     {
       if (m_ToFImageGrabber->GetBoolProperty("RGB"))
       {
         this->m_RGBImageNode = ReplaceNodeData("RGB image",this->m_ToFImageGrabber->GetOutput(3));
         this->m_ToFDistanceImageToSurfaceFilter->SetInput(3,this->m_ToFImageGrabber->GetOutput(3));
       }
       else if (m_ToFImageGrabber->GetBoolProperty("IR"))
       {
         this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
         this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
       }
     }
     this->UseToFVisibilitySettings(true);
   }
 }
 
 void QmitkToFUtilView::OnToFCameraStarted()
 {
   if (m_ToFImageGrabber.IsNotNull())
   {
     // initialize camera intrinsics
     if (this->m_ToFImageGrabber->GetProperty("CameraIntrinsics"))
     {
       m_CameraIntrinsics = dynamic_cast<mitk::CameraIntrinsicsProperty*>(this->m_ToFImageGrabber->GetProperty("CameraIntrinsics"))->GetValue();
       MITK_INFO << m_CameraIntrinsics->ToString();
     }
     else
     {
       m_CameraIntrinsics = nullptr;
       MITK_ERROR << "No camera intrinsics were found!";
     }
 
     // set camera intrinsics
     if ( m_CameraIntrinsics.IsNotNull() )
     {
       this->m_ToFDistanceImageToSurfaceFilter->SetCameraIntrinsics(m_CameraIntrinsics);
     }
 
     // initial update of image grabber
     this->m_ToFImageGrabber->Update();
 
     bool hasRGBImage = false;
     m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("HasRGBImage",hasRGBImage);
 
     bool hasIntensityImage = false;
     m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("HasIntensityImage",hasIntensityImage);
 
     bool hasAmplitudeImage = false;
     m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("HasAmplitudeImage",hasAmplitudeImage);
 
     this->m_ToFCompositeFilter->SetInput(0,this->m_ToFImageGrabber->GetOutput(0));
     if(hasAmplitudeImage)
       this->m_ToFCompositeFilter->SetInput(1,this->m_ToFImageGrabber->GetOutput(1));
     if(hasIntensityImage)
       this->m_ToFCompositeFilter->SetInput(2,this->m_ToFImageGrabber->GetOutput(2));
 
     // initial update of composite filter
     this->m_ToFCompositeFilter->Update();
     this->m_MitkDistanceImage = m_ToFCompositeFilter->GetOutput();
     this->m_DistanceImageNode = ReplaceNodeData("Distance image",m_MitkDistanceImage);
 
     std::string rgbFileName;
     m_ToFImageGrabber->GetCameraDevice()->GetStringProperty("RGBImageFileName",rgbFileName);
 
     if(hasRGBImage || (rgbFileName!=""))
     {
       if(m_ToFImageGrabber->GetBoolProperty("IR"))
       {
         this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
       }
       else
       {
         this->m_RGBImageNode = ReplaceNodeData("RGB image",this->m_ToFImageGrabber->GetOutput(3));
       }
     }
     else
     {
       this->m_RGBImageNode = nullptr;
     }
 
     if(hasAmplitudeImage)
     {
       this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
       this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
     }
 
     if(hasIntensityImage)
     {
       this->m_MitkIntensityImage = m_ToFCompositeFilter->GetOutput(2);
       this->m_IntensityImageNode = ReplaceNodeData("Intensity image",m_MitkIntensityImage);
     }
 
     this->m_ToFDistanceImageToSurfaceFilter->SetInput(0,m_MitkDistanceImage);
     this->m_ToFDistanceImageToSurfaceFilter->SetInput(1,m_MitkAmplitudeImage);
     this->m_ToFDistanceImageToSurfaceFilter->SetInput(2,m_MitkIntensityImage);
 
     this->UseToFVisibilitySettings(true);
 
     this->m_SurfaceNode = ReplaceNodeData("Surface", nullptr);
     m_Controls->m_ToFCompositeFilterWidget->UpdateFilterParameter();
     // initialize visualization widget
     m_Controls->m_ToFVisualisationSettingsWidget->Initialize(this->m_DistanceImageNode,
                                                              this->m_AmplitudeImageNode,
                                                              this->m_IntensityImageNode,
                                                              this->m_SurfaceNode);
     m_Controls->m_ToFSurfaceGenerationWidget->Initialize(m_ToFDistanceImageToSurfaceFilter,
                                                          m_ToFImageGrabber,
                                                          m_CameraIntrinsics,
                                                          m_SurfaceNode,
                                                          GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderer()->GetVtkRenderer()->GetActiveCamera());
     // set distance image to measurement widget
     m_Controls->m_ToFMeasurementWidget->SetDistanceImage(m_MitkDistanceImage);
 
     this->m_Frametimer->start(50);
 
     m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(true);
     m_Controls->m_ToFCompositeFilterWidget->setEnabled(true);
     m_Controls->m_ToFMeasurementWidget->setEnabled(true);
     m_Controls->m_ToFSurfaceGenerationWidget->setEnabled(true);
   }
 }
 
 void QmitkToFUtilView::OnToFCameraStopped()
 {
   m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
   m_Controls->m_ToFCompositeFilterWidget->setEnabled(false);
 
   this->m_Frametimer->stop();
 }
 
 void QmitkToFUtilView::OnUpdateCamera()
 {
   if(!m_Controls->m_ToFSurfaceGenerationWidget->UpdateSurface())
   {
     // update pipeline
     this->m_MitkDistanceImage->Update();
   }
 
   this->RequestRenderWindowUpdate();
 
   if (m_Framerateoutput)
   {
     this->m_2DDisplayCount++;
     if ((this->m_2DDisplayCount % this->m_StepsForFramerate) == 0)
     {
       this->m_2DTimeAfter = this->m_RealTimeClock->GetCurrentStamp() - this->m_2DTimeBefore;
       MITK_INFO << " 2D-Display-framerate (fps): " << this->m_StepsForFramerate / (this->m_2DTimeAfter / 1000);
       this->m_2DTimeBefore = this->m_RealTimeClock->GetCurrentStamp();
     }
   }
 
 }
 
 void QmitkToFUtilView::OnChangeCoronalWindowOutput(int index)
 {
   this->OnToFCameraStopped();
   if(index == 0)
   {
     if(this->m_IntensityImageNode.IsNotNull())
       this->m_IntensityImageNode->SetVisibility(false);
     if(this->m_RGBImageNode.IsNotNull())
       this->m_RGBImageNode->SetVisibility(true);
   }
   else if(index == 1)
   {
     if(this->m_IntensityImageNode.IsNotNull())
       this->m_IntensityImageNode->SetVisibility(true);
     if(this->m_RGBImageNode.IsNotNull())
       this->m_RGBImageNode->SetVisibility(false);
   }
   this->RequestRenderWindowUpdate();
   this->OnToFCameraStarted();
 }
 
 mitk::DataNode::Pointer QmitkToFUtilView::ReplaceNodeData( std::string nodeName, mitk::BaseData* data )
 {
   mitk::DataNode::Pointer node = this->GetDataStorage()->GetNamedNode(nodeName);
   if (node.IsNull())
   {
     node = mitk::DataNode::New();
     node->SetName(nodeName);
     node->SetBoolProperty("binary",false);
     node->SetData(data);
     this->GetDataStorage()->Add(node);
   }
   else
   {
     node->SetData(data);
   }
   return node;
 }
 
 void QmitkToFUtilView::UseToFVisibilitySettings(bool useToF)
 {
   //We need this property for every node.
   mitk::RenderingModeProperty::Pointer renderingModePropertyForTransferFunction = mitk::RenderingModeProperty::New(mitk::RenderingModeProperty::COLORTRANSFERFUNCTION_COLOR);
 
   // set node properties
   if (m_DistanceImageNode.IsNotNull())
   {
     this->m_DistanceImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
     this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetRenderWindow() ) );
     this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetRenderWindow() ) );
     this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
     this->m_DistanceImageNode->SetProperty("Image Rendering.Mode", renderingModePropertyForTransferFunction);
   }
   if (m_AmplitudeImageNode.IsNotNull())
   {
     this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetRenderWindow() ) );
     this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetRenderWindow() ) );
     this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
     this->m_AmplitudeImageNode->SetProperty("Image Rendering.Mode", renderingModePropertyForTransferFunction);
   }
   if (m_IntensityImageNode.IsNotNull())
   {
       this->m_IntensityImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
       this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetRenderWindow() ) );
       this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetRenderWindow() ) );
       this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
       this->m_IntensityImageNode->SetProperty("Image Rendering.Mode", renderingModePropertyForTransferFunction);
   }
   if ((m_RGBImageNode.IsNotNull()))
   {
       this->m_RGBImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
       this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("axial")->GetRenderWindow() ) );
       this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("sagittal")->GetRenderWindow() ) );
       this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
   }
   // initialize images
   if (m_MitkDistanceImage.IsNotNull())
   {
       mitk::RenderingManager::GetInstance()->InitializeViews(
           this->m_MitkDistanceImage->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS, true);
   }
   if(this->m_SurfaceNode.IsNotNull())
   {
     QHash<QString, QmitkRenderWindow*> renderWindowHashMap = this->GetRenderWindowPart()->GetQmitkRenderWindows();
     QHashIterator<QString, QmitkRenderWindow*> i(renderWindowHashMap);
     while (i.hasNext()){
       i.next();
       this->m_SurfaceNode->SetVisibility( false, mitk::BaseRenderer::GetInstance(i.value()->GetRenderWindow()) );
     }
     this->m_SurfaceNode->SetVisibility( true, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderWindow() ) );
   }
   //disable/enable gradient background
   this->GetRenderWindowPart()->EnableDecorations(!useToF, QStringList(QString("background")));
 
   if((this->m_RGBImageNode.IsNotNull()))
   {
     bool RGBImageHasDifferentResolution = false;
     m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("RGBImageHasDifferentResolution",RGBImageHasDifferentResolution);
     if(RGBImageHasDifferentResolution)
     {
       //update the display geometry by using the RBG image node. Only for renderwindow coronal
       mitk::RenderingManager::GetInstance()->InitializeView( GetRenderWindowPart()->GetQmitkRenderWindow("coronal")->GetRenderWindow(), this->m_RGBImageNode->GetData()->GetGeometry() );
     }
   }
 }