diff --git a/Modules/ToFHardware/mitkToFCameraMITKPlayerDevice.cpp b/Modules/ToFHardware/mitkToFCameraMITKPlayerDevice.cpp
index 5abc2b1011..bdd808012b 100644
--- a/Modules/ToFHardware/mitkToFCameraMITKPlayerDevice.cpp
+++ b/Modules/ToFHardware/mitkToFCameraMITKPlayerDevice.cpp
@@ -1,388 +1,381 @@
 /*===================================================================
 
 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 "mitkToFCameraMITKPlayerDevice.h"
 #include "mitkToFCameraMITKPlayerController.h"
 #include "mitkRealTimeClock.h"
 
 #include <iostream>
 #include <itkMultiThreader.h>
 #include <itksys/SystemTools.hxx>
 
 namespace mitk
 {
 ToFCameraMITKPlayerDevice::ToFCameraMITKPlayerDevice() :
   m_DistanceDataBuffer(NULL), m_AmplitudeDataBuffer(NULL), m_IntensityDataBuffer(NULL), m_RGBDataBuffer(NULL)
 {
   m_Controller = ToFCameraMITKPlayerController::New();
 }
 
 ToFCameraMITKPlayerDevice::~ToFCameraMITKPlayerDevice()
 {
   DisconnectCamera();
   CleanUpDataBuffers();
 }
 
 bool ToFCameraMITKPlayerDevice::OnConnectCamera()
 {
   bool ok = m_Controller->OpenCameraConnection();
   if (ok)
   {
     this->m_CaptureWidth = m_Controller->GetCaptureWidth();
     this->m_CaptureHeight = m_Controller->GetCaptureHeight();
     this->m_RGBImageWidth = m_Controller->GetRGBCaptureWidth();
     this->m_RGBImageHeight = m_Controller->GetRGBCaptureHeight();
     this->m_PixelNumber = m_Controller->GetPixelNumber();
     this->m_RGBPixelNumber = m_Controller->GetRGBPixelNumber();
 
     if(m_RGBPixelNumber != m_PixelNumber)
       this->SetBoolProperty("RGBImageHasDifferentResolution", true);
 
 
     AllocatePixelArrays();
     AllocateDataBuffers();
 
     m_CameraConnected = true;
   }
   return ok;
 }
 
 bool ToFCameraMITKPlayerDevice::DisconnectCamera()
 {
   bool ok =  m_Controller->CloseCameraConnection();
   if (ok)
   {
     m_CameraConnected = false;
-//    m_PropertyList->DeleteProperty("HasAmplitudeImage");
-//    m_PropertyList->DeleteProperty("HasIntensityImage");
-//    m_PropertyList->DeleteProperty("HasRGBImage");
-//    m_PropertyList->DeleteProperty("DistanceImageFileName");
-//    m_PropertyList->DeleteProperty("AmplitudeImageFileName");
-//    m_PropertyList->DeleteProperty("IntensityImageFileName");
-//    m_PropertyList->DeleteProperty("RGBImageFileName");
-//    m_PropertyList->DeleteProperty("RGBImageHasDifferentResolution");
+    m_PropertyList->Clear();
   }
   return ok;
 }
 
 void ToFCameraMITKPlayerDevice::StartCamera()
 {
   if (m_CameraConnected)
   {
     // get the first image
     this->m_Controller->UpdateCamera();
     this->m_ImageMutex->Lock();
     this->m_Controller->GetDistances(this->m_DistanceDataBuffer[this->m_FreePos]);
     this->m_Controller->GetAmplitudes(this->m_AmplitudeDataBuffer[this->m_FreePos]);
     this->m_Controller->GetIntensities(this->m_IntensityDataBuffer[this->m_FreePos]);
     this->m_Controller->GetRgb(this->m_RGBDataBuffer[this->m_FreePos]);
     this->m_FreePos = (this->m_FreePos+1) % this->m_BufferSize;
     this->m_CurrentPos = (this->m_CurrentPos+1) % this->m_BufferSize;
     this->m_ImageSequence++;
     this->m_ImageMutex->Unlock();
 
     this->m_CameraActiveMutex->Lock();
     this->m_CameraActive = true;
     this->m_CameraActiveMutex->Unlock();
     this->m_ThreadID = this->m_MultiThreader->SpawnThread(this->Acquire, this);
     // wait a little to make sure that the thread is started
     itksys::SystemTools::Delay(10);
   }
   else
   {
     MITK_INFO<<"Camera not connected";
   }
 }
 
 void ToFCameraMITKPlayerDevice::UpdateCamera()
 {
   m_Controller->UpdateCamera();
 }
 
 ITK_THREAD_RETURN_TYPE ToFCameraMITKPlayerDevice::Acquire(void* pInfoStruct)
 {
   /* extract this pointer from Thread Info structure */
   struct itk::MultiThreader::ThreadInfoStruct * pInfo = (struct itk::MultiThreader::ThreadInfoStruct*)pInfoStruct;
   if (pInfo == NULL)
   {
     return ITK_THREAD_RETURN_VALUE;
   }
   if (pInfo->UserData == NULL)
   {
     return ITK_THREAD_RETURN_VALUE;
   }
   ToFCameraMITKPlayerDevice* toFCameraDevice = (ToFCameraMITKPlayerDevice*)pInfo->UserData;
   if (toFCameraDevice!=NULL)
   {
     mitk::RealTimeClock::Pointer realTimeClock;
     realTimeClock = mitk::RealTimeClock::New();
     int n = 100;
     double t1, t2;
     t1 = realTimeClock->GetCurrentStamp();
     bool overflow = false;
     bool printStatus = false;
     while (toFCameraDevice->IsCameraActive())
     {
       // update the ToF camera
       toFCameraDevice->UpdateCamera();
       // get image data from controller and write it to the according buffer
       toFCameraDevice->m_Controller->GetDistances(toFCameraDevice->m_DistanceDataBuffer[toFCameraDevice->m_FreePos]);
       toFCameraDevice->m_Controller->GetAmplitudes(toFCameraDevice->m_AmplitudeDataBuffer[toFCameraDevice->m_FreePos]);
       toFCameraDevice->m_Controller->GetIntensities(toFCameraDevice->m_IntensityDataBuffer[toFCameraDevice->m_FreePos]);
       toFCameraDevice->m_Controller->GetRgb(toFCameraDevice->m_RGBDataBuffer[toFCameraDevice->m_FreePos]);
       toFCameraDevice->Modified();
       toFCameraDevice->m_ImageMutex->Lock();
       toFCameraDevice->m_FreePos = (toFCameraDevice->m_FreePos+1) % toFCameraDevice->m_BufferSize;
       toFCameraDevice->m_CurrentPos = (toFCameraDevice->m_CurrentPos+1) % toFCameraDevice->m_BufferSize;
       toFCameraDevice->m_ImageSequence++;
       if (toFCameraDevice->m_FreePos == toFCameraDevice->m_CurrentPos)
       {
         overflow = true;
       }
       if (toFCameraDevice->m_ImageSequence % n == 0)
       {
         printStatus = true;
       }
       toFCameraDevice->m_ImageMutex->Unlock();
       if (overflow)
       {
         overflow = false;
       }
       // print current framerate
       if (printStatus)
       {
         t2 = realTimeClock->GetCurrentStamp() - t1;
         MITK_INFO << " Framerate (fps): " << n / (t2/1000) << " Sequence: " << toFCameraDevice->m_ImageSequence;
         t1 = realTimeClock->GetCurrentStamp();
         printStatus = false;
       }
     }  // end of while loop
   }
   return ITK_THREAD_RETURN_VALUE;
 }
 
 void ToFCameraMITKPlayerDevice::GetAmplitudes(float* amplitudeArray, int& imageSequence)
 {
   m_ImageMutex->Lock();
   // write amplitude image data to float array
   for (int i=0; i<this->m_PixelNumber; i++)
   {
     amplitudeArray[i] = this->m_AmplitudeDataBuffer[this->m_CurrentPos][i];
   }
   imageSequence = this->m_ImageSequence;
   m_ImageMutex->Unlock();
 }
 
 void ToFCameraMITKPlayerDevice::GetIntensities(float* intensityArray, int& imageSequence)
 {
   m_ImageMutex->Lock();
   // write intensity image data to float array
   for (int i=0; i<this->m_PixelNumber; i++)
   {
     intensityArray[i] = this->m_IntensityDataBuffer[this->m_CurrentPos][i];
   }
   imageSequence = this->m_ImageSequence;
   m_ImageMutex->Unlock();
 }
 
 void ToFCameraMITKPlayerDevice::GetDistances(float* distanceArray, int& imageSequence)
 {
   m_ImageMutex->Lock();
   // write distance image data to float array
   for (int i=0; i<this->m_PixelNumber; i++)
   {
     distanceArray[i] = this->m_DistanceDataBuffer[this->m_CurrentPos][i];
   }
   imageSequence = this->m_ImageSequence;
   m_ImageMutex->Unlock();
 }
 
 void ToFCameraMITKPlayerDevice::GetRgb(unsigned char* rgbArray, int& imageSequence)
 {
   m_ImageMutex->Lock();
   // write intensity image data to unsigned char array
   for (int i=0; i<this->m_RGBPixelNumber*3; i++)
   {
     rgbArray[i] = this->m_RGBDataBuffer[this->m_CurrentPos][i];
   }
   imageSequence = this->m_ImageSequence;
   m_ImageMutex->Unlock();
 }
 
 void ToFCameraMITKPlayerDevice::GetAllImages(float* distanceArray, float* amplitudeArray, float* intensityArray, char* /*sourceDataArray*/,
                                              int requiredImageSequence, int& capturedImageSequence, unsigned char* rgbDataArray)
 {
   m_ImageMutex->Lock();
 
   //check for empty buffer
   if (this->m_ImageSequence < 0)
   {
     // buffer empty
     MITK_INFO << "Buffer empty!! ";
     capturedImageSequence = this->m_ImageSequence;
     m_ImageMutex->Unlock();
     return;
   }
   // determine position of image in buffer
   int pos = 0;
   if ((requiredImageSequence < 0) || (requiredImageSequence > this->m_ImageSequence))
   {
     capturedImageSequence = this->m_ImageSequence;
     pos = this->m_CurrentPos;
   }
   else if (requiredImageSequence <= this->m_ImageSequence - this->m_BufferSize)
   {
     capturedImageSequence = (this->m_ImageSequence - this->m_BufferSize) + 1;
     pos = (this->m_CurrentPos + 1) % this->m_BufferSize;
   }
   else // (requiredImageSequence > this->m_ImageSequence - this->m_BufferSize) && (requiredImageSequence <= this->m_ImageSequence)
   {
     capturedImageSequence = requiredImageSequence;
     pos = (this->m_CurrentPos + (10-(this->m_ImageSequence - requiredImageSequence))) % this->m_BufferSize;
   }
 
   if(this->m_DistanceDataBuffer&&this->m_AmplitudeDataBuffer&&this->m_IntensityDataBuffer&&this->m_RGBDataBuffer)
   {
     // write image data to float arrays
     memcpy(distanceArray, this->m_DistanceDataBuffer[pos], this->m_PixelNumber * sizeof(float));
     memcpy(amplitudeArray, this->m_AmplitudeDataBuffer[pos], this->m_PixelNumber * sizeof(float));
     memcpy(intensityArray, this->m_IntensityDataBuffer[pos], this->m_PixelNumber * sizeof(float));
     memcpy(rgbDataArray, this->m_RGBDataBuffer[pos], this->m_RGBPixelNumber * 3 * sizeof(unsigned char));
   }
   m_ImageMutex->Unlock();
 }
 
 void ToFCameraMITKPlayerDevice::SetInputFileName(std::string inputFileName)
 {
   this->m_InputFileName = inputFileName;
   this->m_Controller->SetInputFileName(inputFileName);
 }
 
 void ToFCameraMITKPlayerDevice::SetProperty( const char *propertyKey, BaseProperty* propertyValue )
 {
   this->m_PropertyList->SetProperty(propertyKey, propertyValue);
 
   ToFCameraMITKPlayerController::Pointer myController = dynamic_cast<mitk::ToFCameraMITKPlayerController*>(this->m_Controller.GetPointer());
 
   std::string strValue;
   GetStringProperty(propertyKey, strValue);
   if (strcmp(propertyKey, "DistanceImageFileName") == 0)
   {
     myController->SetDistanceImageFileName(strValue);
   }
   else if (strcmp(propertyKey, "AmplitudeImageFileName") == 0)
   {
     std::ifstream amplitudeImage(strValue.c_str());
     if(amplitudeImage)
     {
       this->m_PropertyList->SetBoolProperty("HasAmplitudeImage", true);
       myController->SetAmplitudeImageFileName(strValue);
     }
     else
     {
       MITK_WARN << "File " << strValue << " does not exist!";
     }
   }
   else if (strcmp(propertyKey, "IntensityImageFileName") == 0)
   {
     std::ifstream intensityImage(strValue.c_str());
     if(intensityImage)
     {
       this->m_PropertyList->SetBoolProperty("HasIntensityImage", true);
       myController->SetIntensityImageFileName(strValue);
     }
     else
     {
       MITK_WARN << "File " << strValue << " does not exist!";
     }
   }
   else if (strcmp(propertyKey, "RGBImageFileName") == 0)
   {
     std::ifstream intensityImage(strValue.c_str());
     if(intensityImage)
     {
       this->m_PropertyList->SetBoolProperty("HasRGBImage", true);
       myController->SetRGBImageFileName(strValue);
     }
     else
     {
       MITK_WARN << "File " << strValue << " does not exist!";
     }
   }
 }
 
 void ToFCameraMITKPlayerDevice::CleanUpDataBuffers()
 {
   if (m_DistanceDataBuffer)
   {
     for(int i=0; i<this->m_MaxBufferSize; i++)
     {
       delete[] this->m_DistanceDataBuffer[i];
     }
     delete[] this->m_DistanceDataBuffer;
   }
   if (m_AmplitudeDataBuffer)
   {
     for(int i=0; i<this->m_MaxBufferSize; i++)
     {
       delete[] this->m_AmplitudeDataBuffer[i];
     }
     delete[] this->m_AmplitudeDataBuffer;
   }
   if (m_IntensityDataBuffer)
   {
     for(int i=0; i<this->m_MaxBufferSize; i++)
     {
       delete[] this->m_IntensityDataBuffer[i];
     }
     delete[] this->m_IntensityDataBuffer;
   }
   if (m_RGBDataBuffer)
   {
     for(int i=0; i<this->m_MaxBufferSize; i++)
     {
       delete[] this->m_RGBDataBuffer[i];
     }
     delete[] this->m_RGBDataBuffer;
   }
 }
 
 void ToFCameraMITKPlayerDevice::AllocateDataBuffers()
 {
   // free memory if it was already allocated
   this->CleanUpDataBuffers();
   // allocate buffers
   this->m_DistanceDataBuffer = new float*[this->m_MaxBufferSize];
   for(int i=0; i<this->m_MaxBufferSize; i++)
   {
     this->m_DistanceDataBuffer[i] = new float[this->m_PixelNumber];
   }
   this->m_AmplitudeDataBuffer = new float*[this->m_MaxBufferSize];
   for(int i=0; i<this->m_MaxBufferSize; i++)
   {
     this->m_AmplitudeDataBuffer[i] = new float[this->m_PixelNumber];
   }
   this->m_IntensityDataBuffer = new float*[this->m_MaxBufferSize];
   for(int i=0; i<this->m_MaxBufferSize; i++)
   {
     this->m_IntensityDataBuffer[i] = new float[this->m_PixelNumber];
   }
   this->m_RGBDataBuffer = new unsigned char*[this->m_MaxBufferSize];
   for(int i=0; i<this->m_MaxBufferSize; i++)
   {
     this->m_RGBDataBuffer[i] = new unsigned char[this->m_RGBPixelNumber*3];
   }
 }
 }
diff --git a/Modules/ToFUI/Qmitk/QmitkToFConnectionWidget.cpp b/Modules/ToFUI/Qmitk/QmitkToFConnectionWidget.cpp
index 8942bd69a2..d382795302 100644
--- a/Modules/ToFUI/Qmitk/QmitkToFConnectionWidget.cpp
+++ b/Modules/ToFUI/Qmitk/QmitkToFConnectionWidget.cpp
@@ -1,385 +1,385 @@
 /*===================================================================
 
 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 _USE_MATH_DEFINES
 #include <QmitkToFConnectionWidget.h>
 
 //QT headers
 #include <qmessagebox.h>
 #include <qfiledialog.h>
 #include <qcombobox.h>
 
 //mitk headers
 #include "mitkToFConfig.h"
 #include "mitkCameraIntrinsics.h"
 #include "mitkCameraIntrinsicsProperty.h"
 
 //itk headers
 #include <itksys/SystemTools.hxx>
 
 //Setting the View_ID
 const std::string QmitkToFConnectionWidget::VIEW_ID = "org.mitk.views.qmitktofconnectionwidget2";
 
 //Constructor of QmitkToFConnectionWidget
 QmitkToFConnectionWidget::QmitkToFConnectionWidget(QWidget* parent, Qt::WindowFlags f): QWidget(parent, f)
 , m_Controls(NULL)
 , m_IntegrationTime(0)
 , m_ModulationFrequency(0)
 , m_SelectedCameraName("")
 {
   this->m_ToFImageGrabber = mitk::ToFImageGrabber::New();
   //Calling CreateQtPartControl
   CreateQtPartControl(this);
 }
 
 //Destructor of QmitkToFConnectionWidget
 QmitkToFConnectionWidget::~QmitkToFConnectionWidget()
 {
   //MitkServiceListWidget must not be deinizialized here. Qmitk methods destroy their children automatically before self-destruction
 }
 
 void QmitkToFConnectionWidget::CreateQtPartControl(QWidget *parent)   //Definition of CreateQtPartControll-Methode in QmitkToFConnectionWidget; Input= Pointer
 {
   if (!m_Controls) //Define if not alreaddy exists
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkToFConnectionWidgetControls2;
     m_Controls->setupUi(parent);
     //and hide them on startup
     this->HideAllParameterWidgets();
 
     // initzializing MitkServiceListWidget here
     std::string empty= "";
     m_Controls->m_DeviceList->Initialize<mitk::ToFCameraDevice>("ToFDeviceName", empty);// the empty could just be any kind of filter
 
     this->CreateConnections();
   }
 }
 //Creating the SIGNAL-SLOT-Connectuions
 void QmitkToFConnectionWidget::CreateConnections()
 {
   if ( m_Controls )
   {
     //ConnectCameraButton as a trigger for OnConnectCamera()
     connect( (QObject*)(m_Controls->m_ConnectCameraButton), SIGNAL(clicked()),(QObject*) this, SLOT(OnConnectCamera()) );
 
     //QmitkServiceListWidget::ServiceSelectionChanged as a Signal for the OnSlectCamera() slot
     connect( m_Controls->m_DeviceList, SIGNAL(ServiceSelectionChanged(us::ServiceReferenceU)), this, SLOT(OnSelectCamera()));
 
     /*Creating an other Datanode structur for Kinect is done here: As soon as a Kinect is connected, the KinectParameterWidget is enabled,
     which can be used to trigger the KinectAcqusitionModeChanged-Method, to create a working Data-Node-structure*/
     connect( m_Controls->m_KinectParameterWidget, SIGNAL(AcquisitionModeChanged()), this, SIGNAL(KinectAcquisitionModeChanged()) );
 
   }
 }
 
 mitk::ToFImageGrabber::Pointer QmitkToFConnectionWidget::GetToFImageGrabber()
 {
   return m_ToFImageGrabber;
 }
 
 //The OnSelectCamer-Method is in charge of activating the appropiate ParameterWidgets
 void QmitkToFConnectionWidget::OnSelectCamera()
 {
   //Here we are getting our decvie through the QmitkServiceListWidget-Instance m_DeviceList through the GetSelectedService-Method
   mitk::ToFCameraDevice* device = m_Controls->m_DeviceList->GetSelectedService<mitk::ToFCameraDevice>();
 
   //getting the selectedCamera through a static Method used to transform the device->GetNameOfClass
   QString selectedCamera = QString::fromStdString(device->GetNameOfClass());
 
   this->HideAllParameterWidgets();
   //reactivating the Widgets on slecting a device
   if (selectedCamera.contains("PMD")) //Check if selectedCamera string contains ".." for each device
   {
     this->m_Controls->m_PMDParameterWidget->show(); //and activate the correct widget
   }
   else if (selectedCamera.contains("MESA"))
   {
     this->m_Controls->m_MESAParameterWidget->show();
   }
   else if (selectedCamera.contains("Kinect"))
   {
     this->m_Controls->m_KinectParameterWidget->show();
   }
   m_Controls->m_ConnectCameraButton->setEnabled(true); //ConnectCameraButton gets enabled
   m_SelectedCameraName = selectedCamera;
   emit  (selectedCamera);
 }
 //This Methods hides all Widgets (later each widget is activated on its own)
 void QmitkToFConnectionWidget::HideAllParameterWidgets()
 {
   this->m_Controls->m_PMDParameterWidget->hide();
   this->m_Controls->m_MESAParameterWidget->hide();
   this->m_Controls->m_KinectParameterWidget->hide();
 }
 
 //OnConnectCamera-Method; represents one of the main parts of ToFConnectionWidget2.
 void QmitkToFConnectionWidget::OnConnectCamera()
 {
   //After connecting a device
   if (m_Controls->m_ConnectCameraButton->text()=="Connect")
   {
     //Getting the device- and the slectedCamera-variables using the ServiceListWidget as we did it in the CameraSelect-Method
     mitk::ToFCameraDevice* device = m_Controls->m_DeviceList->GetSelectedService<mitk::ToFCameraDevice>();
     if (device)
     {
       QString tmpFileName("");
       QString fileFilter("");
       QString selectedCamera = QString::fromStdString(device->GetNameOfClass());
 
       emit ToFCameraSelected(selectedCamera);
 
       //Feeding it with the Info from ServiceListWidget
       this->m_ToFImageGrabber->SetCameraDevice(device);
 
       // Calling Alex FixForKinect, if the Kinect is selected
       if (selectedCamera.contains("Kinect") )
       {
         MITK_INFO<< "Kinect is connected here";
         //If the particular property is selected, the suitable data-node will be generated
-        this->m_ToFImageGrabber->SetBoolProperty("RGB", m_Controls->m_KinectParameterWidget->IsAcquisitionModeRGB());//--------------------------------------------------------
+        this->m_ToFImageGrabber->SetBoolProperty("RGB", m_Controls->m_KinectParameterWidget->IsAcquisitionModeRGB());
         this->m_ToFImageGrabber->SetBoolProperty("IR", m_Controls->m_KinectParameterWidget->IsAcquisitionModeIR());
       }
 
       //Activation of "PlayerMode". If the selectedCamera String contains "Player", we start the Player Mode
       if (selectedCamera.contains("Player"))
       {
         //IF PMD-Player selected
         if (selectedCamera.contains("PMD"))
         {
           fileFilter.append("PMD Files (*.pmd)");   //And seting the corresponding fileFilter
         }
         else
         {
           fileFilter.append("NRRD Images (*.nrrd);;PIC Images - deprecated (*.pic)");
         }
 
         //open a QFileDialog to chose the corresponding file from the disc
         tmpFileName = QFileDialog::getOpenFileName(NULL, "Play Image From...", "", fileFilter);
 
         //If no fileName is returned by the Dialog,Button and Widget have to return to default(disconnected) + Opening a MessageBox
         if (tmpFileName.isEmpty())
         {
           m_Controls->m_ConnectCameraButton->setChecked(false);
           m_Controls->m_ConnectCameraButton->setEnabled(true);  //re-enabling the ConnectCameraButton
           m_Controls->m_DeviceList->setEnabled(true);           //Reactivating ServiceListWidget
 
           this->OnSelectCamera();       //Calling the OnSelctCamera-Method -> Hides all Widget and just activates the needed ones
           QMessageBox::information( this, "Template functionality", "Please select a valid image before starting some action.");
           return;
         }
 
         if(selectedCamera.contains("PMDPlayer"))  //If PMD-Player is selected, set ToFImageGrabberProperty correspondingly
         {
           this->m_ToFImageGrabber->SetStringProperty("PMDFileName", tmpFileName.toStdString().c_str() );
         }
         else    //Default action
         {
           std::string msg = "";
           try
           {
             //get 3 corresponding file names
             std::string dir = itksys::SystemTools::GetFilenamePath( tmpFileName.toStdString() );
             std::string baseFilename = itksys::SystemTools::GetFilenameWithoutLastExtension( tmpFileName.toStdString() );
             std::string extension = itksys::SystemTools::GetFilenameLastExtension( tmpFileName.toStdString() );
 
             //"Incorrect format"-warning while using .nrrd or .pic files
             if (extension != ".pic" && extension != ".nrrd")
             {
               msg = msg + "Invalid file format, please select a \".nrrd\"-file";
               throw std::logic_error(msg.c_str());
             }
 
             //Checking for npos. If available, check for the Amplitude-, Intensity- and RGBImage
 
             int found = baseFilename.rfind("_DistanceImage");  //Defining "found" variable+checking if baseFilname contains "_DistanceImage". If not, found == npos(0)
 
             if (found == static_cast<int>(std::string::npos))  //If found =0
             {
               found = baseFilename.rfind("_AmplitudeImage");  //If "_AmplitudeImage" is found, the found variable is 1-> the next if statment is false
             }
 
             if (found == static_cast<int>(std::string::npos))
             {
               found = baseFilename.rfind("_IntensityImage"); //found = true if baseFilename cotains "_IntesityImage"
             }
 
             if (found == static_cast<int>(std::string::npos))
             {
               found = baseFilename.rfind("_RGBImage");
             }
 
             if (found == static_cast<int>(std::string::npos)) //If none of the Nodes is found, display an error
             {
               msg = msg + "Input file name must end with \"_DistanceImage\", \"_AmplitudeImage\", \"_IntensityImage\" or \"_RGBImage\"!";
               throw std::logic_error(msg.c_str());
             }
 
             std::string baseFilenamePrefix = baseFilename.substr(0,found);//Set the baseFilenamePrefix as a substring from baseFilname
 
             //Set corresponding FileNames
             std::string distanceImageFileName = dir + "/" + baseFilenamePrefix + "_DistanceImage" + extension; //Set the name as: directory+FilenamePrefix+""+extension
             std::string amplitudeImageFileName = dir + "/" + baseFilenamePrefix + "_AmplitudeImage" + extension;
             std::string intensityImageFileName = dir + "/" + baseFilenamePrefix + "_IntensityImage" + extension;
             std::string rgbImageFileName = dir + "/" + baseFilenamePrefix + "_RGBImage" + extension;
 
 
             if (!itksys::SystemTools::FileExists(distanceImageFileName.c_str(), true))
             {
               this->m_ToFImageGrabber->SetStringProperty("DistanceImageFileName", "");
             }
             else
             {
               this->m_ToFImageGrabber->SetStringProperty("DistanceImageFileName", distanceImageFileName.c_str());
             }
             if (!itksys::SystemTools::FileExists(amplitudeImageFileName.c_str(), true))
             {
             }
             else
             {
               this->m_ToFImageGrabber->SetStringProperty("AmplitudeImageFileName", amplitudeImageFileName.c_str());
             }
             if (!itksys::SystemTools::FileExists(intensityImageFileName.c_str(), true))
             {
               this->m_ToFImageGrabber->SetStringProperty("IntensityImageFileName", "");
             }
             else
             {
               this->m_ToFImageGrabber->SetStringProperty("IntensityImageFileName", intensityImageFileName.c_str());
             }
             if (!itksys::SystemTools::FileExists(rgbImageFileName.c_str(), true))
             {
               this->m_ToFImageGrabber->SetStringProperty("RGBImageFileName", "");
             }
             else
             {
               this->m_ToFImageGrabber->SetStringProperty("RGBImageFileName", rgbImageFileName.c_str());
             }
           }
 
           catch (std::exception &e)
           {
             MITK_ERROR << e.what();
             QMessageBox::critical( this, "Error", e.what() );
             m_Controls->m_ConnectCameraButton->setChecked(false);
             m_Controls->m_ConnectCameraButton->setEnabled(true);
             m_Controls->m_DeviceList->setEnabled(true);
             this->OnSelectCamera();
             return;
           }
         }
       }
       //End "PlayerMode"
 
       //Reset the ConnectCameraButton to disconnected
       m_Controls->m_ConnectCameraButton->setText("Disconnect");
 
       //if a connection could be established
       try
       {
 
         if (this->m_ToFImageGrabber->ConnectCamera())
         {
           this->m_Controls->m_PMDParameterWidget->SetToFImageGrabber(this->m_ToFImageGrabber);
           this->m_Controls->m_MESAParameterWidget->SetToFImageGrabber(this->m_ToFImageGrabber);
           this->m_Controls->m_KinectParameterWidget->SetToFImageGrabber(this->m_ToFImageGrabber);
 
           //Activating the respective widgets
           if (selectedCamera.contains("PMD"))
           {
             this->m_Controls->m_PMDParameterWidget->ActivateAllParameters();
           }
           else if (selectedCamera.contains("MESA"))
           {
             this->m_Controls->m_MESAParameterWidget->ActivateAllParameters();
           }
           else if (selectedCamera.contains("Kinect"))
           {
             this->m_Controls->m_KinectParameterWidget->ActivateAllParameters();
           }
           else
           {
             this->HideAllParameterWidgets();
           }
           // send connect signal to the caller functionality
           emit ToFCameraConnected();
         }
         else
           //##### TODO: Remove this else part once all controllers are throwing exceptions
           //if they cannot to any device!
         {
           //Throw an error if the Connection failed and reset the Widgets <- better catch an exception!
           QMessageBox::critical( this, "Error", "Connection failed. Check if you have installed the latest driver for your system." );
           m_Controls->m_ConnectCameraButton->setChecked(false);
           m_Controls->m_ConnectCameraButton->setEnabled(true);
           m_Controls->m_ConnectCameraButton->setText("Connect");
           m_Controls->m_DeviceList->setEnabled(true);           //Reactivating ServiceListWidget
           this->OnSelectCamera();
           return;
         }
       }catch(std::exception &e)
       {
         //catch exceptions of camera which cannot connect give a better reason
         QMessageBox::critical( this, "Connection failed.", e.what() );
         m_Controls->m_ConnectCameraButton->setChecked(false);
         m_Controls->m_ConnectCameraButton->setEnabled(true);
         m_Controls->m_ConnectCameraButton->setText("Connect");
         m_Controls->m_DeviceList->setEnabled(true);           //Reactivating ServiceListWidget
         this->OnSelectCamera();
         return;
       }
       m_Controls->m_ConnectCameraButton->setEnabled(true);
 
       // ask wether camera parameters (intrinsics, ...) should be loaded
       if (QMessageBox::question(this,"Camera parameters","Do you want to specify your own camera intrinsics?",QMessageBox::Yes,QMessageBox::No)==QMessageBox::Yes)
       {
         try {
           QString fileName = QFileDialog::getOpenFileName(this,"Open camera intrinsics","/","*.xml");
           mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
           cameraIntrinsics->FromXMLFile(fileName.toStdString());
           this->m_ToFImageGrabber->SetProperty("CameraIntrinsics",mitk::CameraIntrinsicsProperty::New(cameraIntrinsics));
         } catch ( std::exception &e ) {
           MITK_WARN << "Error loading camera intrinsics: " << e.what();
         }
       }
       ////Reset the status of some GUI-Elements
       m_Controls->m_DeviceList->setEnabled(false);          //Deactivating the Instance of QmitkServiceListWidget
       //repaint the widget
       this->repaint();
     }
     else
     {
       QMessageBox::information(this,"Camera connection","No camera selected, please select a range camera");
       m_Controls->m_ConnectCameraButton->setChecked(false);
     }
   }
   else if (m_Controls->m_ConnectCameraButton->text()=="Disconnect")
   {
     this->m_ToFImageGrabber->StopCamera();
     this->m_ToFImageGrabber->DisconnectCamera();
     m_Controls->m_ConnectCameraButton->setText("Connect");
     m_Controls->m_DeviceList->setEnabled(true);           //Reactivating ServiceListWidget
     this->OnSelectCamera();
 
     // send disconnect signal to the caller functionality
     emit ToFCameraDisconnected();
   }
 }
 
 void QmitkToFConnectionWidget::ConnectCamera()
 {
   this->m_Controls->m_ConnectCameraButton->animateClick();
 }
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 f838453790..722356ab9a 100644
--- a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
+++ b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
@@ -1,515 +1,525 @@
 /*===================================================================
 
 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"
 #include <QmitkStdMultiWidget.h>
 #include <QmitkTextOverlay.h>
 
 // Qt
 #include <QMessageBox>
 #include <QString>
 #include <qmessagebox.h>
 #include <qfiledialog.h>
 #include <qcombobox.h>
 
 // MITK
 #include <mitkBaseRenderer.h>
 #include <mitkGlobalInteraction.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(NULL), m_MultiWidget( NULL )
   , m_MitkDistanceImage(NULL), m_MitkAmplitudeImage(NULL), m_MitkIntensityImage(NULL), m_Surface(NULL)
   , m_DistanceImageNode(NULL), m_AmplitudeImageNode(NULL), m_IntensityImageNode(NULL), m_RGBImageNode(NULL), m_SurfaceNode(NULL)
   , m_ToFImageRecorder(NULL), m_ToFImageGrabber(NULL), m_ToFDistanceImageToSurfaceFilter(NULL), m_ToFCompositeFilter(NULL)
   , m_2DDisplayCount(0)
   , m_RealTimeClock(NULL)
   , m_StepsForFramerate(100)
   , m_2DTimeBefore(0.0)
   , m_2DTimeAfter(0.0)
   , m_CameraIntrinsics(NULL)
 {
   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 StdMultiWidget 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();
 
     this->GetRenderWindowPart()->GetRenderingManager()->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());
   }
 
   // initialize measurement widget
   m_Controls->m_ToFMeasurementWidget->InitializeWidget(this->GetRenderWindowPart()->GetQmitkRenderWindows(),this->GetDataStorage(), this->m_ToFDistanceImageToSurfaceFilter->GetCameraIntrinsics());
 
   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 StdMultiWidget 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
     this->GetRenderWindowPart()->GetRenderingManager()->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 = NULL;
       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 = NULL;
     }
 
     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", NULL);
     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(0);
 
     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();
 
   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->SetData(data);
     node->SetName(nodeName);
     node->SetBoolProperty("binary",false);
     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())
   {
     this->GetRenderWindowPart()->GetRenderingManager()->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() );
     }
   }
 }