diff --git a/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.cpp b/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.cpp
index de53cc5d41..12c6f6ada0 100644
--- a/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.cpp
+++ b/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.cpp
@@ -1,270 +1,287 @@
 /*=========================================================================
 
 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.
 
 =========================================================================*/
 
 #include <QmitkToFPointSetWidget.h>
 
 #include <QmitkTextOverlay.h>
 
 #include <mitkGlobalInteraction.h>
+#include <mitkVtkLayerController.h>
 
 const std::string QmitkToFPointSetWidget::VIEW_ID = "org.mitk.views.qmitktofpointsetwidget";
 
 QmitkToFPointSetWidget::QmitkToFPointSetWidget(QWidget* parent, Qt::WindowFlags f): QWidget(parent, f)
 , m_CameraIntrinsics(NULL)
-, m_OverlayController(NULL)
-, m_MeasurementPropertyList(NULL)
 , m_MeasurementPointSet2D(NULL)
 , m_MeasurementPointSet3DNode(NULL)
 , m_PointSet2D(NULL)
 , m_PointSet3DNode(NULL)
 , m_PointSetInteractor(NULL)
 , m_MeasurementPointSetInteractor(NULL)
 , m_MeasurementPointSetChangedObserverTag(0)
 , m_PointSetChangedObserverTag(0)
 {
   m_Controls = NULL;
   CreateQtPartControl(this);
 }
 
 QmitkToFPointSetWidget::~QmitkToFPointSetWidget()
 {
   if (m_MeasurementPointSet2D.IsNotNull())
   {
     m_MeasurementPointSet2D->RemoveObserver(m_MeasurementPointSetChangedObserverTag);
   }
   if (m_PointSet2D.IsNotNull())
   {
     m_PointSet2D->RemoveObserver(m_PointSetChangedObserverTag);
   }
-  delete m_OverlayController;
+  if (m_ForegroundRenderer&&m_MultiWidget)
+  {
+    mitk::VtkLayerController::GetInstance(m_MultiWidget->mitkWidget1->GetRenderWindow())->RemoveRenderer(m_ForegroundRenderer);
+  }
 }
 
 void QmitkToFPointSetWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkToFPointSetWidgetControls;
     m_Controls->setupUi(parent);
 
     this->CreateConnections();
   }
 }
 
 void QmitkToFPointSetWidget::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->measureButton), SIGNAL(clicked()),(QObject*) this, SLOT(OnMeasurement()) );
     connect( (QObject*)(m_Controls->pointSetButton), SIGNAL(clicked()),(QObject*) this, SLOT(OnPointSet()) );
   }
 }
 
 void QmitkToFPointSetWidget::InitializeWidget(QmitkStdMultiWidget* stdMultiWidget, mitk::DataStorage::Pointer dataStorage, mitk::Image::Pointer distanceImage)
 {
   // initialize members
+  m_MultiWidget = stdMultiWidget;
   m_DistanceImage = distanceImage;
   if ((stdMultiWidget!=NULL)&&(dataStorage.IsNotNull()))
   {
     // enable buttons
     m_Controls->pointSetButton->setEnabled(true);
     m_Controls->measureButton->setEnabled(true);
     // initialize overlays
-    m_MeasurementPropertyList = mitk::PropertyList::New();
-    m_MeasurementPropertyList->SetStringProperty("overlay.text.distance","");
-    m_MeasurementPropertyList->SetIntProperty("overlay.fontSize",16);
-    QmitkTextOverlay* textOverlay1 = new QmitkTextOverlay("overlay.text.distance");
-    m_OverlayController = new QmitkOverlayController(stdMultiWidget->mitkWidget1,m_MeasurementPropertyList);
-    m_OverlayController->AddOverlay(textOverlay1);
-    m_OverlayController->SetOverlayVisibility(false);
+    this->m_VtkTextActor = vtkTextActor::New();
+    this->m_VtkTextActor->SetInput("");
+    int windowHeight = m_MultiWidget->mitkWidget1->GetRenderer()->GetSizeY();
+    this->m_VtkTextActor->SetDisplayPosition(10,windowHeight-30);
+    this->m_VtkTextActor->GetTextProperty()->SetFontSize(20);
+//    this->m_VtkTextActor->GetTextProperty()->SetColor(1,0,0);
+    this->m_VtkTextActor->GetTextProperty()->BoldOn();
+    this->m_ForegroundRenderer = vtkRenderer::New();
+    this->m_ForegroundRenderer->AddActor(m_VtkTextActor);
+    mitk::VtkLayerController::GetInstance(m_MultiWidget->mitkWidget1->GetRenderWindow())->InsertForegroundRenderer(m_ForegroundRenderer,true);
     // initialize 2D measurement point set
     m_MeasurementPointSet2D = mitk::PointSet::New();
     mitk::DataNode::Pointer measurementNode2D = mitk::DataNode::New();
     measurementNode2D->SetName("Measurement PointSet 2D");
     measurementNode2D->SetBoolProperty("helper object",true);
     measurementNode2D->SetBoolProperty("show contour",true);
     measurementNode2D->SetVisibility(false,stdMultiWidget->mitkWidget4->GetRenderer());
     measurementNode2D->SetData(m_MeasurementPointSet2D);
     dataStorage->Add(measurementNode2D);
     m_MeasurementPointSetInteractor = mitk::PointSetInteractor::New("pointsetinteractor",measurementNode2D,2);
     // create observer for m_MeasurementPointSet2D
     itk::SimpleMemberCommand<QmitkToFPointSetWidget>::Pointer measurementPointSetChangedCommand;
     measurementPointSetChangedCommand = itk::SimpleMemberCommand<QmitkToFPointSetWidget>::New();
     measurementPointSetChangedCommand->SetCallbackFunction(this, &QmitkToFPointSetWidget::MeasurementPointSetChanged);
     m_MeasurementPointSetChangedObserverTag = m_MeasurementPointSet2D->AddObserver(itk::ModifiedEvent(), measurementPointSetChangedCommand);
     // initialize 3D measurement PointSet
     m_MeasurementPointSet3DNode = mitk::DataNode::New();
     m_MeasurementPointSet3DNode->SetName("Measurement PointSet 3D");
     m_MeasurementPointSet3DNode->SetBoolProperty("helper object",true);
     m_MeasurementPointSet3DNode->SetBoolProperty("show contour",true);
     m_MeasurementPointSet3DNode->SetFloatProperty("pointsize",5.0f);
     mitk::PointSet::Pointer measurementPointSet3D = mitk::PointSet::New();
     m_MeasurementPointSet3DNode->SetData(measurementPointSet3D);
     dataStorage->Add(m_MeasurementPointSet3DNode);
     // initialize PointSets
     m_PointSet2D = mitk::PointSet::New();
     mitk::DataNode::Pointer pointSet2DNode = mitk::DataNode::New();
     pointSet2DNode->SetName("ToF PointSet 2D");
     pointSet2DNode->SetVisibility(false,stdMultiWidget->mitkWidget4->GetRenderer());
     pointSet2DNode->SetData(m_PointSet2D);
     dataStorage->Add(pointSet2DNode);
     m_PointSetInteractor = mitk::PointSetInteractor::New("pointsetinteractor",pointSet2DNode);
     // create observer for m_MeasurementPointSet2D
     itk::SimpleMemberCommand<QmitkToFPointSetWidget>::Pointer pointSetChangedCommand;
     pointSetChangedCommand = itk::SimpleMemberCommand<QmitkToFPointSetWidget>::New();
     pointSetChangedCommand->SetCallbackFunction(this, &QmitkToFPointSetWidget::PointSetChanged);
     m_PointSetChangedObserverTag = m_PointSet2D->AddObserver(itk::ModifiedEvent(), pointSetChangedCommand);
     // initialize 3D point set
     m_PointSet3DNode = mitk::DataNode::New();
     m_PointSet3DNode->SetName("ToF PointSet 3D");
     m_PointSet3DNode->SetFloatProperty("pointsize",5.0f);
     mitk::PointSet::Pointer pointSet3D = mitk::PointSet::New();
     m_PointSet3DNode->SetData(pointSet3D);
     dataStorage->Add(m_PointSet3DNode);
   }
 }
 
 void QmitkToFPointSetWidget::SetCameraIntrinsics(mitk::CameraIntrinsics::Pointer cameraIntrinsics)
 {
   m_CameraIntrinsics = cameraIntrinsics;
 }
 
 void QmitkToFPointSetWidget::OnMeasurement()
 {
-  // initial update of measurement
-  this->MeasurementPointSetChanged();
   if (m_Controls->measureButton->isChecked())
   {
-    // uncheck point set button
-    m_Controls->pointSetButton->setChecked(false);
+    // disable point set interaction
+    if (m_Controls->pointSetButton->isChecked())
+    {
+      m_Controls->pointSetButton->setChecked(false);
+      // remove interactor
+      mitk::GlobalInteraction::GetInstance()->RemoveInteractor(m_PointSetInteractor);
+    }
     // show overlays
-    m_OverlayController->SetOverlayVisibility(true);
+    m_VtkTextActor->SetVisibility(1);
     // enable interactor
     mitk::GlobalInteraction::GetInstance()->AddInteractor(m_MeasurementPointSetInteractor);
+    // initial update of measurement
+    this->MeasurementPointSetChanged();
   }
   else
   {
     // hide overlays
-    m_OverlayController->SetOverlayVisibility(false);
+    m_VtkTextActor->SetVisibility(0);
     // disable interactor
     mitk::GlobalInteraction::GetInstance()->RemoveInteractor(m_MeasurementPointSetInteractor);
   }
 }
 
 void QmitkToFPointSetWidget::OnPointSet()
 {
-  // initial update of PointSet
-  this->PointSetChanged();
   if (m_Controls->pointSetButton->isChecked())
   {
-    // uncheck point set button
-    m_Controls->measureButton->setChecked(false);
+    // disable measurement
+    if (m_Controls->measureButton->isChecked())
+    {
+      m_Controls->measureButton->setChecked(false);
+      // remove interactor
+      mitk::GlobalInteraction::GetInstance()->RemoveInteractor(m_MeasurementPointSetInteractor);
+    }
     // hide overlays
-    m_OverlayController->SetOverlayVisibility(false);
+    m_VtkTextActor->SetVisibility(0);
     // enable interactor
     mitk::GlobalInteraction::GetInstance()->AddInteractor(m_PointSetInteractor);
+    // initial update of PointSet
+    this->PointSetChanged();
   }
   else
   {
     // disable interactor
     mitk::GlobalInteraction::GetInstance()->RemoveInteractor(m_PointSetInteractor);
   }
 }
 
 void QmitkToFPointSetWidget::MeasurementPointSetChanged()
 {
   int imageSizeX = m_DistanceImage->GetDimensions()[0];
   int imageSizeY = m_DistanceImage->GetDimensions()[1];
   mitk::Point3D point1 = m_MeasurementPointSet2D->GetPoint(0);
   mitk::Point3D point2 = m_MeasurementPointSet2D->GetPoint(1);
   if (m_MeasurementPointSet2D->GetSize()>0)
   {
     if ((point1[0]>=0.0f)&&(point1[0]<imageSizeX)&&(point1[1]>=0)&&(point1[1]<imageSizeY)&&
         (point2[0]>=0.0f)&&(point2[0]<imageSizeX)&&(point2[1]>=0)&&(point2[1]<imageSizeY))
     {
       // create PointSet filter
       mitk::ToFDistanceImageToPointSetFilter::Pointer toFDistanceImageToPointSetFilter = mitk::ToFDistanceImageToPointSetFilter::New();
       if (m_CameraIntrinsics.IsNotNull())
       {
         toFDistanceImageToPointSetFilter->SetCameraIntrinsics(m_CameraIntrinsics);
       }
       toFDistanceImageToPointSetFilter->SetInput(m_DistanceImage);
       toFDistanceImageToPointSetFilter->SetSubset(m_MeasurementPointSet2D);
       toFDistanceImageToPointSetFilter->Update();
       mitk::PointSet::Pointer measurementPointSet3D = toFDistanceImageToPointSetFilter->GetOutput();
       m_MeasurementPointSet3DNode->SetData(measurementPointSet3D);
 
       // calculate distance between points
       if (measurementPointSet3D->GetSize()==2)
       {
         mitk::Point3D point1 = measurementPointSet3D->GetPoint(0);
         mitk::Point3D point2 = measurementPointSet3D->GetPoint(1);
         float distance = point1.EuclideanDistanceTo(point2);
         std::stringstream stream;
         stream<<distance<<" mm";
-        m_MeasurementPropertyList->SetStringProperty("overlay.text.distance",stream.str().c_str());
+        this->m_VtkTextActor->SetInput(stream.str().c_str());
       }
     }
     else
     {
-      m_MeasurementPropertyList->SetStringProperty("overlay.text.distance","Measurement outside image range.");
+      this->m_VtkTextActor->SetInput("Measurement outside image range.");
     }
   }
 }
 
 void QmitkToFPointSetWidget::PointSetChanged()
 {
   int imageSizeX = m_DistanceImage->GetDimensions()[0];
   int imageSizeY = m_DistanceImage->GetDimensions()[1];
   int pointSetValid = 1;
   for (int i=0; i<m_PointSet2D->GetSize(); i++)
   {
     mitk::Point3D currentPoint = m_PointSet2D->GetPoint(i);
     if ((currentPoint[0]>=0.0f)&&(currentPoint[0]<imageSizeX)&&(currentPoint[1]>=0)&&(currentPoint[1]<imageSizeY))
     {
       pointSetValid*=1;
     }
     else
     {
       pointSetValid*=0;
     }
   }
   if (m_PointSet2D->GetSize()>0)
   {
     if (pointSetValid)
     {
-      m_OverlayController->SetOverlayVisibility(false);
+      // hide overlay
+      m_VtkTextActor->SetVisibility(0);
       // create PointSet filter
       mitk::ToFDistanceImageToPointSetFilter::Pointer toFDistanceImageToPointSetFilter = mitk::ToFDistanceImageToPointSetFilter::New();
       if (m_CameraIntrinsics.IsNotNull())
       {
         toFDistanceImageToPointSetFilter->SetCameraIntrinsics(m_CameraIntrinsics);
       }
       toFDistanceImageToPointSetFilter->SetInput(m_DistanceImage);
       toFDistanceImageToPointSetFilter->SetSubset(m_PointSet2D);
       toFDistanceImageToPointSetFilter->Update();
       mitk::PointSet::Pointer pointSet3D = toFDistanceImageToPointSetFilter->GetOutput();
       m_PointSet3DNode->SetData(pointSet3D);
     }
     else
     {
-      m_OverlayController->SetOverlayVisibility(true);
-      m_MeasurementPropertyList->SetStringProperty("overlay.text.distance","PointSet outside image range.");
+      m_VtkTextActor->SetVisibility(1);
+      this->m_VtkTextActor->SetInput("Point set outside image range.");
     }
   }
 }
diff --git a/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.h b/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.h
index 872fa3fe4d..a012b760ec 100644
--- a/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.h
+++ b/Modules/ToFUI/Qmitk/QmitkToFPointSetWidget.h
@@ -1,121 +1,127 @@
 /*=========================================================================
 
 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.
 
 =========================================================================*/
 
 #ifndef _QmitkToFPointSetWidget_H_INCLUDED
 #define _QmitkToFPointSetWidget_H_INCLUDED
 
 #include "mitkTOFUIExports.h"
 #include "ui_QmitkToFPointSetWidgetControls.h"
 
 //mitk headers
 #include <mitkCameraIntrinsics.h>
 #include <mitkDataStorage.h>
 #include <mitkPointSet.h>
 #include <mitkPointSetInteractor.h>
 #include <mitkPropertyList.h>
 #include <mitkToFDistanceImageToPointSetFilter.h>
 
 // Qmitk headers
 #include <QmitkStdMultiWidget.h>
-#include <QmitkOverlayController.h>
+
+// vtk includes
+#include <vtkSmartPointer.h>
+#include <vtkTextActor.h>
+#include <vtkRenderer.h>
 
 /**
 * @brief Widget allowing interaction with point sets for measurement and PointSet definition
 *
 * The widget allows to
 * 1. Measure the distance between two points in 3D ToF space by clicking the points in the 2D slices
 * 2. Defining a ToF PointSet both in 2D and 3D. CameraIntrinsics are used for calculation between 2D and 3D
 *
 * @ingroup ToFUI
 */
 class mitkTOFUI_EXPORT QmitkToFPointSetWidget :public QWidget
 {
   //this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
   public:
 
     static const std::string VIEW_ID;
 
     QmitkToFPointSetWidget(QWidget* p = 0, Qt::WindowFlags f1 = 0);
     virtual ~QmitkToFPointSetWidget();
 
     /* @brief This method is part of the widget an needs not to be called seperately. */
     virtual void CreateQtPartControl(QWidget *parent);
     /* @brief This method is part of the widget an needs not to be called seperately. (Creation of the connections of main and control widget.)*/
     virtual void CreateConnections();
 
     /*!
     \brief initializes the widget
     \param stdMultiWidget QmitkStdMultiWidget used for painting overlays for measurement
     \param dataStorage DataStorage to add PointSets
     \param distanceImage range image used to calculate 3D PointSet from 2D index
     */
     void InitializeWidget(QmitkStdMultiWidget* stdMultiWidget, mitk::DataStorage::Pointer dataStorage, mitk::Image::Pointer distanceImage);
 
     /*!
     \brief specify the intrinsic parameters of the camera (holds focal length, principal point, distortion coefficients)
     */
     void SetCameraIntrinsics(mitk::CameraIntrinsics::Pointer cameraIntrinsics);
 
   signals:
 
   protected slots:
     /*!
     \brief Activates the interactor for the measurement point set
     */
     void OnMeasurement();
     /*!
     \brief Activates the interactor for the point set
     */
     void OnPointSet();
 
   protected:
 
     /*!
     \brief function called when the 2D measurement PointSet has changed
     */
     void MeasurementPointSetChanged();
     /*!
     \brief function called when the 2D PointSet has changed
     */
     void PointSetChanged();
 
     Ui::QmitkToFPointSetWidgetControls* m_Controls; ///< member holding the UI elements of this widget
 
+    QmitkStdMultiWidget* m_MultiWidget; ///< multi widget used for overlay visualization
+
     mitk::Image::Pointer m_DistanceImage; ///< image holding the range data of the ToF camera
     mitk::CameraIntrinsics::Pointer m_CameraIntrinsics; ///< intrinsic parameters of the camera
 
-    QmitkOverlayController* m_OverlayController; ///< overlay controller holding the text overlay of the measurement
-    mitk::PropertyList::Pointer m_MeasurementPropertyList; ///< property list holding the properties for the measurement text
+    vtkSmartPointer<vtkTextActor> m_VtkTextActor; ///< actor containing the text of the overlay
+    vtkSmartPointer<vtkRenderer> m_ForegroundRenderer; ///< renderer responsible for text rendering in the foreground
 
     mitk::PointSet::Pointer m_MeasurementPointSet2D; ///< PointSet holding the 2D ToF image point selection used for measuring
     mitk::DataNode::Pointer m_MeasurementPointSet3DNode; ///< DataNode holding the 3D ToF coordinates used for measuring
     mitk::PointSet::Pointer m_PointSet2D; ///< PointSet holding the 2D ToF image points
     mitk::DataNode::Pointer m_PointSet3DNode; ///< DataNode holding the 3D ToF coordinates
 
     mitk::PointSetInteractor::Pointer m_PointSetInteractor; ///< PointSetInteractor used for PointSet definition
     mitk::PointSetInteractor::Pointer m_MeasurementPointSetInteractor; ///< PointSetInteractor used for measurement
 
     long m_MeasurementPointSetChangedObserverTag; ///< observer tag for measurement PointSet observer
     long m_PointSetChangedObserverTag; ///< observer tag for PointSet observer
 
   private:
 };
 
 #endif // _QmitkToFPointSetWidget_H_INCLUDED