diff --git a/Modules/ToFHardware/Testing/mitkToFCameraPMDCamBoardControllerTest.cpp b/Modules/ToFHardware/Testing/mitkToFCameraPMDCamBoardControllerTest.cpp
index 0bab28eed7..b1ecc1aa3f 100644
--- a/Modules/ToFHardware/Testing/mitkToFCameraPMDCamBoardControllerTest.cpp
+++ b/Modules/ToFHardware/Testing/mitkToFCameraPMDCamBoardControllerTest.cpp
@@ -1,52 +1,52 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2010-03-12 14:05:50 +0100 (Fr, 12 Mrz 2010) $
 Version:   $Revision: 16010 $
 
 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 <mitkTestingMacros.h>
 #include <mitkToFCameraPMDCamBoardController.h>
 
 /**Documentation
  *  test for the class "ToFCameraPMDCamBoardController".
  */
 int mitkToFCameraPMDCamBoardControllerTest(int /* argc */, char* /*argv*/[])
 {
   MITK_TEST_BEGIN("ToFCameraPMDCamBoardController");
 
   mitk::ToFCameraPMDCamBoardController::Pointer testObject = mitk::ToFCameraPMDCamBoardController::New();
   MITK_TEST_CONDITION_REQUIRED(!testObject.GetPointer()==NULL,"Testing initialzation!");
   MITK_TEST_CONDITION_REQUIRED(testObject->GetCaptureHeight()== 200 ,"Testing initialization of CaptureHeight");
   MITK_TEST_CONDITION_REQUIRED(testObject->GetCaptureWidth()== 200 ,"Testing initialization of CaptureWidth");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->OpenCameraConnection(),"Testing opening of camera connection!");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->UpdateCamera(),"Testing UpdateCamera()");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->SetDistanceOffset(0.5f),"Testing SetDistanceOffset()");
+  MITK_TEST_CONDITION_REQUIRED(testObject->OpenCameraConnection(),"Testing opening of camera connection!");
+  MITK_TEST_CONDITION_REQUIRED(testObject->UpdateCamera(),"Testing UpdateCamera()");
+  MITK_TEST_CONDITION_REQUIRED(testObject->SetDistanceOffset(0.5f),"Testing SetDistanceOffset()");
   MITK_TEST_OUTPUT(<<"Call GetDistanceOffset()");
   MITK_INFO<<testObject->GetDistanceOffset();
-  MITK_TEST_CONDITION_REQUIRED(!testObject->SetRegionOfInterest(3,5,200,201),"Testing SetRegionOfInterest()");
+  MITK_TEST_CONDITION_REQUIRED(testObject->SetRegionOfInterest(3,5,200,201),"Testing SetRegionOfInterest()");
   MITK_TEST_OUTPUT(<<"Call GetRegionOfInterest()");
   MITK_INFO<<testObject->GetRegionOfInterest();
-  MITK_TEST_CONDITION_REQUIRED(!testObject->SetExposureMode(0),"Testing SetExposureMode()");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->SetFieldOfView(35.7f),"Testing SetFieldOfView()");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->SetFPNCalibration(true),"Testing SetFPNCalibration()");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->SetFPPNCalibration(true),"Testing SetFPPNCalibration()");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->SetLinearityCalibration(true),"Testing SetLinearityCalibration()");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->SetLensCalibration(true),"Testing SetLensCalibration()");
+  MITK_TEST_CONDITION_REQUIRED(testObject->SetExposureMode(0),"Testing SetExposureMode()");
+  MITK_TEST_CONDITION_REQUIRED(testObject->SetFieldOfView(35.7f),"Testing SetFieldOfView()");
+  MITK_TEST_CONDITION_REQUIRED(testObject->SetFPNCalibration(true),"Testing SetFPNCalibration()");
+  MITK_TEST_CONDITION_REQUIRED(testObject->SetFPPNCalibration(true),"Testing SetFPPNCalibration()");
+  MITK_TEST_CONDITION_REQUIRED(testObject->SetLinearityCalibration(true),"Testing SetLinearityCalibration()");
+  MITK_TEST_CONDITION_REQUIRED(testObject->SetLensCalibration(true),"Testing SetLensCalibration()");
   MITK_TEST_CONDITION_REQUIRED(testObject->CloseCameraConnection(),"Testing closing of camera connection!");
 
   MITK_TEST_END();
 
 }
 
 
diff --git a/Modules/ToFHardware/Testing/mitkToFCameraPMDCamBoardDeviceTest.cpp b/Modules/ToFHardware/Testing/mitkToFCameraPMDCamBoardDeviceTest.cpp
index 3652eca06f..b959b38d73 100644
--- a/Modules/ToFHardware/Testing/mitkToFCameraPMDCamBoardDeviceTest.cpp
+++ b/Modules/ToFHardware/Testing/mitkToFCameraPMDCamBoardDeviceTest.cpp
@@ -1,61 +1,64 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2010-03-12 14:05:50 +0100 (Fr, 12 Mrz 2010) $
 Version:   $Revision: 16010 $
 
 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 <mitkTestingMacros.h>
 #include <mitkToFCameraPMDCamBoardDevice.h>
 
 /**Documentation
  *  test for the class "ToFCameraPMDCamBoardDevice".
  */
 int mitkToFCameraPMDCamBoardDeviceTest(int /* argc */, char* /*argv*/[])
 {
   MITK_TEST_BEGIN("ToFCameraPMDCamBoardDevice");
 
   mitk::ToFCameraPMDCamBoardDevice::Pointer tofCameraPMDCamBoardDevice = mitk::ToFCameraPMDCamBoardDevice::New();
   // No hardware attached for automatic testing -> test correct error handling
-  MITK_TEST_CONDITION_REQUIRED(!tofCameraPMDCamBoardDevice->ConnectCamera(), "Test ConnectCamera()");
-  MITK_TEST_CONDITION_REQUIRED(!tofCameraPMDCamBoardDevice->IsCameraActive(), "Test IsCameraActive()");
+  MITK_TEST_CONDITION_REQUIRED(tofCameraPMDCamBoardDevice->ConnectCamera(), "Test ConnectCamera()");
+  MITK_TEST_CONDITION_REQUIRED(!tofCameraPMDCamBoardDevice->IsCameraActive(), "Test IsCameraActive() before StartCamera()");
   MITK_TEST_OUTPUT(<<"Call StartCamera()");
   tofCameraPMDCamBoardDevice->StartCamera();
+  MITK_TEST_CONDITION_REQUIRED(tofCameraPMDCamBoardDevice->IsCameraActive(), "Test IsCameraActive() after StartCamera()");
   MITK_TEST_OUTPUT(<<"Call UpdateCamera()");
   tofCameraPMDCamBoardDevice->UpdateCamera();
   int numberOfPixels = tofCameraPMDCamBoardDevice->GetCaptureWidth()*tofCameraPMDCamBoardDevice->GetCaptureHeight();
   MITK_INFO<<numberOfPixels;
   float* distances = new float[numberOfPixels];
   float* amplitudes = new float[numberOfPixels];
   float* intensities = new float[numberOfPixels];
   char* sourceData = new char[numberOfPixels];
   int requiredImageSequence = 0;
   int imageSequence = 0;
   tofCameraPMDCamBoardDevice->GetDistances(distances,imageSequence);
   tofCameraPMDCamBoardDevice->GetAmplitudes(amplitudes,imageSequence);
   tofCameraPMDCamBoardDevice->GetIntensities(intensities,imageSequence);
   tofCameraPMDCamBoardDevice->GetAllImages(distances,amplitudes,intensities,sourceData,requiredImageSequence,imageSequence);
+  MITK_TEST_CONDITION_REQUIRED(tofCameraPMDCamBoardDevice->IsCameraActive(), "Test IsCameraActive() before StopCamera()");
   MITK_TEST_OUTPUT(<<"Call StopCamera()");
   tofCameraPMDCamBoardDevice->StopCamera();
+  MITK_TEST_CONDITION_REQUIRED(!tofCameraPMDCamBoardDevice->IsCameraActive(), "Test IsCameraActive() after StopCamera()");
 
   MITK_TEST_CONDITION_REQUIRED(tofCameraPMDCamBoardDevice->DisconnectCamera(), "Test DisonnectCamera()");
   delete[] distances;
   delete[] amplitudes;
   delete[] intensities;
   delete[] sourceData;
 
   MITK_TEST_END();
 
 }
 
 
diff --git a/Modules/ToFHardware/Testing/mitkToFCameraPMDCamCubeControllerTest.cpp b/Modules/ToFHardware/Testing/mitkToFCameraPMDCamCubeControllerTest.cpp
index d566f41e12..546f9e7630 100644
--- a/Modules/ToFHardware/Testing/mitkToFCameraPMDCamCubeControllerTest.cpp
+++ b/Modules/ToFHardware/Testing/mitkToFCameraPMDCamCubeControllerTest.cpp
@@ -1,52 +1,52 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2010-03-12 14:05:50 +0100 (Fr, 12 Mrz 2010) $
 Version:   $Revision: 16010 $
 
 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 <mitkTestingMacros.h>
 #include <mitkToFCameraPMDCamCubeController.h>
 
 /**Documentation
  *  test for the class "ToFCameraPMDCamCubeController".
  */
 int mitkToFCameraPMDCamCubeControllerTest(int /* argc */, char* /*argv*/[])
 {
 
   MITK_TEST_BEGIN("ToFCameraPMDCamCubeController");
   mitk::ToFCameraPMDCamCubeController::Pointer testObject = mitk::ToFCameraPMDCamCubeController::New();
   MITK_TEST_CONDITION_REQUIRED(!testObject.GetPointer()==NULL,"Testing initialzation!");
   MITK_TEST_CONDITION_REQUIRED(testObject->GetCaptureHeight()== 200 ,"Testing initialization of CaptureHeight");
   MITK_TEST_CONDITION_REQUIRED(testObject->GetCaptureWidth()== 200 ,"Testing initialization of CaptureWidth");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->OpenCameraConnection(),"Testing opening of camera connection!");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->UpdateCamera(),"Testing UpdateCamera()");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->SetDistanceOffset(0.5f),"Testing SetDistanceOffset()");
+  MITK_TEST_CONDITION_REQUIRED(testObject->OpenCameraConnection(),"Testing opening of camera connection!");
+  MITK_TEST_CONDITION_REQUIRED(testObject->UpdateCamera(),"Testing UpdateCamera()");
+  MITK_TEST_CONDITION_REQUIRED(testObject->SetDistanceOffset(0.5f),"Testing SetDistanceOffset()");
   MITK_TEST_OUTPUT(<<"Call GetDistanceOffset()");
   MITK_INFO<<testObject->GetDistanceOffset();
-  MITK_TEST_CONDITION_REQUIRED(!testObject->SetRegionOfInterest(3,5,200,201),"Testing SetRegionOfInterest()");
+  MITK_TEST_CONDITION_REQUIRED(testObject->SetRegionOfInterest(3,5,200,201),"Testing SetRegionOfInterest()");
   MITK_TEST_OUTPUT(<<"Call GetRegionOfInterest()");
   MITK_INFO<<testObject->GetRegionOfInterest();
-  MITK_TEST_CONDITION_REQUIRED(!testObject->SetExposureMode(0),"Testing SetExposureMode()");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->SetFieldOfView(35.7f),"Testing SetFieldOfView()");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->SetFPNCalibration(true),"Testing SetFPNCalibration()");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->SetFPPNCalibration(true),"Testing SetFPPNCalibration()");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->SetLinearityCalibration(true),"Testing SetLinearityCalibration()");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->SetLensCalibration(true),"Testing SetLensCalibration()");
+  MITK_TEST_CONDITION_REQUIRED(testObject->SetExposureMode(0),"Testing SetExposureMode()");
+  MITK_TEST_CONDITION_REQUIRED(testObject->SetFieldOfView(35.7f),"Testing SetFieldOfView()");
+  MITK_TEST_CONDITION_REQUIRED(testObject->SetFPNCalibration(true),"Testing SetFPNCalibration()");
+  MITK_TEST_CONDITION_REQUIRED(testObject->SetFPPNCalibration(true),"Testing SetFPPNCalibration()");
+  MITK_TEST_CONDITION_REQUIRED(testObject->SetLinearityCalibration(true),"Testing SetLinearityCalibration()");
+  MITK_TEST_CONDITION_REQUIRED(testObject->SetLensCalibration(true),"Testing SetLensCalibration()");
   MITK_TEST_CONDITION_REQUIRED(testObject->CloseCameraConnection(),"Testing closing of camera connection!");
 
   MITK_TEST_END();
 
 }
 
 
diff --git a/Modules/ToFHardware/Testing/mitkToFCameraPMDCamCubeDeviceTest.cpp b/Modules/ToFHardware/Testing/mitkToFCameraPMDCamCubeDeviceTest.cpp
index 28888b1731..923d5fa71d 100644
--- a/Modules/ToFHardware/Testing/mitkToFCameraPMDCamCubeDeviceTest.cpp
+++ b/Modules/ToFHardware/Testing/mitkToFCameraPMDCamCubeDeviceTest.cpp
@@ -1,60 +1,64 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2010-03-12 14:05:50 +0100 (Fr, 12 Mrz 2010) $
 Version:   $Revision: 16010 $
 
 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 <mitkTestingMacros.h>
 #include <mitkToFCameraPMDCamCubeDevice.h>
 
 /**Documentation
  *  test for the class "ToFCameraPMDCamCubeDevice".
  */
 int mitkToFCameraPMDCamCubeDeviceTest(int /* argc */, char* /*argv*/[])
 {
   MITK_TEST_BEGIN("ToFCameraPMDCamCubeDevice");
 
   mitk::ToFCameraPMDCamCubeDevice::Pointer tofCameraPMDCamCubeDevice = mitk::ToFCameraPMDCamCubeDevice::New();
   // No hardware attached for automatic testing -> test correct error handling
-  MITK_TEST_CONDITION_REQUIRED(!tofCameraPMDCamCubeDevice->ConnectCamera(), "Test ConnectCamera()");
-  MITK_TEST_CONDITION_REQUIRED(!tofCameraPMDCamCubeDevice->IsCameraActive(), "Test IsCameraActive()");
+  MITK_TEST_CONDITION_REQUIRED(tofCameraPMDCamCubeDevice->ConnectCamera(), "Test ConnectCamera()");
+  MITK_TEST_CONDITION_REQUIRED(!tofCameraPMDCamCubeDevice->IsCameraActive(), "Test IsCameraActive() before StartCamera()");
   MITK_TEST_OUTPUT(<<"Call StartCamera()");
   tofCameraPMDCamCubeDevice->StartCamera();
+  MITK_TEST_CONDITION_REQUIRED(tofCameraPMDCamCubeDevice->IsCameraActive(), "Test IsCameraActive() after StartCamera()");
   MITK_TEST_OUTPUT(<<"Call UpdateCamera()");
   tofCameraPMDCamCubeDevice->UpdateCamera();
   int numberOfPixels = tofCameraPMDCamCubeDevice->GetCaptureWidth()*tofCameraPMDCamCubeDevice->GetCaptureHeight();
   MITK_INFO<<numberOfPixels;
   float* distances = new float[numberOfPixels];
   float* amplitudes = new float[numberOfPixels];
   float* intensities = new float[numberOfPixels];
   char* sourceData = new char[numberOfPixels];
   int requiredImageSequence = 0;
   int imageSequence = 0;
   tofCameraPMDCamCubeDevice->GetDistances(distances,imageSequence);
   tofCameraPMDCamCubeDevice->GetAmplitudes(amplitudes,imageSequence);
   tofCameraPMDCamCubeDevice->GetIntensities(intensities,imageSequence);
   tofCameraPMDCamCubeDevice->GetAllImages(distances,amplitudes,intensities,sourceData,requiredImageSequence,imageSequence);
+  MITK_TEST_CONDITION_REQUIRED(tofCameraPMDCamCubeDevice->IsCameraActive(), "Test IsCameraActive() before StopCamera()");
   MITK_TEST_OUTPUT(<<"Call StopCamera()");
   tofCameraPMDCamCubeDevice->StopCamera();
+  MITK_TEST_CONDITION_REQUIRED(!tofCameraPMDCamCubeDevice->IsCameraActive(), "Test IsCameraActive() after StopCamera()");
 
   MITK_TEST_CONDITION_REQUIRED(tofCameraPMDCamCubeDevice->DisconnectCamera(), "Test DisonnectCamera()");
   delete[] distances;
   delete[] amplitudes;
   delete[] intensities;
   delete[] sourceData;
+
   MITK_TEST_END();
 
 }
 
 
diff --git a/Modules/ToFHardware/Testing/mitkToFCameraPMDControllerTest.cpp b/Modules/ToFHardware/Testing/mitkToFCameraPMDControllerTest.cpp
index e8be51cf29..3dc2b5d695 100644
--- a/Modules/ToFHardware/Testing/mitkToFCameraPMDControllerTest.cpp
+++ b/Modules/ToFHardware/Testing/mitkToFCameraPMDControllerTest.cpp
@@ -1,77 +1,77 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2010-03-12 14:05:50 +0100 (Fr, 12 Mrz 2010) $
 Version:   $Revision: 16010 $
 
 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.
 
 =========================================================================*/
 // mitk includes
 #include <mitkTestingMacros.h>
 #include <mitkToFCameraPMDController.h>
 #include <mitkCommon.h>
 #include <mitkToFConfig.h>
 
 // itk includes
 #include "itkObject.h"
 #include "itkObjectFactory.h"
 
 /**Documentation
  *  test for the class "ToFCameraPMDController".
  */
 //creating a concrete test implementation of the abstract class 
 namespace mitk
 {
   class ToFCameraPMDControllerTest : public ToFCameraPMDController
   {
   public:
     mitkClassMacro( ToFCameraPMDControllerTest, ToFCameraPMDController);
     itkNewMacro( ToFCameraPMDControllerTest );
 
     inline bool OpenCameraConnection(){return true;};
 
   protected:
     inline ToFCameraPMDControllerTest(){};
     inline ~ToFCameraPMDControllerTest(){};
 
   private:
 
   };
 } // end namespace mitk
 
 int mitkToFCameraPMDControllerTest(int /* argc */, char* /*argv*/[])
 {
   MITK_TEST_BEGIN("ToFCameraPMDController");
 
   // initialize test
   mitk::ToFCameraPMDControllerTest::Pointer testObject = mitk::ToFCameraPMDControllerTest::New();
   MITK_TEST_CONDITION_REQUIRED(!(testObject.GetPointer() == NULL) ,"Testing initialization class");
   MITK_TEST_CONDITION_REQUIRED(testObject->GetCaptureHeight()== 200 ,"Testing initialization of CaptureHeight");
   MITK_TEST_CONDITION_REQUIRED(testObject->GetCaptureWidth()== 200 ,"Testing initialization of CaptureWidth"); 
   int numberOfPixels = testObject->GetCaptureHeight()*testObject->GetCaptureWidth();
   float* dataArray = new float[numberOfPixels];
   char* sourceArray = new char[numberOfPixels];
   MITK_TEST_CONDITION_REQUIRED(testObject->OpenCameraConnection(),"Testing OpenCameraConnection()");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->UpdateCamera(),"Testing UpdateCamera() with no camera connected");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->GetAmplitudes(dataArray),"Testing GetAmplitudes(float*) with no camera connected");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->GetAmplitudes(sourceArray,dataArray),"Testing GetAmplitudes(char*,float*) with no camera connected");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->GetIntensities(dataArray),"Testing GetIntensities(float*) with no camera connected");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->GetIntensities(sourceArray,dataArray),"Testing GetIntensities(char*,float*) with no camera connected");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->GetDistances(dataArray),"Testing GetDistances(float*) with no camera connected");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->GetDistances(sourceArray,dataArray),"Testing GetDistances(char*,float*) with no camera connected");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->GetSourceData(sourceArray),"Testing GetSourceData(char*) with no camera connected");
+  MITK_TEST_CONDITION_REQUIRED(testObject->UpdateCamera(),"Testing UpdateCamera() with no camera connected");
+  MITK_TEST_CONDITION_REQUIRED(testObject->GetAmplitudes(dataArray),"Testing GetAmplitudes(float*) with no camera connected");
+  MITK_TEST_CONDITION_REQUIRED(testObject->GetAmplitudes(sourceArray,dataArray),"Testing GetAmplitudes(char*,float*) with no camera connected");
+  MITK_TEST_CONDITION_REQUIRED(testObject->GetIntensities(dataArray),"Testing GetIntensities(float*) with no camera connected");
+  MITK_TEST_CONDITION_REQUIRED(testObject->GetIntensities(sourceArray,dataArray),"Testing GetIntensities(char*,float*) with no camera connected");
+  MITK_TEST_CONDITION_REQUIRED(testObject->GetDistances(dataArray),"Testing GetDistances(float*) with no camera connected");
+  MITK_TEST_CONDITION_REQUIRED(testObject->GetDistances(sourceArray,dataArray),"Testing GetDistances(char*,float*) with no camera connected");
+  MITK_TEST_CONDITION_REQUIRED(testObject->GetSourceData(sourceArray),"Testing GetSourceData(char*) with no camera connected");
   MITK_TEST_CONDITION_REQUIRED(testObject->CloseCameraConnection(),"Testing closing of connection");
   delete [] dataArray;
   delete [] sourceArray;
   MITK_TEST_END();
 }
 
 
diff --git a/Modules/ToFHardware/Testing/mitkToFCameraPMDMITKPlayerControllerTest.cpp b/Modules/ToFHardware/Testing/mitkToFCameraPMDMITKPlayerControllerTest.cpp
index dc99aa8ad4..122e06d3cf 100644
--- a/Modules/ToFHardware/Testing/mitkToFCameraPMDMITKPlayerControllerTest.cpp
+++ b/Modules/ToFHardware/Testing/mitkToFCameraPMDMITKPlayerControllerTest.cpp
@@ -1,68 +1,68 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2010-03-12 14:05:50 +0100 (Fr, 12 Mrz 2010) $
 Version:   $Revision: 16010 $
 
 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 <mitkTestingMacros.h>
 #include <mitkToFCameraPMDMITKPlayerController.h>
 #include <mitkToFConfig.h>
 
 /**Documentation
  *  test for the class "ToFCameraPMDMITKPlayerController". 
  */
 int mitkToFCameraPMDMITKPlayerControllerTest(int /* argc */, char* /*argv*/[])
 {
   MITK_TEST_BEGIN("ToFCameraPMDMITKPlayerController");
 
   mitk::ToFCameraPMDMITKPlayerController::Pointer testObject = mitk::ToFCameraPMDMITKPlayerController::New();
   MITK_TEST_CONDITION_REQUIRED(!(testObject.GetPointer() == NULL) ,"Testing initialization class");
-  MITK_TEST_CONDITION_REQUIRED(testObject->GetCaptureHeight()== 0 ,"Testing initialization of CaptureHeight");
-  MITK_TEST_CONDITION_REQUIRED(testObject->GetCaptureWidth()== 0 ,"Testing initialization of CaptureWidth"); 
+  MITK_TEST_CONDITION_REQUIRED(testObject->GetCaptureHeight()== 200 ,"Testing initialization of CaptureHeight");
+  MITK_TEST_CONDITION_REQUIRED(testObject->GetCaptureWidth()== 200 ,"Testing initialization of CaptureWidth");
   // test empty file behavior
   std::string testFile = "";
   testObject->SetInputFileName(testFile);
-  MITK_TEST_CONDITION_REQUIRED(!testObject->OpenCameraConnection(),"Testing open camera without valid data"); 
+  MITK_TEST_CONDITION_REQUIRED(testObject->OpenCameraConnection(),"Testing open camera without valid data");
   //MITK_TEST_CONDITION_REQUIRED(!testObject->CloseCameraConnection(),"Testing closing of connection");
 
   //test valid data behavior
   //CAVE: The following test cases are valid once rawData recording is fixed. Currently the 
   //      functionality is not working therefor the test cases are excluded!!
 
   //std::string filePath = MITK_TOF_DATA_DIR;
   //testFile = "/aa_raw.pic";
   //filePath.append(testFile);
   //testObject->SetInputFileName(filePath);
   //MITK_TEST_CONDITION_REQUIRED( testObject->OpenCameraConnection(),"Testing open camera with valid data");
   //MITK_TEST_CONDITION_REQUIRED( testObject->GetIntegrationTime() == 2500,"Testing correct setting of integration time!");
   //MITK_TEST_CONDITION_REQUIRED( testObject->GetModulationFrequency() == 20,"Testing correct setting of modulation frequency!");
   //
   ////test source data passing and updating!
   //int size = testObject->GetSourceDataStructSize();
   //MITK_TEST_CONDITION_REQUIRED( size != 0 , "Testing correct setting of source data size!" )
   //char* sourceData = NULL;
   //testObject->GetSourceData( sourceData );
   //MITK_TEST_CONDITION_REQUIRED( sourceData == NULL, "Testing setting of source data without update camera!");
   //testObject->UpdateCamera();
   //sourceData = new char[size];
   //testObject->GetSourceData(sourceData);
   //MITK_TEST_CONDITION_REQUIRED( sourceData != NULL, "Testing setting of source data with update camera!");
   //delete[] sourceData;
   MITK_TEST_CONDITION( testObject->CloseCameraConnection(),"Closing Connection!");
 
   MITK_TEST_END();
 
 }
 
 
diff --git a/Modules/ToFHardware/Testing/mitkToFCameraPMDO3ControllerTest.cpp b/Modules/ToFHardware/Testing/mitkToFCameraPMDO3ControllerTest.cpp
index 1be54864a7..a0cf445359 100644
--- a/Modules/ToFHardware/Testing/mitkToFCameraPMDO3ControllerTest.cpp
+++ b/Modules/ToFHardware/Testing/mitkToFCameraPMDO3ControllerTest.cpp
@@ -1,38 +1,38 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2010-03-12 14:05:50 +0100 (Fr, 12 Mrz 2010) $
 Version:   $Revision: 16010 $
 
 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 <mitkTestingMacros.h>
 #include <mitkToFCameraPMDO3Controller.h>
 
 /**Documentation
  *  test for the class "ToFCameraPMDO3Controller".
  */
 int mitkToFCameraPMDO3ControllerTest(int /* argc */, char* /*argv*/[])
 {
   MITK_TEST_BEGIN("ToFCameraPMDO3Controller");
   mitk::ToFCameraPMDO3Controller::Pointer testObject = mitk::ToFCameraPMDO3Controller::New();
   MITK_TEST_CONDITION_REQUIRED(!testObject.GetPointer()==NULL,"Testing initialzation!");
   MITK_TEST_CONDITION_REQUIRED(testObject->GetCaptureHeight()== 200 ,"Testing initialization of CaptureHeight");
   MITK_TEST_CONDITION_REQUIRED(testObject->GetCaptureWidth()== 200 ,"Testing initialization of CaptureWidth");
-  MITK_TEST_CONDITION_REQUIRED(!testObject->OpenCameraConnection(),"Testing OpenCameraConnection!");
+  MITK_TEST_CONDITION_REQUIRED(testObject->OpenCameraConnection(),"Testing OpenCameraConnection!");
   MITK_TEST_CONDITION_REQUIRED(testObject->CloseCameraConnection(),"Testing closing of camera connection!");
 
   MITK_TEST_END();
 
 }
 
 
diff --git a/Modules/ToFHardware/Testing/mitkToFCameraPMDO3DeviceTest.cpp b/Modules/ToFHardware/Testing/mitkToFCameraPMDO3DeviceTest.cpp
index f9fd23b0c7..820d942168 100644
--- a/Modules/ToFHardware/Testing/mitkToFCameraPMDO3DeviceTest.cpp
+++ b/Modules/ToFHardware/Testing/mitkToFCameraPMDO3DeviceTest.cpp
@@ -1,61 +1,64 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2010-03-12 14:05:50 +0100 (Fr, 12 Mrz 2010) $
 Version:   $Revision: 16010 $
 
 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 <mitkTestingMacros.h>
 #include <mitkToFCameraPMDO3Device.h>
 
 /**Documentation
  *  test for the class "ToFCameraPMDO3Device".
  */
 int mitkToFCameraPMDO3DeviceTest(int /* argc */, char* /*argv*/[])
 {
   MITK_TEST_BEGIN("ToFCameraPMDO3Device");
 
   mitk::ToFCameraPMDO3Device::Pointer tofCameraPMDO3Device = mitk::ToFCameraPMDO3Device::New();
   // No hardware attached for automatic testing -> test correct error handling
-  MITK_TEST_CONDITION_REQUIRED(!tofCameraPMDO3Device->ConnectCamera(), "Test ConnectCamera()");
-  MITK_TEST_CONDITION_REQUIRED(!tofCameraPMDO3Device->IsCameraActive(), "Test IsCameraActive()");
+  MITK_TEST_CONDITION_REQUIRED(tofCameraPMDO3Device->ConnectCamera(), "Test ConnectCamera()");
+  MITK_TEST_CONDITION_REQUIRED(!tofCameraPMDO3Device->IsCameraActive(), "Test IsCameraActive() before StartCamera()");
   MITK_TEST_OUTPUT(<<"Call StartCamera()");
   tofCameraPMDO3Device->StartCamera();
+  MITK_TEST_CONDITION_REQUIRED(tofCameraPMDO3Device->IsCameraActive(), "Test IsCameraActive() after StartCamera()");
   MITK_TEST_OUTPUT(<<"Call UpdateCamera()");
   tofCameraPMDO3Device->UpdateCamera();
   int numberOfPixels = tofCameraPMDO3Device->GetCaptureWidth()*tofCameraPMDO3Device->GetCaptureHeight();
   MITK_INFO<<numberOfPixels;
   float* distances = new float[numberOfPixels];
   float* amplitudes = new float[numberOfPixels];
   float* intensities = new float[numberOfPixels];
   char* sourceData = new char[numberOfPixels];
   int requiredImageSequence = 0;
   int imageSequence = 0;
   tofCameraPMDO3Device->GetDistances(distances,imageSequence);
   tofCameraPMDO3Device->GetAmplitudes(amplitudes,imageSequence);
   tofCameraPMDO3Device->GetIntensities(intensities,imageSequence);
   tofCameraPMDO3Device->GetAllImages(distances,amplitudes,intensities,sourceData,requiredImageSequence,imageSequence);
+  MITK_TEST_CONDITION_REQUIRED(tofCameraPMDO3Device->IsCameraActive(), "Test IsCameraActive() before StopCamera()");
   MITK_TEST_OUTPUT(<<"Call StopCamera()");
   tofCameraPMDO3Device->StopCamera();
+  MITK_TEST_CONDITION_REQUIRED(!tofCameraPMDO3Device->IsCameraActive(), "Test IsCameraActive() after StopCamera()");
 
   MITK_TEST_CONDITION_REQUIRED(tofCameraPMDO3Device->DisconnectCamera(), "Test DisonnectCamera()");
   delete[] distances;
   delete[] amplitudes;
   delete[] intensities;
   delete[] sourceData;
 
   MITK_TEST_END();
 
 }
 
 
diff --git a/Modules/ToFHardware/mitkToFCameraPMDCamBoardControllerStub.cpp b/Modules/ToFHardware/mitkToFCameraPMDCamBoardControllerStub.cpp
index 17e58bf61c..072d54eb37 100644
--- a/Modules/ToFHardware/mitkToFCameraPMDCamBoardControllerStub.cpp
+++ b/Modules/ToFHardware/mitkToFCameraPMDCamBoardControllerStub.cpp
@@ -1,104 +1,104 @@
 /*=========================================================================
 
 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 "mitkToFCameraPMDCamBoardController.h"
 
 namespace mitk
 {
   ToFCameraPMDCamBoardController::ToFCameraPMDCamBoardController()
   {
     MITK_WARN("ToF") << "Error: PMD CamBoard currently not available";
   }
 
   ToFCameraPMDCamBoardController::~ToFCameraPMDCamBoardController()
   {
     MITK_WARN("ToF") << "Error: PMD CamBoard currently not available";
   }
 
   bool ToFCameraPMDCamBoardController::OpenCameraConnection()
   {
     MITK_WARN("ToF") << "Error: PMD CamBoard currently not available";
-    return false;
+    return true;
   }
 
   bool mitk::ToFCameraPMDCamBoardController::SetDistanceOffset( float offset )
   {
     MITK_WARN("ToF") << "Error: PMD CamBoard currently not available";
-    return false;
+    return true;
   }
 
   float mitk::ToFCameraPMDCamBoardController::GetDistanceOffset()
   {
     MITK_WARN("ToF") << "Error: PMD CamBoard currently not available";
     return 0.0;
   }
 
   bool mitk::ToFCameraPMDCamBoardController::SetRegionOfInterest( unsigned int leftUpperCornerX, unsigned int leftUpperCornerY, unsigned int width, unsigned int height )
   {
     MITK_WARN("ToF") << "Error: PMD CamBoard currently not available";
-    return false;
+    return true;
   }
 
   bool mitk::ToFCameraPMDCamBoardController::SetRegionOfInterest( unsigned int roi[4] )
   {
     MITK_WARN("ToF") << "Error: PMD CamBoard currently not available";
-    return false;
+    return true;
   }
 
   unsigned int* mitk::ToFCameraPMDCamBoardController::GetRegionOfInterest()
   {
     MITK_WARN("ToF") << "Error: PMD CamBoard currently not available";
     return NULL;
   }
 
   bool mitk::ToFCameraPMDCamBoardController::SetExposureMode( int mode )
   {
     MITK_WARN("ToF") << "Error: PMD CamBoard currently not available";
-    return false;
+    return true;
   }
 
   bool mitk::ToFCameraPMDCamBoardController::SetFieldOfView( float fov )
   {
     MITK_WARN("ToF") << "Error: PMD CamBoard currently not available";
-    return false;
+    return true;
   }
 
   bool mitk::ToFCameraPMDCamBoardController::SetFPNCalibration( bool on )
   {
     MITK_WARN("ToF") << "Error: PMD CamBoard currently not available";
-    return false;
+    return true;
   }
 
   bool mitk::ToFCameraPMDCamBoardController::SetFPPNCalibration( bool on )
   {
     MITK_WARN("ToF") << "Error: PMD CamBoard currently not available";
-    return false;
+    return true;
   }
 
   bool mitk::ToFCameraPMDCamBoardController::SetLinearityCalibration( bool on )
   {
     MITK_WARN("ToF") << "Error: PMD CamBoard currently not available";
-    return false;
+    return true;
   }
 
   bool mitk::ToFCameraPMDCamBoardController::SetLensCalibration( bool on )
   {
     MITK_WARN("ToF") << "Error: PMD CamBoard currently not available";
-    return false;
+    return true;
   }
 }
diff --git a/Modules/ToFHardware/mitkToFCameraPMDCamCubeControllerStub.cpp b/Modules/ToFHardware/mitkToFCameraPMDCamCubeControllerStub.cpp
index da53353a10..2cbb62f2f9 100644
--- a/Modules/ToFHardware/mitkToFCameraPMDCamCubeControllerStub.cpp
+++ b/Modules/ToFHardware/mitkToFCameraPMDCamCubeControllerStub.cpp
@@ -1,93 +1,102 @@
 /*=========================================================================
 
 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 "mitkToFCameraPMDCamCubeController.h"
 
 namespace mitk
 {
   ToFCameraPMDCamCubeController::ToFCameraPMDCamCubeController()
   {
     MITK_WARN("ToF") << "Error: PMD Camcube currently not available";
   }
 
   ToFCameraPMDCamCubeController::~ToFCameraPMDCamCubeController()
   {
   }
 
   bool ToFCameraPMDCamCubeController::OpenCameraConnection()
   {
     MITK_WARN("ToF") << "Error: PMD Camcube currently not available";
-    return false;
+    return true;
   }
 
   bool mitk::ToFCameraPMDCamCubeController::SetDistanceOffset( float offset )
   {
     MITK_WARN("ToF") << "Error: PMD Camcube currently not available";
+    return true;
   }
 
   float mitk::ToFCameraPMDCamCubeController::GetDistanceOffset()
   {
     MITK_WARN("ToF") << "Error: PMD Camcube currently not available";
     return 0.0f;
   }
 
   bool mitk::ToFCameraPMDCamCubeController::SetRegionOfInterest( unsigned int leftUpperCornerX, unsigned int leftUpperCornerY, unsigned int width, unsigned int height )
   {
     MITK_WARN("ToF") << "Error: PMD Camcube currently not available";
+    return true;
   }
 
   bool mitk::ToFCameraPMDCamCubeController::SetRegionOfInterest( unsigned int roi[4] )
   {
     MITK_WARN("ToF") << "Error: PMD Camcube currently not available";
+    return true;
   }
 
   unsigned int* mitk::ToFCameraPMDCamCubeController::GetRegionOfInterest()
   {
     MITK_WARN("ToF") << "Error: PMD Camcube currently not available";
     return NULL;
   }
 
   bool mitk::ToFCameraPMDCamCubeController::SetExposureMode( int mode )
   {
     MITK_WARN("ToF") << "Error: PMD Camcube currently not available";
+    return true;
   }
 
   bool mitk::ToFCameraPMDCamCubeController::SetFieldOfView( float fov )
   {
     MITK_WARN("ToF") << "Error: PMD Camcube currently not available";
+    return true;
   }
 
   bool mitk::ToFCameraPMDCamCubeController::SetFPNCalibration( bool on )
   {
     MITK_WARN("ToF") << "Error: PMD Camcube currently not available";
+    return true;
   }
 
   bool mitk::ToFCameraPMDCamCubeController::SetFPPNCalibration( bool on )
   {
     MITK_WARN("ToF") << "Error: PMD Camcube currently not available";
+    return true;
   }
 
   bool mitk::ToFCameraPMDCamCubeController::SetLinearityCalibration( bool on )
   {
     MITK_WARN("ToF") << "Error: PMD Camcube currently not available";
+    return true;
   }
 
   bool mitk::ToFCameraPMDCamCubeController::SetLensCalibration( bool on )
   {
     MITK_WARN("ToF") << "Error: PMD Camcube currently not available";
+    return true;
   }
 }
diff --git a/Modules/ToFHardware/mitkToFCameraPMDControllerStub.cpp b/Modules/ToFHardware/mitkToFCameraPMDControllerStub.cpp
index f8de081454..1ad8e73067 100644
--- a/Modules/ToFHardware/mitkToFCameraPMDControllerStub.cpp
+++ b/Modules/ToFHardware/mitkToFCameraPMDControllerStub.cpp
@@ -1,119 +1,121 @@
 /*=========================================================================
 
 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 "mitkToFCameraPMDController.h"
 
 namespace mitk
 {
-  ToFCameraPMDController::ToFCameraPMDController()
+  ToFCameraPMDController::ToFCameraPMDController():m_PMDRes(0), m_PixelNumber(40000), m_NumberOfBytes(0), 
+    m_CaptureWidth(200), m_CaptureHeight(200), m_SourceDataSize(0), m_SourceDataStructSize(0), m_ConnectionCheck(false), 
+    m_InputFileName("")
   {
-    MITK_WARN("ToF") << "Error: PMD devices currently not available";
+    MITK_WARN("ToF") << "PMD devices currently not available";
   }
 
   ToFCameraPMDController::~ToFCameraPMDController()
   {
   }
 
   bool ToFCameraPMDController::CloseCameraConnection()
   {
-    MITK_WARN("ToF") << "Error: PMD devices currently not available";
-    return false;
+    MITK_WARN("ToF") << "PMD devices currently not available";
+    return true;
   } 
 
   bool ToFCameraPMDController::ErrorText(int error)
   {
-    MITK_WARN("ToF") << "Error: PMD devices currently not available";
-    return false;
+    MITK_WARN("ToF") << "PMD devices currently not available";
+    return true;
   }
 
   bool ToFCameraPMDController::UpdateCamera()
   {
-    MITK_WARN("ToF") << "Error: PMD devices currently not available";
-    return false;
+    MITK_WARN("ToF") << "PMD devices currently not available";
+    return true;
   }
 
   bool ToFCameraPMDController::GetAmplitudes(float* amplitudeArray)
   {
-    MITK_WARN("ToF") << "Error: PMD devices currently not available";
-    return false;
+    MITK_WARN("ToF") << "PMD devices currently not available";
+    return true;
   }
 
   bool ToFCameraPMDController::GetAmplitudes(char* sourceData, float* amplitudeArray)
   {
-    MITK_WARN("ToF") << "Error: PMD devices currently not available";
-    return false;
+    MITK_WARN("ToF") << "PMD devices currently not available";
+    return true;
   }
 
   bool ToFCameraPMDController::GetIntensities(float* intensityArray)
   {
-    MITK_WARN("ToF") << "Error: PMD devices currently not available";
-    return false;
+    MITK_WARN("ToF") << "PMD devices currently not available";
+    return true;
   }
 
   bool ToFCameraPMDController::GetIntensities(char* sourceData, float* intensityArray)
   {
-    MITK_WARN("ToF") << "Error: PMD devices currently not available";
-    return false;
+    MITK_WARN("ToF") << "PMD devices currently not available";
+    return true;
   }
 
   bool ToFCameraPMDController::GetDistances(float* distanceArray)
   {
-    MITK_WARN("ToF") << "Error: PMD devices currently not available";
-    return false;
+    MITK_WARN("ToF") << "PMD devices currently not available";
+    return true;
   }
 
   bool ToFCameraPMDController::GetSourceData(char* sourceDataArray)
   {
-    MITK_WARN("ToF") << "Error: PMD devices currently not available";
-    return false;
+    MITK_WARN("ToF") << "PMD devices currently not available";
+    return true;
   }
 
   bool ToFCameraPMDController::GetDistances(char* sourceData, float* distanceArray)
   {
-    MITK_WARN("ToF") << "Error: PMD devices currently not available";
-    return false;
+    MITK_WARN("ToF") << "PMD devices currently not available";
+    return true;
   }
 
   int ToFCameraPMDController::SetIntegrationTime(unsigned int integrationTime)
   {
-    MITK_WARN("ToF") << "Error: PMD devices currently not available";
+    MITK_WARN("ToF") << "PMD devices currently not available";
     return 0;
   }
 
   int ToFCameraPMDController::GetIntegrationTime()
   {
-    MITK_WARN("ToF") << "Error: PMD devices currently not available";
+    MITK_WARN("ToF") << "PMD devices currently not available";
     return 0;
   }
 
   int ToFCameraPMDController::SetModulationFrequency(unsigned int modulationFrequency)
   {
-    MITK_WARN("ToF") << "Error: PMD devices currently not available";
+    MITK_WARN("ToF") << "PMD devices currently not available";
     return 0;
   }
 
   int ToFCameraPMDController::GetModulationFrequency()
   {
-    MITK_WARN("ToF") << "Error: PMD devices currently not available";
+    MITK_WARN("ToF") << "PMD devices currently not available";
     return 0;
   }
 
   void ToFCameraPMDController::SetInputFileName(std::string inputFileName)
   {
-    MITK_WARN("ToF") << "Error: PMD devices currently not available";
+    MITK_WARN("ToF") << "PMD devices currently not available";
   }
 }
diff --git a/Modules/ToFHardware/mitkToFCameraPMDMITKPlayerController.cpp b/Modules/ToFHardware/mitkToFCameraPMDMITKPlayerController.cpp
index 3af0af9390..73f559731c 100644
--- a/Modules/ToFHardware/mitkToFCameraPMDMITKPlayerController.cpp
+++ b/Modules/ToFHardware/mitkToFCameraPMDMITKPlayerController.cpp
@@ -1,206 +1,200 @@
 /*=========================================================================
 
 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 "mitkToFCameraPMDMITKPlayerController.h"
 #include <pmdsdk2.h>
 
 #include <mitkPicFileReader.h>
 #include <mitkInstantiateAccessFunctions.h>
 #include <mitkToFConfig.h>
 
 #include <itksys/SystemTools.hxx>
 
 //Plugin defines for Camcube 2.0
 #define PROC_PARAM ""
 
 extern PMDHandle m_PMDHandle; //TODO
 
 extern PMDDataDescription m_DataDescription; //TODO
 
 struct SourceDataStruct {
    PMDDataDescription dataDescription;
    char sourceData;
 };
 
 namespace mitk
 {
   ToFCameraPMDMITKPlayerController::ToFCameraPMDMITKPlayerController()
   {
     m_ProcPlugin = MITK_TOF_PMDCAMCUBE_PROCESSING_PLUGIN; //MITK_TOF_PMDFILE_SOURCE_PLUGIN; //
     m_ProcParam = PROC_PARAM;
 
-    m_CaptureWidth  = 0;
-    m_CaptureHeight = 0;
-    m_PixelNumber = m_CaptureWidth * m_CaptureHeight;
-    m_PMDRes = 0;
-    m_ConnectionCheck = false;
-
     this->m_CurrentFrame = -1;
     this->m_NumOfFrames = 0;
   }
 
   ToFCameraPMDMITKPlayerController::~ToFCameraPMDMITKPlayerController()
   {
   }
 
   bool ToFCameraPMDMITKPlayerController::OpenMITKFile()
   {
     if(this->m_InputFileName == "")
     {
       return false;
     }
     mitk::PicFileReader::Pointer reader = mitk::PicFileReader::New();
     reader->SetFileName ( this->m_InputFileName.c_str() );
     reader->Update();
     if ( reader->GetOutput() == NULL )
     {
       MITK_ERROR << "File " << this->m_InputFileName.c_str() << " could not be read!";
       return false;
     }
     this->m_MitkImage = reader->GetOutput();
     unsigned int dim = this->m_MitkImage->GetDimension();
     unsigned int *dims = this->m_MitkImage->GetDimensions();
 //TODO
     if (/*dim != 4 ||*/ dims[1] != 1 || dims[2] != 1) {
       MITK_ERROR << "File " << this->m_InputFileName.c_str() << " is not a ToF format!";
       return false;
     }
     this->m_NumOfFrames = dims[3];
     return true;
   }
 
   bool ToFCameraPMDMITKPlayerController::ReadFile()
   {
     this->m_PMDRes = pmdOpenProcessingPlugin (&m_PMDHandle , this->m_ProcPlugin , this->m_ProcParam );
     bool ok = ErrorText(this->m_PMDRes);
 
     if (!ok)
     {
       return false;
     }
 
     ok = OpenMITKFile();
     if (!ok)
     {
       this->CloseCameraConnection();
       return ok;
     }
 
     try
     {
       SourceDataStruct* sourceDataStruct = (SourceDataStruct*) this->m_MitkImage->GetSliceData(0, 0, 0)->GetData();
       memcpy(&m_DataDescription, &(sourceDataStruct->dataDescription), sizeof(m_DataDescription));
 
       this->m_CaptureWidth = m_DataDescription.img.numColumns;
       this->m_CaptureHeight = m_DataDescription.img.numRows;
 
       if ( this->m_CaptureWidth > 10000 || this->m_CaptureHeight > 10000 ) {
         MITK_ERROR << "File " << this->m_InputFileName.c_str() << " is not a ToF format!";
         return false;
       }
 
       this->m_PixelNumber = this->m_CaptureWidth * this->m_CaptureHeight;
       this->m_NumberOfBytes = this->m_PixelNumber * sizeof(float);
       this->m_SourceDataSize = m_DataDescription.size;
       this->m_SourceDataStructSize = m_DataDescription.size + sizeof(PMDDataDescription);
     }
     catch (...)
     {
       MITK_ERROR << "File " << this->m_InputFileName.c_str() << " is not a ToF format!";
       return false;
     }
     MITK_INFO << "Open MITK file: " << this->m_InputFileName.c_str();
     return true;
   }
 
   bool ToFCameraPMDMITKPlayerController::OpenCameraConnection()
   {
     bool ok = false;
     ok = ReadFile();
     if (ok)
     {
       MITK_INFO << "Datasource size: " << this->m_SourceDataSize <<std::endl;
       MITK_INFO << "Integration Time: " << this->GetIntegrationTime();
       MITK_INFO << "Modulation Frequence: " << this->GetModulationFrequency();
       MITK_INFO << "NumOfFrames: " << this->m_NumOfFrames;
     }
     return ok;
   }
 
   bool ToFCameraPMDMITKPlayerController::CloseCameraConnection()
   {
     if(m_MitkImage.IsNotNull())
     {
       this->m_MitkImage->ReleaseData();
     }
     this->m_PMDRes = pmdClose(m_PMDHandle);
     m_ConnectionCheck = ErrorText(this->m_PMDRes);
     m_PMDHandle = 0;
     return m_ConnectionCheck;
   }
 
   bool ToFCameraPMDMITKPlayerController::UpdateCamera()
   {
     this->m_CurrentFrame = (this->m_CurrentFrame + 1) % this->m_NumOfFrames;
     itksys::SystemTools::Delay(40);
     return true;
   }
 
   bool ToFCameraPMDMITKPlayerController::GetSourceData(char* sourceDataArray)
   {
     if(this->m_CurrentFrame < 0)
     {
       MITK_ERROR<<"Invalid source data request, update camera before data retrieval!";
       return false;
     }
     SourceDataStruct* sourceDataStruct = (SourceDataStruct*) this->m_MitkImage->GetSliceData(0, this->m_CurrentFrame, 0)->GetData();
     if (sourceDataStruct)
     {
       memcpy(&m_DataDescription, &(sourceDataStruct->dataDescription), sizeof(m_DataDescription));
       memcpy(&((SourceDataStruct*)sourceDataArray)->dataDescription, &m_DataDescription, sizeof(m_DataDescription));
       memcpy(&((SourceDataStruct*)sourceDataArray)->sourceData, &sourceDataStruct->sourceData, this->m_SourceDataSize);
       return true;
     }
     else
     {
       return false;
     }
   }
 
   int ToFCameraPMDMITKPlayerController::SetIntegrationTime(unsigned int integrationTime)
   {
     return integrationTime;
   }
 
   int ToFCameraPMDMITKPlayerController::GetIntegrationTime()
   {
     int integrationTime = m_DataDescription.img.integrationTime[0];
     return integrationTime;
   }
 
   int ToFCameraPMDMITKPlayerController::SetModulationFrequency(unsigned int modulationFrequency)
   {
     return modulationFrequency;
   }
 
   int ToFCameraPMDMITKPlayerController::GetModulationFrequency()
   {
     int modulationFrequency = m_DataDescription.img.modulationFrequency[0];
     return (modulationFrequency/1000000);
   }
 
 }
diff --git a/Modules/ToFHardware/mitkToFCameraPMDMITKPlayerControllerStub.cpp b/Modules/ToFHardware/mitkToFCameraPMDMITKPlayerControllerStub.cpp
index b8e21bc280..89664d5cc8 100644
--- a/Modules/ToFHardware/mitkToFCameraPMDMITKPlayerControllerStub.cpp
+++ b/Modules/ToFHardware/mitkToFCameraPMDMITKPlayerControllerStub.cpp
@@ -1,90 +1,90 @@
 /*=========================================================================
 
 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 "mitkToFCameraPMDMITKPlayerController.h"
 
 namespace mitk
 {
   ToFCameraPMDMITKPlayerController::ToFCameraPMDMITKPlayerController()
   {
     MITK_WARN("ToF") << "Error: MITK TOF Player currently not available. Did you set the directory to your PMD processing plugin?";
   }
 
   ToFCameraPMDMITKPlayerController::~ToFCameraPMDMITKPlayerController()
   {
   }
 
   bool ToFCameraPMDMITKPlayerController::OpenMITKFile()
   {
     MITK_WARN("ToF") << "Error: MITK TOF Player currently not available. Did you set the directory to your PMD processing plugin?";
-    return false;
+    return true;
   }
 
   bool ToFCameraPMDMITKPlayerController::ReadFile()
   {
     MITK_WARN("ToF") << "Error: MITK TOF Player currently not available. Did you set the directory to your PMD processing plugin?";
-    return false;
+    return true;
   }
 
   bool ToFCameraPMDMITKPlayerController::OpenCameraConnection()
   {
     MITK_WARN("ToF") << "Error: MITK TOF Player currently not available. Did you set the directory to your PMD processing plugin?";
-    return false;
+    return true;
   }
 
   bool ToFCameraPMDMITKPlayerController::CloseCameraConnection()
   {
     MITK_WARN("ToF") << "Error: MITK TOF Player currently not available. Did you set the directory to your PMD processing plugin?";
-    return false;
+    return true;
   }
 
   bool ToFCameraPMDMITKPlayerController::UpdateCamera()
   {
     MITK_WARN("ToF") << "Error: MITK TOF Player currently not available. Did you set the directory to your PMD processing plugin?";
-    return false;
+    return true;
   }
 
   bool ToFCameraPMDMITKPlayerController::GetSourceData(char* sourceDataArray)
   {
     MITK_WARN("ToF") << "Error: MITK TOF Player currently not available. Did you set the directory to your PMD processing plugin?";
-    return false;
+    return true;
   }
 
   int ToFCameraPMDMITKPlayerController::SetIntegrationTime(unsigned int integrationTime)
   {
     MITK_WARN("ToF") << "Error: MITK TOF Player currently not available. Did you set the directory to your PMD processing plugin?";
     return 0;
   }
 
   int ToFCameraPMDMITKPlayerController::GetIntegrationTime()
   {
     MITK_WARN("ToF") << "Error: MITK TOF Player currently not available. Did you set the directory to your PMD processing plugin?";
     return 0;
   }
 
   int ToFCameraPMDMITKPlayerController::SetModulationFrequency(unsigned int modulationFrequency)
   {
     MITK_WARN("ToF") << "Error: MITK TOF Player currently not available. Did you set the directory to your PMD processing plugin?";
     return 0;
   }
 
   int ToFCameraPMDMITKPlayerController::GetModulationFrequency()
   {
     MITK_WARN("ToF") << "Error: MITK TOF Player currently not available. Did you set the directory to your PMD processing plugin?";
     return 0;
   }
 }
diff --git a/Modules/ToFHardware/mitkToFCameraPMDO3ControllerStub.cpp b/Modules/ToFHardware/mitkToFCameraPMDO3ControllerStub.cpp
index fa7d6d3639..d69866e0ae 100644
--- a/Modules/ToFHardware/mitkToFCameraPMDO3ControllerStub.cpp
+++ b/Modules/ToFHardware/mitkToFCameraPMDO3ControllerStub.cpp
@@ -1,35 +1,35 @@
 /*=========================================================================
 
 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 "mitkToFCameraPMDO3Controller.h"
 namespace mitk
 {
   ToFCameraPMDO3Controller::ToFCameraPMDO3Controller()
   {
     MITK_WARN("ToF") << "Error: PMD O3 camera currently not available.";
   }
 
   ToFCameraPMDO3Controller::~ToFCameraPMDO3Controller()
   {
   }
 
   bool ToFCameraPMDO3Controller::OpenCameraConnection()
   {
     MITK_WARN("ToF") << "Error: PMD O3 camera currently not available.";
-    return false;
+    return true;
   }
 }