diff --git a/Modules/ToFHardware/mitkToFCameraMITKPlayerDevice.cpp b/Modules/ToFHardware/mitkToFCameraMITKPlayerDevice.cpp
index 0f101bd693..de90ffeabc 100644
--- a/Modules/ToFHardware/mitkToFCameraMITKPlayerDevice.cpp
+++ b/Modules/ToFHardware/mitkToFCameraMITKPlayerDevice.cpp
@@ -1,394 +1,396 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
-Copyright (c) German Cancer Research Center, 
+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 
+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() : 
+  ToFCameraMITKPlayerDevice::ToFCameraMITKPlayerDevice() :
     m_DistanceDataBuffer(NULL), m_AmplitudeDataBuffer(NULL), m_IntensityDataBuffer(NULL), m_RGBDataBuffer(NULL)
   {
     m_Controller = ToFCameraMITKPlayerController::New();
   }
 
   ToFCameraMITKPlayerDevice::~ToFCameraMITKPlayerDevice()
   {
     DisconnectCamera();
     CleanUpDataBuffers();
   }
 
   bool ToFCameraMITKPlayerDevice::ConnectCamera()
   {
     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)
     {
       myController->SetAmplitudeImageFileName(strValue);
     }
     else if (strcmp(propertyKey, "IntensityImageFileName") == 0)
     {
       myController->SetIntensityImageFileName(strValue);
     }
     else if (strcmp(propertyKey, "RGBImageFileName") == 0)
     {
       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/Modules/ToFHardware/mitkToFImageGrabber.cpp b/Modules/ToFHardware/mitkToFImageGrabber.cpp
index 67f7681fe5..75933feec4 100644
--- a/Modules/ToFHardware/mitkToFImageGrabber.cpp
+++ b/Modules/ToFHardware/mitkToFImageGrabber.cpp
@@ -1,335 +1,336 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
-Copyright (c) German Cancer Research Center, 
+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 
+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 "mitkToFImageGrabber.h"
 #include "mitkToFCameraPMDCamCubeDevice.h"
 
 #include "itkCommand.h"
 
 
 namespace mitk
 {
   ToFImageGrabber::ToFImageGrabber():m_CaptureWidth(204),m_CaptureHeight(204),m_PixelNumber(41616),
     m_ImageSequence(0), m_RGBImageWidth(0), m_RGBImageHeight(0), m_RGBPixelNumber(0),
     m_IntensityArray(NULL), m_DistanceArray(NULL), m_AmplitudeArray(NULL), m_SourceDataArray(NULL), m_RgbDataArray(NULL)
   {
     // Create the output. We use static_cast<> here because we know the default
     // output must be of type TOutputImage
-    OutputImageType::Pointer output0 = static_cast<OutputImageType*>(this->MakeOutput(0).GetPointer()); 
-    OutputImageType::Pointer output1 = static_cast<OutputImageType*>(this->MakeOutput(1).GetPointer()); 
-    OutputImageType::Pointer output2 = static_cast<OutputImageType*>(this->MakeOutput(2).GetPointer()); 
-    OutputImageType::Pointer output3 = static_cast<OutputImageType*>(this->MakeOutput(3).GetPointer()); 
+    OutputImageType::Pointer output0 = static_cast<OutputImageType*>(this->MakeOutput(0).GetPointer());
+    OutputImageType::Pointer output1 = static_cast<OutputImageType*>(this->MakeOutput(1).GetPointer());
+    OutputImageType::Pointer output2 = static_cast<OutputImageType*>(this->MakeOutput(2).GetPointer());
+    OutputImageType::Pointer output3 = static_cast<OutputImageType*>(this->MakeOutput(3).GetPointer());
     mitk::ImageSource::SetNumberOfRequiredOutputs(3);
     mitk::ImageSource::SetNthOutput(0, output0.GetPointer());
     mitk::ImageSource::SetNthOutput(1, output1.GetPointer());
     mitk::ImageSource::SetNthOutput(2, output2.GetPointer());
     mitk::ImageSource::SetNthOutput(3, output3.GetPointer());
   }
 
   ToFImageGrabber::~ToFImageGrabber()
   {
     if (m_IntensityArray||m_AmplitudeArray||m_DistanceArray||m_RgbDataArray)
     {
       if (m_ToFCameraDevice)
       {
         m_ToFCameraDevice->RemoveObserver(m_DeviceObserverTag);
       }
       this->DisconnectCamera();
       this->CleanUpImageArrays();
     }
   }
 
   mitk::ImageSource::DataObjectPointer mitk::ImageSource::MakeOutput(unsigned int)
   {
     return static_cast<itk::DataObject*>(OutputImageType::New().GetPointer());
   }
 
   void ToFImageGrabber::GenerateData()
   {
     int requiredImageSequence = 0;
     int capturedImageSequence = 0;
     unsigned int dimensions[3];
     dimensions[0] = this->m_ToFCameraDevice->GetCaptureWidth();
     dimensions[1] = this->m_ToFCameraDevice->GetCaptureHeight();
     dimensions[2] = 1;
     mitk::PixelType FloatType = MakeScalarPixelType<float>();
     // acquire new image data
-    this->m_ToFCameraDevice->GetAllImages(this->m_DistanceArray, this->m_AmplitudeArray, this->m_IntensityArray, this->m_SourceDataArray, 
+    this->m_ToFCameraDevice->GetAllImages(this->m_DistanceArray, this->m_AmplitudeArray, this->m_IntensityArray, this->m_SourceDataArray,
       requiredImageSequence, this->m_ImageSequence, this->m_RgbDataArray );
 
     mitk::Image::Pointer distanceImage = this->GetOutput(0);
     if (!distanceImage->IsInitialized())
     {
       distanceImage->ReleaseData();
       distanceImage->Initialize(FloatType, 3, dimensions, 1);
     }
     mitk::Image::Pointer amplitudeImage = this->GetOutput(1);
     if (!amplitudeImage->IsInitialized())
     {
       amplitudeImage->ReleaseData();
       amplitudeImage->Initialize(FloatType, 3, dimensions, 1);
     }
     mitk::Image::Pointer intensityImage = this->GetOutput(2);
     if (!intensityImage->IsInitialized())
     {
       intensityImage->ReleaseData();
       intensityImage->Initialize(FloatType, 3, dimensions, 1);
     }
 
     unsigned int rgbDimension[3];
     rgbDimension[0] = this->GetRGBImageWidth();
     rgbDimension[1] = this->GetRGBImageHeight();
     rgbDimension[2] = 1 ;
     mitk::Image::Pointer rgbImage = this->GetOutput(3);
     if (!rgbImage->IsInitialized())
     {
       rgbImage->ReleaseData();
       rgbImage->Initialize(mitk::PixelType(MakePixelType<unsigned char, itk::RGBPixel<unsigned char>, 3>()), 3, rgbDimension,1);
     }
 
     capturedImageSequence = this->m_ImageSequence;
     if (m_DistanceArray)
     {
       distanceImage->SetSlice(this->m_DistanceArray, 0, 0, 0);
     }
     if (m_AmplitudeArray)
     {
       amplitudeImage->SetSlice(this->m_AmplitudeArray, 0, 0, 0);
     }
     if (m_IntensityArray)
     {
       intensityImage->SetSlice(this->m_IntensityArray, 0, 0, 0);
     }
     if (m_RgbDataArray)
     {
       rgbImage->SetSlice(this->m_RgbDataArray, 0, 0, 0);
     }
   }
 
   bool ToFImageGrabber::ConnectCamera()
   {
     bool ok = m_ToFCameraDevice->ConnectCamera();
     if (ok)
     {
       this->m_CaptureWidth = this->m_ToFCameraDevice->GetCaptureWidth();
       this->m_CaptureHeight = this->m_ToFCameraDevice->GetCaptureHeight();
       this->m_PixelNumber = this->m_CaptureWidth * this->m_CaptureHeight;
 
       this->m_RGBImageWidth = this->m_ToFCameraDevice->GetRGBCaptureWidth();
       this->m_RGBImageHeight = this->m_ToFCameraDevice->GetRGBCaptureHeight();
       this->m_RGBPixelNumber = this->m_RGBImageWidth * this->m_RGBImageHeight;
 
       this->m_SourceDataSize = m_ToFCameraDevice->GetSourceDataSize();
       this->AllocateImageArrays();
     }
     return ok;
   }
 
   bool ToFImageGrabber::DisconnectCamera()
   {
     bool success = m_ToFCameraDevice->DisconnectCamera();
 
     return success;
   }
 
   void ToFImageGrabber::StartCamera()
   {
     m_ToFCameraDevice->StartCamera();
   }
 
   void ToFImageGrabber::StopCamera()
   {
     m_ToFCameraDevice->StopCamera();
   }
 
   bool ToFImageGrabber::IsCameraActive()
   {
     return m_ToFCameraDevice->IsCameraActive();
   }
 
   void ToFImageGrabber::SetCameraDevice(ToFCameraDevice* aToFCameraDevice)
   {
     m_ToFCameraDevice = aToFCameraDevice;
     itk::SimpleMemberCommand<ToFImageGrabber>::Pointer modifiedCommand = itk::SimpleMemberCommand<ToFImageGrabber>::New();
     modifiedCommand->SetCallbackFunction(this, &ToFImageGrabber::OnToFCameraDeviceModified);
     m_DeviceObserverTag = m_ToFCameraDevice->AddObserver(itk::ModifiedEvent(), modifiedCommand);
     this->Modified();
   }
 
   ToFCameraDevice* ToFImageGrabber::GetCameraDevice()
   {
     return m_ToFCameraDevice;
   }
 
   int ToFImageGrabber::GetCaptureWidth()
   {
     return m_CaptureWidth;
   }
 
   int ToFImageGrabber::GetCaptureHeight()
   {
     return m_CaptureHeight;
   }
 
   int ToFImageGrabber::GetPixelNumber()
   {
     return m_PixelNumber;
   }
 
   int ToFImageGrabber::GetRGBImageWidth()
   {
     return m_RGBImageWidth;
   }
 
   int ToFImageGrabber::GetRGBImageHeight()
   {
     return m_RGBImageHeight;
   }
 
   int ToFImageGrabber::GetRGBPixelNumber()
   {
     return m_RGBPixelNumber;
   }
 
   int ToFImageGrabber::SetModulationFrequency(int modulationFrequency)
   {
     this->m_ToFCameraDevice->SetProperty("ModulationFrequency",mitk::IntProperty::New(modulationFrequency));
     this->Modified();
     modulationFrequency = this->GetModulationFrequency(); // return the new valid modulation frequency from the camera
     return modulationFrequency;
   }
 
   int ToFImageGrabber::SetIntegrationTime(int integrationTime)
   {
     this->m_ToFCameraDevice->SetProperty("IntegrationTime",mitk::IntProperty::New(integrationTime));
     this->Modified();
     integrationTime = this->GetIntegrationTime(); // return the new valid integration time from the camera
     return integrationTime;
   }
 
   int ToFImageGrabber::GetIntegrationTime()
   {
     int integrationTime = 0;
     this->m_ToFCameraDevice->GetIntProperty("IntegrationTime",integrationTime);
     return integrationTime;
   }
 
   int ToFImageGrabber::GetModulationFrequency()
   {
     int modulationFrequency = 0;
     this->m_ToFCameraDevice->GetIntProperty("ModulationFrequency",modulationFrequency);
     return modulationFrequency;
   }
   void ToFImageGrabber::SetBoolProperty( const char* propertyKey, bool boolValue )
   {
     SetProperty(propertyKey, mitk::BoolProperty::New(boolValue));
   }
 
   void ToFImageGrabber::SetIntProperty( const char* propertyKey, int intValue )
   {
     SetProperty(propertyKey, mitk::IntProperty::New(intValue));
   }
 
   void ToFImageGrabber::SetFloatProperty( const char* propertyKey, float floatValue )
   {
     SetProperty(propertyKey, mitk::FloatProperty::New(floatValue));
   }
 
   void ToFImageGrabber::SetStringProperty( const char* propertyKey, const char* stringValue )
   {
     SetProperty(propertyKey, mitk::StringProperty::New(stringValue));
   }
 
   void ToFImageGrabber::SetProperty( const char *propertyKey, BaseProperty* propertyValue )
   {
     this->m_ToFCameraDevice->SetProperty(propertyKey, propertyValue);
   }
 
   bool ToFImageGrabber::GetBoolProperty( const char* propertyKey)
   {
     mitk::BoolProperty::Pointer boolProp = dynamic_cast<mitk::BoolProperty*>(GetProperty(propertyKey));
+    if(!boolProp) return false;
     return boolProp->GetValue();
   }
 
   int ToFImageGrabber::GetIntProperty( const char* propertyKey)
   {
     mitk::IntProperty::Pointer intProp = dynamic_cast<mitk::IntProperty*>(GetProperty(propertyKey));
     return intProp->GetValue();
   }
 
   float ToFImageGrabber::GetFloatProperty( const char* propertyKey)
   {
     mitk::FloatProperty::Pointer floatProp = dynamic_cast<mitk::FloatProperty*>(GetProperty(propertyKey));
     return floatProp->GetValue();
   }
 
   const char* ToFImageGrabber::GetStringProperty( const char* propertyKey)
   {
     mitk::StringProperty::Pointer stringProp = dynamic_cast<mitk::StringProperty*>(GetProperty(propertyKey));
     return stringProp->GetValue();
   }
 
   BaseProperty* ToFImageGrabber::GetProperty( const char *propertyKey)
   {
     return this->m_ToFCameraDevice->GetProperty(propertyKey);
   }
 
   void ToFImageGrabber::OnToFCameraDeviceModified()
   {
     this->Modified();
   }
 
   void ToFImageGrabber::CleanUpImageArrays()
   {
     // free buffer
     if (m_IntensityArray)
     {
       delete [] m_IntensityArray;
       m_IntensityArray = NULL;
     }
     if (m_DistanceArray)
     {
       delete [] m_DistanceArray;
       m_DistanceArray = NULL;
     }
     if (m_AmplitudeArray)
     {
       delete [] m_AmplitudeArray;
       m_AmplitudeArray = NULL;
     }
     if (m_SourceDataArray)
     {
       delete [] m_SourceDataArray;
       m_SourceDataArray = NULL;
     }
     if (m_RgbDataArray)
     {
       delete [] m_RgbDataArray;
       m_RgbDataArray = NULL;
     }
   }
 
   void ToFImageGrabber::AllocateImageArrays()
   {
     // cleanup memory if necessary
     this->CleanUpImageArrays();
     // allocate buffer
     m_IntensityArray = new float[m_PixelNumber];
     m_DistanceArray = new float[m_PixelNumber];
     m_AmplitudeArray = new float[m_PixelNumber];
     m_SourceDataArray = new char[m_SourceDataSize];
     m_RgbDataArray = new unsigned char[m_RGBPixelNumber*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 d4dee45a2d..df05d5fdb3 100644
--- a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
+++ b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
@@ -1,660 +1,660 @@
 /*===================================================================
 
 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>
 
 // MITK
 #include <mitkBaseRenderer.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkToFDistanceImageToPointSetFilter.h>
 #include <mitkTransferFunction.h>
 #include <mitkTransferFunctionProperty.h>
 
 // VTK
 #include <vtkCamera.h>
 
 // ITK
 #include <itkCommand.h>
 
 const std::string QmitkToFUtilView::VIEW_ID = "org.mitk.views.tofutil";
 
 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_SurfaceDisplayCount(0), m_2DDisplayCount(0)
 , m_RealTimeClock(NULL)
 , m_StepsForFramerate(100)
 , m_2DTimeBefore(0.0)
 , m_2DTimeAfter(0.0)
 , m_VideoEnabled(false)
 {
   this->m_Frametimer = new QTimer(this);
 
   this->m_ToFDistanceImageToSurfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
   this->m_ToFCompositeFilter = mitk::ToFCompositeFilter::New();
   this->m_ToFImageRecorder = mitk::ToFImageRecorder::New();
   this->m_ToFSurfaceVtkMapper3D = mitk::ToFSurfaceVtkMapper3D::New();
 }
 
 QmitkToFUtilView::~QmitkToFUtilView()
 {
         OnToFCameraStopped();
         OnToFCameraDisconnected();
 }
 
 void QmitkToFUtilView::SetFocus()
 {
   m_Controls->m_ToFConnectionWidget->setFocus();
 }
 
 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 );
 
     connect(m_Frametimer, SIGNAL(timeout()), this, SLOT(OnUpdateCamera()));
     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_ToFConnectionWidget), SIGNAL(KinectAcquisitionModeChanged()), this, SLOT(OnKinectAcquisitionModeChanged()) );
     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_TextureCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnTextureCheckBoxChecked(bool)) );
     connect( (QObject*)(m_Controls->m_VideoTextureCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnVideoTextureCheckBoxChecked(bool)) );
   }
 }
 
 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()->GetRenderWindow("axial")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     GetRenderWindowPart()->GetRenderWindow("axial")->GetSliceNavigationController()->SliceLockedOn();
     GetRenderWindowPart()->GetRenderWindow("sagittal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     GetRenderWindowPart()->GetRenderWindow("sagittal")->GetSliceNavigationController()->SliceLockedOn();
     GetRenderWindowPart()->GetRenderWindow("coronal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     GetRenderWindowPart()->GetRenderWindow("coronal")->GetSliceNavigationController()->SliceLockedOn();
 
     this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews();
 
     this->UseToFVisibilitySettings(true);
 
     m_Controls->m_ToFCompositeFilterWidget->SetToFCompositeFilter(this->m_ToFCompositeFilter);
     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);
     }
   }
 }
 
 void QmitkToFUtilView::ActivatedZombieView(berry::IWorkbenchPartReference::Pointer /*zombieView*/)
 {
   ResetGUIToDefault();
 }
 
 void QmitkToFUtilView::Deactivated()
 {
 
 }
 
 void QmitkToFUtilView::Visible()
 {
 }
 
 void QmitkToFUtilView::Hidden()
 {
 
     ResetGUIToDefault();
 }
 
 void QmitkToFUtilView::OnToFCameraConnected()
 {
   this->m_SurfaceDisplayCount = 0;
   this->m_2DDisplayCount = 0;
 
   this->m_ToFDistanceImageToSurfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
   this->m_ToFCompositeFilter = mitk::ToFCompositeFilter::New();
   this->m_ToFImageRecorder = mitk::ToFImageRecorder::New();
   this->m_ToFSurfaceVtkMapper3D = mitk::ToFSurfaceVtkMapper3D::New();
 
   this->m_ToFImageGrabber = m_Controls->m_ToFConnectionWidget->GetToFImageGrabber();
 
   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();
 
   // initialize measurement widget
   m_Controls->tofMeasurementWidget->InitializeWidget(this->GetRenderWindowPart()->GetQmitkRenderWindows(),this->GetDataStorage());
 
   //TODO
   this->m_RealTimeClock = mitk::RealTimeClock::New();
   this->m_2DTimeBefore = this->m_RealTimeClock->GetCurrentStamp();
-
+/*
   try
   {
     this->m_VideoSource = mitk::OpenCVVideoSource::New();
 
     this->m_VideoSource->SetVideoCameraInput(0, false);
     this->m_VideoSource->StartCapturing();
     if(!this->m_VideoSource->IsCapturingEnabled())
     {
       MITK_INFO << "unable to initialize video grabbing/playback";
       this->m_VideoEnabled = false;
       m_Controls->m_VideoTextureCheckBox->setEnabled(false);
     }
     else
     {
       this->m_VideoEnabled = true;
       m_Controls->m_VideoTextureCheckBox->setEnabled(true);
     }
 
     if (this->m_VideoEnabled)
     {
 
       this->m_VideoSource->FetchFrame();
       this->m_VideoCaptureHeight = this->m_VideoSource->GetImageHeight();
       this->m_VideoCaptureWidth = this->m_VideoSource->GetImageWidth();
       this->m_VideoTexture = this->m_VideoSource->GetVideoTexture();
 
       this->m_ToFDistanceImageToSurfaceFilter->SetTextureImageWidth(this->m_VideoCaptureWidth);
       this->m_ToFDistanceImageToSurfaceFilter->SetTextureImageHeight(this->m_VideoCaptureHeight);
 
 
       this->m_ToFSurfaceVtkMapper3D->SetTextureWidth(this->m_VideoCaptureWidth);
       this->m_ToFSurfaceVtkMapper3D->SetTextureHeight(this->m_VideoCaptureHeight);
     }
   }
   catch (std::logic_error& e)
   {
     QMessageBox::warning(NULL, "Warning", QString(e.what()));
     MITK_ERROR << e.what();
     return;
   }
-
+*/
   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()->GetRenderWindow("axial")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
     GetRenderWindowPart()->GetRenderWindow("axial")->GetSliceNavigationController()->SliceLockedOff();
     GetRenderWindowPart()->GetRenderWindow("sagittal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
     GetRenderWindowPart()->GetRenderWindow("sagittal")->GetSliceNavigationController()->SliceLockedOff();
     GetRenderWindowPart()->GetRenderWindow("coronal")->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal);
     GetRenderWindowPart()->GetRenderWindow("coronal")->GetSliceNavigationController()->SliceLockedOff();
 
     this->UseToFVisibilitySettings(false);
 
     //global reinit
     this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews(/*this->GetDataStorage()->ComputeBoundingGeometry3D(this->GetDataStorage()->GetAll())*/);
     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();
 
   if(this->m_VideoSource)
   {
     this->m_VideoSource->StopCapturing();
     this->m_VideoSource = NULL;
   }
 }
 
 void QmitkToFUtilView::OnKinectAcquisitionModeChanged()
 {
   if (m_ToFCompositeFilter.IsNotNull()&&m_ToFImageGrabber.IsNotNull())
   {
     if (m_SelectedCamera=="Microsoft Kinect")
     {
       if (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);
         this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
       }
     }
     this->UseToFVisibilitySettings(true);
   }
 }
 
 void QmitkToFUtilView::OnToFCameraStarted()
 {
   if (m_ToFImageGrabber.IsNotNull())
   {
     // 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));
 
     // 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);
-    if ((m_SelectedCamera=="Microsoft Kinect")||(rgbFileName!=""))
+    if ((m_SelectedCamera=="Microsoft Kinect") || rgbFileName!="")
     {
-      if (m_ToFImageGrabber->GetBoolProperty("RGB"))
+      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_MitkIntensityImage = m_ToFCompositeFilter->GetOutput(2);
     }
     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);
     }
     if (m_Controls->m_VideoTextureCheckBox->isChecked())
     {
       OnVideoTextureCheckBoxChecked(true);
     }
   }
   m_Controls->m_TextureCheckBox->setEnabled(true);
 }
 
 void QmitkToFUtilView::OnToFCameraStopped()
 {
   m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
   m_Controls->m_ToFCompositeFilterWidget->setEnabled(false);
   m_Controls->tofMeasurementWidget->setEnabled(false);
   m_Controls->SurfacePropertiesBox->setEnabled(false);
 
   this->m_Frametimer->stop();
 }
 
 void QmitkToFUtilView::OnToFCameraSelected(const QString selected)
 {
   m_SelectedCamera = selected;
   if ((selected=="PMD CamBoard")||(selected=="PMD 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_VideoTextureCheckBox->setEnabled(false);
     this->m_Controls->m_SurfaceCheckBox->setChecked(false);
     this->m_Controls->m_TextureCheckBox->setChecked(false);
     this->m_Controls->m_VideoTextureCheckBox->setChecked(false);
   }
   else
   {
     this->m_Controls->m_SurfaceCheckBox->setEnabled(true);
     this->m_Controls->m_TextureCheckBox->setEnabled(true); // TODO enable when bug 8106 is solved
     this->m_Controls->m_VideoTextureCheckBox->setEnabled(true);
   }
 }
 
 void QmitkToFUtilView::OnUpdateCamera()
 {
   if (m_Controls->m_VideoTextureCheckBox->isChecked() && this->m_VideoEnabled && this->m_VideoSource)
   {
     this->m_VideoTexture = this->m_VideoSource->GetVideoTexture();
     ProcessVideoTransform();
   }
 
   if (m_Controls->m_SurfaceCheckBox->isChecked())
   {
     // update surface
     m_ToFDistanceImageToSurfaceFilter->SetTextureIndex(m_Controls->m_ToFVisualisationSettingsWidget->GetSelectedImageIndex());
     this->m_Surface->Update();
 
     vtkColorTransferFunction* colorTransferFunction = m_Controls->m_ToFVisualisationSettingsWidget->GetSelectedColorTransferFunction();
 
     this->m_ToFSurfaceVtkMapper3D->SetVtkScalarsToColors(colorTransferFunction);
 
     if (this->m_SurfaceDisplayCount<2)
     {
       this->m_SurfaceNode->SetData(this->m_Surface);
       this->m_SurfaceNode->SetMapper(mitk::BaseRenderer::Standard3D, m_ToFSurfaceVtkMapper3D);
 
       this->GetRenderWindowPart()->GetRenderingManager()->InitializeViews(
         this->m_Surface->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_3DWINDOWS, true);
 
       mitk::Point3D surfaceCenter= this->m_Surface->GetGeometry()->GetCenter();
       vtkCamera* camera3d = GetRenderWindowPart()->GetRenderWindow("3d")->GetRenderer()->GetVtkRenderer()->GetActiveCamera();
       camera3d->SetPosition(0,0,-50);
       camera3d->SetViewUp(0,-1,0);
       camera3d->SetFocalPoint(0,0,surfaceCenter[2]);
       camera3d->SetViewAngle(40);
       camera3d->SetClippingRange(1, 10000);
     }
     this->m_SurfaceDisplayCount++;
 
   }
   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::ProcessVideoTransform()
 {
   IplImage *src, *dst;
   src = cvCreateImageHeader(cvSize(this->m_VideoCaptureWidth, this->m_VideoCaptureHeight), IPL_DEPTH_8U, 3);
   src->imageData = (char*)this->m_VideoTexture;
 
   CvPoint2D32f srcTri[3], dstTri[3];
   CvMat* rot_mat = cvCreateMat(2,3,CV_32FC1);
   CvMat* warp_mat = cvCreateMat(2,3,CV_32FC1);
   dst = cvCloneImage(src);
   dst->origin = src->origin;
   cvZero( dst );
 
   int xOffset = 0;//m_Controls->m_XOffsetSpinBox->value();
   int yOffset = 0;//m_Controls->m_YOffsetSpinBox->value();
   int zoom = 0;//m_Controls->m_ZoomSpinBox->value();
 
   // Compute warp matrix
   srcTri[0].x = 0 + zoom;
   srcTri[0].y = 0 + zoom;
   srcTri[1].x = src->width - 1 - zoom;
   srcTri[1].y = 0 + zoom;
   srcTri[2].x = 0 + zoom;
   srcTri[2].y = src->height - 1 - zoom;
 
   dstTri[0].x = 0;
   dstTri[0].y = 0;
   dstTri[1].x = src->width - 1;
   dstTri[1].y = 0;
   dstTri[2].x = 0;
   dstTri[2].y = src->height - 1;
 
   cvGetAffineTransform( srcTri, dstTri, warp_mat );
   cvWarpAffine( src, dst, warp_mat );
   cvCopy ( dst, src );
 
 
   // Compute warp matrix
   srcTri[0].x = 0;
   srcTri[0].y = 0;
   srcTri[1].x = src->width - 1;
   srcTri[1].y = 0;
   srcTri[2].x = 0;
   srcTri[2].y = src->height - 1;
 
   dstTri[0].x = srcTri[0].x + xOffset;
   dstTri[0].y = srcTri[0].y + yOffset;
   dstTri[1].x = srcTri[1].x + xOffset;
   dstTri[1].y = srcTri[1].y + yOffset;
   dstTri[2].x = srcTri[2].x + xOffset;
   dstTri[2].y = srcTri[2].y + yOffset;
 
   cvGetAffineTransform( srcTri, dstTri, warp_mat );
   cvWarpAffine( src, dst, warp_mat );
   cvCopy ( dst, src );
 
   src->imageData = NULL;
   cvReleaseImage( &src );
   cvReleaseImage( &dst );
   cvReleaseMat( &rot_mat );
   cvReleaseMat( &warp_mat );
 
 }
 
 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::OnVideoTextureCheckBoxChecked(bool checked)
 {
   if (checked)
   {
     if (this->m_VideoEnabled)
     {
       this->m_ToFSurfaceVtkMapper3D->SetTexture(this->m_VideoTexture);
     }
     else
     {
       this->m_ToFSurfaceVtkMapper3D->SetTexture(NULL);
     }
   }
 }
 
 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);
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   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())
   {
     this->m_DistanceImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
     this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetRenderWindow("sagittal")->GetRenderWindow() ) );
     this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetRenderWindow("coronal")->GetRenderWindow() ) );
     this->m_DistanceImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetRenderWindow("3d")->GetRenderWindow() ) );
     this->m_DistanceImageNode->SetBoolProperty("use color",!useToF);
     this->m_DistanceImageNode->GetPropertyList()->DeleteProperty("LookupTable");
   }
   if (m_AmplitudeImageNode.IsNotNull())
   {
     if ((m_SelectedCamera=="Microsoft 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()->GetRenderWindow("axial")->GetRenderWindow() ) );
     this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetRenderWindow("coronal")->GetRenderWindow() ) );
     this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetRenderWindow("3d")->GetRenderWindow() ) );
     this->m_AmplitudeImageNode->SetBoolProperty("use color",!useToF);
     this->m_AmplitudeImageNode->GetPropertyList()->DeleteProperty("LookupTable");
   }
   if (m_IntensityImageNode.IsNotNull())
   {
     if (m_SelectedCamera=="Microsoft 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()->GetRenderWindow("axial")->GetRenderWindow() ) );
       this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetRenderWindow("sagittal")->GetRenderWindow() ) );
       this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetRenderWindow("3d")->GetRenderWindow() ) );
       this->m_IntensityImageNode->SetBoolProperty("use color",!useToF);
       this->m_IntensityImageNode->GetPropertyList()->DeleteProperty("LookupTable");
     }
   }
   if ((m_RGBImageNode.IsNotNull()))
   {
     if ((m_SelectedCamera=="Microsoft 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()->GetRenderWindow("axial")->GetRenderWindow() ) );
       this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetRenderWindow("sagittal")->GetRenderWindow() ) );
       this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->GetRenderWindow("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()->GetRenderWindow("3d")->GetRenderWindow() ) );
   }
   //disable/enable gradient background
   this->GetRenderWindowPart()->EnableDecorations(!useToF, QStringList(QString("background")));
 }