diff --git a/Core/Code/Rendering/mitkBaseRenderer.cpp b/Core/Code/Rendering/mitkBaseRenderer.cpp
index 93086181f4..30ceb8082c 100644
--- a/Core/Code/Rendering/mitkBaseRenderer.cpp
+++ b/Core/Code/Rendering/mitkBaseRenderer.cpp
@@ -1,888 +1,889 @@
 /*===================================================================
 
  The Medical Imaging Interaction Toolkit (MITK)
 
  Copyright (c) German Cancer Research Center,
  Division of Medical and Biological Informatics.
  All rights reserved.
 
  This software is distributed WITHOUT ANY WARRANTY; without
  even the implied warranty of MERCHANTABILITY or FITNESS FOR
  A PARTICULAR PURPOSE.
 
  See LICENSE.txt or http://www.mitk.org for details.
 
  ===================================================================*/
 
 #include "mitkBaseRenderer.h"
 #include "mitkMapper.h"
 #include "mitkResliceMethodProperty.h"
 #include "mitkKeyEvent.h"
 
 // Geometries
 #include "mitkPlaneGeometry.h"
 #include "mitkSlicedGeometry3D.h"
 
 // Controllers
 #include "mitkCameraController.h"
 #include "mitkSliceNavigationController.h"
 #include "mitkCameraRotationController.h"
 #include "mitkVtkInteractorCameraController.h"
 
 #ifdef MITK_USE_TD_MOUSE
 #include "mitkTDMouseVtkCameraController.h"
 #else
 #include "mitkCameraController.h"
 #endif
 
 #include "mitkVtkLayerController.h"
 
 // Events // TODO: INTERACTION_LEGACY
 #include "mitkEventMapper.h"
 #include "mitkGlobalInteraction.h"
 #include "mitkPositionEvent.h"
 #include "mitkDisplayPositionEvent.h"
 #include "mitkProperties.h"
 #include "mitkWeakPointerProperty.h"
 #include "mitkInteractionConst.h"
 #include "mitkOverlayManager.h"
 
 // VTK
 #include <vtkLinearTransform.h>
 #include <vtkRenderer.h>
 #include <vtkRenderWindow.h>
 #include <vtkCamera.h>
 
 #include <vtkProperty.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkActor.h>
 
 mitk::BaseRenderer::BaseRendererMapType mitk::BaseRenderer::baseRendererMap;
 
 mitk::BaseRenderer* mitk::BaseRenderer::GetInstance(vtkRenderWindow * renWin)
 {
   for (BaseRendererMapType::iterator mapit = baseRendererMap.begin(); mapit != baseRendererMap.end(); mapit++)
   {
     if ((*mapit).first == renWin)
       return (*mapit).second;
   }
   return NULL;
 }
 
 void mitk::BaseRenderer::AddInstance(vtkRenderWindow* renWin, BaseRenderer* baseRenderer)
 {
   if (renWin == NULL || baseRenderer == NULL)
     return;
 
   // ensure that no BaseRenderer is managed twice
   mitk::BaseRenderer::RemoveInstance(renWin);
 
   baseRendererMap.insert(BaseRendererMapType::value_type(renWin, baseRenderer));
 }
 
 void mitk::BaseRenderer::RemoveInstance(vtkRenderWindow* renWin)
 {
   BaseRendererMapType::iterator mapit = baseRendererMap.find(renWin);
   if (mapit != baseRendererMap.end())
     baseRendererMap.erase(mapit);
 }
 
 mitk::BaseRenderer* mitk::BaseRenderer::GetByName(const std::string& name)
 {
   for (BaseRendererMapType::iterator mapit = baseRendererMap.begin(); mapit != baseRendererMap.end(); mapit++)
   {
     if ((*mapit).second->m_Name == name)
       return (*mapit).second;
   }
   return NULL;
 }
 
 vtkRenderWindow* mitk::BaseRenderer::GetRenderWindowByName(const std::string& name)
 {
   for (BaseRendererMapType::iterator mapit = baseRendererMap.begin(); mapit != baseRendererMap.end(); mapit++)
   {
     if ((*mapit).second->m_Name == name)
       return (*mapit).first;
   }
   return NULL;
 }
 
 mitk::BaseRenderer::BaseRenderer(const char* name, vtkRenderWindow * renWin, mitk::RenderingManager* rm) :
     m_RenderWindow(NULL), m_VtkRenderer(NULL), m_MapperID(defaultMapper), m_DataStorage(NULL), m_RenderingManager(rm), m_LastUpdateTime(0), m_CameraController(
         NULL), m_SliceNavigationController(NULL), m_CameraRotationController(NULL), /*m_Size(),*/
     m_Focused(false), m_WorldGeometry(NULL), m_WorldTimeGeometry(NULL), m_CurrentWorldGeometry(NULL), m_CurrentWorldGeometry2D(NULL), m_DisplayGeometry(
         NULL), m_Slice(0), m_TimeStep(), m_CurrentWorldGeometry2DUpdateTime(), m_DisplayGeometryUpdateTime(), m_TimeStepUpdateTime(), m_WorldGeometryData(
         NULL), m_DisplayGeometryData(NULL), m_CurrentWorldGeometry2DData(NULL), m_WorldGeometryNode(NULL), m_DisplayGeometryNode(NULL), m_CurrentWorldGeometry2DNode(
         NULL), m_DisplayGeometryTransformTime(0), m_CurrentWorldGeometry2DTransformTime(0), m_Name(name), /*m_Bounds(),*/m_EmptyWorldGeometry(
         true), m_DepthPeelingEnabled(true), m_MaxNumberOfPeels(100), m_NumberOfVisibleLODEnabledMappers(0)
 {
   m_Bounds[0] = 0;
   m_Bounds[1] = 0;
   m_Bounds[2] = 0;
   m_Bounds[3] = 0;
   m_Bounds[4] = 0;
   m_Bounds[5] = 0;
 
   if (name != NULL)
   {
     m_Name = name;
   }
   else
   {
     m_Name = "unnamed renderer";
     itkWarningMacro(<< "Created unnamed renderer. Bad for serialization. Please choose a name.");
   }
 
   if (renWin != NULL)
   {
     m_RenderWindow = renWin;
     m_RenderWindow->Register(NULL);
   }
   else
   {
     itkWarningMacro(<< "Created mitkBaseRenderer without vtkRenderWindow present.");
   }
 
   m_Size[0] = 0;
   m_Size[1] = 0;
 
   //instances.insert( this );
 
   //adding this BaseRenderer to the List of all BaseRenderer
   // TODO: INTERACTION_LEGACY
   m_RenderingManager->GetGlobalInteraction()->AddFocusElement(this);
 
   m_BindDispatcherInteractor = new mitk::BindDispatcherInteractor( GetName() );
 
   WeakPointerProperty::Pointer rendererProp = WeakPointerProperty::New((itk::Object*) this);
 
   m_CurrentWorldGeometry2D = mitk::PlaneGeometry::New();
 
   m_CurrentWorldGeometry2DData = mitk::Geometry2DData::New();
   m_CurrentWorldGeometry2DData->SetGeometry2D(m_CurrentWorldGeometry2D);
   m_CurrentWorldGeometry2DNode = mitk::DataNode::New();
   m_CurrentWorldGeometry2DNode->SetData(m_CurrentWorldGeometry2DData);
   m_CurrentWorldGeometry2DNode->GetPropertyList()->SetProperty("renderer", rendererProp);
   m_CurrentWorldGeometry2DNode->GetPropertyList()->SetProperty("layer", IntProperty::New(1000));
 
   m_CurrentWorldGeometry2DNode->SetProperty("reslice.thickslices", mitk::ResliceMethodProperty::New());
   m_CurrentWorldGeometry2DNode->SetProperty("reslice.thickslices.num", mitk::IntProperty::New(1));
 
   m_CurrentWorldGeometry2DTransformTime = m_CurrentWorldGeometry2DNode->GetVtkTransform()->GetMTime();
 
   m_DisplayGeometry = mitk::DisplayGeometry::New();
   m_DisplayGeometry->SetWorldGeometry(m_CurrentWorldGeometry2D);
   m_DisplayGeometryData = mitk::Geometry2DData::New();
   m_DisplayGeometryData->SetGeometry2D(m_DisplayGeometry);
   m_DisplayGeometryNode = mitk::DataNode::New();
   m_DisplayGeometryNode->SetData(m_DisplayGeometryData);
   m_DisplayGeometryNode->GetPropertyList()->SetProperty("renderer", rendererProp);
   m_DisplayGeometryTransformTime = m_DisplayGeometryNode->GetVtkTransform()->GetMTime();
 
   mitk::SliceNavigationController::Pointer sliceNavigationController = mitk::SliceNavigationController::New("navigation");
   sliceNavigationController->SetRenderer(this);
   sliceNavigationController->ConnectGeometrySliceEvent(this);
   sliceNavigationController->ConnectGeometryUpdateEvent(this);
   sliceNavigationController->ConnectGeometryTimeEvent(this, false);
   m_SliceNavigationController = sliceNavigationController;
 
   m_CameraRotationController = mitk::CameraRotationController::New();
   m_CameraRotationController->SetRenderWindow(m_RenderWindow);
   m_CameraRotationController->AcquireCamera();
 
 //if TD Mouse Interaction is activated, then call TDMouseVtkCameraController instead of VtkInteractorCameraController
 #ifdef MITK_USE_TD_MOUSE
   m_CameraController = mitk::TDMouseVtkCameraController::New();
 #else
   m_CameraController = mitk::CameraController::New(NULL);
 #endif
 
   m_VtkRenderer = vtkRenderer::New();
 
   if (mitk::VtkLayerController::GetInstance(m_RenderWindow) == NULL)
   {
     mitk::VtkLayerController::AddInstance(m_RenderWindow, m_VtkRenderer);
     mitk::VtkLayerController::GetInstance(m_RenderWindow)->InsertSceneRenderer(m_VtkRenderer);
   }
   else
     mitk::VtkLayerController::GetInstance(m_RenderWindow)->InsertSceneRenderer(m_VtkRenderer);
 }
 
 mitk::BaseRenderer::~BaseRenderer()
 {
+  if (m_OverlayManager.IsNotNull())
+  {
+    m_OverlayManager->RemoveBaseRenderer(this);
+  }
+
   if (m_VtkRenderer != NULL)
   {
     m_VtkRenderer->Delete();
     m_VtkRenderer = NULL;
   }
 
   if (m_CameraController.IsNotNull())
     m_CameraController->SetRenderer(NULL);
 
   m_RenderingManager->GetGlobalInteraction()->RemoveFocusElement(this);
 
   mitk::VtkLayerController::RemoveInstance(m_RenderWindow);
 
   RemoveAllLocalStorages();
 
   m_DataStorage = NULL;
 
   if (m_BindDispatcherInteractor != NULL)
   {
     delete m_BindDispatcherInteractor;
   }
 
   if (m_RenderWindow != NULL)
   {
     m_RenderWindow->Delete();
     m_RenderWindow = NULL;
   }
 
-  if (m_OverlayManager.IsNotNull())
-  {
-    m_OverlayManager->RemoveBaseRenderer(this);
-  }
 }
 
 void mitk::BaseRenderer::RemoveAllLocalStorages()
 {
   this->InvokeEvent(mitk::BaseRenderer::RendererResetEvent());
 
   std::list<mitk::BaseLocalStorageHandler*>::iterator it;
   for (it = m_RegisteredLocalStorageHandlers.begin(); it != m_RegisteredLocalStorageHandlers.end(); it++)
     (*it)->ClearLocalStorage(this, false);
   m_RegisteredLocalStorageHandlers.clear();
 }
 
 void mitk::BaseRenderer::RegisterLocalStorageHandler(mitk::BaseLocalStorageHandler *lsh)
 {
   m_RegisteredLocalStorageHandlers.push_back(lsh);
 }
 
 mitk::Dispatcher::Pointer mitk::BaseRenderer::GetDispatcher() const
 {
   return m_BindDispatcherInteractor->GetDispatcher();
 }
 
 mitk::Point3D mitk::BaseRenderer::Map2DRendererPositionTo3DWorldPosition(Point2D* mousePosition) const
 {
   Point2D p_mm;
   Point3D position;
   if (m_MapperID == 1)
   {
     GetDisplayGeometry()->ULDisplayToDisplay(*mousePosition, *mousePosition);
     GetDisplayGeometry()->DisplayToWorld(*mousePosition, p_mm);
     GetDisplayGeometry()->Map(p_mm, position);
   }
   else if (m_MapperID == 2)
   {
     GetDisplayGeometry()->ULDisplayToDisplay(*mousePosition, *mousePosition);
     PickWorldPoint(*mousePosition, position);
   }
   return position;
 }
 
 void mitk::BaseRenderer::UnregisterLocalStorageHandler(mitk::BaseLocalStorageHandler *lsh)
 {
   m_RegisteredLocalStorageHandlers.remove(lsh);
 }
 
 void mitk::BaseRenderer::SetDataStorage(DataStorage* storage)
 {
   if (storage != NULL)
   {
     m_DataStorage = storage;
     m_BindDispatcherInteractor->SetDataStorage(m_DataStorage);
     this->Modified();
   }
 }
 
 const mitk::BaseRenderer::MapperSlotId mitk::BaseRenderer::defaultMapper = 1;
 
 void mitk::BaseRenderer::Paint()
 {
 }
 
 void mitk::BaseRenderer::Initialize()
 {
 }
 
 void mitk::BaseRenderer::Resize(int w, int h)
 {
   m_Size[0] = w;
   m_Size[1] = h;
 
   if (m_CameraController)
     m_CameraController->Resize(w, h); //(formerly problematic on windows: vtkSizeBug)
 
   GetDisplayGeometry()->SetSizeInDisplayUnits(w, h);
 }
 
 void mitk::BaseRenderer::InitRenderer(vtkRenderWindow* renderwindow)
 {
   if (m_RenderWindow != NULL)
   {
     m_RenderWindow->Delete();
   }
   m_RenderWindow = renderwindow;
   if (m_RenderWindow != NULL)
   {
     m_RenderWindow->Register(NULL);
   }
 
   RemoveAllLocalStorages();
 
   if (m_CameraController.IsNotNull())
   {
     m_CameraController->SetRenderer(this);
   }
 
   //BUG (#1551) added settings for depth peeling
   m_RenderWindow->SetAlphaBitPlanes(1);
   m_VtkRenderer->SetUseDepthPeeling(m_DepthPeelingEnabled);
   m_VtkRenderer->SetMaximumNumberOfPeels(m_MaxNumberOfPeels);
   m_VtkRenderer->SetOcclusionRatio(0.1);
 }
 
 void mitk::BaseRenderer::InitSize(int w, int h)
 {
   m_Size[0] = w;
   m_Size[1] = h;
   GetDisplayGeometry()->SetSizeInDisplayUnits(w, h, false);
   GetDisplayGeometry()->Fit();
 }
 
 void mitk::BaseRenderer::SetSlice(unsigned int slice)
 {
   if (m_Slice != slice)
   {
     m_Slice = slice;
     if (m_WorldTimeGeometry.IsNotNull())
     {
       SlicedGeometry3D* slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(m_WorldTimeGeometry->GetGeometryForTimeStep(m_TimeStep).GetPointer());
       if (slicedWorldGeometry != NULL)
       {
         if (m_Slice >= slicedWorldGeometry->GetSlices())
           m_Slice = slicedWorldGeometry->GetSlices() - 1;
         SetCurrentWorldGeometry2D(slicedWorldGeometry->GetGeometry2D(m_Slice));
         SetCurrentWorldGeometry(slicedWorldGeometry);
       }
     }
     else
       Modified();
   }
 }
 
 void mitk::BaseRenderer::SetOverlayManager(itk::SmartPointer<OverlayManager> overlayManager)
 {
   if(overlayManager.IsNull())
     return;
 
   if(this->m_OverlayManager.IsNotNull())
   {
     if(this->m_OverlayManager.GetPointer() == overlayManager.GetPointer())
     {
       return;
     }
     else
     {
       this->m_OverlayManager->RemoveBaseRenderer(this);
     }
   }
   this->m_OverlayManager = overlayManager;
   this->m_OverlayManager->AddBaseRenderer(this); //TODO
 }
 
 itk::SmartPointer<mitk::OverlayManager> mitk::BaseRenderer::GetOverlayManager()
 {
   if(this->m_OverlayManager.IsNull())
   {
     m_OverlayManager = mitk::OverlayManager::New();
     m_OverlayManager->AddBaseRenderer(this);
   }
   return this->m_OverlayManager;
 }
 
 void mitk::BaseRenderer::SetTimeStep(unsigned int timeStep)
 {
   if (m_TimeStep != timeStep)
   {
     m_TimeStep = timeStep;
     m_TimeStepUpdateTime.Modified();
 
     if (m_WorldTimeGeometry.IsNotNull())
     {
       if (m_TimeStep >= m_WorldTimeGeometry->CountTimeSteps())
         m_TimeStep = m_WorldTimeGeometry->CountTimeSteps() - 1;
       SlicedGeometry3D* slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(m_WorldTimeGeometry->GetGeometryForTimeStep(m_TimeStep).GetPointer());
       if (slicedWorldGeometry != NULL)
       {
         SetCurrentWorldGeometry2D(slicedWorldGeometry->GetGeometry2D(m_Slice));
         SetCurrentWorldGeometry(slicedWorldGeometry);
       }
     }
     else
       Modified();
   }
 }
 
 int mitk::BaseRenderer::GetTimeStep(const mitk::BaseData* data) const
 {
   if ((data == NULL) || (data->IsInitialized() == false))
   {
     return -1;
   }
   return data->GetTimeGeometry()->TimePointToTimeStep(GetTime());
 }
 
 mitk::ScalarType mitk::BaseRenderer::GetTime() const
 {
   if (m_WorldTimeGeometry.IsNull())
   {
     return 0;
   }
   else
   {
     ScalarType timeInMS = m_WorldTimeGeometry->TimeStepToTimePoint(GetTimeStep());
     if (timeInMS == ScalarTypeNumericTraits::NonpositiveMin())
       return 0;
     else
       return timeInMS;
   }
 }
 
 void mitk::BaseRenderer::SetWorldTimeGeometry(mitk::TimeGeometry* geometry)
 {
   assert(geometry != NULL);
 
   itkDebugMacro("setting WorldTimeGeometry to " << geometry);
   if (m_WorldTimeGeometry != geometry)
   {
     if (geometry->GetBoundingBoxInWorld()->GetDiagonalLength2() == 0)
       return;
 
     m_WorldTimeGeometry = geometry;
     itkDebugMacro("setting WorldTimeGeometry to " << m_WorldTimeGeometry);
 
     if (m_TimeStep >= m_WorldTimeGeometry->CountTimeSteps())
         m_TimeStep = m_WorldTimeGeometry->CountTimeSteps() - 1;
 
     Geometry3D* geometry3d;
     geometry3d = m_WorldTimeGeometry->GetGeometryForTimeStep(m_TimeStep);
     SetWorldGeometry3D(geometry3d);
   }
 }
 
 void mitk::BaseRenderer::SetWorldGeometry3D(mitk::Geometry3D* geometry)
 {
   itkDebugMacro("setting WorldGeometry3D to " << geometry);
 
   if (m_WorldGeometry != geometry)
   {
     if (geometry->GetBoundingBox()->GetDiagonalLength2() == 0)
       return;
 
     m_WorldGeometry = geometry;
     SlicedGeometry3D* slicedWorldGeometry;
     slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(geometry);
 
     Geometry2D::Pointer geometry2d;
     if (slicedWorldGeometry != NULL)
     {
       if (m_Slice >= slicedWorldGeometry->GetSlices() && (m_Slice != 0))
         m_Slice = slicedWorldGeometry->GetSlices() - 1;
       geometry2d = slicedWorldGeometry->GetGeometry2D(m_Slice);
       if (geometry2d.IsNull())
       {
         PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
         plane->InitializeStandardPlane(slicedWorldGeometry);
         geometry2d = plane;
       }
       SetCurrentWorldGeometry(slicedWorldGeometry);
     }
     else
     {
       geometry2d = dynamic_cast<Geometry2D*>(geometry);
       if (geometry2d.IsNull())
       {
         PlaneGeometry::Pointer plane = PlaneGeometry::New();
         plane->InitializeStandardPlane(geometry);
         geometry2d = plane;
       }
       SetCurrentWorldGeometry(geometry);
     }
     SetCurrentWorldGeometry2D(geometry2d); // calls Modified()
   }
   if (m_CurrentWorldGeometry2D.IsNull())
     itkWarningMacro("m_CurrentWorldGeometry2D is NULL");
 }
 
 void mitk::BaseRenderer::SetDisplayGeometry(mitk::DisplayGeometry* geometry2d)
 {
   itkDebugMacro("setting DisplayGeometry to " << geometry2d);
   if (m_DisplayGeometry != geometry2d)
   {
     m_DisplayGeometry = geometry2d;
     m_DisplayGeometryData->SetGeometry2D(m_DisplayGeometry);
     m_DisplayGeometryUpdateTime.Modified();
     Modified();
   }
 }
 
 void mitk::BaseRenderer::SetCurrentWorldGeometry2D(mitk::Geometry2D* geometry2d)
 {
   if (m_CurrentWorldGeometry2D != geometry2d)
   {
     m_CurrentWorldGeometry2D = geometry2d;
     m_CurrentWorldGeometry2DData->SetGeometry2D(m_CurrentWorldGeometry2D);
     m_DisplayGeometry->SetWorldGeometry(m_CurrentWorldGeometry2D);
     m_CurrentWorldGeometry2DUpdateTime.Modified();
     Modified();
   }
 }
 
 void mitk::BaseRenderer::SendUpdateSlice()
 {
   m_DisplayGeometryUpdateTime.Modified();
   m_CurrentWorldGeometry2DUpdateTime.Modified();
 }
 
 void mitk::BaseRenderer::SetCurrentWorldGeometry(mitk::Geometry3D* geometry)
 {
   m_CurrentWorldGeometry = geometry;
   if (geometry == NULL)
   {
     m_Bounds[0] = 0;
     m_Bounds[1] = 0;
     m_Bounds[2] = 0;
     m_Bounds[3] = 0;
     m_Bounds[4] = 0;
     m_Bounds[5] = 0;
     m_EmptyWorldGeometry = true;
     return;
   }
   BoundingBox::Pointer boundingBox = m_CurrentWorldGeometry->CalculateBoundingBoxRelativeToTransform(NULL);
   const BoundingBox::BoundsArrayType& worldBounds = boundingBox->GetBounds();
   m_Bounds[0] = worldBounds[0];
   m_Bounds[1] = worldBounds[1];
   m_Bounds[2] = worldBounds[2];
   m_Bounds[3] = worldBounds[3];
   m_Bounds[4] = worldBounds[4];
   m_Bounds[5] = worldBounds[5];
   if (boundingBox->GetDiagonalLength2() <= mitk::eps)
     m_EmptyWorldGeometry = true;
   else
     m_EmptyWorldGeometry = false;
 }
 
 void mitk::BaseRenderer::UpdateOverlays()
 {
   if(m_OverlayManager.IsNotNull())
   {
     m_OverlayManager->UpdateOverlays(this);
   }
 }
 
 void mitk::BaseRenderer::SetGeometry(const itk::EventObject & geometrySendEvent)
 {
   const SliceNavigationController::GeometrySendEvent* sendEvent =
       dynamic_cast<const SliceNavigationController::GeometrySendEvent *>(&geometrySendEvent);
 
   assert(sendEvent!=NULL);
   SetWorldTimeGeometry(sendEvent->GetTimeGeometry());
 }
 
 void mitk::BaseRenderer::UpdateGeometry(const itk::EventObject & geometryUpdateEvent)
 {
   const SliceNavigationController::GeometryUpdateEvent* updateEvent =
       dynamic_cast<const SliceNavigationController::GeometryUpdateEvent*>(&geometryUpdateEvent);
 
   if (updateEvent == NULL)
     return;
 
   if (m_CurrentWorldGeometry.IsNotNull())
   {
     SlicedGeometry3D* slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(m_CurrentWorldGeometry.GetPointer());
     if (slicedWorldGeometry)
     {
       Geometry2D* geometry2D = slicedWorldGeometry->GetGeometry2D(m_Slice);
 
       SetCurrentWorldGeometry2D(geometry2D); // calls Modified()
     }
   }
 }
 
 void mitk::BaseRenderer::SetGeometrySlice(const itk::EventObject & geometrySliceEvent)
 {
   const SliceNavigationController::GeometrySliceEvent* sliceEvent =
       dynamic_cast<const SliceNavigationController::GeometrySliceEvent *>(&geometrySliceEvent);
 
   assert(sliceEvent!=NULL);
   SetSlice(sliceEvent->GetPos());
 }
 
 void mitk::BaseRenderer::SetGeometryTime(const itk::EventObject & geometryTimeEvent)
 {
   const SliceNavigationController::GeometryTimeEvent * timeEvent =
       dynamic_cast<const SliceNavigationController::GeometryTimeEvent *>(&geometryTimeEvent);
 
   assert(timeEvent!=NULL);
   SetTimeStep(timeEvent->GetPos());
 }
 
 const double* mitk::BaseRenderer::GetBounds() const
 {
   return m_Bounds;
 }
 
 void mitk::BaseRenderer::MousePressEvent(mitk::MouseEvent *me)
 {
   //set the Focus on the renderer
   /*bool success =*/m_RenderingManager->GetGlobalInteraction()->SetFocus(this);
   /*
    if (! success)
    mitk::StatusBar::GetInstance()->DisplayText("Warning! from mitkBaseRenderer.cpp: Couldn't focus this BaseRenderer!");
    */
 
   //if (m_CameraController)
   //{
   //  if(me->GetButtonState()!=512) // provisorisch: Ctrl nicht durchlassen. Bald wird aus m_CameraController eine StateMachine
   //    m_CameraController->MousePressEvent(me);
   //}
   if (m_MapperID == 1)
   {
     Point2D p(me->GetDisplayPosition());
     Point2D p_mm;
     Point3D position;
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     GetDisplayGeometry()->DisplayToWorld(p, p_mm);
     GetDisplayGeometry()->Map(p_mm, position);
     mitk::PositionEvent event(this, me->GetType(), me->GetButton(), me->GetButtonState(), mitk::Key_unknown, p, position);
     mitk::EventMapper::MapEvent(&event, m_RenderingManager->GetGlobalInteraction());
   }
   else if (m_MapperID > 1)  //==2 for 3D and ==5 for stencil
   {
     Point2D p(me->GetDisplayPosition());
 
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     me->SetDisplayPosition(p);
     mitk::EventMapper::MapEvent(me, m_RenderingManager->GetGlobalInteraction());
   }
 }
 
 void mitk::BaseRenderer::MouseReleaseEvent(mitk::MouseEvent *me)
 {
   //if (m_CameraController)
   //{
   //  if(me->GetButtonState()!=512) // provisorisch: Ctrl nicht durchlassen. Bald wird aus m_CameraController eine StateMachine
   //    m_CameraController->MouseReleaseEvent(me);
   //}
 
   if (m_MapperID == 1)
   {
     Point2D p(me->GetDisplayPosition());
     Point2D p_mm;
     Point3D position;
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     GetDisplayGeometry()->DisplayToWorld(p, p_mm);
     GetDisplayGeometry()->Map(p_mm, position);
     mitk::PositionEvent event(this, me->GetType(), me->GetButton(), me->GetButtonState(), mitk::Key_unknown, p, position);
     mitk::EventMapper::MapEvent(&event, m_RenderingManager->GetGlobalInteraction());
   }
   else if (m_MapperID == 2)
   {
     Point2D p(me->GetDisplayPosition());
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     me->SetDisplayPosition(p);
     mitk::EventMapper::MapEvent(me, m_RenderingManager->GetGlobalInteraction());
   }
 }
 
 void mitk::BaseRenderer::MouseMoveEvent(mitk::MouseEvent *me)
 {
   //if (m_CameraController)
   //{
   //  if((me->GetButtonState()<=512) || (me->GetButtonState()>=516))// provisorisch: Ctrl nicht durchlassen. Bald wird aus m_CameraController eine StateMachine
   //    m_CameraController->MouseMoveEvent(me);
   //}
   if (m_MapperID == 1)
   {
     Point2D p(me->GetDisplayPosition());
     Point2D p_mm;
     Point3D position;
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     GetDisplayGeometry()->DisplayToWorld(p, p_mm);
     GetDisplayGeometry()->Map(p_mm, position);
     mitk::PositionEvent event(this, me->GetType(), me->GetButton(), me->GetButtonState(), mitk::Key_unknown, p, position);
     mitk::EventMapper::MapEvent(&event, m_RenderingManager->GetGlobalInteraction());
   }
   else if (m_MapperID == 2)
   {
     Point2D p(me->GetDisplayPosition());
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     me->SetDisplayPosition(p);
     mitk::EventMapper::MapEvent(me, m_RenderingManager->GetGlobalInteraction());
   }
 }
 
 void mitk::BaseRenderer::PickWorldPoint(const mitk::Point2D& displayPoint, mitk::Point3D& worldPoint) const
 {
   mitk::Point2D worldPoint2D;
   GetDisplayGeometry()->DisplayToWorld(displayPoint, worldPoint2D);
   GetDisplayGeometry()->Map(worldPoint2D, worldPoint);
 }
 
 void mitk::BaseRenderer::WheelEvent(mitk::WheelEvent * we)
 {
   if (m_MapperID == 1)
   {
     Point2D p(we->GetDisplayPosition());
     Point2D p_mm;
     Point3D position;
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     GetDisplayGeometry()->DisplayToWorld(p, p_mm);
     GetDisplayGeometry()->Map(p_mm, position);
     mitk::PositionEvent event(this, we->GetType(), we->GetButton(), we->GetButtonState(), mitk::Key_unknown, p, position);
     mitk::EventMapper::MapEvent(we, m_RenderingManager->GetGlobalInteraction());
     mitk::EventMapper::MapEvent(&event, m_RenderingManager->GetGlobalInteraction());
   }
   else if (m_MapperID == 2)
   {
     Point2D p(we->GetDisplayPosition());
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     we->SetDisplayPosition(p);
     mitk::EventMapper::MapEvent(we, m_RenderingManager->GetGlobalInteraction());
   }
 }
 
 void mitk::BaseRenderer::KeyPressEvent(mitk::KeyEvent *ke)
 {
   if (m_MapperID == 1)
   {
     Point2D p(ke->GetDisplayPosition());
     Point2D p_mm;
     Point3D position;
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     GetDisplayGeometry()->DisplayToWorld(p, p_mm);
     GetDisplayGeometry()->Map(p_mm, position);
     mitk::KeyEvent event(this, ke->GetType(), ke->GetButton(), ke->GetButtonState(), ke->GetKey(), ke->GetText(), p);
     mitk::EventMapper::MapEvent(&event, m_RenderingManager->GetGlobalInteraction());
   }
   else if (m_MapperID == 2)
   {
     Point2D p(ke->GetDisplayPosition());
     GetDisplayGeometry()->ULDisplayToDisplay(p, p);
     ke->SetDisplayPosition(p);
     mitk::EventMapper::MapEvent(ke, m_RenderingManager->GetGlobalInteraction());
   }
 }
 
 void mitk::BaseRenderer::DrawOverlayMouse(mitk::Point2D& itkNotUsed(p2d))
 {
   MITK_INFO<<"BaseRenderer::DrawOverlayMouse()- should be inconcret implementation OpenGLRenderer."<<std::endl;
 }
 
 void mitk::BaseRenderer::RequestUpdate()
 {
   m_RenderingManager->RequestUpdate(this->m_RenderWindow);
 }
 
 void mitk::BaseRenderer::ForceImmediateUpdate()
 {
   m_RenderingManager->ForceImmediateUpdate(this->m_RenderWindow);
 }
 
 unsigned int mitk::BaseRenderer::GetNumberOfVisibleLODEnabledMappers() const
 {
   return m_NumberOfVisibleLODEnabledMappers;
 }
 
 mitk::RenderingManager* mitk::BaseRenderer::GetRenderingManager() const
 {
   return m_RenderingManager.GetPointer();
 }
 
 /*!
  Sets the new Navigation controller
  */
 void mitk::BaseRenderer::SetSliceNavigationController(mitk::SliceNavigationController *SlicenavigationController)
 {
   if (SlicenavigationController == NULL)
     return;
 
   //disconnect old from globalinteraction
   m_RenderingManager->GetGlobalInteraction()->RemoveListener(SlicenavigationController);
 
   //copy worldgeometry
   SlicenavigationController->SetInputWorldTimeGeometry(SlicenavigationController->GetCreatedWorldGeometry());
   SlicenavigationController->Update();
 
   //set new
   m_SliceNavigationController = SlicenavigationController;
   m_SliceNavigationController->SetRenderer(this);
 
   if (m_SliceNavigationController.IsNotNull())
   {
     m_SliceNavigationController->ConnectGeometrySliceEvent(this);
     m_SliceNavigationController->ConnectGeometryUpdateEvent(this);
     m_SliceNavigationController->ConnectGeometryTimeEvent(this, false);
   }
 }
 
 /*!
  Sets the new camera controller and deletes the vtkRenderWindowInteractor in case of the VTKInteractorCameraController
  */
 void mitk::BaseRenderer::SetCameraController(CameraController* cameraController)
 {
   mitk::VtkInteractorCameraController::Pointer vtkInteractorCameraController =
       dynamic_cast<mitk::VtkInteractorCameraController*>(cameraController);
   if (vtkInteractorCameraController.IsNotNull())
     MITK_INFO<<"!!!WARNING!!!: RenderWindow interaction events are no longer handled via CameraController (See Bug #954)."<<std::endl;
   m_CameraController->SetRenderer(NULL);
   m_CameraController = NULL;
   m_CameraController = cameraController;
   m_CameraController->SetRenderer(this);
 }
 
 void mitk::BaseRenderer::PrintSelf(std::ostream& os, itk::Indent indent) const
 {
   os << indent << " MapperID: " << m_MapperID << std::endl;
   os << indent << " Slice: " << m_Slice << std::endl;
   os << indent << " TimeStep: " << m_TimeStep << std::endl;
 
   os << indent << " WorldGeometry: ";
   if (m_WorldGeometry.IsNull())
     os << "NULL" << std::endl;
   else
     m_WorldGeometry->Print(os, indent);
 
   os << indent << " CurrentWorldGeometry2D: ";
   if (m_CurrentWorldGeometry2D.IsNull())
     os << "NULL" << std::endl;
   else
     m_CurrentWorldGeometry2D->Print(os, indent);
 
   os << indent << " CurrentWorldGeometry2DUpdateTime: " << m_CurrentWorldGeometry2DUpdateTime << std::endl;
   os << indent << " CurrentWorldGeometry2DTransformTime: " << m_CurrentWorldGeometry2DTransformTime << std::endl;
 
   os << indent << " DisplayGeometry: ";
   if (m_DisplayGeometry.IsNull())
     os << "NULL" << std::endl;
   else
     m_DisplayGeometry->Print(os, indent);
 
   os << indent << " DisplayGeometryTransformTime: " << m_DisplayGeometryTransformTime << std::endl;
   Superclass::PrintSelf(os, indent);
 }
 
 void mitk::BaseRenderer::SetDepthPeelingEnabled(bool enabled)
 {
   m_DepthPeelingEnabled = enabled;
   m_VtkRenderer->SetUseDepthPeeling(enabled);
 }
 
 void mitk::BaseRenderer::SetMaxNumberOfPeels(int maxNumber)
 {
   m_MaxNumberOfPeels = maxNumber;
   m_VtkRenderer->SetMaximumNumberOfPeels(maxNumber);
-}
\ No newline at end of file
+}
diff --git a/Core/Code/Rendering/mitkPointSetVtkMapper3D.cpp b/Core/Code/Rendering/mitkPointSetVtkMapper3D.cpp
index dc06cdbd9a..d40171d355 100644
--- a/Core/Code/Rendering/mitkPointSetVtkMapper3D.cpp
+++ b/Core/Code/Rendering/mitkPointSetVtkMapper3D.cpp
@@ -1,631 +1,641 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #include "mitkPointSetVtkMapper3D.h"
 #include "mitkDataNode.h"
 #include "mitkProperties.h"
 #include "mitkColorProperty.h"
 #include "mitkVtkPropRenderer.h"
 #include "mitkPointSet.h"
-#include "mitkLabelOverlay3D.h"
-#include "mitkOverlayManager.h"
 
 #include <vtkActor.h>
 #include <vtkAppendPolyData.h>
 #include <vtkPropAssembly.h>
 #include <vtkTubeFilter.h>
 #include <vtkRenderer.h>
 #include <vtkSphereSource.h>
 #include <vtkCubeSource.h>
 #include <vtkConeSource.h>
 #include <vtkCylinderSource.h>
 #include <vtkProperty.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkCellArray.h>
 #include <vtkVectorText.h>
 #include <vtkTransform.h>
 #include <vtkTransformPolyDataFilter.h>
 #include <vtkPolyDataAlgorithm.h>
 
 #include <stdlib.h>
 
 
 
 const mitk::PointSet* mitk::PointSetVtkMapper3D::GetInput()
 {
   return static_cast<const mitk::PointSet * > ( GetDataNode()->GetData() );
 }
 
 mitk::PointSetVtkMapper3D::PointSetVtkMapper3D()
 : m_vtkSelectedPointList(NULL),
  m_vtkUnselectedPointList(NULL),
  m_VtkSelectedPolyDataMapper(NULL),
  m_VtkUnselectedPolyDataMapper(NULL),
  m_vtkTextList(NULL),
  m_NumberOfSelectedAdded(0),
  m_NumberOfUnselectedAdded(0),
  m_PointSize(1.0),
  m_ContourRadius(0.5)
 {
   //propassembly
   m_PointsAssembly = vtkSmartPointer<vtkPropAssembly>::New();
 
   //creating actors to be able to set transform
   m_SelectedActor = vtkSmartPointer<vtkActor>::New();
   m_UnselectedActor = vtkSmartPointer<vtkActor>::New();
   m_ContourActor = vtkSmartPointer<vtkActor>::New();
-
-  m_OverlayManager = mitk::OverlayManager::New();
-  m_LabelOverlay = mitk::LabelOverlay3D::New();
-  m_OverlayManager->AddOverlay(m_LabelOverlay.GetPointer());
 }
 
 mitk::PointSetVtkMapper3D::~PointSetVtkMapper3D()
 {
 }
 
 void mitk::PointSetVtkMapper3D::ReleaseGraphicsResources(vtkWindow *renWin)
 {
   m_PointsAssembly->ReleaseGraphicsResources(renWin);
 
   m_SelectedActor->ReleaseGraphicsResources(renWin);
   m_UnselectedActor->ReleaseGraphicsResources(renWin);
   m_ContourActor->ReleaseGraphicsResources(renWin);
 }
 
 void mitk::PointSetVtkMapper3D::ReleaseGraphicsResources(mitk::BaseRenderer* renderer)
 {
   m_PointsAssembly->ReleaseGraphicsResources(renderer->GetRenderWindow());
 
   m_SelectedActor->ReleaseGraphicsResources(renderer->GetRenderWindow());
   m_UnselectedActor->ReleaseGraphicsResources(renderer->GetRenderWindow());
   m_ContourActor->ReleaseGraphicsResources(renderer->GetRenderWindow());
 
 }
 
 void mitk::PointSetVtkMapper3D::CreateVTKRenderObjects()
 {
   m_vtkSelectedPointList = vtkSmartPointer<vtkAppendPolyData>::New();
   m_vtkUnselectedPointList = vtkSmartPointer<vtkAppendPolyData>::New();
 
   m_PointsAssembly->VisibilityOn();
 
   if(m_PointsAssembly->GetParts()->IsItemPresent(m_SelectedActor))
     m_PointsAssembly->RemovePart(m_SelectedActor);
   if(m_PointsAssembly->GetParts()->IsItemPresent(m_UnselectedActor))
     m_PointsAssembly->RemovePart(m_UnselectedActor);
   if(m_PointsAssembly->GetParts()->IsItemPresent(m_ContourActor))
     m_PointsAssembly->RemovePart(m_ContourActor);
 
   // exceptional displaying for PositionTracker -> MouseOrientationTool
   int mapperID;
   bool isInputDevice=false;
   if( this->GetDataNode()->GetBoolProperty("inputdevice",isInputDevice) && isInputDevice )
   {
     if( this->GetDataNode()->GetIntProperty("BaseRendererMapperID",mapperID) && mapperID == 2)
       return; //The event for the PositionTracker came from the 3d widget and  not needs to be displayed
   }
 
   // get and update the PointSet
   mitk::PointSet::Pointer input  = const_cast<mitk::PointSet*>(this->GetInput());
 
   /* only update the input data, if the property tells us to */
   bool update = true;
   this->GetDataNode()->GetBoolProperty("updateDataOnRender", update);
   if (update == true)
     input->Update();
 
   int timestep = this->GetTimestep();
 
   mitk::PointSet::DataType::Pointer itkPointSet = input->GetPointSet( timestep );
 
   if ( itkPointSet.GetPointer() == NULL)
   {
     m_PointsAssembly->VisibilityOff();
     return;
   }
 
   mitk::PointSet::PointsContainer::Iterator pointsIter;
   mitk::PointSet::PointDataContainer::Iterator pointDataIter;
   int j;
 
   m_NumberOfSelectedAdded = 0;
   m_NumberOfUnselectedAdded = 0;
 
   //create contour
   bool makeContour = false;
   this->GetDataNode()->GetBoolProperty("show contour", makeContour);
   if (makeContour)
   {
     this->CreateContour();
   }
 
   //now fill selected and unselected pointList
   //get size of Points in Property
   m_PointSize = 2;
   mitk::FloatProperty::Pointer pointSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("pointsize"));
   if ( pointSizeProp.IsNotNull() )
     m_PointSize = pointSizeProp->GetValue();
 
   //get the property for creating a label onto every point only once
   bool showLabel = true;
   this->GetDataNode()->GetBoolProperty("show label", showLabel);
   const char * pointLabel=NULL;
   if(showLabel)
   {
-    m_LabelOverlay->SetVisibility(true);
     if(dynamic_cast<mitk::StringProperty *>(this->GetDataNode()->GetPropertyList()->GetProperty("label")) != NULL)
       pointLabel =dynamic_cast<mitk::StringProperty *>(this->GetDataNode()->GetPropertyList()->GetProperty("label"))->GetValue();
     else
       showLabel = false;
   }
 
-  std::vector<std::string> labelVector;
+
   //check if the list for the PointDataContainer is the same size as the PointsContainer. Is not, then the points were inserted manually and can not be visualized according to the PointData (selected/unselected)
   bool pointDataBroken = (itkPointSet->GetPointData()->Size() != itkPointSet->GetPoints()->Size());
   //now add an object for each point in data
   pointDataIter = itkPointSet->GetPointData()->Begin();
   for (j=0, pointsIter=itkPointSet->GetPoints()->Begin();
     pointsIter!=itkPointSet->GetPoints()->End();
     pointsIter++, j++)
   {
     //check for the pointtype in data and decide which geom-object to take and then add to the selected or unselected list
     int pointType;
 
     if(itkPointSet->GetPointData()->size() == 0 || pointDataBroken)
       pointType = mitk::PTUNDEFINED;
     else
       pointType = pointDataIter.Value().pointSpec;
 
     vtkSmartPointer<vtkPolyDataAlgorithm> source;
 
     switch (pointType)
     {
     case mitk::PTUNDEFINED:
       {
         vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
         sphere->SetRadius(m_PointSize);
         itk::Point<float> point1 = pointsIter->Value();
         sphere->SetCenter(point1[0],point1[1],point1[2]);
         //sphere->SetCenter(pointsIter.Value()[0],pointsIter.Value()[1],pointsIter.Value()[2]);
 
         //MouseOrientation Tool (PositionTracker)
         if(isInputDevice)
         {
           sphere->SetThetaResolution(10);
           sphere->SetPhiResolution(10);
         }
         else
         {
           sphere->SetThetaResolution(20);
           sphere->SetPhiResolution(20);
         }
         source = sphere;
       }
       break;
     case mitk::PTSTART:
       {
         vtkSmartPointer<vtkCubeSource> cube = vtkSmartPointer<vtkCubeSource>::New();
         cube->SetXLength(m_PointSize/2);
         cube->SetYLength(m_PointSize/2);
         cube->SetZLength(m_PointSize/2);
         itk::Point<float> point1 = pointsIter->Value();
         cube->SetCenter(point1[0],point1[1],point1[2]);
         source = cube;
       }
       break;
     case mitk::PTCORNER:
       {
         vtkSmartPointer<vtkConeSource> cone = vtkSmartPointer<vtkConeSource>::New();
         cone->SetRadius(m_PointSize);
         itk::Point<float> point1 = pointsIter->Value();
         cone->SetCenter(point1[0],point1[1],point1[2]);
         cone->SetResolution(20);
         source = cone;
       }
       break;
     case mitk::PTEDGE:
       {
         vtkSmartPointer<vtkCylinderSource> cylinder = vtkSmartPointer<vtkCylinderSource>::New();
         cylinder->SetRadius(m_PointSize);
         itk::Point<float> point1 = pointsIter->Value();
         cylinder->SetCenter(point1[0],point1[1],point1[2]);
         cylinder->SetResolution(20);
         source = cylinder;
       }
       break;
     case mitk::PTEND:
       {
         vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
         sphere->SetRadius(m_PointSize);
         //itk::Point<float> point1 = pointsIter->Value();
         sphere->SetThetaResolution(20);
         sphere->SetPhiResolution(20);
         source = sphere;
       }
       break;
     default:
       {
         vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
         sphere->SetRadius(m_PointSize);
         itk::Point<float> point1 = pointsIter->Value();
         sphere->SetCenter(point1[0],point1[1],point1[2]);
         sphere->SetThetaResolution(20);
         sphere->SetPhiResolution(20);
         source = sphere;
       }
       break;
     }
     if (!pointDataBroken)
     {
       if (pointDataIter.Value().selected)
       {
         m_vtkSelectedPointList->AddInputConnection(source->GetOutputPort());
         ++m_NumberOfSelectedAdded;
       }
       else
       {
         m_vtkUnselectedPointList->AddInputConnection(source->GetOutputPort());
         ++m_NumberOfUnselectedAdded;
       }
     }
     else
     {
       m_vtkUnselectedPointList->AddInputConnection(source->GetOutputPort());
       ++m_NumberOfUnselectedAdded;
     }
 
     if (showLabel)
     {
       char buffer[20];
       std::string l = pointLabel;
       if ( input->GetSize()>1 )
       {
         sprintf(buffer,"%d",j+1);
         l.append(buffer);
       }
-      labelVector.push_back(l);
+      // Define the text for the label
+      vtkSmartPointer<vtkVectorText> label = vtkSmartPointer<vtkVectorText>::New();
+      label->SetText(l.c_str());
+
+      //# Set up a transform to move the label to a new position.
+      vtkSmartPointer<vtkTransform> aLabelTransform = vtkSmartPointer<vtkTransform>::New();
+      aLabelTransform->Identity();
+      itk::Point<float> point1 = pointsIter->Value();
+      aLabelTransform->Translate(point1[0]+2,point1[1]+2,point1[2]);
+      aLabelTransform->Scale(5.7,5.7,5.7);
+
+      //# Move the label to a new position.
+      vtkSmartPointer<vtkTransformPolyDataFilter> labelTransform = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
+      labelTransform->SetTransform(aLabelTransform);
+      labelTransform->SetInputConnection(label->GetOutputPort());
+
+      //add it to the wright PointList
+      if (pointType)
+      {
+        m_vtkSelectedPointList->AddInputConnection(labelTransform->GetOutputPort());
+        ++m_NumberOfSelectedAdded;
+      }
+      else
+      {
+        m_vtkUnselectedPointList->AddInputConnection(labelTransform->GetOutputPort());
+        ++m_NumberOfUnselectedAdded;
+      }
     }
 
     if(pointDataIter != itkPointSet->GetPointData()->End())
       pointDataIter++;
   } // end FOR
 
-  m_LabelOverlay->SetLabelVector(labelVector);
 
   //now according to number of elements added to selected or unselected, build up the rendering pipeline
   if (m_NumberOfSelectedAdded > 0)
   {
     m_VtkSelectedPolyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
     m_VtkSelectedPolyDataMapper->SetInputConnection(m_vtkSelectedPointList->GetOutputPort());
 
     //create a new instance of the actor
     m_SelectedActor = vtkSmartPointer<vtkActor>::New();
 
     m_SelectedActor->SetMapper(m_VtkSelectedPolyDataMapper);
     m_PointsAssembly->AddPart(m_SelectedActor);
   }
 
   if (m_NumberOfUnselectedAdded > 0)
   {
     m_VtkUnselectedPolyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
     m_VtkUnselectedPolyDataMapper->SetInputConnection(m_vtkUnselectedPointList->GetOutputPort());
 
     //create a new instance of the actor
     m_UnselectedActor = vtkSmartPointer<vtkActor>::New();
 
     m_UnselectedActor->SetMapper(m_VtkUnselectedPolyDataMapper);
     m_PointsAssembly->AddPart(m_UnselectedActor);
   }
 }
 
-mitk::OverlayManager *mitk::PointSetVtkMapper3D::GetOverlayManager() const
-{
-  return m_OverlayManager.GetPointer();
-}
-
 
 void mitk::PointSetVtkMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
   if(!visible)
   {
     m_UnselectedActor->VisibilityOff();
     m_SelectedActor->VisibilityOff();
     m_ContourActor->VisibilityOff();
-    m_LabelOverlay->SetVisibility(false);
     return;
   }
 
-  m_LabelOverlay->SetLabelCoordinates(dynamic_cast<PointSet*>(GetDataNode()->GetData()));
-
   // create new vtk render objects (e.g. sphere for a point)
 
   SetVtkMapperImmediateModeRendering(m_VtkSelectedPolyDataMapper);
   SetVtkMapperImmediateModeRendering(m_VtkUnselectedPolyDataMapper);
 
   BaseLocalStorage *ls = m_LSH.GetLocalStorage(renderer);
   bool needGenerateData = ls->IsGenerateDataRequired( renderer, this, GetDataNode() );
 
   if(!needGenerateData)
   {
     mitk::FloatProperty * pointSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("pointsize"));
     mitk::FloatProperty * contourSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("contoursize"));
 
     // only create new vtk render objects if property values were changed
     if(pointSizeProp && m_PointSize!=pointSizeProp->GetValue() )
       needGenerateData = true;
     if(contourSizeProp && m_ContourRadius!=contourSizeProp->GetValue() )
       needGenerateData = true;
   }
 
   if(needGenerateData)
   {
     this->CreateVTKRenderObjects();
     ls->UpdateGenerateDataTime();
   }
 
   this->ApplyAllProperties(renderer, m_ContourActor);
 
   bool showPoints = true;
   this->GetDataNode()->GetBoolProperty("show points", showPoints);
 
   if(showPoints)
   {
     m_UnselectedActor->VisibilityOn();
     m_SelectedActor->VisibilityOn();
   }
   else
   {
     m_UnselectedActor->VisibilityOff();
     m_SelectedActor->VisibilityOff();
   }
 
   if(dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("opacity")) != NULL)
   {
     mitk::FloatProperty::Pointer pointOpacity =dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("opacity"));
     float opacity = pointOpacity->GetValue();
     m_ContourActor->GetProperty()->SetOpacity(opacity);
     m_UnselectedActor->GetProperty()->SetOpacity(opacity);
     m_SelectedActor->GetProperty()->SetOpacity(opacity);
   }
 
   bool makeContour = false;
   this->GetDataNode()->GetBoolProperty("show contour", makeContour);
   if (makeContour)
   {
     m_ContourActor->VisibilityOn();
   }
   else
   {
     m_ContourActor->VisibilityOff();
   }
 }
 
 
 void mitk::PointSetVtkMapper3D::ResetMapper( BaseRenderer* /*renderer*/ )
 {
   m_PointsAssembly->VisibilityOff();
 }
 
 
 vtkProp* mitk::PointSetVtkMapper3D::GetVtkProp(mitk::BaseRenderer * /*renderer*/)
 {
   return m_PointsAssembly;
 }
 
 void mitk::PointSetVtkMapper3D::UpdateVtkTransform(mitk::BaseRenderer * /*renderer*/)
 {
   vtkSmartPointer<vtkLinearTransform> vtktransform =
     this->GetDataNode()->GetVtkTransform(this->GetTimestep());
 
   m_SelectedActor->SetUserTransform(vtktransform);
   m_UnselectedActor->SetUserTransform(vtktransform);
   m_ContourActor->SetUserTransform(vtktransform);
 }
 
 void mitk::PointSetVtkMapper3D::ApplyAllProperties(mitk::BaseRenderer* renderer, vtkActor* actor)
 {
   Superclass::ApplyColorAndOpacityProperties(renderer, actor);
   //check for color props and use it for rendering of selected/unselected points and contour
   //due to different params in VTK (double/float) we have to convert!
 
   //vars to convert to
   double unselectedColor[4]={1.0f,1.0f,0.0f,1.0f};//yellow
   double selectedColor[4]={1.0f,0.0f,0.0f,1.0f};//red
   double contourColor[4]={1.0f,0.0f,0.0f,1.0f};//red
 
   //different types for color!!!
   mitk::Color tmpColor;
   double opacity = 1.0;
 
   //check if there is an unselected property
   if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("unselectedcolor")) != NULL)
   {
     tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("unselectedcolor"))->GetValue();
     unselectedColor[0] = tmpColor[0];
     unselectedColor[1] = tmpColor[1];
     unselectedColor[2] = tmpColor[2];
     unselectedColor[3] = 1.0f; //!!define a new ColorProp to be able to pass alpha value
   }
   else if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("unselectedcolor")) != NULL)
   {
     tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("unselectedcolor"))->GetValue();
     unselectedColor[0] = tmpColor[0];
     unselectedColor[1] = tmpColor[1];
     unselectedColor[2] = tmpColor[2];
     unselectedColor[3] = 1.0f; //!!define a new ColorProp to be able to pass alpha value
   }
   else
   {
     //check if the node has a color
     float unselectedColorTMP[4]={1.0f,1.0f,0.0f,1.0f};//yellow
     m_DataNode->GetColor(unselectedColorTMP, NULL);
     unselectedColor[0] = unselectedColorTMP[0];
     unselectedColor[1] = unselectedColorTMP[1];
     unselectedColor[2] = unselectedColorTMP[2];
     //unselectedColor[3] stays 1.0f
   }
 
   //get selected property
   if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("selectedcolor")) != NULL)
   {
     tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("selectedcolor"))->GetValue();
     selectedColor[0] = tmpColor[0];
     selectedColor[1] = tmpColor[1];
     selectedColor[2] = tmpColor[2];
     selectedColor[3] = 1.0f;
   }
   else if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("selectedcolor")) != NULL)
   {
     tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("selectedcolor"))->GetValue();
     selectedColor[0] = tmpColor[0];
     selectedColor[1] = tmpColor[1];
     selectedColor[2] = tmpColor[2];
     selectedColor[3] = 1.0f;
   }
 
   //get contour property
   if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("contourcolor")) != NULL)
   {
     tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("contourcolor"))->GetValue();
     contourColor[0] = tmpColor[0];
     contourColor[1] = tmpColor[1];
     contourColor[2] = tmpColor[2];
     contourColor[3] = 1.0f;
   }
   else if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("contourcolor")) != NULL)
   {
     tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("contourcolor"))->GetValue();
     contourColor[0] = tmpColor[0];
     contourColor[1] = tmpColor[1];
     contourColor[2] = tmpColor[2];
     contourColor[3] = 1.0f;
   }
 
   if(dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("opacity")) != NULL)
   {
     mitk::FloatProperty::Pointer pointOpacity =dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("opacity"));
     opacity = pointOpacity->GetValue();
   }
   else if(dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("opacity")) != NULL)
   {
     mitk::FloatProperty::Pointer pointOpacity =dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("opacity"));
     opacity = pointOpacity->GetValue();
   }
   //finished color / opacity fishing!
 
   //check if a contour shall be drawn
   bool makeContour = false;
   this->GetDataNode()->GetBoolProperty("show contour", makeContour, renderer);
   if(makeContour && (m_ContourActor != NULL) )
   {
     this->CreateContour();
     m_ContourActor->GetProperty()->SetColor(contourColor);
     m_ContourActor->GetProperty()->SetOpacity(opacity);
   }
 
   m_SelectedActor->GetProperty()->SetColor(selectedColor);
   m_SelectedActor->GetProperty()->SetOpacity(opacity);
 
   m_UnselectedActor->GetProperty()->SetColor(unselectedColor);
   m_UnselectedActor->GetProperty()->SetOpacity(opacity);
 
 }
 
 void mitk::PointSetVtkMapper3D::CreateContour()
 {
   vtkSmartPointer<vtkAppendPolyData> vtkContourPolyData = vtkSmartPointer<vtkAppendPolyData>::New();
   vtkSmartPointer<vtkPolyDataMapper> vtkContourPolyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
 
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkCellArray> polys = vtkSmartPointer<vtkCellArray>::New();
 
   mitk::PointSet::PointsContainer::Iterator pointsIter;
 //  mitk::PointSet::PointDataContainer::Iterator pointDataIter;
   int j;
 
   // get and update the PointSet
   mitk::PointSet::Pointer input  = const_cast<mitk::PointSet*>(this->GetInput());
 
   int timestep = this->GetTimestep();
   mitk::PointSet::DataType::Pointer itkPointSet = input->GetPointSet( timestep );
   if ( itkPointSet.GetPointer() == NULL)
   {
     return;
   }
 
   for (j=0, pointsIter=itkPointSet->GetPoints()->Begin(); pointsIter!=itkPointSet->GetPoints()->End() ; pointsIter++,j++)
   {
     vtkIdType cell[2] = {j-1,j};
     itk::Point<float> point1 = pointsIter->Value();
     points->InsertPoint(j,point1[0],point1[1],point1[2]);
     if (j>0)
       polys->InsertNextCell(2,cell);
   }
 
   bool close = false;
   this->GetDataNode()->GetBoolProperty("close contour", close);
   if (close)
   {
     vtkIdType cell[2] = {j-1,0};
     polys->InsertNextCell(2,cell);
   }
 
   vtkSmartPointer<vtkPolyData> contour = vtkSmartPointer<vtkPolyData>::New();
   contour->SetPoints(points);
   contour->SetLines(polys);
 
   vtkSmartPointer<vtkTubeFilter> tubeFilter = vtkSmartPointer<vtkTubeFilter>::New();
   tubeFilter->SetNumberOfSides( 12 );
   tubeFilter->SetInputData(contour);
 
   //check for property contoursize.
   m_ContourRadius = 0.5;
   mitk::FloatProperty::Pointer contourSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("contoursize") );
 
   if (contourSizeProp.IsNotNull())
     m_ContourRadius = contourSizeProp->GetValue();
 
   tubeFilter->SetRadius( m_ContourRadius );
   tubeFilter->Update();
 
   //add to pipeline
   vtkContourPolyData->AddInputConnection(tubeFilter->GetOutputPort());
   vtkContourPolyDataMapper->SetInputConnection(vtkContourPolyData->GetOutputPort());
 
   m_ContourActor->SetMapper(vtkContourPolyDataMapper);
   m_PointsAssembly->AddPart(m_ContourActor);
 }
 
 void mitk::PointSetVtkMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   node->AddProperty( "line width", mitk::IntProperty::New(2), renderer, overwrite );
   node->AddProperty( "pointsize", mitk::FloatProperty::New(1.0), renderer, overwrite);
   node->AddProperty( "selectedcolor", mitk::ColorProperty::New(1.0f, 0.0f, 0.0f), renderer, overwrite);  //red
   node->AddProperty( "color", mitk::ColorProperty::New(1.0f, 1.0f, 0.0f), renderer, overwrite);  //yellow
   node->AddProperty( "opacity", mitk::FloatProperty::New(1.0f), renderer, overwrite );
   node->AddProperty( "show contour", mitk::BoolProperty::New(false), renderer, overwrite );
   node->AddProperty( "close contour", mitk::BoolProperty::New(false), renderer, overwrite );
   node->AddProperty( "contourcolor", mitk::ColorProperty::New(1.0f, 0.0f, 0.0f), renderer, overwrite);
   node->AddProperty( "contoursize", mitk::FloatProperty::New(0.5), renderer, overwrite );
   node->AddProperty( "show points", mitk::BoolProperty::New(true), renderer, overwrite );
   node->AddProperty( "updateDataOnRender", mitk::BoolProperty::New(true), renderer, overwrite );
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
 
diff --git a/Core/Code/Rendering/mitkPointSetVtkMapper3D.h b/Core/Code/Rendering/mitkPointSetVtkMapper3D.h
index 69ff5bb1a6..12b8481144 100644
--- a/Core/Code/Rendering/mitkPointSetVtkMapper3D.h
+++ b/Core/Code/Rendering/mitkPointSetVtkMapper3D.h
@@ -1,163 +1,158 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #ifndef MITKPointSetVtkMAPPER3D_H_HEADER_INCLUDED_C1907273
 #define MITKPointSetVtkMAPPER3D_H_HEADER_INCLUDED_C1907273
 
 #include <MitkExports.h>
 #include "mitkVtkMapper.h"
 #include "mitkBaseRenderer.h"
 #include <vtkSmartPointer.h>
 
 class vtkActor;
 class vtkPropAssembly;
 class vtkAppendPolyData;
 class vtkPolyData;
 class vtkTubeFilter;
 class vtkPolyDataMapper;
 
 namespace mitk {
 
   class PointSet;
-  class LabelOverlay3D;
 
   /**
   * @brief Vtk-based mapper for PointSet
   *
   * Due to the need of different colors for selected
   * and unselected points and the facts, that we also have a contour and
   * labels for the points, the vtk structure is build up the following way:
   *
   * We have two AppendPolyData, one selected, and one unselected and one
   * for a contour between the points. Each one is connected to an own
   * PolyDaraMapper and an Actor. The different color for the unselected and
   * selected state and for the contour is read from properties.
   *
   * "unselectedcolor", "selectedcolor" and "contourcolor" are the strings,
   * that are looked for. Pointlabels are added besides the selected or the
   * deselected points.
   *
   * Then the three Actors are combined inside a vtkPropAssembly and this
   * object is returned in GetProp() and so hooked up into the rendering
   * pipeline.
 
   * Properties that can be set for point sets and influence the PointSetVTKMapper3D are:
   *
 
   *   - \b "color": (ColorProperty*) Color of the point set
   *   - \b "Opacity": (FloatProperty) Opacity of the point set
   *   - \b "show contour": (BoolProperty) If the contour of the points are visible
   *   - \b "contourSizeProp":(FloatProperty) Contour size of the points
 
 
   The default properties are:
 
   *   - \b "line width": (IntProperty::New(2), renderer, overwrite )
   *   - \b "pointsize": (FloatProperty::New(1.0), renderer, overwrite)
   *   - \b "selectedcolor": (ColorProperty::New(1.0f, 0.0f, 0.0f), renderer, overwrite)  //red
   *   - \b "color": (ColorProperty::New(1.0f, 1.0f, 0.0f), renderer, overwrite)  //yellow
   *   - \b "show contour": (BoolProperty::New(false), renderer, overwrite )
   *   - \b "contourcolor": (ColorProperty::New(1.0f, 0.0f, 0.0f), renderer, overwrite)
   *   - \b "contoursize": (FloatProperty::New(0.5), renderer, overwrite )
   *   - \b "close contour": (BoolProperty::New(false), renderer, overwrite )
   *   - \b "show points": (BoolProperty::New(true), renderer, overwrite )
   *   - \b "updateDataOnRender": (BoolProperty::New(true), renderer, overwrite )
 
 
 
   *Other properties looked for are:
   *
   *   - \b "show contour": if set to on, lines between the points are shown
   *   - \b "close contour": if set to on, the open strip is closed (first point
   *       connected with last point)
   *   - \b "pointsize": size of the points mapped
   *   - \b "label": text of the Points to show besides points
   *   - \b "contoursize": size of the contour drawn between the points
   *       (if not set, the pointsize is taken)
   *
   * @ingroup Mapper
   */
   class MITK_CORE_EXPORT PointSetVtkMapper3D : public VtkMapper
   {
   public:
     mitkClassMacro(PointSetVtkMapper3D, VtkMapper);
 
     itkNewMacro(Self);
 
     virtual const mitk::PointSet* GetInput();
 
     //overwritten from VtkMapper3D to be able to return a
     //m_PointsAssembly which is much faster than a vtkAssembly
     virtual vtkProp* GetVtkProp(mitk::BaseRenderer* renderer);
     virtual void UpdateVtkTransform(mitk::BaseRenderer* renderer);
 
 
     static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = NULL, bool overwrite = false);
 
     /*
     * \deprecatedSince{2013_12} Use ReleaseGraphicsResources(mitk::BaseRenderer* renderer) instead
     */
     DEPRECATED(void ReleaseGraphicsResources(vtkWindow *renWin));
 
     void ReleaseGraphicsResources(mitk::BaseRenderer* renderer);
 
     LocalStorageHandler<BaseLocalStorage> m_LSH;
 
   protected:
     PointSetVtkMapper3D();
 
     virtual ~PointSetVtkMapper3D();
 
     virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer);
     virtual void ResetMapper( BaseRenderer* renderer );
     virtual void ApplyAllProperties(mitk::BaseRenderer* renderer, vtkActor* actor);
     virtual void CreateContour();
     virtual void CreateVTKRenderObjects();
-    virtual mitk::OverlayManager* GetOverlayManager() const;
 
     vtkSmartPointer<vtkAppendPolyData> m_vtkSelectedPointList;
     vtkSmartPointer<vtkAppendPolyData> m_vtkUnselectedPointList;
 
     vtkSmartPointer<vtkPolyDataMapper> m_VtkSelectedPolyDataMapper;
     vtkSmartPointer<vtkPolyDataMapper> m_VtkUnselectedPolyDataMapper;
 
     vtkSmartPointer<vtkActor> m_SelectedActor;
     vtkSmartPointer<vtkActor> m_UnselectedActor;
     vtkSmartPointer<vtkActor> m_ContourActor;
 
     vtkSmartPointer<vtkPropAssembly> m_PointsAssembly;
 
-    itk::SmartPointer<LabelOverlay3D> m_LabelOverlay;
-    itk::SmartPointer<OverlayManager> m_OverlayManager;
-
     //help for contour between points
     vtkSmartPointer<vtkAppendPolyData> m_vtkTextList;
 
     //variables to be able to log, how many inputs have been added to PolyDatas
     unsigned int m_NumberOfSelectedAdded;
     unsigned int m_NumberOfUnselectedAdded;
 
     //variables to check if an update of the vtk objects is needed
     ScalarType m_PointSize;
     ScalarType m_ContourRadius;
   };
 
 
 } // namespace mitk
 
 #endif /* MITKPointSetVtkMAPPER3D_H_HEADER_INCLUDED_C1907273 */
 
diff --git a/Core/Code/Rendering/mitkVtkOverlay.cpp b/Core/Code/Rendering/mitkVtkOverlay.cpp
index ae22cd6506..4dbf8d641f 100644
--- a/Core/Code/Rendering/mitkVtkOverlay.cpp
+++ b/Core/Code/Rendering/mitkVtkOverlay.cpp
@@ -1,63 +1,67 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkVtkOverlay.h"
 #include <vtkProperty.h>
 #include <vtkProp.h>
 
 mitk::VtkOverlay::VtkOverlay()
 {
 }
 
 
 mitk::VtkOverlay::~VtkOverlay()
 {
 }
 
 void mitk::VtkOverlay::Update(mitk::BaseRenderer *renderer)
 {
   vtkSmartPointer<vtkProp> prop = GetVtkProp(renderer);
   if(!IsVisible(renderer))
   {
     prop->SetVisibility(false);
     return;
   }
   else
   {
 
     prop->SetVisibility(true);
     UpdateVtkOverlay(renderer);
   }
 }
 
 void mitk::VtkOverlay::AddToBaseRenderer(mitk::BaseRenderer *renderer)
 {
+  if(!renderer || !renderer->GetVtkRenderer())
+    return;
   Update(renderer);
   vtkSmartPointer<vtkProp> vtkProp = GetVtkProp(renderer);
-  if(!renderer->GetVtkRenderer()->HasViewProp(vtkProp))
+  if(renderer && renderer->GetVtkRenderer() && !renderer->GetVtkRenderer()->HasViewProp(vtkProp))
   {
     renderer->GetVtkRenderer()->AddViewProp(vtkProp);
   }
 }
 
 void mitk::VtkOverlay::RemoveFromBaseRenderer(mitk::BaseRenderer *renderer)
 {
+  if(!renderer || !renderer->GetVtkRenderer())
+     return;
   vtkSmartPointer<vtkProp> vtkProp = GetVtkProp(renderer);
   if(renderer->GetVtkRenderer()->HasViewProp(vtkProp))
   {
     renderer->GetVtkRenderer()->RemoveViewProp(vtkProp);
   }
 }