diff --git a/Modules/ToFHardware/mitkToFImageGrabber.cpp b/Modules/ToFHardware/mitkToFImageGrabber.cpp
index 4f0820f507..8072466c39 100644
--- a/Modules/ToFHardware/mitkToFImageGrabber.cpp
+++ b/Modules/ToFHardware/mitkToFImageGrabber.cpp
@@ -1,340 +1,341 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #include "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());
     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,
       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();
   }
   bool ToFImageGrabber::IsCameraConnected()
   {
     return m_ToFCameraDevice->IsCameraConnected();
   }
 
   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/Modules/ToFUI/Qmitk/QmitkToFConnectionWidget.cpp b/Modules/ToFUI/Qmitk/QmitkToFConnectionWidget.cpp
index 7b72d092b7..6f0ec007ee 100644
--- a/Modules/ToFUI/Qmitk/QmitkToFConnectionWidget.cpp
+++ b/Modules/ToFUI/Qmitk/QmitkToFConnectionWidget.cpp
@@ -1,357 +1,372 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 //#define _USE_MATH_DEFINES
 #include <QmitkToFConnectionWidget.h>
 
 //QT headers
 #include <qmessagebox.h>
 #include <qfiledialog.h>
 #include <qcombobox.h>
 
 //mitk headers
 #include "mitkToFConfig.h"
+#include "mitkCameraIntrinsics.h"
+#include "mitkCameraIntrinsicsProperty.h"
 
 //itk headers
 #include <itksys/SystemTools.hxx>
 
 //Setting the View_ID
 const std::string QmitkToFConnectionWidget::VIEW_ID = "org.mitk.views.qmitktofconnectionwidget2";
 
 //Constructor of QmitkToFConnectionWidget
 QmitkToFConnectionWidget::QmitkToFConnectionWidget(QWidget* parent, Qt::WindowFlags f): QWidget(parent, f)
 {
   this->m_IntegrationTime = 0;
   this->m_ModulationFrequency = 0;
   this->m_ToFImageGrabber = mitk::ToFImageGrabber::New();
   //Setting m_Controls= NULL on Startup-> CreateQtPartControl will generate the Gui Widget if !m_Controls
   m_Controls = NULL;
   //Calling CreateQtPartControl
   CreateQtPartControl(this);
 }
 
 //Destructor of QmitkToFConnectionWidget
 QmitkToFConnectionWidget::~QmitkToFConnectionWidget()
 {
   //Keno´s MitkServiceListWidget must not be deinizialized here. Qmitk methods destroy their children automatically before self-destruction
 }
 
 void QmitkToFConnectionWidget::CreateQtPartControl(QWidget *parent)   //Definition of CreateQtPartControll-Methode in QmitkToFConnectionWidget; Input= Pointer
 {
   if (!m_Controls) //Define if not alreaddy exists
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkToFConnectionWidgetControls2;
     m_Controls->setupUi(parent);
     //and hide them on startup
     this->HideAllParameterWidgets();
 
     // initzializing MitkServiceListWidget here
     std::string empty= "";
     m_Controls->m_DeviceList->Initialize<mitk::ToFCameraDevice>("ToFDeviceName", empty);// the empty could just be any kind of filter
 
     this->CreateConnections();
     //OnSelectCamera(); //todo: warum geht das hier nicht? -> Sasch fragen
   }
 }
 //Creating the SIGNAL-SLOT-Connectuions
 void QmitkToFConnectionWidget::CreateConnections()
 {
   if ( m_Controls )
   {
     //ConnectCameraButton as a trigger for OnConnectCamera()
     connect( (QObject*)(m_Controls->m_ConnectCameraButton), SIGNAL(clicked()),(QObject*) this, SLOT(OnConnectCamera()) );
 
     //QmitkServiceListWidget::ServiceSelectionChanged as a Signal for the OnSlectCamera() slot
     connect( m_Controls->m_DeviceList, SIGNAL(ServiceSelectionChanged(mitk::ServiceReference)), this, SLOT(OnSelectCamera()));
 
     /*Creating an other Datanode structur for Kinect is done here: As soon as a Kinect is connected, the KinectParameterWidget is enabled,
     which can be used to trigger the KinectAcqusitionModeChanged-Method, to create a working Data-Node-structure*/
     connect( m_Controls->m_KinectParameterWidget, SIGNAL(AcquisitionModeChanged()), this, SIGNAL(KinectAcquisitionModeChanged()) );
 
   }
 }
 
 mitk::ToFImageGrabber::Pointer QmitkToFConnectionWidget::GetToFImageGrabber()
 {
   return m_ToFImageGrabber;
 }
 
 //The OnSelectCamer-Method is in charge of activating the appropiate ParameterWidgets
 void QmitkToFConnectionWidget::OnSelectCamera()
 {
   //Here we are getting our decvie through the QmitkServiceListWidget-Instance m_DeviceList through the GetSelectedService-Method
   mitk::ToFCameraDevice* device = m_Controls->m_DeviceList->GetSelectedService<mitk::ToFCameraDevice>();
 
   //getting the selectedCamera through a static Method used to transform the device->GetNameOfClass
   QString selectedCamera = QString::fromStdString(device->GetNameOfClass());
 
   this->HideAllParameterWidgets();
   //reactivating the Widgets on slecting a device
   if (selectedCamera.contains("PMD")) //Check if selectedCamera string contains ".." for each device
   {
     this->m_Controls->m_PMDParameterWidget->show(); //and activate the correct widget
   }
   else if (selectedCamera.contains("MESA"))
   {
     this->m_Controls->m_MESAParameterWidget->show();
   }
   else if (selectedCamera.contains("Kinect"))
   {
     this->m_Controls->m_KinectParameterWidget->show();
   }
   emit  (selectedCamera);
 }
 //This Methods hides all Widgets (later each widget is activated on its own)
 void QmitkToFConnectionWidget::HideAllParameterWidgets()
 {
   this->m_Controls->m_PMDParameterWidget->hide();
   this->m_Controls->m_MESAParameterWidget->hide();
   this->m_Controls->m_KinectParameterWidget->hide();
 }
 
 //OnConnectCamera-Method; represents one of the main parts of ToFConnectionWidget2.
 void QmitkToFConnectionWidget::OnConnectCamera()
 {
   //Introducing the boolean variable playerMode and set it to false by default
   bool playerMode = false;
 
   //After connecting a device
   if (m_Controls->m_ConnectCameraButton->text()=="Connect")
   {
 
     //Reset the status of some GUI-Elements
     m_Controls->m_ConnectCameraButton->setEnabled(false); //ConnectCameraButton gets disabled, what leads to other changes later
     m_Controls->m_DeviceList->setEnabled(false);          //Deactivating the Instance of QmitkServiceListWidget
     //repaint the widget
     this->repaint();
 
     QString tmpFileName("");
     QString fileFilter("");
 
     //Getting the device- and the slectedCamera-variables using the ServiceListWidget as we did it in the CameraSelect-Method
     mitk::ToFCameraDevice* device = m_Controls->m_DeviceList->GetSelectedService<mitk::ToFCameraDevice>();
     QString selectedCamera = QString::fromStdString(device->GetNameOfClass());
 
     emit ToFCameraSelected(selectedCamera);
 
     //Creating a new  instance of m_ToFImageGrabber
     this->m_ToFImageGrabber = NULL;
     this->m_ToFImageGrabber = mitk::ToFImageGrabber::New();
 
     //Feeding it with the Info from ServiceListWidget
     this->m_ToFImageGrabber->SetCameraDevice(device);
 
     // Calling Alex FixForKinect, if the Kinect is selected
     if (selectedCamera.contains("Kinect") )
     {
       MITK_INFO<< "Kinect is connected here";
       //If the particular property is selected, the suitable data-node will be generated
       this->m_ToFImageGrabber->SetBoolProperty("RGB", m_Controls->m_KinectParameterWidget->IsAcquisitionModeRGB());//--------------------------------------------------------
       this->m_ToFImageGrabber->SetBoolProperty("IR", m_Controls->m_KinectParameterWidget->IsAcquisitionModeIR());
     }
 
 //Activation of "PlayerMode". If the selectedCamera String contains "Player", we start the Player Mode
     if (selectedCamera.contains("Player"))
     {
       playerMode = true;
       //IF PMD-Player selected
       if (selectedCamera.contains("PMD"))
       {
         fileFilter.append("PMD Files (*.pmd)");   //And seting the corresponding fileFilter
       }
       else
       {
         fileFilter.append("NRRD Images (*.nrrd);;PIC Images - deprecated (*.pic)");
       }
     }
 
     // if a player was selected, the playerMode-variable is true, and we will enter the following code
     if (playerMode)
     {
       //open a QFileDialog to chose the corresponding file from the disc
       tmpFileName = QFileDialog::getOpenFileName(NULL, "Play Image From...", "", fileFilter);
 
       //If no fileName is returned by the Dialog,Button and Widget have to return to default(disconnected) + Opening a MessageBox
       if (tmpFileName.isEmpty())
       {
         m_Controls->m_ConnectCameraButton->setChecked(false);
         m_Controls->m_ConnectCameraButton->setEnabled(true);  //re-enabling the ConnectCameraButton
         m_Controls->m_DeviceList->setEnabled(true);           //Reactivating ServiceListWidget
 
         this->OnSelectCamera();       //Calling the OnSelctCamera-Method -> Hides all Widget and just activates the needed ones
         QMessageBox::information( this, "Template functionality", "Please select a valid image before starting some action.");
         return;
       }
 
       if(selectedCamera.contains("PMDPlayer"))  //If PMD-Player is selected, set ToFImageGrabberProperty correspondingly
       {
         this->m_ToFImageGrabber->SetStringProperty("PMDFileName", tmpFileName.toStdString().c_str() );
       }
       else    //Default action
       {
         std::string msg = "";
         try
         {
           //get 3 corresponding file names
           std::string dir = itksys::SystemTools::GetFilenamePath( tmpFileName.toStdString() );
           std::string baseFilename = itksys::SystemTools::GetFilenameWithoutLastExtension( tmpFileName.toStdString() );
           std::string extension = itksys::SystemTools::GetFilenameLastExtension( tmpFileName.toStdString() );
 
           //"Incorrect format"-warning while using .nrrd or .pic files
           if (extension != ".pic" && extension != ".nrrd")
           {
             msg = msg + "Invalid file format, please select a \".nrrd\"-file";
             throw std::logic_error(msg.c_str());
           }
 
           //Checking for npos. If available, check for the Amplitude-, Intensity- and RGBImage
 
           int found = baseFilename.rfind("_DistanceImage");  //Defining "found" variable+checking if baseFilname contains "_DistanceImage". If not, found == npos(0)
 
           if (found == std::string::npos)  //If found =0
           {
             found = baseFilename.rfind("_AmplitudeImage");  //If "_AmplitudeImage" is found, the found variable is 1-> the next if statment is false
           }
 
           if (found == std::string::npos)
           {
             found = baseFilename.rfind("_IntensityImage"); //found = true if baseFilename cotains "_IntesityImage"
           }
 
           if (found == std::string::npos)
           {
             found = baseFilename.rfind("_RGBImage");
           }
 
           if (found == std::string::npos) //If none of the Nodes is found, display an error
           {
             msg = msg + "Input file name must end with \"_DistanceImage\", \"_AmplitudeImage\", \"_IntensityImage\" or \"_RGBImage\"!";
             throw std::logic_error(msg.c_str());
           }
 
           std::string baseFilenamePrefix = baseFilename.substr(0,found);//Set the baseFilenamePrefix as a substring from baseFilname
 
           //Set corresponding FileNames
           std::string distanceImageFileName = dir + "/" + baseFilenamePrefix + "_DistanceImage" + extension; //Set the name as: directory+FilenamePrefix+""+extension
           std::string amplitudeImageFileName = dir + "/" + baseFilenamePrefix + "_AmplitudeImage" + extension;
           std::string intensityImageFileName = dir + "/" + baseFilenamePrefix + "_IntensityImage" + extension;
           std::string rgbImageFileName = dir + "/" + baseFilenamePrefix + "_RGBImage" + extension;
 
 
           if (!itksys::SystemTools::FileExists(distanceImageFileName.c_str(), true))
           {
             this->m_ToFImageGrabber->SetStringProperty("DistanceImageFileName", "");
           }
           else
           {
             this->m_ToFImageGrabber->SetStringProperty("DistanceImageFileName", distanceImageFileName.c_str());
           }
           if (!itksys::SystemTools::FileExists(amplitudeImageFileName.c_str(), true))
           {
           }
           else
           {
             this->m_ToFImageGrabber->SetStringProperty("AmplitudeImageFileName", amplitudeImageFileName.c_str());
           }
           if (!itksys::SystemTools::FileExists(intensityImageFileName.c_str(), true))
           {
             this->m_ToFImageGrabber->SetStringProperty("IntensityImageFileName", "");
           }
           else
           {
             this->m_ToFImageGrabber->SetStringProperty("IntensityImageFileName", intensityImageFileName.c_str());
           }
           if (!itksys::SystemTools::FileExists(rgbImageFileName.c_str(), true))
           {
             this->m_ToFImageGrabber->SetStringProperty("RGBImageFileName", "");
           }
           else
           {
             this->m_ToFImageGrabber->SetStringProperty("RGBImageFileName", rgbImageFileName.c_str());
           }
         }
 
         catch (std::exception &e)
         {
           MITK_ERROR << e.what();
           QMessageBox::critical( this, "Error", e.what() );
           m_Controls->m_ConnectCameraButton->setChecked(false);
           m_Controls->m_ConnectCameraButton->setEnabled(true);
           m_Controls->m_DeviceList->setEnabled(true);
           this->OnSelectCamera();
           return;
         }
       }
     }
 //End "PlayerMode"
 
     m_Controls->m_ConnectCameraButton->setText("Disconnect");  //Reset the ConnectCameraButton to disconnected
 
     //if a connection could be established
     if (this->m_ToFImageGrabber->ConnectCamera())
     {
       this->m_Controls->m_PMDParameterWidget->SetToFImageGrabber(this->m_ToFImageGrabber);
       this->m_Controls->m_MESAParameterWidget->SetToFImageGrabber(this->m_ToFImageGrabber);
       this->m_Controls->m_KinectParameterWidget->SetToFImageGrabber(this->m_ToFImageGrabber);
 
       //Activating the respective widgets
       if (selectedCamera.contains("PMD"))
       {
         this->m_Controls->m_PMDParameterWidget->ActivateAllParameters();
       }
       else if (selectedCamera.contains("MESA"))
       {
         this->m_Controls->m_MESAParameterWidget->ActivateAllParameters();
       }
       else if (selectedCamera.contains("Kinect"))
       {
         this->m_Controls->m_KinectParameterWidget->ActivateAllParameters();
       }
       else
       {
         this->HideAllParameterWidgets();
       }
       // send connect signal to the caller functionality
       emit ToFCameraConnected();
     }
     //Throw an error if the Connection failed and reset the Widgets
     else
     {
       QMessageBox::critical( this, "Error", "Connection failed. Check if you have installed the latest driver for your system." );
       m_Controls->m_ConnectCameraButton->setChecked(false);
       m_Controls->m_ConnectCameraButton->setEnabled(true);
       m_Controls->m_ConnectCameraButton->setText("Connect");
       m_Controls->m_DeviceList->setEnabled(true);           //Reactivating ServiceListWidget
       this->OnSelectCamera();
       return;
 
     }
     m_Controls->m_ConnectCameraButton->setEnabled(true);
 
+    // ask wether camera parameters (intrinsics, ...) should be loaded
+    if (QMessageBox::question(this,"Camera parameters","Do you want to specify your own camera intrinsics?",QMessageBox::Yes,QMessageBox::No)==QMessageBox::Yes)
+    {
+      MITK_INFO<<"Yes";
+      QString fileName = QFileDialog::getOpenFileName(this,"Open camera intrinsics","/","*.xml");
+      mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
+      cameraIntrinsics->FromXMLFile(fileName.toStdString());
+      this->m_ToFImageGrabber->SetProperty("CameraIntrinsics",mitk::CameraIntrinsicsProperty::New(cameraIntrinsics));
+    }
+    else
+    {
+      MITK_INFO<<"No";
+    }
   }
   else if (m_Controls->m_ConnectCameraButton->text()=="Disconnect")
   {
     this->m_ToFImageGrabber->StopCamera();
     this->m_ToFImageGrabber->DisconnectCamera();
     m_Controls->m_ConnectCameraButton->setText("Connect");
     m_Controls->m_DeviceList->setEnabled(true);           //Reactivating ServiceListWidget
     this->OnSelectCamera();
 
     // send disconnect signal to the caller functionality
     emit ToFCameraDisconnected();
   }
 }
diff --git a/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.cpp b/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.cpp
index ab390335f9..87a199a91f 100644
--- a/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.cpp
+++ b/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.cpp
@@ -1,432 +1,437 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkToFPointSetWidget.h"
 
 #include <QmitkTextOverlay.h>
 
 #include <mitkGlobalInteraction.h>
 #include <mitkVtkLayerController.h>
 
 #include <vtkTextProperty.h>
 
 
 const std::string QmitkToFPointSetWidget::VIEW_ID = "org.mitk.views.qmitktofpointsetwidget";
 
 QmitkToFPointSetWidget::QmitkToFPointSetWidget(QWidget* parent, Qt::WindowFlags f): QWidget(parent, f)
 , m_DataStorage(NULL)
 , m_DistanceImage(NULL)
 , m_CameraIntrinsics(NULL)
 , m_VtkTextActor(NULL)
 , m_ForegroundRenderer1(NULL)
 , m_ForegroundRenderer2(NULL)
 , m_ForegroundRenderer3(NULL)
 , m_RenderWindow1(NULL)
 , m_RenderWindow2(NULL)
 , m_RenderWindow3(NULL)
 , m_MeasurementPointSet2D(NULL)
 , m_MeasurementPointSet3DNode(NULL)
 , m_PointSet2D(NULL)
 , m_PointSet3DNode(NULL)
 , m_PointSetInteractor(NULL)
 , m_MeasurementPointSetInteractor(NULL)
 , m_MeasurementPointSetChangedObserverTag(0)
 , m_PointSetChangedObserverTag(0)
 , m_WindowHeight(0)
 {
   m_Controls = NULL;
   CreateQtPartControl(this);
 }
 
 QmitkToFPointSetWidget::~QmitkToFPointSetWidget()
 {
   this->CleanUpWidget();
 }
 
 void QmitkToFPointSetWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkToFPointSetWidgetControls;
     m_Controls->setupUi(parent);
 
     this->CreateConnections();
   }
 }
 
 void QmitkToFPointSetWidget::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->measureButton), SIGNAL(clicked()),(QObject*) this, SLOT(OnMeasurement()) );
     connect( (QObject*)(m_Controls->pointSetButton), SIGNAL(clicked()),(QObject*) this, SLOT(OnPointSet()) );
   }
 }
 
 void QmitkToFPointSetWidget::InitializeWidget(QHash<QString, QmitkRenderWindow*> renderWindowHashMap, mitk::DataStorage::Pointer dataStorage, mitk::CameraIntrinsics::Pointer cameraIntrinsics)
 {
   // initialize members
   m_CameraIntrinsics = cameraIntrinsics;
   m_DataStorage = dataStorage;
   //  m_RenderWindowPart = renderWindowPart;
   m_RenderWindow1 = renderWindowHashMap.value("axial")->GetRenderWindow();
   m_RenderWindow2 = renderWindowHashMap.value("sagittal")->GetRenderWindow();
   m_RenderWindow3 = renderWindowHashMap.value("coronal")->GetRenderWindow();
   m_RenderWindow4 = renderWindowHashMap.value("3d")->GetRenderWindow();
   if ((m_RenderWindow1 != NULL) && (m_RenderWindow2 != NULL) && (m_RenderWindow3 != NULL) && (m_RenderWindow4 != NULL) && (dataStorage.IsNotNull()))
   {
     // enable buttons
     m_Controls->pointSetButton->setEnabled(true);
     m_Controls->measureButton->setEnabled(true);
     // initialize overlays
     this->m_VtkTextActor = vtkSmartPointer<vtkTextActor>::New();
     this->m_VtkTextActor->SetInput("Choose measurement points with SHIFT+Click");
     m_WindowHeight = renderWindowHashMap.value("axial")->GetRenderer()->GetSizeY();
     this->m_VtkTextActor->SetDisplayPosition(10,m_WindowHeight-30);
     this->m_VtkTextActor->GetTextProperty()->SetFontSize(16);
     //    this->m_VtkTextActor->GetTextProperty()->SetColor(1,0,0);
     this->m_VtkTextActor->GetTextProperty()->BoldOn();
     this->m_VtkTextActor->SetVisibility(0);
     if (m_ForegroundRenderer1==NULL)
     {
       this->m_ForegroundRenderer1 = vtkSmartPointer<vtkRenderer>::New();
       this->m_ForegroundRenderer1->AddActor(m_VtkTextActor);
       mitk::VtkLayerController::GetInstance(m_RenderWindow1)->InsertForegroundRenderer(m_ForegroundRenderer1,true);
     }
     if (m_ForegroundRenderer2==NULL)
     {
       this->m_ForegroundRenderer2 = vtkSmartPointer<vtkRenderer>::New();
       this->m_ForegroundRenderer2->AddActor(m_VtkTextActor);
       mitk::VtkLayerController::GetInstance(m_RenderWindow2)->InsertForegroundRenderer(m_ForegroundRenderer2,true);
     }
     if (m_ForegroundRenderer3==NULL)
     {
       this->m_ForegroundRenderer3 =vtkSmartPointer<vtkRenderer>::New();
       this->m_ForegroundRenderer3->AddActor(m_VtkTextActor);
       mitk::VtkLayerController::GetInstance(m_RenderWindow3)->InsertForegroundRenderer(m_ForegroundRenderer3,true);
     }
     mitk::DataNode::Pointer measurementPointSet2DNode = dataStorage->GetNamedNode("Measurement PointSet 2D") ;
     if(dataStorage->Exists(measurementPointSet2DNode))
     {
       dataStorage->Remove(measurementPointSet2DNode);
     }
     // initialize 2D measurement point set
     m_MeasurementPointSet2D = mitk::PointSet::New();
     measurementPointSet2DNode = mitk::DataNode::New();
     measurementPointSet2DNode->SetName("Measurement PointSet 2D");
     measurementPointSet2DNode->SetBoolProperty("helper object",true);
     measurementPointSet2DNode->SetBoolProperty("show contour",true);
     measurementPointSet2DNode->SetVisibility(false, renderWindowHashMap.value("3d")->GetRenderer());
     measurementPointSet2DNode->SetData(m_MeasurementPointSet2D);
     dataStorage->Add(measurementPointSet2DNode);
     m_MeasurementPointSetInteractor = mitk::PointSetInteractor::New("pointsetinteractor",measurementPointSet2DNode,2);
     // create observer for m_MeasurementPointSet2D
     itk::SimpleMemberCommand<QmitkToFPointSetWidget>::Pointer measurementPointSetChangedCommand;
     measurementPointSetChangedCommand = itk::SimpleMemberCommand<QmitkToFPointSetWidget>::New();
     measurementPointSetChangedCommand->SetCallbackFunction(this, &QmitkToFPointSetWidget::MeasurementPointSetChanged);
     m_MeasurementPointSetChangedObserverTag = m_MeasurementPointSet2D->AddObserver(itk::ModifiedEvent(), measurementPointSetChangedCommand);
     // initialize 3D measurement PointSet
     m_MeasurementPointSet3DNode = dataStorage->GetNamedNode("Measurement PointSet 3D");
     if(dataStorage->Exists(m_MeasurementPointSet3DNode))
     {
       dataStorage->Remove(m_MeasurementPointSet3DNode);
     }
     m_MeasurementPointSet3DNode = mitk::DataNode::New();
     m_MeasurementPointSet3DNode->SetName("Measurement PointSet 3D");
     m_MeasurementPointSet3DNode->SetBoolProperty("helper object",true);
     m_MeasurementPointSet3DNode->SetBoolProperty("show contour",true);
     m_MeasurementPointSet3DNode->SetFloatProperty("pointsize",5.0f);
     mitk::PointSet::Pointer measurementPointSet3D = mitk::PointSet::New();
     m_MeasurementPointSet3DNode->SetData(measurementPointSet3D);
     dataStorage->Add(m_MeasurementPointSet3DNode);
 
     // initialize PointSets
     mitk::DataNode::Pointer pointSet2DNode = dataStorage->GetNamedNode("ToF PointSet 2D") ;
     if(dataStorage->Exists(pointSet2DNode))
     {
       dataStorage->Remove(pointSet2DNode);
     }
     m_PointSet2D = mitk::PointSet::New();
     pointSet2DNode = mitk::DataNode::New();
     pointSet2DNode->SetName("ToF PointSet 2D");
     pointSet2DNode->SetVisibility(false, renderWindowHashMap.value("3d")->GetRenderer());
     pointSet2DNode->SetData(m_PointSet2D);
     dataStorage->Add(pointSet2DNode);
     m_PointSetInteractor = mitk::PointSetInteractor::New("pointsetinteractor",pointSet2DNode);
 
     // create observer for m_MeasurementPointSet2D
     itk::SimpleMemberCommand<QmitkToFPointSetWidget>::Pointer pointSetChangedCommand;
     pointSetChangedCommand = itk::SimpleMemberCommand<QmitkToFPointSetWidget>::New();
     pointSetChangedCommand->SetCallbackFunction(this, &QmitkToFPointSetWidget::PointSetChanged);
     m_PointSetChangedObserverTag = m_PointSet2D->AddObserver(itk::ModifiedEvent(), pointSetChangedCommand);
     // initialize 3D point set
     mitk::DataNode::Pointer pointSet3DNode = dataStorage->GetNamedNode("ToF PointSet 3D");
     if(dataStorage->Exists(pointSet3DNode))
     {
       dataStorage->Remove(pointSet3DNode);
     }
     m_PointSet3DNode = mitk::DataNode::New();
     m_PointSet3DNode->SetName("ToF PointSet 3D");
     m_PointSet3DNode->SetFloatProperty("pointsize",5.0f);
     mitk::PointSet::Pointer pointSet3D = mitk::PointSet::New();
     m_PointSet3DNode->SetData(pointSet3D);
     dataStorage->Add(m_PointSet3DNode);
   }
 }
 
 void QmitkToFPointSetWidget::CleanUpWidget()
 {
   // toggle button state
   if (m_Controls->measureButton->isChecked())
   {
     m_Controls->measureButton->setChecked(false);
     this->OnMeasurement();
   }
   if (m_Controls->pointSetButton->isChecked())
   {
     m_Controls->pointSetButton->setChecked(false);
     this->OnPointSet();
   }
   // remove observer
   if (m_MeasurementPointSet2D.IsNotNull())
   {
     m_MeasurementPointSet2D->RemoveObserver(m_MeasurementPointSetChangedObserverTag);
   }
   if (m_PointSet2D.IsNotNull())
   {
     m_PointSet2D->RemoveObserver(m_PointSetChangedObserverTag);
   }
 //  if (m_DistanceImage.IsNotNull())
 //  {
 //    m_DistanceImage->RemoveObserver(m_DistanceImageChangedObserverTag);
 //  }
   // remove foreground renderer
   if (m_ForegroundRenderer1&&m_RenderWindow1)
   {
     if (mitk::VtkLayerController::GetInstance(m_RenderWindow1))
     {
       mitk::VtkLayerController::GetInstance(m_RenderWindow1)->RemoveRenderer(m_ForegroundRenderer1);
     }
     m_ForegroundRenderer1 = NULL;
   }
   if (m_ForegroundRenderer2&&m_RenderWindow2)
   {
     if (mitk::VtkLayerController::GetInstance(m_RenderWindow2))
     {
       mitk::VtkLayerController::GetInstance(m_RenderWindow2)->RemoveRenderer(m_ForegroundRenderer2);
     }
     m_ForegroundRenderer2 = NULL;
   }
   if (m_ForegroundRenderer3&&m_RenderWindow3)
   {
     if (mitk::VtkLayerController::GetInstance(m_RenderWindow3))
     {
       mitk::VtkLayerController::GetInstance(m_RenderWindow3)->RemoveRenderer(m_ForegroundRenderer3);
     }
     m_ForegroundRenderer3 = NULL;
   }
   if (mitk::RenderingManager::GetInstance())
   {
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkToFPointSetWidget::SetDistanceImage(mitk::Image::Pointer distanceImage)
 {
 //  // remove existing observer
 //  if (m_DistanceImage.IsNotNull())
 //  {
 //    m_DistanceImage->RemoveObserver(m_DistanceImageChangedObserverTag);
 //  }
   m_DistanceImage = distanceImage;
 //  // create observer for m_DistanceImage
 //  itk::SimpleMemberCommand<QmitkToFPointSetWidget>::Pointer distanceImageChangedCommand;
 //  distanceImageChangedCommand = itk::SimpleMemberCommand<QmitkToFPointSetWidget>::New();
 //  distanceImageChangedCommand->SetCallbackFunction(this, &QmitkToFPointSetWidget::MeasurementPointSetChanged);
 //  m_DistanceImageChangedObserverTag = m_DistanceImage->AddObserver(itk::ModifiedEvent(), distanceImageChangedCommand);
 }
 
+void QmitkToFPointSetWidget::SetCameraIntrinsics(mitk::CameraIntrinsics::Pointer cameraIntrinsics)
+{
+  m_CameraIntrinsics = cameraIntrinsics;
+}
+
 void QmitkToFPointSetWidget::OnMeasurement()
 {
   // always show 2D PointSet in foreground
   mitk::DataNode::Pointer pointSetNode = m_DataStorage->GetNamedNode("Measurement PointSet 2D");
   if (pointSetNode.IsNotNull())
   {
     pointSetNode->SetIntProperty("layer",100);
   }
   if (m_Controls->measureButton->isChecked())
   {
     // disable point set interaction
     if (m_Controls->pointSetButton->isChecked())
     {
       m_Controls->pointSetButton->setChecked(false);
       // remove interactor
       mitk::GlobalInteraction::GetInstance()->RemoveInteractor(m_PointSetInteractor);
     }
     // show overlays
     m_VtkTextActor->SetVisibility(1);
     this->m_VtkTextActor->SetInput("Choose measurement points with SHIFT+Click");
     // enable interactor
     mitk::GlobalInteraction::GetInstance()->AddInteractor(m_MeasurementPointSetInteractor);
     // initial update of measurement
     this->MeasurementPointSetChanged();
   }
   else
   {
     // hide overlays
     m_VtkTextActor->SetVisibility(0);
     // disable interactor
     mitk::GlobalInteraction::GetInstance()->RemoveInteractor(m_MeasurementPointSetInteractor);
   }
 }
 
 void QmitkToFPointSetWidget::OnPointSet()
 {
   // always show 2D PointSet in foreground
   mitk::DataNode::Pointer pointSetNode = m_DataStorage->GetNamedNode("ToF PointSet 2D");
   if (pointSetNode.IsNotNull())
   {
     pointSetNode->SetIntProperty("layer",100);
   }
   if (m_Controls->pointSetButton->isChecked())
   {
     // disable measurement
     if (m_Controls->measureButton->isChecked())
     {
       m_Controls->measureButton->setChecked(false);
       // remove interactor
       mitk::GlobalInteraction::GetInstance()->RemoveInteractor(m_MeasurementPointSetInteractor);
     }
     // show overlays
     m_VtkTextActor->SetVisibility(1);
     this->m_VtkTextActor->SetInput("Choose points with SHIFT+Click");
     // enable interactor
     mitk::GlobalInteraction::GetInstance()->AddInteractor(m_PointSetInteractor);
     // initial update of PointSet
     this->PointSetChanged();
   }
   else
   {
     // hide overlays
     m_VtkTextActor->SetVisibility(0);
     // disable interactor
     mitk::GlobalInteraction::GetInstance()->RemoveInteractor(m_PointSetInteractor);
   }
 }
 
 void QmitkToFPointSetWidget::MeasurementPointSetChanged()
 {
   // replace text actor
   this->m_VtkTextActor->SetDisplayPosition(10,m_WindowHeight-30);
   if (m_MeasurementPointSet2D->GetSize()==2)
   {
     // check if points are inside the image range
     int imageSizeX = m_DistanceImage->GetDimensions()[0];
     int imageSizeY = m_DistanceImage->GetDimensions()[1];
     mitk::Point3D point1 = m_MeasurementPointSet2D->GetPoint(0);
     mitk::Point3D point2 = m_MeasurementPointSet2D->GetPoint(1);
     if ((point1[0]>=0.0f)&&(point1[0]<imageSizeX)&&(point1[1]>=0)&&(point1[1]<imageSizeY)&&
         (point2[0]>=0.0f)&&(point2[0]<imageSizeX)&&(point2[1]>=0)&&(point2[1]<imageSizeY))
     {
       // create PointSet filter
       mitk::ToFDistanceImageToPointSetFilter::Pointer toFDistanceImageToPointSetFilter = mitk::ToFDistanceImageToPointSetFilter::New();
       if (m_CameraIntrinsics.IsNotNull())
       {
         toFDistanceImageToPointSetFilter->SetCameraIntrinsics(m_CameraIntrinsics);
       }
       toFDistanceImageToPointSetFilter->SetInput(m_DistanceImage);
       toFDistanceImageToPointSetFilter->SetSubset(m_MeasurementPointSet2D);
       toFDistanceImageToPointSetFilter->Update();
       mitk::PointSet::Pointer measurementPointSet3D = toFDistanceImageToPointSetFilter->GetOutput();
       m_MeasurementPointSet3DNode->SetData(measurementPointSet3D);
 
       // calculate distance between points
       if (measurementPointSet3D->GetSize()==2)
       {
         mitk::Point3D point1 = measurementPointSet3D->GetPoint(0);
         mitk::Point3D point2 = measurementPointSet3D->GetPoint(1);
         float distance = point1.EuclideanDistanceTo(point2);
         std::stringstream stream;
         stream<<distance<<" mm";
         this->m_VtkTextActor->SetInput(stream.str().c_str());
       }
       else
       {
         this->m_VtkTextActor->SetInput("Choose measurement points with SHIFT+Click");
       }
     }
     else
     {
       this->m_VtkTextActor->SetInput("Measurement outside image range.");
     }
   }
   else
   {
     // initialize 3D pointset empty
     mitk::PointSet::Pointer pointSet3D = mitk::PointSet::New();
     m_MeasurementPointSet3DNode->SetData(pointSet3D);
   }
 }
 
 void QmitkToFPointSetWidget::PointSetChanged()
 {
   if (m_DistanceImage.IsNotNull())
   {
   int imageSizeX = m_DistanceImage->GetDimensions()[0];
   int imageSizeY = m_DistanceImage->GetDimensions()[1];
   int pointSetValid = 1;
   for (int i=0; i<m_PointSet2D->GetSize(); i++)
   {
     mitk::Point3D currentPoint = m_PointSet2D->GetPoint(i);
     if ((currentPoint[0]>=0.0f)&&(currentPoint[0]<imageSizeX)&&(currentPoint[1]>=0)&&(currentPoint[1]<imageSizeY))
     {
       pointSetValid*=1;
     }
     else
     {
       pointSetValid*=0;
     }
   }
   if (m_PointSet2D->GetSize()>0)
   {
     if (pointSetValid)
     {
       // create PointSet filter
       mitk::ToFDistanceImageToPointSetFilter::Pointer toFDistanceImageToPointSetFilter = mitk::ToFDistanceImageToPointSetFilter::New();
       if (m_CameraIntrinsics.IsNotNull())
       {
         toFDistanceImageToPointSetFilter->SetCameraIntrinsics(m_CameraIntrinsics);
       }
       toFDistanceImageToPointSetFilter->SetInput(m_DistanceImage);
       toFDistanceImageToPointSetFilter->SetSubset(m_PointSet2D);
       toFDistanceImageToPointSetFilter->Update();
       mitk::PointSet::Pointer pointSet3D = toFDistanceImageToPointSetFilter->GetOutput();
       m_PointSet3DNode->SetData(pointSet3D);
       this->m_VtkTextActor->SetInput("Choose points with SHIFT+Click");    }
     else
     {
       this->m_VtkTextActor->SetInput("Point set outside image range.");
     }
   }
   else
   {
     // initialize 3D pointset empty
     mitk::PointSet::Pointer pointSet3D = mitk::PointSet::New();
     m_PointSet3DNode->SetData(pointSet3D);
   }
   }
 }
diff --git a/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.h b/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.h
index 42bf039d02..b15a583c2a 100644
--- a/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.h
+++ b/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.h
@@ -1,143 +1,147 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef _QmitkToFPointSetWidget_H_INCLUDED
 #define _QmitkToFPointSetWidget_H_INCLUDED
 
 #include "mitkTOFUIExports.h"
 #include "ui_QmitkToFPointSetWidgetControls.h"
 
 //mitk headers
 #include <mitkCameraIntrinsics.h>
 #include <mitkDataStorage.h>
 #include <mitkPointSet.h>
 #include <mitkPointSetInteractor.h>
 #include <mitkPropertyList.h>
 #include <mitkToFDistanceImageToPointSetFilter.h>
 
 //Qmitk headers
 #include <QmitkRenderWindow.h>
 
 // vtk includes
 #include <vtkSmartPointer.h>
 #include <vtkTextActor.h>
 #include <vtkRenderer.h>
 
 /**
 * @brief Widget allowing interaction with point sets for measurement and PointSet definition
 *
 * The widget allows to
 * 1. Measure the distance between two points in 3D ToF space by clicking the points in the 2D slices
 * 2. Defining a ToF PointSet both in 2D and 3D. CameraIntrinsics are used for calculation between 2D and 3D
 *
 * NOTE:
 * You have to make sure that the widget is initialized at a position in the plugin using it, where the distance
 * image is available. CleanUp has to be called to make sure that all observers and renderers are removed correctly.
 *
 * @ingroup ToFUI
 */
 class mitkTOFUI_EXPORT QmitkToFPointSetWidget :public QWidget
 {
   //this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
   public:
 
     static const std::string VIEW_ID;
 
     QmitkToFPointSetWidget(QWidget* p = 0, Qt::WindowFlags f1 = 0);
     virtual ~QmitkToFPointSetWidget();
 
     /* @brief This method is part of the widget an needs not to be called seperately. */
     virtual void CreateQtPartControl(QWidget *parent);
     /* @brief This method is part of the widget an needs not to be called seperately. (Creation of the connections of main and control widget.)*/
     virtual void CreateConnections();
 
     /*!
     \brief initializes the widget. Observers to the change events of the point sets are created, text actors are activated
     to be rendered into the foreground of the render window.
     \param stdMultiWidget QmitkStdMultiWidget used for painting overlays for measurement
     \param dataStorage DataStorage to add PointSets
     \param distanceImage range image used to calculate 3D PointSet from 2D index
     */
     void InitializeWidget(QHash<QString, QmitkRenderWindow*> renderWindowHashMap, mitk::DataStorage::Pointer dataStorage, mitk::CameraIntrinsics::Pointer cameraIntrinsics=NULL);
     /*!
     \brief cleans up the widget when it's functionality is not used anymore.
     Removes observers and deletes foreground renderer
     */
     void CleanUpWidget();
     /*!
     \brief set the image holding the distance information used for measuring
     */
     void SetDistanceImage(mitk::Image::Pointer distanceImage);
+    /*!
+    \brief Set intrinsic parameters of the used device
+    */
+    void SetCameraIntrinsics(mitk::CameraIntrinsics::Pointer cameraIntrinsics);
 
   signals:
 
   protected slots:
     /*!
     \brief Activates the interactor for the measurement point set
     */
     void OnMeasurement();
     /*!
     \brief Activates the interactor for the point set
     */
     void OnPointSet();
 
   protected:
 
     /*!
     \brief function called when the 2D measurement PointSet has changed
     */
     void MeasurementPointSetChanged();
     /*!
     \brief function called when the 2D PointSet has changed
     */
     void PointSetChanged();
 
     Ui::QmitkToFPointSetWidgetControls* m_Controls; ///< member holding the UI elements of this widget
 
     mitk::DataStorage::Pointer m_DataStorage; ///< member holding the set DataStorage
 
     mitk::Image::Pointer m_DistanceImage; ///< image holding the range data of the ToF camera
     mitk::CameraIntrinsics::Pointer m_CameraIntrinsics; ///< intrinsic parameters of the camera
 
     vtkSmartPointer<vtkTextActor> m_VtkTextActor; ///< actor containing the text of the overlay
     vtkSmartPointer<vtkRenderer> m_ForegroundRenderer1; ///< renderer responsible for text rendering in the foreground of widget 1
     vtkSmartPointer<vtkRenderer> m_ForegroundRenderer2; ///< renderer responsible for text rendering in the foreground of widget 2
     vtkSmartPointer<vtkRenderer> m_ForegroundRenderer3; ///< renderer responsible for text rendering in the foreground of widget 3
     vtkSmartPointer<vtkRenderWindow> m_RenderWindow1; ///< vtk render window used for showing overlay in widget 1
     vtkSmartPointer<vtkRenderWindow> m_RenderWindow2; ///< vtk render window used for showing overlay in widget 2
     vtkSmartPointer<vtkRenderWindow> m_RenderWindow3; ///< vtk render window used for showing overlay in widget 3
     vtkSmartPointer<vtkRenderWindow> m_RenderWindow4; ///< vtk render window used for showing overlay in widget 3
 
     mitk::PointSet::Pointer m_MeasurementPointSet2D; ///< PointSet holding the 2D ToF image point selection used for measuring
     mitk::DataNode::Pointer m_MeasurementPointSet3DNode; ///< DataNode holding the 3D ToF coordinates used for measuring
     mitk::PointSet::Pointer m_PointSet2D; ///< PointSet holding the 2D ToF image points
     mitk::DataNode::Pointer m_PointSet3DNode; ///< DataNode holding the 3D ToF coordinates
 
     mitk::PointSetInteractor::Pointer m_PointSetInteractor; ///< PointSetInteractor used for PointSet definition
     mitk::PointSetInteractor::Pointer m_MeasurementPointSetInteractor; ///< PointSetInteractor used for measurement
 
     long m_MeasurementPointSetChangedObserverTag; ///< observer tag for measurement PointSet observer
     long m_PointSetChangedObserverTag; ///< observer tag for PointSet observer
 //    long m_DistanceImageChangedObserverTag; ///< observer tag for distance image observer
 
     int m_WindowHeight; ///< Height of the renderWindow
 
   private:
 };
 
 #endif // _QmitkToFPointSetWidget_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
index d110b121ef..35ad1bf486 100644
--- a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
+++ b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.cpp
@@ -1,702 +1,721 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 // Blueberry
 #include <mitkIRenderingManager.h>
 #include <mitkIRenderWindowPart.h>
 #include <mitkILinkedRenderWindowPart.h>
 
 
 // Qmitk
 #include "QmitkToFUtilView.h"
 #include <QmitkStdMultiWidget.h>
 #include <QmitkTextOverlay.h>
 
 // Qt
 #include <QMessageBox>
 #include <QString>
 
 //QT headers
 #include <qmessagebox.h>
 #include <qfiledialog.h>
 #include <qcombobox.h>
 
 // MITK
 #include <mitkBaseRenderer.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkToFDistanceImageToPointSetFilter.h>
 #include <mitkTransferFunction.h>
 #include <mitkTransferFunctionProperty.h>
 
 #include <mitkToFDeviceFactoryManager.h>
 #include <mitkToFCameraDevice.h>
+#include <mitkCameraIntrinsicsProperty.h>
 
 //itk headers
 #include <itksys/SystemTools.hxx>
 
 // VTK
 #include <vtkCamera.h>
 
 // ITK
 #include <itkCommand.h>
 
 const std::string QmitkToFUtilView::VIEW_ID = "org.mitk.views.tofutil";
 
 //Constructor
 QmitkToFUtilView::QmitkToFUtilView()
 : QmitkAbstractView()
 , m_Controls(NULL), m_MultiWidget( NULL )
 , m_MitkDistanceImage(NULL), m_MitkAmplitudeImage(NULL), m_MitkIntensityImage(NULL), m_Surface(NULL)
 , m_DistanceImageNode(NULL), m_AmplitudeImageNode(NULL), m_IntensityImageNode(NULL), m_RGBImageNode(NULL), m_SurfaceNode(NULL)
 , m_ToFImageRecorder(NULL), m_ToFImageGrabber(NULL), m_ToFDistanceImageToSurfaceFilter(NULL), m_ToFCompositeFilter(NULL)
 , m_SurfaceDisplayCount(0), m_2DDisplayCount(0)
 , m_RealTimeClock(NULL)
 , m_StepsForFramerate(100)
 , m_2DTimeBefore(0.0)
 , m_2DTimeAfter(0.0)
 , m_VideoEnabled(false)
+, m_CameraIntrinsics(NULL)
 {
   this->m_Frametimer = new QTimer(this);
 
   this->m_ToFDistanceImageToSurfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
   this->m_ToFCompositeFilter = mitk::ToFCompositeFilter::New();
   this->m_ToFImageRecorder = mitk::ToFImageRecorder::New();
   this->m_ToFSurfaceVtkMapper3D = mitk::ToFSurfaceVtkMapper3D::New();
 }
 
 //Destructor, specifically calling OnToFCameraStopped() and OnToFCammeraDiconnected()
 QmitkToFUtilView::~QmitkToFUtilView()
 {
   OnToFCameraStopped();
   OnToFCameraDisconnected();
 }
 
 //Createing the PartControl Signal-Slot principal
 void QmitkToFUtilView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkToFUtilViewControls;
     m_Controls->setupUi( parent );
 
     //Looking for Input and Defining reaction
     connect(m_Frametimer, SIGNAL(timeout()), this, SLOT(OnUpdateCamera()));
 
     connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(KinectAcquisitionModeChanged()), this, SLOT(OnKinectAcquisitionModeChanged()) ); // Todo in Widget2
     connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraConnected()), this, SLOT(OnToFCameraConnected()) );
     connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraDisconnected()), this, SLOT(OnToFCameraDisconnected()) );
     connect( (QObject*)(m_Controls->m_ToFConnectionWidget), SIGNAL(ToFCameraSelected(const QString)), this, SLOT(OnToFCameraSelected(const QString)) );
     connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(ToFCameraStarted()), this, SLOT(OnToFCameraStarted()) );
     connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(ToFCameraStopped()), this, SLOT(OnToFCameraStopped()) );
     connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(RecordingStarted()), this, SLOT(OnToFCameraStopped()) );
     connect( (QObject*)(m_Controls->m_ToFRecorderWidget), SIGNAL(RecordingStopped()), this, SLOT(OnToFCameraStarted()) );
     connect( (QObject*)(m_Controls->m_TextureCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnTextureCheckBoxChecked(bool)) );
     connect( (QObject*)(m_Controls->m_VideoTextureCheckBox), SIGNAL(toggled(bool)), this, SLOT(OnVideoTextureCheckBoxChecked(bool)) );
   }
 }
 
 //SetFocus-Method -> actually seting Focus to the Recorder
 void QmitkToFUtilView::SetFocus()
 {
   m_Controls->m_ToFRecorderWidget->setFocus();
 }
 
 //Activated-Method->Generating RenderWindow
 void QmitkToFUtilView::Activated()
 {
   //get the current RenderWindowPart or open a new one if there is none
   if(this->GetRenderWindowPart(OPEN))
   {
     mitk::ILinkedRenderWindowPart* linkedRenderWindowPart = dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart());
     if(linkedRenderWindowPart == 0)
     {
       MITK_ERROR << "No linked StdMultiWidget avaiable!!!";
     }
     else
     {
       linkedRenderWindowPart->EnableSlicingPlanes(false);
     }
     GetRenderWindowPart()->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);
 
     if (this->m_ToFCompositeFilter)
     {
       m_Controls->m_ToFCompositeFilterWidget->SetToFCompositeFilter(this->m_ToFCompositeFilter);
     }
     if (this->GetDataStorage())
     {
       m_Controls->m_ToFCompositeFilterWidget->SetDataStorage(this->GetDataStorage());
     }
 
     if (this->m_ToFImageGrabber.IsNull())
     {
       m_Controls->m_ToFRecorderWidget->setEnabled(false);
       m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
       m_Controls->m_ToFCompositeFilterWidget->setEnabled(false);
       m_Controls->tofMeasurementWidget->setEnabled(false);
       m_Controls->SurfacePropertiesBox->setEnabled(false);
     }
   }
 }
 
 //ZomnnieView-Method -> Resetting GUI to default. Why not just QmitkToFUtilView()?!
 void QmitkToFUtilView::ActivatedZombieView(berry::IWorkbenchPartReference::Pointer /*zombieView*/)
 {
   ResetGUIToDefault();
 }
 
 void QmitkToFUtilView::Deactivated()
 {
 }
 
 void QmitkToFUtilView::Visible()
 {
 }
 
 //Reset of the ToFUtilView
 void QmitkToFUtilView::Hidden()
 {
   ResetGUIToDefault();
 }
 
 void QmitkToFUtilView::OnToFCameraConnected()
 {
   MITK_INFO <<"OnToFCameraConnected";
   this->m_SurfaceDisplayCount = 0;
   this->m_2DDisplayCount = 0;
 
   this->m_ToFImageGrabber = m_Controls->m_ToFConnectionWidget->GetToFImageGrabber();
 
   // initialize surface generation
   this->m_ToFDistanceImageToSurfaceFilter = mitk::ToFDistanceImageToSurfaceFilter::New();
   this->m_ToFSurfaceVtkMapper3D = mitk::ToFSurfaceVtkMapper3D::New();
 
   // initialize ToFImageRecorder and ToFRecorderWidget
   this->m_ToFImageRecorder = mitk::ToFImageRecorder::New();
   this->m_ToFImageRecorder->SetCameraDevice(this->m_ToFImageGrabber->GetCameraDevice());
   m_Controls->m_ToFRecorderWidget->SetParameter(this->m_ToFImageGrabber, this->m_ToFImageRecorder);
   m_Controls->m_ToFRecorderWidget->setEnabled(true);
   m_Controls->m_ToFRecorderWidget->ResetGUIToInitial();
   m_Controls->m_ToFVisualisationSettingsWidget->setEnabled(false);
 
   // initialize ToFCompositeFilterWidget
   this->m_ToFCompositeFilter = mitk::ToFCompositeFilter::New();
   if (this->m_ToFCompositeFilter)
   {
     m_Controls->m_ToFCompositeFilterWidget->SetToFCompositeFilter(this->m_ToFCompositeFilter);
   }
   if (this->GetDataStorage())
   {
     m_Controls->m_ToFCompositeFilterWidget->SetDataStorage(this->GetDataStorage());
   }
 
   // initialize measurement widget
   m_Controls->tofMeasurementWidget->InitializeWidget(this->GetRenderWindowPart()->GetQmitkRenderWindows(),this->GetDataStorage());
 
   //TODO
   this->m_RealTimeClock = mitk::RealTimeClock::New();
   this->m_2DTimeBefore = this->m_RealTimeClock->GetCurrentStamp();
   /*//As it seems, this part of the Code doing nothing but producing an error message
   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.contains("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())
   {
+    // initialize camera intrinsics
+    if (this->m_ToFImageGrabber->GetProperty("CameraIntrinsics"))
+    {
+      m_CameraIntrinsics = dynamic_cast<mitk::CameraIntrinsicsProperty*>(this->m_ToFImageGrabber->GetProperty("CameraIntrinsics"))->GetValue();
+    }
+    else
+    {
+      m_CameraIntrinsics = NULL;
+    }
     // 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.contains("Kinect"))||(rgbFileName!=""))
 
     {
       if (rgbFileName!="" || m_ToFImageGrabber->GetBoolProperty("RGB") )
       {
         this->m_RGBImageNode = ReplaceNodeData("RGB image",this->m_ToFImageGrabber->GetOutput(3));
       }
       else if (m_ToFImageGrabber->GetBoolProperty("IR"))
       {
         this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
       }
     }
     else
     {
       this->m_RGBImageNode = NULL;
       this->m_MitkAmplitudeImage = m_ToFCompositeFilter->GetOutput(1);
       this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
       this->m_MitkIntensityImage = m_ToFCompositeFilter->GetOutput(2);
       this->m_IntensityImageNode = ReplaceNodeData("Intensity image",m_MitkIntensityImage);
     }
     this->m_AmplitudeImageNode = ReplaceNodeData("Amplitude image",m_MitkAmplitudeImage);
     this->m_IntensityImageNode = ReplaceNodeData("Intensity image",m_MitkIntensityImage);
 
+    if (m_CameraIntrinsics.IsNotNull())
+    {
+      this->m_ToFDistanceImageToSurfaceFilter->SetCameraIntrinsics(m_CameraIntrinsics);
+    }
     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
+    // initialize measurement widget
+    if (m_CameraIntrinsics.IsNotNull())
+    {
+      m_Controls->tofMeasurementWidget->SetCameraIntrinsics(m_CameraIntrinsics);
+    }
     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.contains("CamBoard"))||(selected.contains("O3D")))
   {
     MITK_INFO<<"Surface representation currently not available for CamBoard and O3. Intrinsic parameters missing.";
     this->m_Controls->m_SurfaceCheckBox->setEnabled(false);
     this->m_Controls->m_TextureCheckBox->setEnabled(false);
     this->m_Controls->m_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);
     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.contains("Kinect"))&&(m_ToFImageGrabber->GetBoolProperty("RGB")))
     {
       this->m_AmplitudeImageNode->SetProperty( "visible" , mitk::BoolProperty::New( false ));
     }
     else
     {
       this->m_AmplitudeImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
     }
     this->m_AmplitudeImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->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.contains("Kinect"))
     {
       this->m_IntensityImageNode->SetProperty( "visible" , mitk::BoolProperty::New( false ));
     }
     else
     {
       this->m_IntensityImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
       this->m_IntensityImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->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.contains("Kinect"))&&(m_ToFImageGrabber->GetBoolProperty("IR")))
     {
       this->m_RGBImageNode->SetProperty( "visible" , mitk::BoolProperty::New( false ));
     }
     else
     {
       this->m_RGBImageNode->SetProperty( "visible" , mitk::BoolProperty::New( true ));
       this->m_RGBImageNode->SetVisibility( !useToF, mitk::BaseRenderer::GetInstance(GetRenderWindowPart()->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")));
 }
diff --git a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.h b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.h
index 75e5127d3c..e3b31f2768 100644
--- a/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.h
+++ b/Plugins/org.mitk.gui.qt.tofutil/src/internal/QmitkToFUtilView.h
@@ -1,195 +1,197 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef QmitkToFUtilView_h
 #define QmitkToFUtilView_h
 
 #include <QmitkOverlayController.h>
 #include <QmitkAbstractView.h>
 #include <berryIWorkbenchPartReference.h>
 #include <mitkIZombieViewPart.h>
 
 
 #include <ui_QmitkToFUtilViewControls.h>
 
 class QTimer;
 
 #include <mitkRealTimeClock.h>
 #include <mitkToFImageGrabber.h>
 #include <mitkOpenCVVideoSource.h>
 #include <mitkSurface.h>
 #include <mitkToFDistanceImageToSurfaceFilter.h>
 #include <mitkToFSurfaceVtkMapper3D.h>
 #include <mitkToFImageRecorder.h>
 #include <mitkToFCompositeFilter.h>
+#include <mitkCameraIntrinsics.h>
 
 /*!
   \brief QmitkToFUtilView
 
   Application that allows simple playing, recording, visualization, processing and measurement of Time-of-Flight (ToF) data.
   Currently the following features are implemented:
   <ul>
   <li>Connecting and showing ToF data from various cameras (PMD CamCube 2/3, PMD CamBoard, PMD O3, MESA SwissRanger)</li>
   <li>Recording and playing of ToF data</li>
   <li>Color coded visualization of ToF images</li>
   <li>Preprocessing of the distance data: Threshold, median, average and bilateral filtering; surface generation</li>
   <li>Simple measurement and PointSet definition</li>
   </ul>
 
   \sa QmitkFunctionality
   \ingroup Functionalities
 */
 class QmitkToFUtilView : public QmitkAbstractView, public mitk::IZombieViewPart
 {
     // this is needed for all Qt objects that should have a Qt meta-object
     // (everything that derives from QObject and wants to have signal/slots)
     Q_OBJECT
 
 public:
 
     static const std::string VIEW_ID;
 
     QmitkToFUtilView();
     ~QmitkToFUtilView();
 
     //TODO bitte loeschen, wenn besserer weg gefunden
     void HackForPlayer();
 
     virtual void CreateQtPartControl(QWidget *parent);
     /// \brief Called when the functionality is activated.
     virtual void Activated();
     /// \brief Called when the functionality is deactivated. In this case the zombie view of this functionality becomes active!
     virtual void ActivatedZombieView(berry::IWorkbenchPartReference::Pointer zombieView);
 
     virtual void Deactivated();
     virtual void Visible();
     virtual void Hidden();
 
     void SetFocus();
 
 protected slots:
 
     /*!
     \brief Slot triggered from the timer to update the images and visualization
     */
     void OnUpdateCamera();
     /*!
     \brief Slot called when the "Connect" button of the ConnectionWidget is pressed
     */
     void OnToFCameraConnected();
     /*!
     \brief Slot called when the "Disconnect" button of the ConnectionWidget is pressed
     */
     void OnToFCameraDisconnected();
     /*!
     \brief Slot called when the camera selection in the ConnectionWidget has changed
     */
     void OnToFCameraSelected(const QString selected);
     /*!
     \brief Slot called when the "Start" button of the RecorderWidget is pressed
     */
     void OnToFCameraStarted();
     /*!
     \brief Slot called when the "Stop" button of the RecorderWidget is pressed
     */
     void OnToFCameraStopped();
     /*!
     \brief Slot invoked when the texture checkbox is checked. Enables the scalar visibility of the surface
     */
     void OnTextureCheckBoxChecked(bool checked);
     /*!
     \brief Slot invoked when the video texture checkbox is checked. Enables the texture of the surface
     */
     void OnVideoTextureCheckBoxChecked(bool checked);
     /*!
     \brief Slot invoked when user alters the coronal window input from RGB to Intensity or vice versa.
     */
     void OnChangeCoronalWindowOutput(int index);
     /*!
     \brief Slot invoked when acquisition mode of Kinect is changed
     */
     void OnKinectAcquisitionModeChanged();
 
 protected:
 
     /*!
     \brief initialize the visibility settings of ToF data (images + surface)
     \param useToF true: distance image: widget1, amplitude image: widget 2, intensity image: widget 3; false: standard
     */
     void UseToFVisibilitySettings(bool useToF);
 
     Ui::QmitkToFUtilViewControls* m_Controls;
 
     QmitkStdMultiWidget* m_MultiWidget;
 
     QTimer* m_Frametimer; ///< Timer used to continuously update the images
 
     QString m_SelectedCamera; ///< String holding the selected camera
 
     mitk::Image::Pointer m_MitkDistanceImage; ///< member holding a pointer to the distance image of the selected camera
     mitk::Image::Pointer m_MitkAmplitudeImage; ///< member holding a pointer to the amplitude image of the selected camera
     mitk::Image::Pointer m_MitkIntensityImage; ///< member holding a pointer to the intensity image of the selected camera
     mitk::Surface::Pointer m_Surface; ///< member holding a pointer to the surface generated from the distance image of the selected camera
 
     mitk::DataNode::Pointer m_DistanceImageNode; ///< DataNode holding the distance image of the selected camera
     mitk::DataNode::Pointer m_AmplitudeImageNode; ///< DataNode holding the amplitude image of the selected camera
     mitk::DataNode::Pointer m_IntensityImageNode; ///< DataNode holding the intensity image of the selected camera
     mitk::DataNode::Pointer m_RGBImageNode; ///< DataNode holding the rgb image of the selected camera
     mitk::DataNode::Pointer m_SurfaceNode; ///< DataNode holding the surface generated from the distanc image of the selected camera
 
     // ToF processing and recording filter
     mitk::ToFImageRecorder::Pointer m_ToFImageRecorder; ///< ToF image recorder used for lossless recording of ToF image data
     mitk::ToFImageGrabber::Pointer m_ToFImageGrabber; ///< Source of a ToF image processing pipeline. Provides pointers to distance, amplitude and intensity image
     mitk::ToFDistanceImageToSurfaceFilter::Pointer m_ToFDistanceImageToSurfaceFilter; ///< Filter for calculating a surface representation from a given distance image
     mitk::ToFCompositeFilter::Pointer m_ToFCompositeFilter; ///< Filter combining several processing steps (thresholding, Median filtering, Bilateral filtering)
 
+    mitk::CameraIntrinsics::Pointer m_CameraIntrinsics;
     int m_SurfaceDisplayCount; ///< member used to determine whether surface is initialized or not
     int m_2DDisplayCount; ///< member used to determine whether frame rate output should be shown
     // members for calculating the frame rate
     mitk::RealTimeClock::Pointer m_RealTimeClock; ///< real time clock used to calculate the display framerate
     int m_StepsForFramerate; ///< number of steps used for calculating the display framerate
     double m_2DTimeBefore; ///< holds the time stamp at the beginning of the display framerate measurement
     double m_2DTimeAfter; ///< holds the time stamp at the end of the display framerate measurement
 
     // members used for displaying an external video source
     mitk::OpenCVVideoSource::Pointer m_VideoSource; ///< OpenCV video source to connect a video device
     unsigned char* m_VideoTexture; ///< texture used to show video image
     int m_VideoCaptureWidth; ///< width of the video image
     int m_VideoCaptureHeight; ///< height of the video image
     bool m_VideoEnabled; ///< flag indicating whether video grabbing is enabled. Set via the RGB texture checkbox
 
 private:
 
     /*!
     \brief helper method to replace data of the specified node. If node does not exist it will be created
     \param nodeName Name of the node
     \param data Data object to be replaced
     \return returns the node
     */
     mitk::DataNode::Pointer ReplaceNodeData(std::string nodeName, mitk::BaseData* data);
 
     void ProcessVideoTransform();
 
     /*!
       \brief Reset all GUI related things to default. E.g. show sagittal and coronal slices in the renderwindows.
       */
     void ResetGUIToDefault();
 
     mitk::ToFSurfaceVtkMapper3D::Pointer m_ToFSurfaceVtkMapper3D;
 };
 
 #endif // _QMITKTOFUTILVIEW_H_INCLUDED