diff --git a/Modules/ToFHardware/mitkToFImageRecorder.cpp b/Modules/ToFHardware/mitkToFImageRecorder.cpp
index c1ee923047..fdd465377c 100644
--- a/Modules/ToFHardware/mitkToFImageRecorder.cpp
+++ b/Modules/ToFHardware/mitkToFImageRecorder.cpp
@@ -1,247 +1,249 @@
 /*=========================================================================
 
 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 "mitkToFImageRecorder.h"
 #include "mitkRealTimeClock.h"
 #include "itkMultiThreader.h"
 #include <itksys/SystemTools.hxx>
 #pragma GCC visibility push(default)
 #include <itkEventObject.h>
 #pragma GCC visibility pop
 
 namespace mitk
 {
   ToFImageRecorder::ToFImageRecorder()
   {
     this->m_ToFCameraDevice = NULL;
     this->m_MultiThreader = itk::MultiThreader::New();
     this->m_AbortMutex = itk::FastMutexLock::New();
     this->m_ThreadID = 0;
     this->m_NumOfFrames = 0;
     this->m_ToFImageWriter = NULL;
     this->m_DistanceImageSelected = true;
     this->m_AmplitudeImageSelected = true;
     this->m_IntensityImageSelected = true;
     this->m_Abort = true;
     this->m_CaptureWidth = 0;
     this->m_CaptureHeight = 0;
     this->m_FileFormat = "";
     this->m_PixelNumber = 0;
     this->m_SourceDataSize = 0;
     this->m_ToFImageType = ToFImageWriter::ToFImageType3D;
     this->m_RecordMode = ToFImageRecorder::PerFrames;
     this->m_DistanceImageFileName = ""; 
     this->m_AmplitudeImageFileName = "";
     this->m_IntensityImageFileName = "";
     this->m_ImageSequence = 0;
     this->m_DistanceArray = NULL;
     this->m_AmplitudeArray = NULL;
     this->m_IntensityArray = NULL;
     this->m_SourceDataArray = NULL;
   }
 
   ToFImageRecorder::~ToFImageRecorder()
   {
     delete[] m_DistanceArray;
     delete[] m_AmplitudeArray;
     delete[] m_IntensityArray;
     delete[] m_SourceDataArray;
   }
 
   void ToFImageRecorder::StopRecording()
   {
+
     this->m_AbortMutex->Lock();
     this->m_Abort = true;
     this->m_AbortMutex->Unlock();
+
   }
 
   void ToFImageRecorder::StartRecording()
   {
     if (this->m_ToFCameraDevice.IsNull())
     {
       throw std::invalid_argument("ToFCameraDevice is NULL.");
       return;
     }
     if (this->m_FileFormat.compare(".csv") == 0)
     {
       this->m_ToFImageWriter = ToFImageCsvWriter::New();
     }
     else if(this->m_FileFormat.compare(".nrrd") == 0)
     {
       this->m_ToFImageWriter = ToFNrrdImageWriter::New();
       this->m_ToFImageWriter->SetExtension(m_FileFormat);
     }
     else if(this->m_FileFormat.compare(".pic") == 0)
     {
       this->m_ToFImageWriter = ToFPicImageWriter::New();
       this->m_ToFImageWriter->SetExtension(m_FileFormat);
     }
     else
     {
       throw std::logic_error("No file format specified!");
     }
 
     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_SourceDataSize = this->m_ToFCameraDevice->GetSourceDataSize();
 
     // allocate buffer
     if(m_IntensityArray == NULL)
     {
       this->m_IntensityArray = new float[m_PixelNumber];
     }
     if(this->m_DistanceArray == NULL)
     {
       this->m_DistanceArray = new float[m_PixelNumber];
     }
     if(this->m_AmplitudeArray == NULL)
     {
       this->m_AmplitudeArray = new float[m_PixelNumber];
     }
     if(this->m_SourceDataArray == NULL)
     {
       this->m_SourceDataArray = new char[m_SourceDataSize];
     }
 
     this->m_ToFImageWriter->SetDistanceImageFileName(this->m_DistanceImageFileName);
     this->m_ToFImageWriter->SetAmplitudeImageFileName(this->m_AmplitudeImageFileName);
     this->m_ToFImageWriter->SetIntensityImageFileName(this->m_IntensityImageFileName);
     this->m_ToFImageWriter->SetCaptureWidth(this->m_CaptureWidth);
     this->m_ToFImageWriter->SetCaptureHeight(this->m_CaptureHeight);
     this->m_ToFImageWriter->SetToFImageType(this->m_ToFImageType);
     this->m_ToFImageWriter->SetDistanceImageSelected(this->m_DistanceImageSelected);
     this->m_ToFImageWriter->SetAmplitudeImageSelected(this->m_AmplitudeImageSelected);
     this->m_ToFImageWriter->SetIntensityImageSelected(this->m_IntensityImageSelected);
     this->m_ToFImageWriter->Open();
 
     this->m_AbortMutex->Lock();
     this->m_Abort = false;
     this->m_AbortMutex->Unlock();
     this->m_ThreadID = this->m_MultiThreader->SpawnThread(this->RecordData, this);
   }
 
   ITK_THREAD_RETURN_TYPE ToFImageRecorder::RecordData(void* pInfoStruct)
   {
     struct itk::MultiThreader::ThreadInfoStruct * pInfo = (struct itk::MultiThreader::ThreadInfoStruct*)pInfoStruct;
     if (pInfo == NULL)
     {
       return ITK_THREAD_RETURN_VALUE;
     }
     if (pInfo->UserData == NULL)
     {
       return ITK_THREAD_RETURN_VALUE;
     }
     ToFImageRecorder* toFImageRecorder = (ToFImageRecorder*)pInfo->UserData;
     if (toFImageRecorder!=NULL)
     {
 
       ToFCameraDevice::Pointer toFCameraDevice = toFImageRecorder->GetCameraDevice();
 
       mitk::RealTimeClock::Pointer realTimeClock;
       realTimeClock = mitk::RealTimeClock::New();
       int n = 100; 
       double t1 = 0;
       double t2 = 0;
       t1 = realTimeClock->GetCurrentStamp();
       bool overflow = false;
       bool printStatus = false;
       int requiredImageSequence = 0;
       int numOfFramesRecorded = 0;
 
       bool abort = false;
       toFImageRecorder->m_AbortMutex->Lock();
       abort = toFImageRecorder->m_Abort;
       toFImageRecorder->m_AbortMutex->Unlock();
       while ( !abort )
       {
         if ( ((toFImageRecorder->m_RecordMode == ToFImageRecorder::PerFrames) && (numOfFramesRecorded < toFImageRecorder->m_NumOfFrames)) ||
               (toFImageRecorder->m_RecordMode == ToFImageRecorder::Infinite) )
         {
         
           toFCameraDevice->GetAllImages(toFImageRecorder->m_DistanceArray, toFImageRecorder->m_AmplitudeArray, 
             toFImageRecorder->m_IntensityArray, toFImageRecorder->m_SourceDataArray, requiredImageSequence, toFImageRecorder->m_ImageSequence );
 
           if (toFImageRecorder->m_ImageSequence >= requiredImageSequence)
           {
             if (toFImageRecorder->m_ImageSequence > requiredImageSequence)
             {
               MITK_INFO << "Problem! required: " << requiredImageSequence << " captured: " << toFImageRecorder->m_ImageSequence;
             }
             requiredImageSequence = toFImageRecorder->m_ImageSequence + 1;
             toFImageRecorder->m_ToFImageWriter->Add( toFImageRecorder->m_DistanceArray, 
               toFImageRecorder->m_AmplitudeArray, toFImageRecorder->m_IntensityArray );
             numOfFramesRecorded++;
             if (numOfFramesRecorded % n == 0)
             {
               printStatus = true;
             }
             if (printStatus)
             {
               t2 = realTimeClock->GetCurrentStamp() - t1;
               MITK_INFO << " Framerate (fps): " << n / (t2/1000) << " Sequence: " << toFImageRecorder->m_ImageSequence;
               t1 = realTimeClock->GetCurrentStamp();
               printStatus = false;
             }
           }
           toFImageRecorder->m_AbortMutex->Lock();
           abort = toFImageRecorder->m_Abort;
           toFImageRecorder->m_AbortMutex->Unlock();
         }
         else
         {
           abort = true;
         }
       }  // end of while loop
 
       toFImageRecorder->InvokeEvent(itk::AbortEvent());
 
       toFImageRecorder->m_ToFImageWriter->Close();
     }
     return ITK_THREAD_RETURN_VALUE;
   }
 
   void ToFImageRecorder::SetCameraDevice(ToFCameraDevice* aToFCameraDevice)
   {
     this->m_ToFCameraDevice = aToFCameraDevice;
   }
 
   ToFCameraDevice* ToFImageRecorder::GetCameraDevice()
   {
     return this->m_ToFCameraDevice;
   }
 
   ToFImageWriter::ToFImageType ToFImageRecorder::GetToFImageType()
   {
     return this->m_ToFImageType;
   }
 
   void ToFImageRecorder::SetToFImageType(ToFImageWriter::ToFImageType toFImageType)
   {
     this->m_ToFImageType = toFImageType;
   }
 
   ToFImageRecorder::RecordMode ToFImageRecorder::GetRecordMode()
   {
     return this->m_RecordMode;
   }
 
   void ToFImageRecorder::SetRecordMode(ToFImageRecorder::RecordMode recordMode)
   {
     this->m_RecordMode = recordMode;
   }
 }
diff --git a/Modules/ToFUI/Qmitk/QmitkToFRecorderWidget.cpp b/Modules/ToFUI/Qmitk/QmitkToFRecorderWidget.cpp
index 0e97b4d94a..55375f6f86 100644
--- a/Modules/ToFUI/Qmitk/QmitkToFRecorderWidget.cpp
+++ b/Modules/ToFUI/Qmitk/QmitkToFRecorderWidget.cpp
@@ -1,393 +1,397 @@
 /*=========================================================================
 
 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 "QmitkToFRecorderWidget.h"
 
 //QT headers
 #include <qmessagebox.h>
 #include <QComboBox>
 #include <QLabel>
 #include <QLayout>
 #include <QGridLayout>
 #include <QCheckBox>
 
 //mitk headers
 #include <mitkToFImageWriter.h>
 
 //itk headers
 #pragma GCC visibility push(default)
 #include <itkEventObject.h>
 #pragma GCC visibility pop
 #include <itksys/SystemTools.hxx>
 
 struct QFileDialogArgs;
 class QFileDialogPrivate;
 
 const std::string QmitkToFRecorderWidget::VIEW_ID = "org.mitk.views.qmitktofrecorderwidget";
 
 QmitkToFRecorderWidget::QmitkToFRecorderWidget(QWidget* parent, Qt::WindowFlags f): QWidget(parent, f)
 {
   this->m_ToFImageRecorder = NULL;
   this->m_ToFImageGrabber = NULL;
   this->m_RecordMode = mitk::ToFImageRecorder::PerFrames;
 
   this-> m_Controls = NULL;
   CreateQtPartControl(this);
 }
 
 QmitkToFRecorderWidget::~QmitkToFRecorderWidget()
 {
 }
 
 void QmitkToFRecorderWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     this->m_Controls = new Ui::QmitkToFRecorderWidgetControls;
     this->m_Controls->setupUi(parent);
     this->CreateConnections();
   }
 }
 
 void QmitkToFRecorderWidget::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_PlayButton), SIGNAL(clicked()),(QObject*) this, SLOT(OnPlay()) );
     connect( (QObject*)(m_Controls->m_StopButton), SIGNAL(clicked()),(QObject*) this, SLOT(OnStop()) );
     connect( (QObject*)(m_Controls->m_StartRecordingButton), SIGNAL(clicked()),(QObject*) this, SLOT(OnStartRecorder()) );
     connect( (QObject*)(m_Controls->m_RecordModeComboBox), SIGNAL(currentIndexChanged(int)),(QObject*) this, SLOT(OnChangeRecordModeComboBox(int)) );    
 
     connect(this, SIGNAL(RecordingStopped()), this, SLOT(OnRecordingStopped()), Qt::BlockingQueuedConnection);
   }
 }
 
 void QmitkToFRecorderWidget::SetParameter(mitk::ToFImageGrabber* toFImageGrabber, mitk::ToFImageRecorder* toFImageRecorder)
 {
   this->m_ToFImageGrabber = toFImageGrabber;
 
   this->m_ToFImageRecorder = toFImageRecorder;
 
   this->m_StopRecordingCommand = CommandType::New();
   this->m_StopRecordingCommand->SetCallbackFunction(this, &QmitkToFRecorderWidget::StopRecordingCallback);
   this->m_ToFImageRecorder->RemoveAllObservers();
   this->m_ToFImageRecorder->AddObserver(itk::AbortEvent(), this->m_StopRecordingCommand);
 
   m_Controls->m_PlayButton->setChecked(false);
   m_Controls->m_PlayButton->setEnabled(true);
   m_Controls->m_StartRecordingButton->setChecked(false);
   m_Controls->m_RecorderGroupBox->setEnabled(true);
 }
 
 void QmitkToFRecorderWidget::StopRecordingCallback()
 {
   emit RecordingStopped();
 }
 
 void QmitkToFRecorderWidget::ResetGUIToInitial()
 {
   m_Controls->m_PlayButton->setChecked(false);
   m_Controls->m_PlayButton->setEnabled(true);
   m_Controls->m_RecorderGroupBox->setEnabled(false);
 }
 
 void QmitkToFRecorderWidget::OnRecordingStopped()
 {  
   m_Controls->m_StartRecordingButton->setChecked(false);
   m_Controls->m_RecorderGroupBox->setEnabled(true);
 }
 
 void QmitkToFRecorderWidget::OnStop()
 {
   StopCamera();
   StopRecorder();
 
   ResetGUIToInitial();
 
   emit ToFCameraStopped();
 }
 
 void QmitkToFRecorderWidget::OnPlay()
 {
   m_Controls->m_PlayButton->setChecked(true);
   m_Controls->m_PlayButton->setEnabled(false);
   m_Controls->m_RecorderGroupBox->setEnabled(true);
   this->repaint();
 
   StartCamera();
 
   emit ToFCameraStarted();
 }
 
 void QmitkToFRecorderWidget::StartCamera()
 {
   bool ok = false;
   if (!m_ToFImageGrabber->IsCameraActive())
   {
     m_ToFImageGrabber->StartCamera();
   }
 }
 
 void QmitkToFRecorderWidget::StopCamera()
 {
-  m_ToFImageGrabber->StopCamera();
+  if( m_ToFImageGrabber.IsNotNull() )
+    m_ToFImageGrabber->StopCamera();
 }
 
 void QmitkToFRecorderWidget::StopRecorder()
 {
-  this->m_ToFImageRecorder->StopRecording();
+  if( m_ToFImageRecorder.IsNotNull() )
+  {
+    this->m_ToFImageRecorder->StopRecording();
+  }
 }
 
 void QmitkToFRecorderWidget::OnStartRecorder()
 {
   m_Controls->m_StartRecordingButton->setChecked(true);
   m_Controls->m_RecorderGroupBox->setEnabled(false);
   this->repaint();
 
   int numOfFrames = m_Controls->m_NumOfFramesSpinBox->value();
   try
   {
     bool fileOK = true;
     bool distanceImageSelected = true;
     bool amplitudeImageSelected = true;
     bool intensityImageSelected = true;
     bool rawDataSelected = false;
 
     QString tmpFileName("");
     QString selectedFilter("");
     QString imageFileName("");
     mitk::ToFImageWriter::ToFImageType tofImageType;
     tmpFileName = QmitkToFRecorderWidget::getSaveFileName(tofImageType, 
       distanceImageSelected, amplitudeImageSelected, intensityImageSelected, rawDataSelected,
       NULL, "Save Image To...", imageFileName, "NRRD Images (*.nrrd);;PIC Images - deprecated (*.pic);;Text (*.csv)", &selectedFilter);
 
     if (tmpFileName.isEmpty())
     {
       fileOK = false;
     }
     else
     {
       imageFileName = tmpFileName;
     }
 
     if (fileOK)
     {
       std::string dir = itksys::SystemTools::GetFilenamePath( imageFileName.toStdString() );
       std::string baseFilename = itksys::SystemTools::GetFilenameWithoutLastExtension( imageFileName.toStdString() );
       std::string extension = itksys::SystemTools::GetFilenameLastExtension( imageFileName.toStdString() );
 
       int integrationTime = this->m_ToFImageGrabber->GetIntegrationTime();
       int modulationFreq = this->m_ToFImageGrabber->GetModulationFrequency();
 
       QString integrationTimeStr;
       integrationTimeStr.setNum(integrationTime);
       QString modulationFreqStr;
       modulationFreqStr.setNum(modulationFreq);
       QString numOfFramesStr("");
       if (this->m_RecordMode == mitk::ToFImageRecorder::PerFrames)
       {
         numOfFramesStr.setNum(numOfFrames);
       }
 
       std::string distImageFileName = prepareFilename(dir, baseFilename, modulationFreqStr.toStdString(), 
         integrationTimeStr.toStdString(), numOfFramesStr.toStdString(), extension, "_DistanceImage");
       MITK_INFO << "Save distance data to: " << distImageFileName;
 
       std::string amplImageFileName = prepareFilename(dir, baseFilename, modulationFreqStr.toStdString(), 
         integrationTimeStr.toStdString(), numOfFramesStr.toStdString(), extension, "_AmplitudeImage");
       MITK_INFO << "Save amplitude data to: " << amplImageFileName;
 
       std::string intenImageFileName = prepareFilename(dir, baseFilename, modulationFreqStr.toStdString(), 
         integrationTimeStr.toStdString(), numOfFramesStr.toStdString(), extension, "_IntensityImage");
       MITK_INFO << "Save intensity data to: " << intenImageFileName;
 
       if (selectedFilter.compare("Text (*.csv)") == 0)
       {
         this->m_ToFImageRecorder->SetFileFormat(".csv");
       }
       else if (selectedFilter.compare("PIC Images - deprecated (*.pic)") == 0)
       {
         //default
         this->m_ToFImageRecorder->SetFileFormat(".pic");
         
         QMessageBox::warning(NULL, "Deprecated File Format!", 
           "Please note that *.pic file format is deprecated and not longer supported! The suggested file format for images is *.nrrd!");
       }
       else if (selectedFilter.compare("NRRD Images (*.nrrd)") == 0)
       {
         this->m_ToFImageRecorder->SetFileFormat(".nrrd");
       }
       else
       {
         QMessageBox::warning(NULL, "Unsupported file format!", "Please specify one of the supported file formats *.nrrd, *.csv!");
         return;
       }
 
       numOfFrames = m_Controls->m_NumOfFramesSpinBox->value();
       this->m_ToFImageRecorder->SetDistanceImageFileName(distImageFileName);
       this->m_ToFImageRecorder->SetAmplitudeImageFileName(amplImageFileName);
       this->m_ToFImageRecorder->SetIntensityImageFileName(intenImageFileName);
       this->m_ToFImageRecorder->SetToFImageType(tofImageType);
       this->m_ToFImageRecorder->SetDistanceImageSelected(distanceImageSelected);
       this->m_ToFImageRecorder->SetAmplitudeImageSelected(amplitudeImageSelected);
       this->m_ToFImageRecorder->SetIntensityImageSelected(intensityImageSelected);
       this->m_ToFImageRecorder->SetRecordMode(this->m_RecordMode);
       this->m_ToFImageRecorder->SetNumOfFrames(numOfFrames);
 
       this->m_ToFImageRecorder->StartRecording();
     }
     else
     {
       this->OnRecordingStopped();
     }
   }
   catch(std::exception& e)
   {
     QMessageBox::critical(NULL, "Error", QString(e.what()));
     this->OnRecordingStopped();
   }
 }
 
 QString QmitkToFRecorderWidget::getSaveFileName(mitk::ToFImageWriter::ToFImageType& tofImageType,
                                      bool& distanceImageSelected,
                                      bool& amplitudeImageSelected,
                                      bool& intensityImageSelected,
                                      bool& rawDataSelected,
                                      QWidget *parent,
                                      const QString &caption,
                                      const QString &dir,
                                      const QString &filter,
                                      QString *selectedFilter,
                                      QFileDialog::Options options
                                      )
 {
   QString selectedFileName = "";
   QComboBox* combo = new QComboBox;
   combo->addItem("3D");
   combo->addItem("2D + t");
 
   QHBoxLayout* checkBoxGroup = new QHBoxLayout();
 
   QCheckBox* distanceImageCheckBox = new QCheckBox;
   distanceImageCheckBox->setText("Distance image");
   distanceImageCheckBox->setChecked(true);
   QCheckBox* amplitudeImageCheckBox = new QCheckBox;
   amplitudeImageCheckBox->setText("Amplitude image");
   amplitudeImageCheckBox->setChecked(true);
   QCheckBox* intensityImageCheckBox = new QCheckBox;
   intensityImageCheckBox->setText("Intensity image");
   intensityImageCheckBox->setChecked(true);
   QCheckBox* rawDataCheckBox = new QCheckBox;
   rawDataCheckBox->setText("Raw data");
   rawDataCheckBox->setChecked(false);
   rawDataCheckBox->setEnabled(false);
 
   checkBoxGroup->addWidget(distanceImageCheckBox);
   checkBoxGroup->addWidget(amplitudeImageCheckBox);
   checkBoxGroup->addWidget(intensityImageCheckBox);
   checkBoxGroup->addWidget(rawDataCheckBox);
 
   QFileDialog* fileDialog = new QFileDialog(parent, caption, dir, filter);
 
   QLayout* layout = fileDialog->layout();
   QGridLayout* gridbox = qobject_cast<QGridLayout*>(layout);
 
   if (gridbox) 
   {
     gridbox->addWidget(new QLabel("ToF-Image type:"));
     gridbox->addWidget(combo);
     int lastRow = gridbox->rowCount();
     gridbox->addLayout(checkBoxGroup, lastRow, 0, 1, -1);
   }
 
   fileDialog->setLayout(gridbox);
   fileDialog->setAcceptMode(QFileDialog::AcceptSave);
 
   if (selectedFilter)
   {
     fileDialog->selectNameFilter(*selectedFilter);
   }
 
   if (fileDialog->exec() == QDialog::Accepted) 
   {
     if (selectedFilter)
     {
       *selectedFilter = fileDialog->selectedFilter();
     }
 
     if (combo->currentIndex() == 0)
     {
       tofImageType = mitk::ToFImageWriter::ToFImageType3D;
     }
 
     else
     {
       tofImageType = mitk::ToFImageWriter::ToFImageType2DPlusT;
     }
 
     distanceImageSelected = distanceImageCheckBox->isChecked();
     amplitudeImageSelected = amplitudeImageCheckBox->isChecked();
     intensityImageSelected = intensityImageCheckBox->isChecked();
     rawDataSelected = rawDataCheckBox->isChecked();
 
     selectedFileName = fileDialog->selectedFiles().value(0);
   }
 
   delete fileDialog;
   return selectedFileName;
 }
 
 std::string QmitkToFRecorderWidget::prepareFilename(std::string dir, 
                                                     std::string baseFilename, 
                                                     std::string modulationFreq, 
                                                     std::string integrationTime, 
                                                     std::string numOfFrames, 
                                                     std::string extension, 
                                                     std::string imageType)
 {
   std::string filenName("");
   filenName.append(dir);
   filenName.append("/");
   filenName.append(baseFilename);
   filenName.append("_MF");
   filenName.append(modulationFreq);
   filenName.append("_IT");
   filenName.append(integrationTime);
   filenName.append("_");
   filenName.append(numOfFrames);
   filenName.append("Images");
   filenName.append(imageType);
   filenName.append(extension);
   return filenName;
 }
 
 void QmitkToFRecorderWidget::OnChangeRecordModeComboBox(int index)
 {
   if (index == 0)
   {
     this->m_RecordMode = mitk::ToFImageRecorder::PerFrames;
     m_Controls->m_NumOfFramesSpinBox->setEnabled(true);
   }
   else
   {
     this->m_RecordMode = mitk::ToFImageRecorder::Infinite;
     m_Controls->m_NumOfFramesSpinBox->setEnabled(false);
   }
 }