diff --git a/Modules/ToFHardware/mitkToFCameraMITKPlayerController.cpp b/Modules/ToFHardware/mitkToFCameraMITKPlayerController.cpp
index ae0bf96a70..55d1220d53 100644
--- a/Modules/ToFHardware/mitkToFCameraMITKPlayerController.cpp
+++ b/Modules/ToFHardware/mitkToFCameraMITKPlayerController.cpp
@@ -1,373 +1,373 @@
 /*=========================================================================
 
 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 <mitkToFCameraMITKPlayerController.h>
 #include <itksys/SystemTools.hxx>
 
 // mitk includes
 #include "mitkItkImageFileReader.h"
 #include "mitkPicFileReader.h"
 #include <mitkIpPic.h>
 
 namespace mitk
 {
 
   ToFCameraMITKPlayerController::ToFCameraMITKPlayerController():m_PixelNumber(0),m_NumberOfBytes(0),
     m_CaptureWidth(0),m_CaptureHeight(0),m_ConnectionCheck(false),m_InputFileName(""),
     m_ToFImageType(ToFImageType3D), m_IntensityArray(NULL),m_DistanceArray(NULL),m_AmplitudeArray(NULL),
     m_DistanceImageFileName(""),m_AmplitudeImageFileName(""),m_IntensityImageFileName(""), m_Extension(""),
     m_CurrentFrame(-1),m_NumOfFrames(0),
     m_DistanceImage(0), m_AmplitudeImage(0),m_IntensityImage(0),
     m_PixelStartInFile(0), m_DistanceInfile(NULL),m_AmplitudeInfile(NULL),m_IntensityInfile(NULL)
   {
     m_ImageStatus = std::vector<bool>(3,true);
   }
 
   ToFCameraMITKPlayerController::~ToFCameraMITKPlayerController()
   {
     this->CleanUp();
   }
 
   void ToFCameraMITKPlayerController::CleanUp()
   {
     if(m_DistanceImage.IsNotNull())
     {
       m_DistanceImage->ReleaseData();
       m_DistanceImage = NULL;
     }
     if(m_AmplitudeImage.IsNotNull())
     {
       m_AmplitudeImage->ReleaseData();
       m_AmplitudeImage = NULL;
     }
     if(m_IntensityImage.IsNotNull())
     {
       m_IntensityImage->ReleaseData();
       m_IntensityImage = NULL;
     }
 
     delete[] this->m_DistanceArray;
     this->m_DistanceArray = NULL;
     delete[] this->m_AmplitudeArray;
     this->m_AmplitudeArray = NULL;
     delete[] this->m_IntensityArray;
     this->m_IntensityArray = NULL;
   }
 
  bool ToFCameraMITKPlayerController::CheckCurrentFileType()
   {
     if(!this->m_DistanceImageFileName.empty())
     {
       if(ItkImageFileReader::CanReadFile(m_DistanceImageFileName,"",".nrrd"))
       {
         m_Extension = ".nrrd";
         return true;
       }
       else if (PicFileReader::CanReadFile(m_DistanceImageFileName,"",".pic"))
       {
         m_Extension = ".pic";
         return true;
       }
     }
 
     if(!this->m_AmplitudeImageFileName.empty())
     {
       if(ItkImageFileReader::CanReadFile(m_AmplitudeImageFileName,"",".nrrd"))
       {
         m_Extension = ".nrrd";
         return true;
       }
       else if (PicFileReader::CanReadFile(m_AmplitudeImageFileName,"",".pic"))
       {
         m_Extension = ".pic";
         return true;
       }
     }
 
     if(!this->m_IntensityImageFileName.empty())
     {
       if(ItkImageFileReader::CanReadFile(m_IntensityImageFileName,"",".nrrd"))
       {
         m_Extension = ".nrrd";
         return true;
       }
       else if (PicFileReader::CanReadFile(m_IntensityImageFileName,"",".pic"))
       {
         m_Extension = ".pic";
         return true;
       }
     }
     return false;
   }
 
   bool ToFCameraMITKPlayerController::OpenCameraConnection()
   {
     if(!this->m_ConnectionCheck)
     {  
       try
       {
         // Check for file type, only .nrrd and .pic files are supported!
         if( this->CheckCurrentFileType())
         { 
           if(m_Extension == ".nrrd")
           {
             this->OpenNrrdImageFile(this->m_DistanceImageFileName, m_DistanceImage);
             this->OpenNrrdImageFile(this->m_AmplitudeImageFileName, m_AmplitudeImage);
             this->OpenNrrdImageFile(this->m_IntensityImageFileName, m_IntensityImage);
           }
           else if(m_Extension == ".pic")
           {
             this->OpenPicImageFile(this->m_DistanceImageFileName, m_DistanceImage);
             this->OpenPicImageFile(this->m_AmplitudeImageFileName, m_AmplitudeImage);
             this->OpenPicImageFile(this->m_IntensityImageFileName, m_IntensityImage);
           }
         }
         else
         {
-          throw std::exception("Please check image type, currently only .nrrd files are supported (.pic files are depracated!)");
+          throw std::logic_error("Please check image type, currently only .nrrd files are supported (.pic files are depracated!)");
         }
 
         // check if the opened files contained data
         if(m_DistanceImage.IsNull())
         {
           m_ImageStatus.at(0) = false;
         }
         if(m_AmplitudeImage.IsNull())
         {
           m_ImageStatus.at(1) = false;
         }
         if(m_IntensityImage.IsNull())
         {
           m_ImageStatus.at(2) = false;
         }
     
         // Check for dimension type
         mitk::Image::Pointer infoImage = NULL;
         if(m_ImageStatus.at(0))
         {  
           infoImage = m_DistanceImage;
         }
         else if (m_ImageStatus.at(1))
         {
           infoImage = m_AmplitudeImage;
         }
         else if(m_ImageStatus.at(2))
         {
           infoImage = m_IntensityImage;
         }
 
         if (infoImage->GetDimension() == 2)
           this->m_ToFImageType = ToFImageType2DPlusT;
 
         else if (infoImage->GetDimension() == 3)
           this->m_ToFImageType = ToFImageType3D;
 
         else if (infoImage->GetDimension() == 4)
           this->m_ToFImageType = ToFImageType2DPlusT;
 
         else
-          throw std::exception("Error opening ToF data file: Invalid dimension.");
+          throw std::logic_error("Error opening ToF data file: Invalid dimension.");
 
         this->m_CaptureWidth = infoImage->GetDimension(0);
         this->m_CaptureHeight = infoImage->GetDimension(1);
         this->m_PixelNumber = this->m_CaptureWidth*this->m_CaptureHeight;
         this->m_NumberOfBytes = this->m_PixelNumber * sizeof(float);
         if (this->m_ToFImageType == ToFImageType2DPlusT)
         {
           this->m_NumOfFrames = infoImage->GetDimension(3);
         }
         else
         {
           this->m_NumOfFrames = infoImage->GetDimension(2);
         }
 
         // allocate buffer
         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_IntensityArray = new float[this->m_PixelNumber];
         for(int i=0; i<this->m_PixelNumber; i++) {this->m_IntensityArray[i]=0.0;}
 
       //  mitkIpPicDescriptor* pic = NULL;
       //  mitkIpPicDescriptor* info = NULL;
 
       //  pic = mitkIpPicGetHeader(const_cast<char *>(this->m_DistanceImageFileName.c_str()), pic);
       //  if (pic==NULL)
       //  {
       //    MITK_ERROR << "Error opening ToF data file " << this->m_InputFileName;
       //    return false;
       //  }
       //  info = mitkIpPicGetTags(const_cast<char *>(this->m_DistanceImageFileName.c_str()), pic);
       //  this->m_PixelStartInFile = info->info->pixel_start_in_file;
 
       //  OpenPicFileToData(&(this->m_DistanceInfile), this->m_DistanceImageFileName.c_str());
       //  OpenPicFileToData(&(this->m_AmplitudeInfile), this->m_AmplitudeImageFileName.c_str());
       //  OpenPicFileToData(&(this->m_IntensityInfile), this->m_IntensityImageFileName.c_str());
 
         MITK_INFO << "NumOfFrames: " << this->m_NumOfFrames;
 
         this->m_ConnectionCheck = true;
         return this->m_ConnectionCheck;
       }
       catch(std::exception& e)
       {
         MITK_ERROR << "Error opening ToF data file " << this->m_InputFileName << " " << e.what();
         throw std::logic_error("Error opening ToF data file");
         return false;
       }
     }
     else 
       return this->m_ConnectionCheck;
   }
 
   void ToFCameraMITKPlayerController::OpenNrrdImageFile( const std::string outfileName, Image::Pointer &image)
   {
     if(!outfileName.empty())
     {
       if(image.IsNotNull())
       {
         image->ReleaseData();
         image = NULL;
       }
       ItkImageFileReader::Pointer nrrdReader = ItkImageFileReader::New();
       nrrdReader->SetFileName(outfileName);
       nrrdReader->Update();
       image = nrrdReader->GetOutput()->Clone();
     }
     else
     {
       MITK_ERROR << "Error opening ToF data file " << outfileName;
     }
 
   }
 
   void ToFCameraMITKPlayerController::OpenPicImageFile( const std::string outfileName, Image::Pointer &image)
   {
     if(!outfileName.empty())
     {
       if(image.IsNotNull())
       {
         image->ReleaseData();
         image = NULL;
       }
       PicFileReader::Pointer picReader = PicFileReader::New();
       picReader->SetFileName(outfileName);
       picReader->Update();
       image = picReader->GetOutput()->Clone();
     }
     else
     {
       MITK_ERROR << "Error opening ToF data file " << outfileName;
     }
   }
 
   //void ToFCameraMITKPlayerController::OpenPicFileToData(FILE** outfile, const char *outfileName)
   //{
   //  (*outfile) = fopen( outfileName, "rb" );
   //  if( (*outfile) == NULL )
   //  {
   //    MITK_ERROR << "Error opening ToF data file: file is empty" << outfileName;
   //    throw std::logic_error("Error opening ToF data file: file is empty");
   //    return;
   //  }
   //  fseek ( (*outfile), this->m_PixelStartInFile, SEEK_SET );
   //}
 
   bool ToFCameraMITKPlayerController::CloseCameraConnection()
   {
     if (this->m_ConnectionCheck)
     {
       this->CleanUp();
       this->m_ConnectionCheck = false;
       return true;
     }
     return false;
   } 
 
   void ToFCameraMITKPlayerController::UpdateCamera()
   {
     this->m_CurrentFrame++;
     if(this->m_CurrentFrame >= this->m_NumOfFrames)
     {
       this->m_CurrentFrame = 0;
     }
 
     if(this->m_ImageStatus.at(0))
     {
       this->AccessData(this->m_CurrentFrame, this->m_DistanceImage, this->m_DistanceArray);
     }
     if(this->m_ImageStatus.at(1))
     {
       this->AccessData(this->m_CurrentFrame, this->m_AmplitudeImage, this->m_AmplitudeArray);
     }
     if(this->m_ImageStatus.at(2))
     {
       this->AccessData(this->m_CurrentFrame, this->m_IntensityImage, this->m_IntensityArray);
     }
     itksys::SystemTools::Delay(50);
 
     //size_t distanceBytesReturn;
     //size_t amplitudeBytesReturn;
     //size_t intensityBytesReturn;
 
     //this->m_CurrentFrame++;
     //if (this->m_CurrentFrame >= this->m_NumOfFrames)
     //{
     //  
     //  fseek ( this->m_DistanceInfile, this->m_PixelStartInFile, SEEK_SET );
     //  fseek ( this->m_AmplitudeInfile, this->m_PixelStartInFile, SEEK_SET );
     //  fseek ( this->m_IntensityInfile, this->m_PixelStartInFile, SEEK_SET );
     //}
     //distanceBytesReturn = fread( this->m_DistanceArray, this->m_NumberOfBytes, 1, this->m_DistanceInfile );
     //amplitudeBytesReturn = fread( this->m_AmplitudeArray, this->m_NumberOfBytes, 1, this->m_AmplitudeInfile );
     //intensityBytesReturn = fread( this->m_IntensityArray, this->m_NumberOfBytes, 1, this->m_IntensityInfile );
   }
 
   void ToFCameraMITKPlayerController::AccessData(int frame, Image::Pointer image, float* &data)
   {
     if(!this->m_ToFImageType)
     {
       memcpy(data, image->GetSliceData(frame)->GetData(),this->m_NumberOfBytes );
     }
     else if(this->m_ToFImageType)
     {
       memcpy(data, image->GetVolumeData(frame)->GetData(), this->m_NumberOfBytes);
     }
   }
 
   void ToFCameraMITKPlayerController::GetAmplitudes(float* amplitudeArray)
   {
     memcpy(amplitudeArray, this->m_AmplitudeArray, this->m_NumberOfBytes);
   }
 
   void ToFCameraMITKPlayerController::GetIntensities(float* intensityArray)
   {
     memcpy(intensityArray, this->m_IntensityArray, this->m_NumberOfBytes);
   }
 
   void ToFCameraMITKPlayerController::GetDistances(float* distanceArray)
   {
     memcpy(distanceArray, this->m_DistanceArray, this->m_NumberOfBytes);
   }
 
   void ToFCameraMITKPlayerController::SetInputFileName(std::string inputFileName)
   {
     this->m_InputFileName = inputFileName;
   }
 
 }
diff --git a/Modules/ToFHardware/mitkToFNrrdImageWriter.h b/Modules/ToFHardware/mitkToFNrrdImageWriter.h
index 49db648aed..0bd7411770 100644
--- a/Modules/ToFHardware/mitkToFNrrdImageWriter.h
+++ b/Modules/ToFHardware/mitkToFNrrdImageWriter.h
@@ -1,79 +1,81 @@
 /*=========================================================================
 
 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 __mitkToFNrrdImageWriter_h
 #define __mitkToFNrrdImageWriter_h
 
 #include "mitkToFHardwareExports.h"
 #include "mitkToFImageWriter.h"
 
+#include <fstream>
+
 namespace mitk
 {
   /**
   * @brief Writer class for ToF nrrd images
   * 
   * This writer class allows streaming of ToF data into a nrrd file. This class uses the itkNrrdImageIO class
   * Writer can simultaneously save "distance", "intensity" and "amplitude" image.
   * Images can be written as 3D volume (ToFImageType::ToFImageType3D) or temporal image stack (ToFImageType::ToFImageType2DPlusT)
   *
   * @ingroup ToFHardware
   */
   class MITK_TOFHARDWARE_EXPORT ToFNrrdImageWriter : public ToFImageWriter
   {
   public: 
     mitkClassMacro( ToFNrrdImageWriter , ToFImageWriter );
     itkNewMacro( Self );
 
     /*!
     \brief Open file(s) for writing
     */
     void Open();
     /*!
     \brief Close file(s) add .pic header and write
     */
     void Close();
     /*!
     \brief Add new data to file.
     */
     void Add(float* distanceFloatData, float* amplitudeFloatData, float* intensityFloatData);
 
   protected:
 
     std::ofstream m_DistanceOutfile; ///< file for distance image
     std::ofstream m_AmplitudeOutfile; ///< file for amplitude image
     std::ofstream m_IntensityOutfile; ///< file for intensity image
 
   private:
 
     ToFNrrdImageWriter();
     ~ToFNrrdImageWriter();
 
     /*!
     \brief Open file by filename to gain write access to it.
     */
     void OpenStreamFile(std::ofstream &outfile, std::string outfileName);
     /*!
     \brief Close file after work on it is finished.
     */
     void CloseStreamFile(std::ofstream &outfile, std::string fileName);
     /*!
     \brief Write image information to the NrrdFile.
     */
     void ConvertStreamToNrrdFormat( std::string fileName );
   };
 } //END mitk namespace
 #endif // __mitkToFNrrdImageWriter_h
diff --git a/Modules/ToFUI/Qmitk/QmitkToFConnectionWidget.cpp b/Modules/ToFUI/Qmitk/QmitkToFConnectionWidget.cpp
index 863eb747d0..b7be317bfe 100644
--- a/Modules/ToFUI/Qmitk/QmitkToFConnectionWidget.cpp
+++ b/Modules/ToFUI/Qmitk/QmitkToFConnectionWidget.cpp
@@ -1,424 +1,424 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Module:    $RCSfile$
 Language:  C++
 Date:      $Date: 2009-05-20 13:35:09 +0200 (Mi, 20 Mai 2009) $
 Version:   $Revision: 17332 $
 
 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.
 
 =========================================================================*/
 
 //#define _USE_MATH_DEFINES
 #include <QmitkToFConnectionWidget.h>
 
 //QT headers
 #include <qmessagebox.h>
 #include <qfiledialog.h>
 #include <qcombobox.h>
 
 //mitk headers
 #include <mitkToFImageGrabberCreator.h>
 
 //itk headers
 #include <itksys/SystemTools.hxx>
 
 const std::string QmitkToFConnectionWidget::VIEW_ID = "org.mitk.views.qmitktofconnectionwidget";
 
 QmitkToFConnectionWidget::QmitkToFConnectionWidget(QWidget* parent, Qt::WindowFlags f): QWidget(parent, f)
 {
   this->m_IntegrationTime = 0;
   this->m_ModulationFrequency = 0;
   this->m_ToFImageGrabber = NULL;
 
   m_Controls = NULL;
   CreateQtPartControl(this);
 }
 
 QmitkToFConnectionWidget::~QmitkToFConnectionWidget()
 {
 }
 
 void QmitkToFConnectionWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkToFConnectionWidgetControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
 
     ShowParameterWidget();
   }
 }
 
 void QmitkToFConnectionWidget::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_ConnectCameraButton), SIGNAL(clicked()),(QObject*) this, SLOT(OnConnectCamera()) );
     connect( m_Controls->m_SelectCameraCombobox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnSelectCamera(int)) );
     connect( m_Controls->m_SelectCameraCombobox, SIGNAL(activated(int)), this, SLOT(OnSelectCamera(int)) );
     connect( m_Controls->m_SelectCameraCombobox, SIGNAL(activated(int)), this, SIGNAL(ToFCameraSelected(int)) );
 
     //connect( m_Controls->m_IntegrationTimeSpinBox, SIGNAL(valueChanged(int)), this, SLOT(OnChangeIntegrationTimeSpinBox(int)) );
     //connect( m_Controls->m_ModulationFrequencySpinBox, SIGNAL(valueChanged(int)), this, SLOT(OnChangeModulationFrequencySpinBox(int)) );
   }
 }
 
 void QmitkToFConnectionWidget::ShowParameterWidget()
 {
   int selectedCamera = m_Controls->m_SelectCameraCombobox->currentIndex();
   switch (selectedCamera)
   {
   case 0:
   case 1:
   case 2:   ShowPMDParameterWidget();
             break;
   case 3:   ShowMESAParameterWidget();
             break;
   default:  this->m_Controls->m_PMDParameterWidget->hide();
             this->m_Controls->m_MESAParameterWidget->hide();
   }
 }
 
 void QmitkToFConnectionWidget::ShowPMDParameterWidget()
 {
   this->m_Controls->m_PMDParameterWidget->show();
   this->m_Controls->m_MESAParameterWidget->hide();
 }
 
 void QmitkToFConnectionWidget::ShowMESAParameterWidget()
 {
   this->m_Controls->m_PMDParameterWidget->hide();
   this->m_Controls->m_MESAParameterWidget->show();
 }
 
 void QmitkToFConnectionWidget::ShowPlayerParameterWidget()
 {
   this->m_Controls->m_PMDParameterWidget->hide();
   this->m_Controls->m_MESAParameterWidget->hide();
 }
 
 mitk::ToFImageGrabber* QmitkToFConnectionWidget::GetToFImageGrabber()
 {
   return m_ToFImageGrabber;
 }
 
 void QmitkToFConnectionWidget::OnSelectCamera(int index)
 {
   if (index == 0) // PMD camcube 2
   {
     //m_Controls->m_IntegrationTimeSpinBox->setEnabled(true);
     //m_Controls->m_ModulationFrequencySpinBox->setEnabled(true);
     //m_Controls->m_CalibrationParameterGroupBox->setEnabled(true);
     ShowPMDParameterWidget();
   }
   else if (index == 1) // pmd camboard
   {
     //m_Controls->m_IntegrationTimeSpinBox->setEnabled(true);
     //m_Controls->m_ModulationFrequencySpinBox->setEnabled(true);
     //m_Controls->m_CalibrationParameterGroupBox->setEnabled(false);
     ShowPMDParameterWidget();
   }
   else if (index == 2) // pmd O3d
   {
     //m_Controls->m_IntegrationTimeSpinBox->setEnabled(true);
     //m_Controls->m_ModulationFrequencySpinBox->setEnabled(true);
     //m_Controls->m_CalibrationParameterGroupBox->setEnabled(false);
     ShowPMDParameterWidget();
   }
   else if (index == 3) // MESA 4000
   {
     ShowMESAParameterWidget();
   }
   else if (index == 4) // pmd file player
   {
     //m_Controls->m_IntegrationTimeSpinBox->setEnabled(false);
     //m_Controls->m_ModulationFrequencySpinBox->setEnabled(false);
     //m_Controls->m_CalibrationParameterGroupBox->setEnabled(false);
     ShowPlayerParameterWidget();
   }
   else if (index == 5) // pmd raw data player
   {
     //m_Controls->m_IntegrationTimeSpinBox->setEnabled(false);
     //m_Controls->m_ModulationFrequencySpinBox->setEnabled(false);
     //m_Controls->m_CalibrationParameterGroupBox->setEnabled(false);
     ShowPlayerParameterWidget();
   }
   else if (index == 6) // mitk player
   {
     //m_Controls->m_IntegrationTimeSpinBox->setEnabled(false);
     //m_Controls->m_ModulationFrequencySpinBox->setEnabled(false);
     //m_Controls->m_CalibrationParameterGroupBox->setEnabled(false);
     ShowPlayerParameterWidget();
   }
 }
 
 void QmitkToFConnectionWidget::OnConnectCamera()
 {
   bool playerMode = false;
 
   if (m_Controls->m_ConnectCameraButton->text()=="Connect")
   {   
     //reset the status of the GUI buttons
     m_Controls->m_ConnectCameraButton->setEnabled(false);
     m_Controls->m_SelectCameraCombobox->setEnabled(false);
 //    m_Controls->m_CalibrationParameterGroupBox->setEnabled(false);
     //repaint the widget
     this->repaint();
 
     QString tmpFileName("");
     QString fileFilter("");
 
     //select the camera to connect with
     int selectedCamera = m_Controls->m_SelectCameraCombobox->currentIndex();
     if (selectedCamera == 0)
     { //PMD CamCube
       this->m_ToFImageGrabber = mitk::ToFImageGrabberCreator::GetInstance()->GetPMDCamCubeImageGrabber();
     }
     else if (selectedCamera == 1)
     { //PMD CamBoard
       this->m_ToFImageGrabber = mitk::ToFImageGrabberCreator::GetInstance()->GetPMDCamBoardImageGrabber();
     }
     else if (selectedCamera == 2)
     {//PMD O3
       this->m_ToFImageGrabber = mitk::ToFImageGrabberCreator::GetInstance()->GetPMDO3ImageGrabber();
     }
     else if (selectedCamera == 3)
     {//MESA SR4000
       this->m_ToFImageGrabber = mitk::ToFImageGrabberCreator::GetInstance()->GetMESASR4000ImageGrabber();
     }
     else if (selectedCamera == 4)
     {//PMD player
       playerMode = true;
       fileFilter.append("PMD Files (*.pmd)");
       this->m_ToFImageGrabber = mitk::ToFImageGrabberCreator::GetInstance()->GetPMDPlayerImageGrabber();
     }
     else if (selectedCamera == 5)
     {//PMD MITK player
       playerMode = true;
-      fileFilter.append("MITK Images (*.nrrd);;MITK Images (deprecated) (*.pic)");
+      fileFilter.append("NRRD Images (*.nrrd);;PIC Images - deprecated (*.pic)");
       this->m_ToFImageGrabber = mitk::ToFImageGrabberCreator::GetInstance()->GetPMDMITKPlayerImageGrabber();
     }
     else if (selectedCamera == 6)
     {//MITK player
       playerMode = true;
-      fileFilter.append("MITK Images (*.nrrd);;MITK Images (deprecated) (*.pic)");
+      fileFilter.append("NRRD Images (*.nrrd);;PIC Images - deprecated (*.pic)");
       this->m_ToFImageGrabber = mitk::ToFImageGrabberCreator::GetInstance()->GetMITKPlayerImageGrabber();
     }
 
     // if a player was selected ...
     if (playerMode)
     { //... open a QFileDialog to chose the corresponding file from the disc
       tmpFileName = QFileDialog::getOpenFileName(NULL, "Play Image From...", "", fileFilter);
       if (tmpFileName.isEmpty())
       {
         m_Controls->m_ConnectCameraButton->setChecked(false);
         m_Controls->m_ConnectCameraButton->setEnabled(true);
         m_Controls->m_SelectCameraCombobox->setEnabled(true);
 //        m_Controls->m_CalibrationParameterGroupBox->setEnabled(true);
         this->OnSelectCamera(m_Controls->m_SelectCameraCombobox->currentIndex());
         QMessageBox::information( this, "Template functionality", "Please select a valid image before starting some action.");
         return;
       }
       if(selectedCamera == 4)
       { //set the PMD file name
         this->m_ToFImageGrabber->SetStringProperty("PMDFileName", tmpFileName.toStdString().c_str() );
       }
       if (selectedCamera == 5 || selectedCamera == 6)
       {
         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() );
 
           if (extension != ".pic" && extension != ".nrrd")
           {
             msg = msg + "Invalid file format, please select a \".nrrd\"-file";
             throw std::logic_error(msg.c_str());
           }
           int found = baseFilename.rfind("_DistanceImage");
           if (found == std::string::npos)
           {
             found = baseFilename.rfind("_AmplitudeImage");
           }
           if (found == std::string::npos)
           {
             found = baseFilename.rfind("_IntensityImage");
           }
           if (found == std::string::npos)
           {
             msg = msg + "Input file name must end with \"_DistanceImage.pic\", \"_AmplitudeImage.pic\" or \"_IntensityImage.pic\"!";
             throw std::logic_error(msg.c_str());
           }
           std::string baseFilenamePrefix = baseFilename.substr(0,found);
 
           std::string distanceImageFileName = dir + "/" + baseFilenamePrefix + "_DistanceImage" + extension;
           std::string amplitudeImageFileName = dir + "/" + baseFilenamePrefix + "_AmplitudeImage" + extension;
           std::string intensityImageFileName = dir + "/" + baseFilenamePrefix + "_IntensityImage" + extension;
 
           if (!itksys::SystemTools::FileExists(distanceImageFileName.c_str(), true))
           {
             msg = msg + "Inputfile not exist! " + distanceImageFileName;
             throw std::logic_error(msg.c_str());
           }
           if (!itksys::SystemTools::FileExists(amplitudeImageFileName.c_str(), true))
           {
             msg = msg + "Inputfile not exist! " + amplitudeImageFileName;
             throw std::logic_error(msg.c_str());
           }
           if (!itksys::SystemTools::FileExists(intensityImageFileName.c_str(), true))
           {
             msg = msg + "Inputfile not exist! " + intensityImageFileName;
             throw std::logic_error(msg.c_str());
           }
           //set the file names
           this->m_ToFImageGrabber->SetStringProperty("DistanceImageFileName", distanceImageFileName.c_str());
           this->m_ToFImageGrabber->SetStringProperty("AmplitudeImageFileName", amplitudeImageFileName.c_str());
           this->m_ToFImageGrabber->SetStringProperty("IntensityImageFileName", intensityImageFileName.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_SelectCameraCombobox->setEnabled(true);
 //          m_Controls->m_CalibrationParameterGroupBox->setEnabled(true);
           this->OnSelectCamera(m_Controls->m_SelectCameraCombobox->currentIndex());
           return;
         }
       }
 
     }
     //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);
 
       switch (selectedCamera)
       {
       case 0:
       case 1:
       case 2: this->m_Controls->m_PMDParameterWidget->ActivateAllParameters();
               break;
       case 3: this->m_Controls->m_MESAParameterWidget->ActivateAllParameters();
               break;
       }
 
       
 /*
       //get the integration time and modulation frequency
       this->m_IntegrationTime = m_Controls->m_IntegrationTimeSpinBox->value();
       this->m_ModulationFrequency = m_Controls->m_ModulationFrequencySpinBox->value();
 
       //set the integration time and modulation frequency in the grabber
       this->m_IntegrationTime = this->m_ToFImageGrabber->SetIntegrationTime(this->m_IntegrationTime);
       this->m_ModulationFrequency = this->m_ToFImageGrabber->SetModulationFrequency(this->m_ModulationFrequency);
 
       //set the PMD calibration according to the check boxes
       bool boolValue = false;
       boolValue = m_Controls->m_FPNCalibCB->isChecked();
       this->m_ToFImageGrabber->SetBoolProperty("SetFPNCalibration", boolValue);
       boolValue = m_Controls->m_FPPNCalibCB->isChecked();
       this->m_ToFImageGrabber->SetBoolProperty("SetFPPNCalibration", boolValue);
       boolValue = m_Controls->m_LinearityCalibCB->isChecked();
       this->m_ToFImageGrabber->SetBoolProperty("SetLinearityCalibration", boolValue);
       boolValue = m_Controls->m_LensCorrection->isChecked();
       this->m_ToFImageGrabber->SetBoolProperty("SetLensCalibration", boolValue);
       boolValue = m_Controls->m_ExposureModeCB->isChecked();
       this->m_ToFImageGrabber->SetBoolProperty("SetExposureMode", boolValue);
 
       //reset the GUI elements
       m_Controls->m_IntegrationTimeSpinBox->setValue(this->m_IntegrationTime);
       m_Controls->m_ModulationFrequencySpinBox->setValue(this->m_ModulationFrequency);
 */
       m_Controls->m_ConnectCameraButton->setText("Disconnect");
 
       // send connect signal to the caller functionality
       emit ToFCameraConnected();
     }
     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_SelectCameraCombobox->setEnabled(true);
 //      m_Controls->m_CalibrationParameterGroupBox->setEnabled(true);
       this->OnSelectCamera(m_Controls->m_SelectCameraCombobox->currentIndex());
       return;
 
     }
     m_Controls->m_ConnectCameraButton->setEnabled(true);
 
   }
   else if (m_Controls->m_ConnectCameraButton->text()=="Disconnect")
   {
     //send camera stop to the caller functionality
     emit ToFCameraStop();
 
     this->m_ToFImageGrabber->StopCamera();
     this->m_ToFImageGrabber->DisconnectCamera();
     m_Controls->m_ConnectCameraButton->setText("Connect");
     m_Controls->m_SelectCameraCombobox->setEnabled(true);
 //    m_Controls->m_CalibrationParameterGroupBox->setEnabled(true);
     this->OnSelectCamera(m_Controls->m_SelectCameraCombobox->currentIndex());
 
     this->m_ToFImageGrabber = NULL;
     // send disconnect signal to the caller functionality
     emit ToFCameraDisconnected();
 
   }
 }
 /*
 void QmitkToFConnectionWidget::OnChangeIntegrationTimeSpinBox(int value)
 {
   if (this->m_ToFImageGrabber != NULL)
   {
     // stop camera if active
     bool active = m_ToFImageGrabber->IsCameraActive();
     if (active)
     {
       m_ToFImageGrabber->StopCamera();
     }
     this->m_IntegrationTime = m_Controls->m_IntegrationTimeSpinBox->value();
     this->m_IntegrationTime = this->m_ToFImageGrabber->SetIntegrationTime(this->m_IntegrationTime);
     if (active)
     {
       m_ToFImageGrabber->StartCamera();
     }
   }
 }
 
 void QmitkToFConnectionWidget::OnChangeModulationFrequencySpinBox(int value)
 {
   if (this->m_ToFImageGrabber != NULL)
   {
     // stop camera if active
     bool active = m_ToFImageGrabber->IsCameraActive();
     if (active)
     {
       m_ToFImageGrabber->StopCamera();
     }
     this->m_ModulationFrequency = m_Controls->m_ModulationFrequencySpinBox->value();
     this->m_ModulationFrequency = this->m_ToFImageGrabber->SetModulationFrequency(this->m_ModulationFrequency);
     if (active)
     {
       m_ToFImageGrabber->StartCamera();
     }
   }
 }
 */