diff --git a/Core/Code/Rendering/mitkOverlayManager.cpp b/Core/Code/Rendering/mitkOverlayManager.cpp
index 1b0e3b3e93..b74124387c 100644
--- a/Core/Code/Rendering/mitkOverlayManager.cpp
+++ b/Core/Code/Rendering/mitkOverlayManager.cpp
@@ -1,148 +1,166 @@
 /*===================================================================
 
 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 "mitkOverlayManager.h"
 #include "mitkBaseRenderer.h"
 
 mitk::OverlayManager::OverlayManager()
 {
 }
 
 mitk::OverlayManager::~OverlayManager()
 {
+  RemoveAllOverlays();
 }
 
 void mitk::OverlayManager::AddBaseRenderer(mitk::BaseRenderer* renderer)
 {
   std::pair<BaseRendererSet::iterator,bool> inSet;
   inSet = m_BaseRendererSet.insert(renderer);
   if(inSet.second)
   {
     OverlaySet::iterator it;
     for ( it=m_OverlaySet.begin() ; it != m_OverlaySet.end(); it++ )
     {
       (*it)->AddToBaseRenderer(renderer);
     }
   }
 }
 
 void mitk::OverlayManager::RemoveBaseRenderer(mitk::BaseRenderer* renderer)
 {
   if(!renderer)
     return;
   std::pair<BaseRendererSet::iterator,bool> inSet;
   inSet = m_BaseRendererSet.insert(renderer);
   m_BaseRendererSet.erase(inSet.first);
+
+  OverlaySet::iterator it;
+  for ( it=m_OverlaySet.begin() ; it != m_OverlaySet.end(); it++ )
+  {
+    (*it)->RemoveFromBaseRenderer(*inSet.first);
+  }
+
 }
 
 void mitk::OverlayManager::AddOverlay(const Overlay::Pointer& overlay)
 {
   std::pair<OverlaySet::iterator,bool> inSet;
   inSet = m_OverlaySet.insert(overlay);
   if(inSet.second)
   {
     BaseRendererSet::iterator it;
     for ( it=m_BaseRendererSet.begin() ; it != m_BaseRendererSet.end(); it++ )
     {
       overlay->AddToBaseRenderer(*it);
     }
   }
 }
 
+void mitk::OverlayManager::AddOverlay(const Overlay::Pointer& overlay, BaseRenderer* renderer)
+{
+  std::pair<OverlaySet::iterator,bool> inSet;
+  inSet = m_OverlaySet.insert(overlay);
+  if(inSet.second)
+  {
+    overlay->AddToBaseRenderer(renderer);
+  }
+}
+
 void mitk::OverlayManager::RemoveOverlay(const Overlay::Pointer &overlay)
 {
   std::pair<OverlaySet::iterator,bool> inSet;
   inSet = m_OverlaySet.insert(overlay);
   if(!inSet.second)
   {
     BaseRendererSet::iterator it;
     for ( it=m_BaseRendererSet.begin() ; it != m_BaseRendererSet.end(); it++ )
     {
       overlay->RemoveFromBaseRenderer(*it);
     }
   }
   m_OverlaySet.erase(inSet.first);
 }
 
 void mitk::OverlayManager::RemoveAllOverlays()
 {
   OverlaySet::iterator it;
   for ( it=m_OverlaySet.begin() ; it != m_OverlaySet.end(); it++ )
   {
     RemoveOverlay(*it);
   }
   m_OverlaySet.clear();
 }
 
 void mitk::OverlayManager::UpdateOverlays(mitk::BaseRenderer* baseRenderer)
 {
   OverlaySet::iterator it;
   for ( it=m_OverlaySet.begin() ; it != m_OverlaySet.end(); it++ )
   {
     (*it)->Update(baseRenderer);
   }
   UpdateLayouts(baseRenderer);
 }
 
 
 void mitk::OverlayManager::SetLayouter(Overlay *overlay, const std::string &identifier, mitk::BaseRenderer *renderer)
 {
   if(renderer)
   {
     AbstractOverlayLayouter::Pointer layouter = GetLayouter(renderer,identifier);
     if(layouter.IsNull())
     {
       MITK_WARN << "Layouter " << identifier << " cannot be found or created!";
       return;
     }
     else
     {
       layouter->AddOverlay(overlay);
     }
   }
 }
 
 void mitk::OverlayManager::UpdateLayouts(mitk::BaseRenderer *renderer)
 {
   LayouterMap layouters = m_LayouterMap[renderer];
   LayouterMap::iterator it;
   for ( it=layouters.begin() ; it != layouters.end(); it++ )
   {
     (it->second)->PrepareLayout();
   }
 }
 
 mitk::AbstractOverlayLayouter::Pointer mitk::OverlayManager::GetLayouter(mitk::BaseRenderer *renderer, const std::string& identifier)
 {
   AbstractOverlayLayouter::Pointer layouter = m_LayouterMap[renderer][identifier];
   return layouter;
 }
 
 void mitk::OverlayManager::AddLayouter(const AbstractOverlayLayouter::Pointer& layouter)
 {
   if(layouter.IsNotNull())
   {
     AbstractOverlayLayouter::Pointer oldLayouter = m_LayouterMap[layouter->GetBaseRenderer()][layouter->GetIdentifier()];
     if(oldLayouter.IsNotNull() && oldLayouter.GetPointer() != layouter.GetPointer())
     {
       MITK_WARN << "Layouter " << layouter->GetIdentifier() << " does already exist!";
     }
     else if(oldLayouter.IsNull())
     {
       m_LayouterMap[layouter->GetBaseRenderer()][layouter->GetIdentifier()] = layouter;
     }
   }
 }
diff --git a/Core/Code/Rendering/mitkOverlayManager.h b/Core/Code/Rendering/mitkOverlayManager.h
index 57ffcf3c37..c4e854f453 100644
--- a/Core/Code/Rendering/mitkOverlayManager.h
+++ b/Core/Code/Rendering/mitkOverlayManager.h
@@ -1,97 +1,98 @@
 /*===================================================================
 
 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 OVERLAYMANAGER_H
 #define OVERLAYMANAGER_H
 
 #include "MitkExports.h"
 #include <itkLightObject.h>
 #include <vtkSmartPointer.h>
 #include "mitkOverlay.h"
 #include "mitkAbstractOverlayLayouter.h"
 #include "mitkLocalStorageHandler.h"
 
 namespace mitk {
 
 class BaseRenderer;
 
 /** \brief The OverlayManager updates and manages Overlays and the respective Layouters. */
 /** An Instance of the OverlayManager can be registered to several BaseRenderer instances in order to
  * call the update method of each Overlay during the rendering phase of the renderer.
  * See \ref OverlaysPage for more info.
 */
 class MITK_CORE_EXPORT OverlayManager : public itk::LightObject {
 public:
   typedef std::set<BaseRenderer*> BaseRendererSet;
   typedef std::set<Overlay::Pointer> OverlaySet;
   typedef std::map<const std::string,AbstractOverlayLayouter::Pointer > LayouterMap;
   typedef std::map<const BaseRenderer*,LayouterMap > LayouterRendererMap;
 
   mitkClassMacro(OverlayManager, itk::LightObject);
   itkNewMacro(OverlayManager);
 
   void AddOverlay(const Overlay::Pointer& overlay);
+  void AddOverlay(const Overlay::Pointer& overlay, BaseRenderer* renderer);
   void RemoveOverlay(const Overlay::Pointer& overlay);
 
   /** \brief Clears the manager of all Overlays.*/
   void RemoveAllOverlays();
 
   /** \brief Adds the overlay to the layouter specified by identifier and renderer*/
   void SetLayouter(Overlay* overlay, const std::string& identifier, BaseRenderer* renderer);
 
   /** \brief Calls all layouters to update the position and size of the registered Overlays*/
   void UpdateLayouts(BaseRenderer* renderer);
 
   /** \brief Returns the Layouter specified by renderer and the identifier*/
   AbstractOverlayLayouter::Pointer GetLayouter(BaseRenderer* renderer, const std::string& identifier);
 
   /** \brief Add a layouter to provide it with the use of the SetLayouter method*/
   void AddLayouter(const AbstractOverlayLayouter::Pointer& layouter);
 
   void AddBaseRenderer(BaseRenderer* renderer);
 
   /** \brief The layout of each Overlay will be prepared and the properties of each Overlay is updated.*/
   void UpdateOverlays(BaseRenderer *baseRenderer);
 
   void RemoveBaseRenderer(mitk::BaseRenderer *renderer);
 protected:
 
   /** \brief explicit constructor which disallows implicit conversions */
   explicit OverlayManager();
 
   ~OverlayManager();
 
 private:
 
   OverlaySet m_OverlaySet;
 
   BaseRendererSet m_BaseRendererSet;
 
   LayouterRendererMap m_LayouterMap;
 
   /** \brief copy constructor */
   OverlayManager( const OverlayManager &);
 
   /** \brief assignment operator */
   OverlayManager &operator=(const OverlayManager &);
 
 };
 
 } // namespace mitk
 
 #endif // OVERLAYMANAGER_H