diff --git a/Modules/ToFHardware/Kinect/mitkKinectDeviceFactory.h b/Modules/ToFHardware/Kinect/mitkKinectDeviceFactory.h
index eeff536474..e58b73a102 100644
--- a/Modules/ToFHardware/Kinect/mitkKinectDeviceFactory.h
+++ b/Modules/ToFHardware/Kinect/mitkKinectDeviceFactory.h
@@ -1,87 +1,92 @@
 /*===================================================================
 
 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 __mitkKinectDeviceFactory_h
 #define __mitkKinectDeviceFactory_h
 
 #include "mitkKinectModuleExports.h"
 #include "mitkKinectDevice.h"
 #include "mitkAbstractToFDeviceFactory.h"
 #include <mitkCameraIntrinsics.h>
 #include <mitkCameraIntrinsicsProperty.h>
 
 namespace mitk
 {
   /**
   * \brief KinectDeviceFactory is an implementation of the factory pattern to generate Microsoft Kinect devices.
   * KinectDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface.
   * This offers users the oppertunity to generate new KinectDevices via a global instance of this factory.
   * @ingroup ToFHardware
   */
   class MITK_KINECTMODULE_EXPORT KinectDeviceFactory : public itk::LightObject, public AbstractToFDeviceFactory {
 
   public:
 
     KinectDeviceFactory()
     {
       this->m_DeviceNumber = 1;
     }
     /*!
     \brief Defining the Factorie´s Name, here for the Kinect.
     */
     std::string GetFactoryName()
     {
       return std::string("Kinect Factory");
     }
     //Interating the Device name on calling the Factory
     std::string GetCurrentDeviceName()
     {
       std::stringstream name;
       if (m_DeviceNumber>1)
       {
         name << "Kinect " << m_DeviceNumber;
       }
       else
       {
         name << "Kinect ";
       }
       m_DeviceNumber++;
       return name.str();
     }
 
   private:
 
     /*!
     \brief Create an instance of a KinectDevice.
     */
     ToFCameraDevice::Pointer createToFCameraDevice()
     {
       KinectDevice::Pointer device = KinectDevice::New();
 
       //Set default camera intrinsics for the kinect RGB camera.
       //(OpenNI warps the distance data into the RGB space).
       mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
       std::string pathToDefaulCalibrationFile(MITK_TOF_DATA_DIR);
       pathToDefaulCalibrationFile.append("/CalibrationFiles/Kinect_RGB_camera.xml");
       cameraIntrinsics->FromXMLFile(pathToDefaulCalibrationFile);
       device->SetProperty("CameraIntrinsics", mitk::CameraIntrinsicsProperty::New(cameraIntrinsics));
 
+      device->SetBoolProperty("HasRGBImage", true);
+      device->SetBoolProperty("HasAmplitudeImage", false);
+      device->SetBoolProperty("HasIntensityImage", false);
+      device->SetBoolProperty("KinectReconstructionMode", true);
+
       return device.GetPointer();
     }
     //Member variable as variable for our DeviceNumber
     int m_DeviceNumber;
   };
 }
 #endif
diff --git a/Modules/ToFHardware/MesaSR4000/mitkToFCameraMESASR4000DeviceFactory.h b/Modules/ToFHardware/MesaSR4000/mitkToFCameraMESASR4000DeviceFactory.h
index da792364d4..56796f6b6b 100644
--- a/Modules/ToFHardware/MesaSR4000/mitkToFCameraMESASR4000DeviceFactory.h
+++ b/Modules/ToFHardware/MesaSR4000/mitkToFCameraMESASR4000DeviceFactory.h
@@ -1,85 +1,89 @@
 /*===================================================================
 
 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 __mitkToFCameraMESASR4000DeviceFactory_h
 #define __mitkToFCameraMESASR4000DeviceFactory_h
 
 #include "mitkMESASR4000ModuleExports.h"
 #include "mitkToFCameraMESASR4000Device.h"
 #include "mitkAbstractToFDeviceFactory.h"
 #include <mitkCameraIntrinsics.h>
 #include <mitkCameraIntrinsicsProperty.h>
 #include <mitkToFConfig.h>
 
 namespace mitk
 {
   /**
   * \brief ToFPMDRawPlayerDeviceFactory is an implementation of the factory pattern to generate MESASR4000Devices.
   * ToFCameraMESASR4000DeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface.
   * This offers users the oppertunity to generate new Raw Player Devices via a global instance of this factory.
   * @ingroup ToFHardware
   */
 
   class MITK_MESASR4000MODULE_EXPORT ToFCameraMESASR4000DeviceFactory : public itk::LightObject, public AbstractToFDeviceFactory {
 
   public:
     ToFCameraMESASR4000DeviceFactory()
     {
       this->m_DeviceNumber = 1;
     }
     /*!
     \brief Defining the Factorie´s Name, here for the MESASR4000DeviceFactory
     */
     std::string GetFactoryName()
     {
       return std::string("MESA SR4000 Factory");
     }
     std::string GetCurrentDeviceName()
     {
       std::stringstream name;
       if(m_DeviceNumber>1)
       {
         name << "MESA SR4000 "<< m_DeviceNumber;
       }
       else
       {
         name << "MESA SR4000";
       }
       m_DeviceNumber++;
       return name.str();
     }
 
   private:
     /*!
     \brief Create an instance of a ToFPMDRawDataDevice.
     */
     ToFCameraDevice::Pointer createToFCameraDevice()
     {
       ToFCameraMESASR4000Device::Pointer device = ToFCameraMESASR4000Device::New();
 
       //Set default camera intrinsics for the Mesa-SR4000-camera.
       mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
       std::string pathToDefaulCalibrationFile(MITK_TOF_DATA_DIR);
 
       pathToDefaulCalibrationFile.append("/CalibrationFiles/Mesa-SR4000_Camera.xml");
       cameraIntrinsics->FromXMLFile(pathToDefaulCalibrationFile);
       device->SetProperty("CameraIntrinsics", mitk::CameraIntrinsicsProperty::New(cameraIntrinsics));
 
+      device->SetBoolProperty("HasRGBImage", false);
+      device->SetBoolProperty("HasAmplitudeImage", true);
+      device->SetBoolProperty("HasIntensityImage", true);
+
       return device.GetPointer();
     }
     int m_DeviceNumber;
   };
 }
 #endif
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDCamCubeDeviceFactory.h b/Modules/ToFHardware/PMD/mitkToFCameraPMDCamCubeDeviceFactory.h
index 9c9c9c35c6..4d2e129ce1 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDCamCubeDeviceFactory.h
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDCamCubeDeviceFactory.h
@@ -1,87 +1,90 @@
 /*===================================================================
 
 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 __mitkToFCameraPMDCamCubeDeviceFactory_h
 #define __mitkToFCameraPMDCamCubeDeviceFactory_h
 
 #include "mitkPMDModuleExports.h"
 #include "mitkToFCameraPMDCamCubeDevice.h"
 #include "mitkAbstractToFDeviceFactory.h"
 #include <mitkCameraIntrinsics.h>
 #include <mitkCameraIntrinsicsProperty.h>
 #include <mitkToFConfig.h>
 
 namespace mitk
 {
   /**
   * \brief ToFPMDCamBoardDeviceFactory is an implementation of the factory pattern to generate Cam Cube Devices.
   * ToFPMDCamCubeDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface.
   * This offers users the oppertunity to generate new Cam Cube Devices via a global instance of this factory.
   * @ingroup ToFHardware
   */
 
 class MITK_PMDMODULE_EXPORT ToFCameraPMDCamCubeDeviceFactory : public itk::LightObject, public AbstractToFDeviceFactory {
 
 public:
   ToFCameraPMDCamCubeDeviceFactory()
   {
     this->m_DeviceNumber=1;
   }
    /*!
    \brief Defining the Factorie´s Name, here for the ToFPMDCamCube.
    */
    std::string GetFactoryName()
    {
        return std::string("PMD Camcube 2.0/3.0 Factory ");
    }
 
    std::string GetCurrentDeviceName()
    {
      std::stringstream name;
      if(m_DeviceNumber>1)
      {
        name << "PMD CamCube 2.0/3.0 "<< m_DeviceNumber;
      }
      else
      {
        name << "PMD CamCube 2.0/3.0 ";
      }
      m_DeviceNumber++;
      return name.str();
    }
 
 private:
      /*!
    \brief Create an instance of a ToFPMDCamCubeDevice.
    */
    ToFCameraDevice::Pointer createToFCameraDevice()
    {
      ToFCameraPMDCamCubeDevice::Pointer device = ToFCameraPMDCamCubeDevice::New();
 
       //Set default camera intrinsics for the CamCube Amplitude Camera.
       mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
       std::string pathToDefaulCalibrationFile(MITK_TOF_DATA_DIR);
       pathToDefaulCalibrationFile.append("/CalibrationFiles/PMDCamCube3_camera.xml");
       MITK_INFO <<pathToDefaulCalibrationFile;
       cameraIntrinsics->FromXMLFile(pathToDefaulCalibrationFile);
       device->SetProperty("CameraIntrinsics", mitk::CameraIntrinsicsProperty::New(cameraIntrinsics));
 
+      device->SetBoolProperty("HasRGBImage", false);
+      device->SetBoolProperty("HasAmplitudeImage", true);
+      device->SetBoolProperty("HasIntensityImage", true);
 
      return device.GetPointer();
    }
     int m_DeviceNumber;
 };
 }
 #endif
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDPlayerDeviceFactory.h b/Modules/ToFHardware/PMD/mitkToFCameraPMDPlayerDeviceFactory.h
index 1ec824224d..f9054dbece 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDPlayerDeviceFactory.h
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDPlayerDeviceFactory.h
@@ -1,90 +1,93 @@
 /*===================================================================
 
 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 __mitkToFCameraPMDPlayerDeviceFactory_h
 #define __mitkToFCameraPMDPlayerDeviceFactory_h
 
 #include "mitkPMDModuleExports.h"
 #include "mitkToFCameraPMDPlayerDevice.h"
 #include "mitkAbstractToFDeviceFactory.h"
 #include <mitkCameraIntrinsics.h>
 #include <mitkCameraIntrinsicsProperty.h>
 #include <mitkToFConfig.h>
 
 namespace mitk
 {
   /**
   * \brief ToFPMDPlayerDeviceFactory is an implementation of the factory pattern to generate PMD Player Devices.
   * ToFPMDPlayerDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface.
   * This offers users the oppertunity to generate new PMD Player Devices via a global instance of this factory.
   * @ingroup ToFHardware
   */
 
 class MITK_PMDMODULE_EXPORT ToFCameraPMDPlayerDeviceFactory : public itk::LightObject, public AbstractToFDeviceFactory {
 
 public:
   ToFCameraPMDPlayerDeviceFactory()
   {
     this->m_DeviceNumber=1;
   }
   /*!
    \brief Defining the Factorie´s Name, here for the ToFPMDPlayer.
    */
    std::string GetFactoryName()
    {
        return std::string("PMD Player Factory");
    }
 
    std::string GetCurrentDeviceName()
    {
      std::stringstream name;
      if(m_DeviceNumber>1)
      {
        name << "PMD Player "<< m_DeviceNumber;
      }
      else
      {
        name << "PMD Player";
      }
      m_DeviceNumber++;
      return name.str();
    }
 
 private:
      /*!
    \brief Create an instance of a ToFPMDPlayerDevice.
    */
    ToFCameraDevice::Pointer createToFCameraDevice()
    {
      ToFCameraPMDPlayerDevice::Pointer device = ToFCameraPMDPlayerDevice::New();
 
 //-------------------------If no Intrinsics are specified------------------------------
       //Set default camera intrinsics for the PMD-Player.
       mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
       std::string pathToDefaulCalibrationFile(MITK_TOF_DATA_DIR);
 
       pathToDefaulCalibrationFile.append("/CalibrationFiles/Default_Parameters.xml");
       cameraIntrinsics->FromXMLFile(pathToDefaulCalibrationFile);
       device->SetProperty("CameraIntrinsics", mitk::CameraIntrinsicsProperty::New(cameraIntrinsics));
-
 //------------------------------------------------------------------------------------------
 
+      device->SetBoolProperty("HasRGBImage", false);
+      device->SetBoolProperty("HasAmplitudeImage", true);
+      device->SetBoolProperty("HasIntensityImage", true);
+
      return device.GetPointer();
    }
 
    int m_DeviceNumber;
 };
 }
 #endif
diff --git a/Modules/ToFHardware/PMD/mitkToFCameraPMDRawDataCamCubeDeviceFactory.h b/Modules/ToFHardware/PMD/mitkToFCameraPMDRawDataCamCubeDeviceFactory.h
index f4ba0fe70b..f1b84d8004 100644
--- a/Modules/ToFHardware/PMD/mitkToFCameraPMDRawDataCamCubeDeviceFactory.h
+++ b/Modules/ToFHardware/PMD/mitkToFCameraPMDRawDataCamCubeDeviceFactory.h
@@ -1,86 +1,90 @@
 /*===================================================================
 
 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 __mitkToFCameraPMDRawDataCamCubeDeviceFactory_h
 #define __mitkToFCameraPMDRawDataCamCubeDeviceFactory_h
 
 #include "mitkPMDModuleExports.h"
 #include "mitkToFCameraPMDRawDataCamCubeDevice.h"
 #include "mitkAbstractToFDeviceFactory.h"
 #include <mitkCameraIntrinsics.h>
 #include <mitkCameraIntrinsicsProperty.h>
 #include <mitkToFConfig.h>
 
 namespace mitk
 {
 
   /**
   * \brief ToFPMDRawPlayerDeviceFactory is an implementation of the factory pattern to generate Raw Player Devices.
   * ToFPMDRawPlayerDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface.
   * This offers users the oppertunity to generate new Raw Player Devices via a global instance of this factory.
   * @ingroup ToFHardware
   */
 class MITK_PMDMODULE_EXPORT ToFCameraPMDRawDataCamCubeDeviceFactory : public itk::LightObject, public AbstractToFDeviceFactory {
 
 public:
 
   ToFCameraPMDRawDataCamCubeDeviceFactory()
   {
     this->m_DeviceNumber = 1;
   }
   /*!
    \brief Defining the Factorie´s Name, here for the RawDataDeviceFactory.
    */
    std::string GetFactoryName()
    {
        return std::string("PMD RAW Data Camcube Factory ");
    }
    std::string GetCurrentDeviceName()
    {
      std::stringstream name;
      if(m_DeviceNumber>1)
      {
        name << "PMD Raw Data CamCube 2.0/3.0 "<< m_DeviceNumber;
      }
      else
      {
        name << "PMD Raw Data CamCube 2.0/3.0";
      }
      m_DeviceNumber++;
      return name.str();
    }
 
 private:
      /*!
    \brief Create an instance of a ToFPMDRawDataDevice.
    */
    ToFCameraDevice::Pointer createToFCameraDevice()
    {
      ToFCameraPMDRawDataCamCubeDevice::Pointer device = ToFCameraPMDRawDataCamCubeDevice::New();
 
       //Set default camera intrinsics for the RawDataCamCube-Camera.
       mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
       std::string pathToDefaulCalibrationFile(MITK_TOF_DATA_DIR);
 
       pathToDefaulCalibrationFile.append("/CalibrationFiles/PMDCamCube3_camera.xml");
       cameraIntrinsics->FromXMLFile(pathToDefaulCalibrationFile);
       device->SetProperty("CameraIntrinsics", mitk::CameraIntrinsicsProperty::New(cameraIntrinsics));
 
+      device->SetBoolProperty("HasRGBImage", false);
+      device->SetBoolProperty("HasAmplitudeImage", true);
+      device->SetBoolProperty("HasIntensityImage", true);
+
      return device.GetPointer();
    }
    int m_DeviceNumber;
 };
 }
 #endif
diff --git a/Modules/ToFHardware/mitkToFCameraDevice.cpp b/Modules/ToFHardware/mitkToFCameraDevice.cpp
index f56d85b4e8..490a4bb78a 100644
--- a/Modules/ToFHardware/mitkToFCameraDevice.cpp
+++ b/Modules/ToFHardware/mitkToFCameraDevice.cpp
@@ -1,188 +1,195 @@
 /*===================================================================
 
 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 "mitkToFCameraDevice.h"
 #include <itksys/SystemTools.hxx>
 
 //Microservices
 #include <usGetModuleContext.h>
 #include "mitkModuleContext.h"
 
 namespace mitk
 {
   ToFCameraDevice::ToFCameraDevice():m_BufferSize(1),m_MaxBufferSize(100),m_CurrentPos(-1),m_FreePos(0),
     m_CaptureWidth(204),m_CaptureHeight(204),m_PixelNumber(41616),m_SourceDataSize(0),
     m_ThreadID(0),m_CameraActive(false),m_CameraConnected(false),m_ImageSequence(0)
   {
     this->m_AmplitudeArray = NULL;
     this->m_IntensityArray = NULL;
     this->m_DistanceArray = NULL;
     this->m_PropertyList = mitk::PropertyList::New();
 
+    //By default, all devices have no further images (just a distance image)
+    //If a device provides more data (e.g. RGB, Intensity, Amplitde images,
+    //the property has to be true.
+    this->m_PropertyList->SetBoolProperty("HasRGBImage", false);
+    this->m_PropertyList->SetBoolProperty("HasIntensityImage", false);
+    this->m_PropertyList->SetBoolProperty("HasAmplitudeImage", false);
+
     this->m_MultiThreader = itk::MultiThreader::New();
     this->m_ImageMutex = itk::FastMutexLock::New();
     this->m_CameraActiveMutex = itk::FastMutexLock::New();
 
     this->m_RGBImageWidth  = this->m_CaptureWidth;
     this->m_RGBImageHeight  = this->m_CaptureHeight;
     this->m_RGBPixelNumber = this->m_RGBImageWidth* this->m_RGBImageHeight;
   }
 
   ToFCameraDevice::~ToFCameraDevice()
   {
   }
 
   void ToFCameraDevice::SetBoolProperty( const char* propertyKey, bool boolValue )
   {
     SetProperty(propertyKey, mitk::BoolProperty::New(boolValue));
   }
 
   void ToFCameraDevice::SetIntProperty( const char* propertyKey, int intValue )
   {
     SetProperty(propertyKey, mitk::IntProperty::New(intValue));
   }
 
   void ToFCameraDevice::SetFloatProperty( const char* propertyKey, float floatValue )
   {
     SetProperty(propertyKey, mitk::FloatProperty::New(floatValue));
   }
 
   void ToFCameraDevice::SetStringProperty( const char* propertyKey, const char* stringValue )
   {
     SetProperty(propertyKey, mitk::StringProperty::New(stringValue));
   }
 
   void ToFCameraDevice::SetProperty( const char *propertyKey, BaseProperty* propertyValue )
   {
     this->m_PropertyList->SetProperty(propertyKey, propertyValue);
   }
 
   BaseProperty* ToFCameraDevice::GetProperty(const char *propertyKey)
   {
     return this->m_PropertyList->GetProperty(propertyKey);
   }
 
   bool ToFCameraDevice::GetBoolProperty(const char *propertyKey, bool& boolValue)
   {
     mitk::BoolProperty::Pointer boolprop = dynamic_cast<mitk::BoolProperty*>(this->GetProperty(propertyKey));
     if(boolprop.IsNull())
       return false;
 
     boolValue = boolprop->GetValue();
     return true;
   }
 
   bool ToFCameraDevice::GetStringProperty(const char *propertyKey, std::string& string)
   {
     mitk::StringProperty::Pointer stringProp = dynamic_cast<mitk::StringProperty*>(this->GetProperty(propertyKey));
     if(stringProp.IsNull())
     {
       return false;
     }
     else
     {
       string = stringProp->GetValue();
       return true;
     }
   }
   bool ToFCameraDevice::GetIntProperty(const char *propertyKey, int& integer)
   {
     mitk::IntProperty::Pointer intProp = dynamic_cast<mitk::IntProperty*>(this->GetProperty(propertyKey));
     if(intProp.IsNull())
     {
       return false;
     }
     else
     {
       integer = intProp->GetValue();
       return true;
     }
   }
 
   void ToFCameraDevice::CleanupPixelArrays()
   {
     if (m_IntensityArray)
     {
       delete [] m_IntensityArray;
     }
     if (m_DistanceArray)
     {
       delete [] m_DistanceArray;
     }
     if (m_AmplitudeArray)
     {
       delete [] m_AmplitudeArray;
     }
   }
 
   void ToFCameraDevice::AllocatePixelArrays()
   {
     // free memory if it was already allocated
     CleanupPixelArrays();
     // allocate buffer
     this->m_IntensityArray = new float[this->m_PixelNumber];
     for(int i=0; i<this->m_PixelNumber; i++) {this->m_IntensityArray[i]=0.0;}
     this->m_DistanceArray = new float[this->m_PixelNumber];
     for(int i=0; i<this->m_PixelNumber; i++) {this->m_DistanceArray[i]=0.0;}
     this->m_AmplitudeArray = new float[this->m_PixelNumber];
     for(int i=0; i<this->m_PixelNumber; i++) {this->m_AmplitudeArray[i]=0.0;}
   }
 
   int ToFCameraDevice::GetRGBCaptureWidth()
   {
     return this->m_RGBImageWidth;
   }
 
   int ToFCameraDevice::GetRGBCaptureHeight()
   {
     return this->m_RGBImageHeight;
   }
 
   void ToFCameraDevice::StopCamera()
   {
     m_CameraActiveMutex->Lock();
     m_CameraActive = false;
     m_CameraActiveMutex->Unlock();
     itksys::SystemTools::Delay(100);
     if (m_MultiThreader.IsNotNull())
     {
       m_MultiThreader->TerminateThread(m_ThreadID);
     }
     // wait a little to make sure that the thread is terminated
     itksys::SystemTools::Delay(100);
   }
 
   bool ToFCameraDevice::IsCameraActive()
   {
     m_CameraActiveMutex->Lock();
     bool ok = m_CameraActive;
     m_CameraActiveMutex->Unlock();
     return ok;
 }
   bool ToFCameraDevice::ConnectCamera()
   {
       // Prepare connection, fail if this fails.
       if (! this->OnConnectCamera()) return false;
 
       // Get Context and Module
       mitk::ModuleContext* context = GetModuleContext();
       return true;
   }
 
   bool ToFCameraDevice::IsCameraConnected()
   {
     return m_CameraConnected;
   }
 }
diff --git a/Modules/ToFHardware/mitkToFCameraMITKPlayerDevice.cpp b/Modules/ToFHardware/mitkToFCameraMITKPlayerDevice.cpp
index 5782ec28fd..02c02a5002 100644
--- a/Modules/ToFHardware/mitkToFCameraMITKPlayerDevice.cpp
+++ b/Modules/ToFHardware/mitkToFCameraMITKPlayerDevice.cpp
@@ -1,399 +1,402 @@
 /*===================================================================
 
 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 "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->GetCaptureWidth();
       this->m_RGBImageHeight = m_Controller->GetCaptureHeight();
       this->m_PixelNumber = this->m_CaptureWidth * this->m_CaptureHeight;
 
       AllocatePixelArrays();
       AllocateDataBuffers();
 
       m_CameraConnected = true;
     }
     return ok;
   }
 
   bool ToFCameraMITKPlayerDevice::DisconnectCamera()
   {
     bool ok =  m_Controller->CloseCameraConnection();
     if (ok)
     {
       m_CameraConnected = false;
     }
     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();
         /*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
          TODO Buffer Handling currently only works for buffer size 1
          !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
         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)
         {
           // buffer overflow
           //MITK_INFO << "Buffer overflow!! ";
           //toFCameraDevice->m_CurrentPos = (toFCameraDevice->m_CurrentPos+1) % toFCameraDevice->m_BufferSize;
           //toFCameraDevice->m_ImageSequence++;
           overflow = true;
         }
         if (toFCameraDevice->m_ImageSequence % n == 0)
         {
           printStatus = true;
         }
         toFCameraDevice->m_ImageMutex->Unlock();
         if (overflow)
         {
           //itksys::SystemTools::Delay(10);
           overflow = false;
         }
         /*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
          END TODO Buffer Handling currently only works for buffer size 1
          !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
 
         // 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;
   }
 
 //    TODO: Buffer size currently set to 1. Once Buffer handling is working correctly, method may be reactivated
 //  void ToFCameraMITKPlayerDevice::ResetBuffer(int bufferSize)
 //  {
 //    this->m_BufferSize = bufferSize;
 //    this->m_CurrentPos = -1;
 //    this->m_FreePos = 0;
 //  }
 
   void ToFCameraMITKPlayerDevice::GetAmplitudes(float* amplitudeArray, int& imageSequence)
   {
     m_ImageMutex->Lock();
     /*!!!!!!!!!!!!!!!!!!!!!!
       TODO Buffer handling???
     !!!!!!!!!!!!!!!!!!!!!!!!*/
     // 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();
     /*!!!!!!!!!!!!!!!!!!!!!!
       TODO Buffer handling???
     !!!!!!!!!!!!!!!!!!!!!!!!*/
     // 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();
     /*!!!!!!!!!!!!!!!!!!!!!!
       TODO Buffer handling???
     !!!!!!!!!!!!!!!!!!!!!!!!*/
     // 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();
     /*!!!!!!!!!!!!!!!!!!!!!!
       TODO Buffer handling???
     !!!!!!!!!!!!!!!!!!!!!!!!*/
     // write intensity image data to unsigned char array
     for (int i=0; i<this->m_PixelNumber*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)
   {
     /*!!!!!!!!!!!!!!!!!!!!!!
       TODO Document this method!
     !!!!!!!!!!!!!!!!!!!!!!!!*/
     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
       for (int i=0; i<this->m_PixelNumber; i++)
       {
         distanceArray[i] = this->m_DistanceDataBuffer[pos][i];
         amplitudeArray[i] = this->m_AmplitudeDataBuffer[pos][i];
         intensityArray[i] = this->m_IntensityDataBuffer[pos][i];
         if (rgbDataArray)
         {
           rgbDataArray[i] = this->m_RGBDataBuffer[pos][i];
         }
       }
       if (rgbDataArray)
       {
         for (int j=this->m_PixelNumber; j<this->m_PixelNumber*3; j++)
         {
           rgbDataArray[j] = this->m_RGBDataBuffer[pos][j];
         }
       }
     }
     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)
     {
+      this->m_PropertyList->SetBoolProperty("HasAmplitudeImage", true);
       myController->SetAmplitudeImageFileName(strValue);
     }
     else if (strcmp(propertyKey, "IntensityImageFileName") == 0)
     {
+      this->m_PropertyList->SetBoolProperty("HasIntensityImage", true);
       myController->SetIntensityImageFileName(strValue);
     }
     else if (strcmp(propertyKey, "RGBImageFileName") == 0)
     {
+      this->m_PropertyList->SetBoolProperty("HasRGBImage", true);
       myController->SetRGBImageFileName(strValue);
     }
   }
 
   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_PixelNumber*3];
     }
   }
 }
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 3fde750bdb..9c591db1ac 100644
--- a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
+++ b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
@@ -1,618 +1,663 @@
 /*===================================================================
 
 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>
 
 //QT headers
 #include <qmessagebox.h>
 #include <qfiledialog.h>
 #include <qcombobox.h>
 
 // MITK
 #include <mitkBaseRenderer.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkToFDistanceImageToPointSetFilter.h>
 #include <mitkTransferFunction.h>
 #include <mitkTransferFunctionProperty.h>
 
 #include <mitkToFDeviceFactoryManager.h>
 #include <mitkToFCameraDevice.h>
 #include <mitkCameraIntrinsicsProperty.h>
 
 //itk headers
 #include <itksys/SystemTools.hxx>
 
 // VTK
 #include <vtkCamera.h>
 
 // ITK
 #include <itkCommand.h>
+#include <mitkRenderingModeProperty.h>
 
 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();
     this->m_ToFSurfaceVtkMapper3D = mitk::ToFSurfaceVtkMapper3D::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_ToFConnectionWidget), SIGNAL(ToFCameraSelected(const QString)), this, SLOT(OnToFCameraSelected(const QString)) );
         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()) );
         connect( (QObject*)(m_Controls->m_SurfaceCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnSurfaceCheckboxChecked(bool)) );
         connect( (QObject*)(m_Controls->m_TextureCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnTextureCheckBoxChecked(bool)) );
         connect( (QObject*)(m_Controls->m_KinectTextureCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnKinectRGBTextureCheckBoxChecked(bool)) );
 
     }
 }
 
 //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->tofMeasurementWidget->setEnabled(false);
             m_Controls->SurfacePropertiesBox->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();
     this->m_ToFSurfaceVtkMapper3D = mitk::ToFSurfaceVtkMapper3D::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->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()
 {
     m_Controls->m_ToFRecorderWidget->OnStop();
     m_Controls->m_ToFRecorderWidget->setEnabled(false);
     m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
     m_Controls->tofMeasurementWidget->setEnabled(false);
     m_Controls->SurfacePropertiesBox->setEnabled(false);
     //clean up measurement widget
     m_Controls->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!";
     }
     // initial update of image grabber
     this->m_ToFImageGrabber->Update();
 
-        this->m_ToFCompositeFilter->SetInput(0,this->m_ToFImageGrabber->GetOutput(0));
-        this->m_ToFCompositeFilter->SetInput(1,this->m_ToFImageGrabber->GetOutput(1));
-        this->m_ToFCompositeFilter->SetInput(2,this->m_ToFImageGrabber->GetOutput(2));
+    this->m_ToFCompositeFilter->SetInput(0,this->m_ToFImageGrabber->GetOutput(0));
+    this->m_ToFCompositeFilter->SetInput(1,this->m_ToFImageGrabber->GetOutput(1));
+    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(0);
-        this->m_DistanceImageNode = ReplaceNodeData("Distance image",m_MitkDistanceImage);
+    // initial update of composite filter
+    this->m_ToFCompositeFilter->Update();
+    this->m_MitkDistanceImage = m_ToFCompositeFilter->GetOutput(0);
+    this->m_DistanceImageNode = ReplaceNodeData("Distance image",m_MitkDistanceImage);
 
-        std::string rgbFileName;
-        m_ToFImageGrabber->GetCameraDevice()->GetStringProperty("RGBImageFileName",rgbFileName);
+    std::string rgbFileName;
+    m_ToFImageGrabber->GetCameraDevice()->GetStringProperty("RGBImageFileName",rgbFileName);
 
-        if ((m_SelectedCamera.contains("Kinect"))||(rgbFileName!=""))
-        {
-            //set the reconstruction mode for kinect
-            this->m_ToFDistanceImageToSurfaceFilter->SetReconstructionMode(mitk::ToFDistanceImageToSurfaceFilter::Kinect);
-            if (rgbFileName!="" || m_ToFImageGrabber->GetBoolProperty("RGB") )
-            {
-                this->m_RGBImageNode = ReplaceNodeData("RGB image",this->m_ToFImageGrabber->GetOutput(3));
-            }
-            else if (m_ToFImageGrabber->GetBoolProperty("IR"))
-            {
-                this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
-            }
-        }
-        else
-        {
-            this->m_RGBImageNode = NULL;
-            this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
-            this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
-            this->m_MitkIntensityImage = m_ToFCompositeFilter->GetOutput(2);
-            this->m_IntensityImageNode = ReplaceNodeData("Intensity image",m_MitkIntensityImage);
-        }
-        this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
-        this->m_IntensityImageNode = ReplaceNodeData("Intensity image",m_MitkIntensityImage);
+    bool hasRGBImage = false;
+    m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("HasRGBImage",hasRGBImage);
 
-        this->m_ToFDistanceImageToSurfaceFilter->SetInput(0,m_MitkDistanceImage);
-        this->m_ToFDistanceImageToSurfaceFilter->SetInput(1,m_MitkAmplitudeImage);
-        this->m_ToFDistanceImageToSurfaceFilter->SetInput(2,m_MitkIntensityImage);
-        this->m_Surface = this->m_ToFDistanceImageToSurfaceFilter->GetOutput(0);
-        this->m_SurfaceNode = ReplaceNodeData("Surface",m_Surface);
+    bool hasIntensityImage = false;
+    m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("HasIntensityImage",hasIntensityImage);
 
-        this->UseToFVisibilitySettings(true);
+    bool hasAmplitudeImage = false;
+    m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("HasAmplitudeImage",hasAmplitudeImage);
 
-        m_Controls->m_ToFCompositeFilterWidget->UpdateFilterParameter();
-        // initialize visualization widget
-        m_Controls->m_ToFVisualisationSettingsWidget->Initialize(this->m_DistanceImageNode, this->m_AmplitudeImageNode, this->m_IntensityImageNode);
-        // set distance image to measurement widget
-        m_Controls->tofMeasurementWidget->SetDistanceImage(m_MitkDistanceImage);
+    bool KinectReconstructionMode = false;
+    m_ToFImageGrabber->GetCameraDevice()->GetBoolProperty("KinectReconstructionMode",KinectReconstructionMode);
+    if(KinectReconstructionMode)
+    {
+      //set the reconstruction mode for kinect
+      this->m_ToFDistanceImageToSurfaceFilter->SetReconstructionMode(mitk::ToFDistanceImageToSurfaceFilter::Kinect);
+    }
 
-        this->m_Frametimer->start(0);
+    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;
+    }
 
-        m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(true);
-        m_Controls->m_ToFCompositeFilterWidget->setEnabled(true);
-        m_Controls->tofMeasurementWidget->setEnabled(true);
-        m_Controls->SurfacePropertiesBox->setEnabled(true);
+    if(hasAmplitudeImage)
+    {
+      this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
+      this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
+    }
 
-        if (m_Controls->m_TextureCheckBox->isChecked())
-        {
-            OnTextureCheckBoxChecked(true);
-        }
-        if (m_Controls->m_KinectTextureCheckBox->isChecked())
-        {
-            OnKinectRGBTextureCheckBoxChecked(true);
-        }
+    if(hasIntensityImage)
+    {
+      this->m_MitkIntensityImage = m_ToFCompositeFilter->GetOutput(2);
+      this->m_IntensityImageNode = ReplaceNodeData("Intensity image",m_MitkIntensityImage);
+    }
+
+//    if ((rgbFileName!="") || hasRGBImage)
+//    {
+
+//    }
+//    else
+//    {
+
+
+//    }
+//    this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
+//    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->m_Surface = this->m_ToFDistanceImageToSurfaceFilter->GetOutput(0);
+    this->m_SurfaceNode = ReplaceNodeData("Surface",m_Surface);
+
+    this->UseToFVisibilitySettings(true);
+
+    m_Controls->m_ToFCompositeFilterWidget->UpdateFilterParameter();
+    // initialize visualization widget
+    m_Controls->m_ToFVisualisationSettingsWidget->Initialize(this->m_DistanceImageNode, this->m_AmplitudeImageNode, this->m_IntensityImageNode);
+    // set distance image to measurement widget
+    m_Controls->tofMeasurementWidget->SetDistanceImage(m_MitkDistanceImage);
+
+    this->m_Frametimer->start(0);
+
+    m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(true);
+    m_Controls->m_ToFCompositeFilterWidget->setEnabled(true);
+    m_Controls->tofMeasurementWidget->setEnabled(true);
+    m_Controls->SurfacePropertiesBox->setEnabled(true);
+
+    if (m_Controls->m_TextureCheckBox->isChecked())
+    {
+      OnTextureCheckBoxChecked(true);
     }
-    m_Controls->m_TextureCheckBox->setEnabled(true);
+    if (m_Controls->m_KinectTextureCheckBox->isChecked())
+    {
+      OnKinectRGBTextureCheckBoxChecked(true);
+    }
+  }
+  m_Controls->m_TextureCheckBox->setEnabled(true);
 }
 
 void QmitkToFUtilView::OnToFCameraStopped()
 {
     m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
     m_Controls->m_ToFCompositeFilterWidget->setEnabled(false);
     m_Controls->SurfacePropertiesBox->setEnabled(false);
 
     this->m_Frametimer->stop();
 }
 
 void QmitkToFUtilView::OnToFCameraSelected(const QString selected)
 {
     m_SelectedCamera = selected;
     if ((selected.contains("CamBoard"))||(selected.contains("O3D")))
     {
         MITK_INFO<<"Surface representation currently not available for CamBoard and O3. Intrinsic parameters missing.";
         this->m_Controls->m_SurfaceCheckBox->setEnabled(false);
         this->m_Controls->m_TextureCheckBox->setEnabled(false);
         this->m_Controls->m_KinectTextureCheckBox->setEnabled(false);
         this->m_Controls->m_SurfaceCheckBox->setChecked(false);
         this->m_Controls->m_TextureCheckBox->setChecked(false);
         this->m_Controls->m_KinectTextureCheckBox->setChecked(false);
     }
     else
     {
         this->m_Controls->m_SurfaceCheckBox->setEnabled(true);
         this->m_Controls->m_TextureCheckBox->setEnabled(true);
         this->m_Controls->m_KinectTextureCheckBox->setEnabled(true);
     }
 }
 
 void QmitkToFUtilView::OnSurfaceCheckboxChecked(bool checked)
 {
     if(checked)
     {
         //initialize the surface once
         MITK_DEBUG << "OnSurfaceCheckboxChecked true";
         this->m_SurfaceNode->SetData(this->m_Surface);
         this->m_SurfaceNode->SetMapper(mitk::BaseRenderer::Standard3D, m_ToFSurfaceVtkMapper3D);
 
         //we need to initialize (reinit) the surface, to make it fit into the renderwindow
         this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews(
                     this->m_Surface->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_3DWINDOWS, true);
 
         //the default camera position is rather unfortunate,
         //that's why we set our own position according to the surface center
         mitk::Point3D surfaceCenter= this->m_Surface->GetGeometry()->GetCenter();
         vtkCamera* camera3d = GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetRenderer()->GetVtkRenderer()->GetActiveCamera();
         //1m distance to camera should be a nice default value for most cameras
         camera3d->SetPosition(0,0,-1000);
         camera3d->SetViewUp(0,-1,0);
         camera3d->SetFocalPoint(0,0,surfaceCenter[2]);
         camera3d->SetViewAngle(40);
         camera3d->SetClippingRange(1, 10000);
     }
 }
 
 void QmitkToFUtilView::OnUpdateCamera()
 {
     //##### Code for surface #####
     if (m_Controls->m_SurfaceCheckBox->isChecked())
     {
         // update surface
         m_ToFDistanceImageToSurfaceFilter->SetTextureIndex(m_Controls->m_ToFVisualisationSettingsWidget->GetSelectedImageIndex());
 
         //if the user wants to see the texture, it has to be updated for every frame
         if(m_Controls->m_KinectTextureCheckBox->isChecked() && (m_SelectedCamera.contains("Kinect")) && (m_ToFImageGrabber->GetBoolProperty("RGB")))
         {
             //remove the vtkScalarsToColors object, if there was one.
             this->m_ToFSurfaceVtkMapper3D->SetVtkScalarsToColors(NULL);
             //set RGB-iamge as texture
             this->m_ToFSurfaceVtkMapper3D->SetTexture((this->m_ToFImageGrabber->GetOutput(3)->GetVtkImageData()));
         }
         else
         {
             //we have to delete the texture, if there was one.
             this->m_ToFSurfaceVtkMapper3D->SetTexture(NULL);
             //get the colortransferfunction from the visualization widget
             this->m_ToFSurfaceVtkMapper3D->SetVtkScalarsToColors(m_Controls->m_ToFVisualisationSettingsWidget->GetSelectedColorTransferFunction());
         }
         //update pipeline
         this->m_Surface->Update();
     }
     //##### End code for surface #####
     else
     {
         // 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::OnTextureCheckBoxChecked(bool checked)
 {
     if(m_SurfaceNode.IsNotNull())
     {
         if (checked)
         {
             this->m_SurfaceNode->SetBoolProperty("scalar visibility", true);
         }
         else
         {
             this->m_SurfaceNode->SetBoolProperty("scalar visibility", false);
         }
     }
 }
 
 void QmitkToFUtilView::OnKinectRGBTextureCheckBoxChecked(bool checked)
 {
     if((m_SelectedCamera.contains("Kinect")) && (m_ToFImageGrabber->GetBoolProperty("RGB")))
     {
         if (checked)
         {
             //define the dimensions of the texture
             this->m_ToFDistanceImageToSurfaceFilter->SetTextureImageWidth(this->m_ToFImageGrabber->GetOutput(3)->GetDimension(0));
             this->m_ToFDistanceImageToSurfaceFilter->SetTextureImageHeight(this->m_ToFImageGrabber->GetOutput(3)->GetDimension(1));
         }
     }
 }
 
 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)
 {
-    // set node properties
-    if (m_DistanceImageNode.IsNotNull())
+  //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())
+  {
+    if ((m_SelectedCamera.contains("Kinect"))&&(m_ToFImageGrabber->GetBoolProperty("RGB")))
     {
-        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->SetBoolProperty("use color",!useToF);
-        this->m_DistanceImageNode->GetPropertyList()->DeleteProperty("LookupTable");
+      this->m_AmplitudeImageNode->SetProperty( "visible" , mitk::BoolProperty::New( false ));
     }
-    if (m_AmplitudeImageNode.IsNotNull())
+    else
     {
-        if ((m_SelectedCamera.contains("Kinect"))&&(m_ToFImageGrabber->GetBoolProperty("RGB")))
-        {
-            this->m_AmplitudeImageNode->SetProperty( "visible" , mitk::BoolProperty::New( false ));
-        }
-        else
-        {
-            this->m_AmplitudeImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
-        }
-        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->SetBoolProperty("use color",!useToF);
-        this->m_AmplitudeImageNode->GetPropertyList()->DeleteProperty("LookupTable");
+      this->m_AmplitudeImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
     }
-    if (m_IntensityImageNode.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())
+  {
+    if (m_SelectedCamera.contains("Kinect"))
     {
-        if (m_SelectedCamera.contains("Kinect"))
-        {
-            this->m_IntensityImageNode->SetProperty( "visible" , mitk::BoolProperty::New( false ));
-        }
-        else
-        {
-            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->SetBoolProperty("use color",!useToF);
-            this->m_IntensityImageNode->GetPropertyList()->DeleteProperty("LookupTable");
-        }
+      this->m_IntensityImageNode->SetProperty( "visible" , mitk::BoolProperty::New( false ));
     }
-    if ((m_RGBImageNode.IsNotNull()))
+    else
     {
-        if ((m_SelectedCamera.contains("Kinect"))&&(m_ToFImageGrabber->GetBoolProperty("IR")))
-        {
-            this->m_RGBImageNode->SetProperty( "visible" , mitk::BoolProperty::New( false ));
-        }
-        else
-        {
-            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() ) );
-        }
+      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);
     }
-    // initialize images
-    if (m_MitkDistanceImage.IsNotNull())
+  }
+  if ((m_RGBImageNode.IsNotNull()))
+  {
+    if ((m_SelectedCamera.contains("Kinect"))&&(m_ToFImageGrabber->GetBoolProperty("IR")))
     {
-        this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews(
-                    this->m_MitkDistanceImage->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS, true);
+      this->m_RGBImageNode->SetProperty( "visible" , mitk::BoolProperty::New( false ));
     }
-    if(this->m_SurfaceNode.IsNotNull())
+    else
     {
-        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() ) );
+      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->GetTimeSlicedGeometry(), 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()->GetRenderWindow("coronal")->GetRenderWindow(), this->m_RGBImageNode->GetData()->GetGeometry() );
     }
-    //disable/enable gradient background
-    this->GetRenderWindowPart()->EnableDecorations(!useToF, QStringList(QString("background")));
+  }
 }