diff --git a/Modules/ToFHardware/mitkToFCameraMITKPlayerDevice.cpp b/Modules/ToFHardware/mitkToFCameraMITKPlayerDevice.cpp
index 10aa478887..760a077256 100644
--- a/Modules/ToFHardware/mitkToFCameraMITKPlayerDevice.cpp
+++ b/Modules/ToFHardware/mitkToFCameraMITKPlayerDevice.cpp
@@ -1,361 +1,362 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Module:    $RCSfile$
 Language:  C++
 Date:      $Date: 2010-05-27 16:06:53 +0200 (Do, 27 Mai 2010) $
 Version:   $Revision: $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 #include "mitkToFCameraMITKPlayerDevice.h"
 #include "mitkToFCameraMITKPlayerController.h"
 #include "mitkRealTimeClock.h"
 
 #include "itkMultiThreader.h"
 #include <itksys/SystemTools.hxx>
 
 namespace mitk
 {
   ToFCameraMITKPlayerDevice::ToFCameraMITKPlayerDevice()
   {
     m_Controller = ToFCameraMITKPlayerController::New();
   }
 
   ToFCameraMITKPlayerDevice::~ToFCameraMITKPlayerDevice()
   {
     DisconnectCamera();
   }
 
   bool ToFCameraMITKPlayerDevice::ConnectCamera()
   {
     bool ok = m_Controller->OpenCameraConnection();
     if (ok)
     {
       this->m_CaptureWidth = m_Controller->GetCaptureWidth();
       this->m_CaptureHeight = m_Controller->GetCaptureHeight();
       this->m_PixelNumber = this->m_CaptureWidth * this->m_CaptureHeight;
 
       // 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;}
 
       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];
       }
 
       m_CameraConnected = true;
     }
     return ok;
   }
 
   bool ToFCameraMITKPlayerDevice::DisconnectCamera()
   {
     bool ok =  m_Controller->CloseCameraConnection();
 
     // free buffer if camera was connected
     if (m_CameraConnected)
     {
       delete [] m_IntensityArray;
       delete [] m_DistanceArray;
       delete [] m_AmplitudeArray;
 
       for(int i=0; i<this->m_MaxBufferSize; i++)
       {
         delete[] this->m_DistanceDataBuffer[i];
       }
       delete[] this->m_DistanceDataBuffer;
       for(int i=0; i<this->m_MaxBufferSize; i++)
       {
         delete[] this->m_AmplitudeDataBuffer[i];
       }
       delete[] this->m_AmplitudeDataBuffer;
       for(int i=0; i<this->m_MaxBufferSize; i++)
       {
         delete[] this->m_IntensityDataBuffer[i];
       }
       delete[] this->m_IntensityDataBuffer;
 
       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_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::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 ToFCameraMITKPlayerDevice::IsCameraActive()
   {
     m_CameraActiveMutex->Lock();
     bool ok = m_CameraActive;
     m_CameraActiveMutex->Unlock();
     return ok;
   }
 
   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->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::GetAllImages(float* distanceArray, float* amplitudeArray, float* intensityArray, char* sourceDataArray,
     int requiredImageSequence, int& capturedImageSequence)
   {
     /*!!!!!!!!!!!!!!!!!!!!!!
       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;
     }
 
     // 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];
     }
     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(propertyValue, 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);
     }
   }
 
 }
diff --git a/Modules/ToFHardware/mitkToFCameraPMDDevice.cpp b/Modules/ToFHardware/mitkToFCameraPMDDevice.cpp
index 4b96eeb453..95a12fe3e7 100644
--- a/Modules/ToFHardware/mitkToFCameraPMDDevice.cpp
+++ b/Modules/ToFHardware/mitkToFCameraPMDDevice.cpp
@@ -1,404 +1,406 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Module:    $RCSfile$
 Language:  C++
 Date:      $Date: 2010-05-27 16:06:53 +0200 (Do, 27 Mai 2010) $
 Version:   $Revision: $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 #include "mitkToFCameraPMDDevice.h"
 #include "mitkRealTimeClock.h"
 
 #include "itkMultiThreader.h"
 #include <itksys/SystemTools.hxx>
 
 namespace mitk
 {
   ToFCameraPMDDevice::ToFCameraPMDDevice()
   {
   }
 
   ToFCameraPMDDevice::~ToFCameraPMDDevice()
   {
   }
 
   bool ToFCameraPMDDevice::ConnectCamera()
   {
     bool ok = false;
     if (m_Controller)
     {
       ok = m_Controller->OpenCameraConnection();
       if (ok)
       {
         this->m_CaptureWidth = m_Controller->GetCaptureWidth();
         this->m_CaptureHeight = m_Controller->GetCaptureHeight();
         this->m_SourceDataSize = m_Controller->GetSourceDataStructSize();
         this->m_PixelNumber = this->m_CaptureWidth * this->m_CaptureHeight;
 
         // 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;}
         this->m_SourceDataArray = new char[this->m_SourceDataSize];
         for(int i=0; i<this->m_SourceDataSize; i++) {this->m_SourceDataArray[i]=0;}
 
         this->m_SourceDataBuffer = new char*[this->m_MaxBufferSize];
         for(int i=0; i<this->m_MaxBufferSize; i++)
         {
           this->m_SourceDataBuffer[i] = new char[this->m_SourceDataSize];
         }
 
         m_CameraConnected = true;
       }
     }
     return ok;
   }
 
   bool ToFCameraPMDDevice::DisconnectCamera()
   {
     bool ok = false;
     if (m_Controller)
     {
       ok =  m_Controller->CloseCameraConnection();
 
       // clean-up only if camera was connected
       if (m_CameraConnected)
       {
         MITK_INFO<<"free buffer";
         // free buffer
         delete [] m_IntensityArray;
         delete [] m_DistanceArray;
         delete [] m_AmplitudeArray;
         delete [] m_SourceDataArray;
         for(int i=0; i<this->m_MaxBufferSize; i++)
         {
           delete[] this->m_SourceDataBuffer[i];
         }
         delete[] this->m_SourceDataBuffer;
         m_CameraConnected = false;
       }
 
     }
     return ok;
   }
 
   void ToFCameraPMDDevice::StartCamera()
   {
     if (m_CameraConnected)
     {
       // get the first image
       this->m_Controller->UpdateCamera();
       this->m_ImageMutex->Lock();
       //this->m_Controller->GetSourceData(this->m_SourceDataArray);
       this->m_Controller->GetSourceData(this->m_SourceDataBuffer[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 ToFCameraPMDDevice::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(10);
   }
 
   bool ToFCameraPMDDevice::IsCameraActive()
   {
     m_CameraActiveMutex->Lock();
     bool ok = m_CameraActive;
     m_CameraActiveMutex->Unlock();
     return ok;
   }
 
   void ToFCameraPMDDevice::UpdateCamera()
   {
     if (m_Controller)
     {
       m_Controller->UpdateCamera();
     }
   }
 
   ITK_THREAD_RETURN_TYPE ToFCameraPMDDevice::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;
     }
     ToFCameraPMDDevice* toFCameraDevice = (ToFCameraPMDDevice*)pInfo->UserData;
     if (toFCameraDevice!=NULL)
     {
       mitk::RealTimeClock::Pointer realTimeClock;
       realTimeClock = mitk::RealTimeClock::New();
       double t1, t2;
       t1 = realTimeClock->GetCurrentStamp();
       int n = 100;
       bool overflow = false;
       bool printStatus = false;
       while (toFCameraDevice->IsCameraActive())
       {
         // update the ToF camera
         toFCameraDevice->UpdateCamera();
         // get the source data from the camera and write it at the next free position in the buffer
         toFCameraDevice->m_Controller->GetSourceData(toFCameraDevice->m_SourceDataBuffer[toFCameraDevice->m_FreePos]);
+        // call modified to indicate that cameraDevice was modified
+        toFCameraDevice->Modified();
 
         /*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
          TODO Buffer Handling currently only works for buffer size 1
          !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
         toFCameraDevice->m_ImageMutex->Lock();
         //toFCameraDevice->m_ImageSequence++;
         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 << "t2: " << t2 <<" Time (s) for 1 image: " << (t2/1000) / n << " Framerate (fps): " << n / (t2/1000) << " Sequence: " << toFCameraDevice->m_ImageSequence;
           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 ToFCameraPMDDevice::ResetBuffer(int bufferSize)
   //  {
   //    this->m_BufferSize = bufferSize;
   //    this->m_CurrentPos = -1;
   //    this->m_FreePos = 0;
   //  }
 
   void ToFCameraPMDDevice::GetAmplitudes(float* amplitudeArray, int& imageSequence)
   {
     m_ImageMutex->Lock();
     if (m_CameraActive)
     {
       // 1) copy the image buffer
       // 2) Flip around y- axis (vertical axis)
 
       this->m_Controller->GetAmplitudes(this->m_SourceDataBuffer[this->m_CurrentPos], this->m_AmplitudeArray);
 
       for (int i=0; i<this->m_CaptureHeight; i++)
       {
         for (int j=0; j<this->m_CaptureWidth; j++)
         {
           amplitudeArray[i*this->m_CaptureWidth+j] = this->m_AmplitudeArray[(i+1)*this->m_CaptureWidth-1-j];
         }
       }
       imageSequence = this->m_ImageSequence;
     }
     else
     {
       MITK_WARN("ToF") << "Warning: Data can only be acquired if camera is active.";
     }
     m_ImageMutex->Unlock();
   }
 
   void ToFCameraPMDDevice::GetIntensities(float* intensityArray, int& imageSequence)
   {
     m_ImageMutex->Lock();
     if (m_CameraActive)
     {
     // 1) copy the image buffer
     // 2) Flip around y- axis (vertical axis)
 
     this->m_Controller->GetIntensities(this->m_SourceDataBuffer[this->m_CurrentPos], this->m_IntensityArray);
 
     for (int i=0; i<this->m_CaptureHeight; i++)
     {
       for (int j=0; j<this->m_CaptureWidth; j++)
       {
         intensityArray[i*this->m_CaptureWidth+j] = this->m_IntensityArray[(i+1)*this->m_CaptureWidth-1-j];
       }
     }
     imageSequence = this->m_ImageSequence;
     }
     else
     {
       MITK_WARN("ToF") << "Warning: Data can only be acquired if camera is active.";
     }
     m_ImageMutex->Unlock();
   }
 
   void ToFCameraPMDDevice::GetDistances(float* distanceArray, int& imageSequence)
   {
     m_ImageMutex->Lock();
     if (m_CameraActive)
     {
       // 1) copy the image buffer
       // 2) convert the distance values from m to mm
       // 3) Flip around y- axis (vertical axis)
 
       this->m_Controller->GetDistances(this->m_SourceDataBuffer[this->m_CurrentPos], this->m_DistanceArray);
 
       for (int i=0; i<this->m_CaptureHeight; i++)
       {
         for (int j=0; j<this->m_CaptureWidth; j++)
         {
           distanceArray[i*this->m_CaptureWidth+j] = 1000 * this->m_DistanceArray[(i+1)*this->m_CaptureWidth-1-j];
         }
       }
       imageSequence = this->m_ImageSequence;
     }
     else
     {
       MITK_WARN("ToF") << "Warning: Data can only be acquired if camera is active.";
     }
     m_ImageMutex->Unlock();
   }
 
   void ToFCameraPMDDevice::GetAllImages(float* distanceArray, float* amplitudeArray, float* intensityArray, char* sourceDataArray,
                                         int requiredImageSequence, int& capturedImageSequence)
   {
     if (m_CameraActive)
     {
       m_ImageMutex->Lock();
       // 1) copy the image buffer
       // 2) convert the distance values from m to mm
       // 3) Flip around y- axis (vertical axis)
 
       // 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;
         //MITK_INFO << "Required image not found! Required: " << requiredImageSequence << " delivered/current: " << this->m_ImageSequence;
       }
       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;
         //MITK_INFO << "Out of buffer! Required: " << requiredImageSequence << " delivered: " << capturedImageSequence << " current: " << this->m_ImageSequence;
       }
       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;
       }
 
       m_ImageMutex->Unlock();
 
       this->m_Controller->GetDistances(this->m_SourceDataBuffer[pos], this->m_DistanceArray);
       this->m_Controller->GetAmplitudes(this->m_SourceDataBuffer[pos], this->m_AmplitudeArray);
       this->m_Controller->GetIntensities(this->m_SourceDataBuffer[pos], this->m_IntensityArray);
 
       int u, v;
       for (int i=0; i<this->m_CaptureHeight; i++)
       {
         for (int j=0; j<this->m_CaptureWidth; j++)
         {
           u = i*this->m_CaptureWidth+j;
           v = (i+1)*this->m_CaptureWidth-1-j;
           distanceArray[u] = 1000 * this->m_DistanceArray[v]; // unit in minimeter
           //distanceArray[u] = this->m_DistanceArray[v]; // unit in meter
           amplitudeArray[u] = this->m_AmplitudeArray[v];
           intensityArray[u] = this->m_IntensityArray[v];
         }
       }
 
       memcpy(sourceDataArray, this->m_SourceDataBuffer[this->m_CurrentPos], this->m_SourceDataSize);
     }
     else
     {
       MITK_WARN("ToF") << "Warning: Data can only be acquired if camera is active.";
     }
   }
 
   ToFCameraPMDController::Pointer ToFCameraPMDDevice::GetController()
   {
     return this->m_Controller;
   }
 
   void ToFCameraPMDDevice::SetProperty( const char *propertyKey, BaseProperty* propertyValue )
   {
     ToFCameraDevice::SetProperty(propertyKey,propertyValue);
     this->m_PropertyList->SetProperty(propertyKey, propertyValue);
     if (strcmp(propertyKey, "ModulationFrequency") == 0)
     {
       int modulationFrequency = 0;
       GetIntProperty(propertyValue, modulationFrequency);
       m_Controller->SetModulationFrequency(modulationFrequency);
     }
     else if (strcmp(propertyKey, "IntegrationTime") == 0)
     {
       int integrationTime = 0;
       GetIntProperty(propertyValue, integrationTime);
       m_Controller->SetIntegrationTime(integrationTime);
     }
   }
 }
diff --git a/Modules/ToFHardware/mitkToFImageGrabber.cpp b/Modules/ToFHardware/mitkToFImageGrabber.cpp
index 6b06d2b946..da39f558e8 100644
--- a/Modules/ToFHardware/mitkToFImageGrabber.cpp
+++ b/Modules/ToFHardware/mitkToFImageGrabber.cpp
@@ -1,210 +1,216 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Module:    $RCSfile$
 Language:  C++
 Date:      $Date: 2010-05-27 16:06:53 +0200 (Do, 27 Mai 2010) $
 Version:   $Revision: $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 #include "mitkToFImageGrabber.h"
 #include "mitkToFCameraPMDCamCubeDevice.h"
 
 
 namespace mitk
 {
   ToFImageGrabber::ToFImageGrabber():m_CaptureWidth(204),m_CaptureHeight(204),m_PixelNumber(41616),m_ImageSequence(0),
     m_IntensityArray(NULL), m_DistanceArray(NULL), m_AmplitudeArray(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()); 
     mitk::ImageSource::SetNumberOfRequiredOutputs(3);
     mitk::ImageSource::SetNthOutput(0, output0.GetPointer());
     mitk::ImageSource::SetNthOutput(1, output1.GetPointer());
     mitk::ImageSource::SetNthOutput(2, output2.GetPointer());
   }
 
   ToFImageGrabber::~ToFImageGrabber()
   {
     if (m_IntensityArray||m_AmplitudeArray||m_DistanceArray)
     {
       this->DisconnectCamera();
     }
   }
 
   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;
 
     mitk::Image::Pointer distanceImage = this->GetOutput(0);
     mitk::Image::Pointer amplitudeImage = this->GetOutput(1);
     mitk::Image::Pointer intensityImage = this->GetOutput(2);
 
     if (!distanceImage->IsInitialized())
     {
       distanceImage->ReleaseData();
       amplitudeImage->ReleaseData();
       intensityImage->ReleaseData();
 
       unsigned int dimensions[2];
       dimensions[0] = this->m_ToFCameraDevice->GetCaptureWidth();
       dimensions[1] = this->m_ToFCameraDevice->GetCaptureHeight();       
       distanceImage->Initialize(mitk::PixelType(typeid(float)), 2, dimensions, 1);
       amplitudeImage->Initialize(mitk::PixelType(typeid(float)), 2, dimensions, 1);
       intensityImage->Initialize(mitk::PixelType(typeid(float)), 2, dimensions, 1);
     }
 
     this->m_ToFCameraDevice->GetAllImages(this->m_DistanceArray, this->m_AmplitudeArray, this->m_IntensityArray, this->m_SourceDataArray,
       requiredImageSequence, this->m_ImageSequence );
     capturedImageSequence = this->m_ImageSequence;
 
     distanceImage->SetSlice(this->m_DistanceArray, 0, 0, 0);
     amplitudeImage->SetSlice(this->m_AmplitudeArray, 0, 0, 0);
     intensityImage->SetSlice(this->m_IntensityArray, 0, 0, 0);
   }
 
   bool ToFImageGrabber::ConnectCamera()
   {
     bool ok = m_ToFCameraDevice->ConnectCamera();
     if (ok)
     {
       m_CaptureWidth = m_ToFCameraDevice->GetCaptureWidth();
       m_CaptureHeight = m_ToFCameraDevice->GetCaptureHeight();
       m_PixelNumber = m_CaptureWidth * m_CaptureHeight;
       m_SourceDataSize = m_ToFCameraDevice->GetSourceDataSize();
 
       // 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];
     }
     return ok;
   }
 
   bool ToFImageGrabber::DisconnectCamera()
   {
     bool success = m_ToFCameraDevice->DisconnectCamera();
     // free buffer
     if (m_IntensityArray||m_DistanceArray||m_AmplitudeArray)
     {
       delete [] m_IntensityArray;
       delete [] m_DistanceArray;
       delete [] m_AmplitudeArray;
       m_IntensityArray = NULL;
       m_DistanceArray = NULL;
       m_AmplitudeArray = NULL;
     }
 
     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;
   }
 
   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::SetModulationFrequency(int modulationFrequency)
   {
     this->m_ToFCameraDevice->SetProperty("ModulationFrequency",mitk::IntProperty::New(modulationFrequency));
     return modulationFrequency;
   }
 
   int ToFImageGrabber::SetIntegrationTime(int integrationTime)
   {
     this->m_ToFCameraDevice->SetProperty("IntegrationTime",mitk::IntProperty::New(integrationTime));
     return integrationTime;
   }
 
   int ToFImageGrabber::GetIntegrationTime()
   {
     int integrationTime = 0;
     BaseProperty* property = this->m_ToFCameraDevice->GetProperty("IntegrationTime");
     this->m_ToFCameraDevice->GetIntProperty(property,integrationTime);
     return integrationTime;
   }
 
   int ToFImageGrabber::GetModulationFrequency()
   {
     int modulationFrequency = 0;
     BaseProperty* property = this->m_ToFCameraDevice->GetProperty("ModulationFrequency");
     this->m_ToFCameraDevice->GetIntProperty(property,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);
   }
+
+  void ToFImageGrabber::UpdateOutputInformation()
+  {
+    this->Modified();  // make sure that we need to be updated
+    Superclass::UpdateOutputInformation();
+  }
 }
diff --git a/Modules/ToFHardware/mitkToFImageGrabber.h b/Modules/ToFHardware/mitkToFImageGrabber.h
index ad90371b13..8ba5063a1a 100644
--- a/Modules/ToFHardware/mitkToFImageGrabber.h
+++ b/Modules/ToFHardware/mitkToFImageGrabber.h
@@ -1,158 +1,162 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Module:    $RCSfile$
 Language:  C++
 Date:      $Date: 2010-05-27 16:06:53 +0200 (Do, 27 Mai 2010) $
 Version:   $Revision:  $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 #ifndef __mitkToFImageGrabber_h
 #define __mitkToFImageGrabber_h
 
 #include "mitkToFHardwareExports.h"
 #include "mitkCommon.h"
 #include "mitkImageSource.h"
 #include "mitkToFCameraDevice.h"
 
 #include "itkObject.h"
 #include "itkObjectFactory.h"
 
 namespace mitk
 {
   /**Documentation
   * \brief Image source providing ToF images. Interface for filters provided in ToFProcessing module
   *
   * This class internally holds a ToFCameraDevice to access the images acquired by a ToF camera.
   * A pre-configured instance for a specific ToF camera (e.g. PMD CamCube 3) can be obtained using
   * the class ToFImageGrabberCreator.
   * Provided images include: distance image (output 0), amplitude image (output 1), intensity image (output 2)
   *
   * \ingroup ToFHardware
   */
   class MITK_TOFHARDWARE_EXPORT ToFImageGrabber : public mitk::ImageSource
   {
   public: 
 
     mitkClassMacro( ToFImageGrabber , ImageSource );
 
     itkNewMacro( Self );
 
+    /**
+    * \brief Used for pipeline update
+    */
+    virtual void UpdateOutputInformation();
     /*!
     \brief Establish a connection to the ToF camera
     \param device specifies the actually used ToF Camera. 0: PMD O3D, 1: PMD CamCube 2.0
     */
     virtual bool ConnectCamera();
     /*!
     \brief Disconnects the ToF camera
     */
     virtual bool DisconnectCamera();
     /*!
     \brief Starts the continuous updating of the camera. 
     A separate thread updates the source data, the main thread processes the source data and creates images and coordinates
     */
     virtual void StartCamera();
     /*!
     \brief Stops the continuous updating of the camera
     */
     virtual void StopCamera();
     /*!
     \brief Returns true if the camera is connected and started
     */
     virtual bool IsCameraActive();
     /*!
     \brief Sets the ToF device, the image grabber is grabbing the images from
     \param aToFCameraDevice device internally used for grabbing the images from the camera
     */
     void SetCameraDevice(ToFCameraDevice* aToFCameraDevice);
     /*!
     \brief Get the currently set ToF camera device
     \return device currently used for grabbing images from the camera
     */
     ToFCameraDevice* GetCameraDevice();
     /*!
     \brief Set the modulation frequency used by the ToF camera.
     For default values see the corresponding device classes
     \param modulationFrequency modulation frequency in Hz
     */
     int SetModulationFrequency(int modulationFrequency);
     /*!
     \brief Get the modulation frequency used by the ToF camera.
     \return modulation frequency in MHz
     */
     int GetModulationFrequency();
     /*!
     \brief Set the integration time used by the ToF camera.
     For default values see the corresponding device classes
     \param integrationTime integration time in ms
     */
     int SetIntegrationTime(int integrationTime);
     /*!
     \brief Get the integration time in used by the ToF camera.
     \return integration time in ms
     */
     int GetIntegrationTime();
     /*!
     \brief Get the dimension in x direction of the ToF image
     \return width of the image
     */
     int GetCaptureWidth();
     /*!
     \brief Get the dimension in y direction of the ToF image
     \return height of the image
     */
     int GetCaptureHeight();
     /*!
     \brief Get the number of pixel in the ToF image
     \return number of pixel
     */
     int GetPixelNumber();
 // properties
     void SetBoolProperty( const char* propertyKey, bool boolValue );
 
     void SetIntProperty( const char* propertyKey, int intValue );
 
     void SetFloatProperty( const char* propertyKey, float floatValue );
 
     void SetStringProperty( const char* propertyKey, const char* stringValue );
 
     void SetProperty( const char *propertyKey, BaseProperty* propertyValue );
 
   protected:
 
     ToFCameraDevice::Pointer m_ToFCameraDevice; ///< Device allowing acces to ToF image data
     int m_CaptureWidth; ///< Width of the captured ToF image
     int m_CaptureHeight; ///< Height of the captured ToF image
     int m_PixelNumber; ///< Number of pixels in the image
     int m_ImageSequence; ///< counter for currently acquired images
     int m_SourceDataSize; ///< size of the source data in bytes
     float* m_IntensityArray; ///< member holding the current intensity array
     float* m_DistanceArray; ///< member holding the current distance array
     float* m_AmplitudeArray; ///< member holding the current amplitude array
     char* m_SourceDataArray;///< member holding the current source data array
 
     ToFImageGrabber();
 
     ~ToFImageGrabber();
 
     /*!
     \brief Method generating the outputs of this filter. Called in the updated process of the pipeline.
     0: distance image
     1: amplitude image
     2: intensity image
     */
     void GenerateData();
 
   private:
 
   };
 } //END mitk namespace
 #endif