diff --git a/Core/Code/Rendering/mitkOverlay.cpp b/Core/Code/Rendering/mitkOverlay.cpp
index cfc221992f..772417a679 100644
--- a/Core/Code/Rendering/mitkOverlay.cpp
+++ b/Core/Code/Rendering/mitkOverlay.cpp
@@ -1,309 +1,332 @@
 /*===================================================================
 
 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 "mitkOverlay.h"
 
 mitk::Overlay::Overlay() : m_LayoutedBy(NULL)
 {
   m_PropertyList = mitk::PropertyList::New();
 }
 
 
 mitk::Overlay::~Overlay()
 {
 
 }
 
 void mitk::Overlay::SetProperty(const std::string& propertyKey,
                                      const BaseProperty::Pointer& propertyValue,
                                      const mitk::BaseRenderer* renderer)
 {
   GetPropertyList(renderer)->SetProperty(propertyKey, propertyValue);
   this->Modified();
 }
 
 void mitk::Overlay::ReplaceProperty(const std::string& propertyKey,
                                          const BaseProperty::Pointer& propertyValue,
                                          const mitk::BaseRenderer* renderer)
 {
   GetPropertyList(renderer)->ReplaceProperty(propertyKey, propertyValue);
 }
 
 void mitk::Overlay::AddProperty(const std::string& propertyKey,
                                      const BaseProperty::Pointer& propertyValue,
                                      const mitk::BaseRenderer* renderer,
                                      bool overwrite)
 {
   if((overwrite) || (GetProperty(propertyKey, renderer) == NULL))
   {
     SetProperty(propertyKey, propertyValue, renderer);
   }
 }
 
 void mitk::Overlay::ConcatenatePropertyList(PropertyList *pList, bool replace)
 {
   m_PropertyList->ConcatenatePropertyList(pList, replace);
 }
 
 mitk::BaseProperty* mitk::Overlay::GetProperty(const std::string& propertyKey, const mitk::BaseRenderer* renderer) const
 {
   //renderer specified?
   if (renderer)
   {
     std::map<const mitk::BaseRenderer*,mitk::PropertyList::Pointer>::const_iterator it;
     //check for the renderer specific property
     it=m_MapOfPropertyLists.find(renderer);
     if(it!=m_MapOfPropertyLists.end()) //found
     {
       mitk::BaseProperty::Pointer property;
       property=it->second->GetProperty(propertyKey);
       if(property.IsNotNull())//found an enabled property in the render specific list
         return property;
       else //found a renderer specific list, but not the desired property
         return m_PropertyList->GetProperty(propertyKey); //return renderer unspecific property
     }
     else //didn't find the property list of the given renderer
     {
       //return the renderer unspecific property if there is one
       return m_PropertyList->GetProperty(propertyKey);
     }
   }
   else //no specific renderer given; use the renderer independent one
   {
     mitk::BaseProperty::Pointer property;
     property=m_PropertyList->GetProperty(propertyKey);
     if(property.IsNotNull())
       return property;
   }
 
   //only to satisfy compiler!
   return NULL;
 }
 
 bool mitk::Overlay::GetBoolProperty(const std::string&  propertyKey, bool& boolValue, mitk::BaseRenderer* renderer) const
 {
   mitk::BoolProperty::Pointer boolprop = dynamic_cast<mitk::BoolProperty*>(GetProperty(propertyKey, renderer));
   if(boolprop.IsNull())
     return false;
 
   boolValue = boolprop->GetValue();
   return true;
 }
 
 bool mitk::Overlay::GetIntProperty(const std::string&  propertyKey, int &intValue, mitk::BaseRenderer* renderer) const
 {
   mitk::IntProperty::Pointer intprop = dynamic_cast<mitk::IntProperty*>(GetProperty(propertyKey, renderer));
   if(intprop.IsNull())
     return false;
 
   intValue = intprop->GetValue();
   return true;
 }
 
 bool mitk::Overlay::GetFloatProperty(const std::string&  propertyKey, float &floatValue, mitk::BaseRenderer* renderer) const
 {
   mitk::FloatProperty::Pointer floatprop = dynamic_cast<mitk::FloatProperty*>(GetProperty(propertyKey, renderer));
   if(floatprop.IsNull())
     return false;
 
   floatValue = floatprop->GetValue();
   return true;
 }
 
 bool mitk::Overlay::GetStringProperty(const std::string&  propertyKey, std::string& string, mitk::BaseRenderer* renderer) const
 {
   mitk::StringProperty::Pointer stringProp = dynamic_cast<mitk::StringProperty*>(GetProperty(propertyKey, renderer));
   if(stringProp.IsNull())
   {
     return false;
   }
   else
   {
     //memcpy((void*)string, stringProp->GetValue(), strlen(stringProp->GetValue()) + 1 ); // looks dangerous
     string = stringProp->GetValue();
     return true;
   }
 }
 
 void mitk::Overlay::SetIntProperty(const std::string&  propertyKey, int intValue, mitk::BaseRenderer* renderer)
 {
   GetPropertyList(renderer)->SetProperty(propertyKey, mitk::IntProperty::New(intValue));
   Modified();
 }
 void mitk::Overlay::SetBoolProperty( const std::string&  propertyKey, bool boolValue, mitk::BaseRenderer* renderer/*=NULL*/ )
 {
   GetPropertyList(renderer)->SetProperty(propertyKey, mitk::BoolProperty::New(boolValue));
   Modified();
 }
 
 void mitk::Overlay::SetFloatProperty( const std::string&  propertyKey, float floatValue, mitk::BaseRenderer* renderer/*=NULL*/ )
 {
   GetPropertyList(renderer)->SetProperty(propertyKey, mitk::FloatProperty::New(floatValue));
   Modified();
 }
 
 void mitk::Overlay::SetStringProperty( const std::string&  propertyKey, const std::string&  stringValue, mitk::BaseRenderer* renderer/*=NULL*/ )
 {
   GetPropertyList(renderer)->SetProperty(propertyKey, mitk::StringProperty::New(stringValue));
   Modified();
 }
 
 std::string mitk::Overlay::GetName() const
 {
   mitk::StringProperty* sp = dynamic_cast<mitk::StringProperty*>(this->GetProperty("name"));
   if (sp == NULL)
     return "";
   return sp->GetValue();
 }
 
 void mitk::Overlay::SetName(const std::string& name)
 {
   this->SetStringProperty("name", name);
 }
 
 bool mitk::Overlay::GetName(std::string& nodeName, mitk::BaseRenderer* renderer, const std::string& propertyKey) const
 {
   return GetStringProperty(propertyKey, nodeName, renderer);
 }
 
 void mitk::Overlay::SetText(std::string text)
 {
   SetStringProperty("Overlay.Text", text.c_str());
 }
 
 std::string mitk::Overlay::GetText() const
 {
   std::string text;
   GetPropertyList()->GetStringProperty("Overlay.Text", text);
   return text;
 }
 
 void mitk::Overlay::SetFontSize(int fontSize)
 {
   SetIntProperty("Overlay.FontSize",fontSize);
 }
 
 int mitk::Overlay::GetFontSize() const
 {
   int fontSize = 1;
   GetPropertyList()->GetIntProperty("Overlay.FontSize", fontSize);
   return fontSize;
 }
 
 bool mitk::Overlay::GetVisibility(bool& visible, mitk::BaseRenderer* renderer, const std::string& propertyKey) const
 {
   return GetBoolProperty(propertyKey, visible, renderer);
 }
 
 bool mitk::Overlay::IsVisible(mitk::BaseRenderer* renderer, const std::string& propertyKey, bool defaultIsOn) const
 {
   return IsOn(propertyKey, renderer, defaultIsOn);
 }
 
 bool mitk::Overlay::GetColor(float rgb[], mitk::BaseRenderer* renderer, const std::string&  propertyKey) const
 {
   mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty*>(GetProperty(propertyKey, renderer));
   if(colorprop.IsNull())
     return false;
 
   memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3*sizeof(float));
   return true;
 }
 
 void mitk::Overlay::SetColor(const mitk::Color &color, mitk::BaseRenderer* renderer, const std::string&  propertyKey)
 {
   mitk::ColorProperty::Pointer prop;
   prop = mitk::ColorProperty::New(color);
   GetPropertyList(renderer)->SetProperty(propertyKey, prop);
 }
 
 void mitk::Overlay::SetColor(float red, float green, float blue, mitk::BaseRenderer* renderer, const std::string&  propertyKey)
 {
   float color[3];
   color[0]=red;
   color[1]=green;
   color[2]=blue;
   SetColor(color, renderer, propertyKey);
 }
 
 void mitk::Overlay::SetColor(const float rgb[], mitk::BaseRenderer* renderer, const std::string&  propertyKey)
 {
   mitk::ColorProperty::Pointer prop;
   prop = mitk::ColorProperty::New(rgb);
   GetPropertyList(renderer)->SetProperty(propertyKey, prop);
 }
 
 bool mitk::Overlay::GetOpacity(float &opacity, mitk::BaseRenderer* renderer, const std::string&  propertyKey) const
 {
   mitk::FloatProperty::Pointer opacityprop = dynamic_cast<mitk::FloatProperty*>(GetProperty(propertyKey, renderer));
   if(opacityprop.IsNull())
     return false;
 
   opacity=opacityprop->GetValue();
   return true;
 }
 
 void mitk::Overlay::SetOpacity(float opacity, mitk::BaseRenderer* renderer, const std::string&  propertyKey)
 {
   mitk::FloatProperty::Pointer prop;
   prop = mitk::FloatProperty::New(opacity);
   GetPropertyList(renderer)->SetProperty(propertyKey, prop);
 }
 
 void mitk::Overlay::SetVisibility(bool visible, mitk::BaseRenderer *renderer, const std::string& propertyKey)
 {
   mitk::BoolProperty::Pointer prop;
   prop = mitk::BoolProperty::New(visible);
   GetPropertyList(renderer)->SetProperty(propertyKey, prop);
 }
 
 mitk::PropertyList* mitk::Overlay::GetPropertyList(const mitk::BaseRenderer* renderer) const
 {
   if(renderer==NULL)
     return m_PropertyList;
 
   mitk::PropertyList::Pointer & propertyList = m_MapOfPropertyLists[renderer];
 
   if(propertyList.IsNull())
     propertyList = mitk::PropertyList::New();
 
   assert(m_MapOfPropertyLists[renderer].IsNotNull());
 
   return propertyList;
 }
 
 bool mitk::Overlay::BaseLocalStorage::IsGenerateDataRequired(mitk::BaseRenderer *renderer, mitk::Overlay *overlay)
 {
   if( m_LastGenerateDataTime < overlay -> GetMTime () )
     return true;
 
   if( renderer && m_LastGenerateDataTime < renderer -> GetTimeStepUpdateTime ( ) )
     return true;
 
   return false;
 }
 
 mitk::Overlay::Bounds mitk::Overlay::GetBoundsOnDisplay(mitk::BaseRenderer*) const
 {
   mitk::Overlay::Bounds bounds;
   bounds.Position[0] = bounds.Position[1] = bounds.Size[0] = bounds.Size[1] = 0;
   return bounds;
 }
 
 void mitk::Overlay::SetBoundsOnDisplay(mitk::BaseRenderer*, const mitk::Overlay::Bounds&)
 {
 }
 
+mitk::Point2D mitk::Overlay::TransformDisplayPointToViewport( mitk::Point2D point , mitk::BaseRenderer* renderer)
+{
+  double* iViewport = renderer->GetVtkRenderer()->GetViewport();
+
+  const mitk::DisplayGeometry* displayGeometry = renderer->GetDisplayGeometry();
+
+  float displayGeometryWidth = displayGeometry->GetSizeInDisplayUnits()[0];
+  float displayGeometryHeight = displayGeometry->GetSizeInDisplayUnits()[1];
+
+  float viewportWidth = (iViewport[2]-iViewport[0]) * displayGeometryWidth;
+  float viewportHeight = (iViewport[3]-iViewport[1]) * displayGeometryHeight; // seemingly right
+
+  float zoom = (iViewport[3]-iViewport[1]);
+
+  point[0] +=
+    0.5 * (viewportWidth/viewportHeight-1.0)*displayGeometryHeight
+    - 0.5 * (displayGeometryWidth - displayGeometryHeight);
+
+  point[0] *= zoom;
+  point[1] *= zoom;
+  return point;
+}
+
diff --git a/Core/Code/Rendering/mitkOverlay.h b/Core/Code/Rendering/mitkOverlay.h
index c2cb72789b..be71abe975 100644
--- a/Core/Code/Rendering/mitkOverlay.h
+++ b/Core/Code/Rendering/mitkOverlay.h
@@ -1,427 +1,429 @@
 /*===================================================================
 
 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 OVERLAY_H
 #define OVERLAY_H
 
 #include <MitkCoreExports.h>
 #include <mitkCommon.h>
 #include <mitkBaseRenderer.h>
 
 namespace mitk {
 
 class AbstractOverlayLayouter;
 
 /** \brief Base class for all overlays */
 /** This class is to be implemented in order to create overlays which are managed by the OverlayManager and can be placed by a AbstractOverlayLayouter.
 This class contains an internal Propertylist, and another PropertyList for each BaseRenderer.
 A property that is specified for a specific renderer always overrides the general internal property of the same name.
 AddOverlay, RemoveOverlay and UpdateOverlay methods have to be implemented.*/
 class MITK_CORE_EXPORT Overlay : public itk::Object {
   friend class AbstractOverlayLayouter;
 public:
 
   /** \brief Container for position and size on the display.*/
   struct Bounds
   {
     itk::Point<double,2> Position;
     itk::Point<double,2> Size;
   };
 
   typedef std::map<const BaseRenderer*,PropertyList::Pointer> MapOfPropertyLists;
 
   /** \brief Base class for mapper specific rendering ressources.
    */
   class MITK_CORE_EXPORT BaseLocalStorage
   {
   public:
 
 
     bool IsGenerateDataRequired(mitk::BaseRenderer *renderer,mitk::Overlay *overlay);
 
     inline void UpdateGenerateDataTime()
     {
       m_LastGenerateDataTime.Modified();
     }
 
     inline itk::TimeStamp & GetLastGenerateDataTime() { return m_LastGenerateDataTime; }
 
 
 
   protected:
 
     /** \brief timestamp of last update of stored data */
     itk::TimeStamp m_LastGenerateDataTime;
 
   };
 
   /**
   * @brief Set the property (instance of BaseProperty) with key @a propertyKey in the PropertyList
   * of the @a renderer (if NULL, use BaseRenderer-independent PropertyList). This is set-by-value.
   *
   * @warning Change in semantics since Aug 25th 2006. Check your usage of this method if you do
   *          more with properties than just call <tt>SetProperty( "key", new SomeProperty("value") )</tt>.
   *
   * @sa GetProperty
   * @sa m_PropertyList
   * @sa m_MapOfPropertyLists
   */
   void SetProperty(const std::string& propertyKey, const BaseProperty::Pointer& property, const mitk::BaseRenderer* renderer = NULL);
 
   /**
   * @brief Replace the property (instance of BaseProperty) with key @a propertyKey in the PropertyList
   * of the @a renderer (if NULL, use BaseRenderer-independent PropertyList). This is set-by-reference.
   *
   * If @a renderer is @a NULL the property is set in the BaseRenderer-independent
   * PropertyList of this Overlay.
   * @sa GetProperty
   * @sa m_PropertyList
   * @sa m_MapOfPropertyLists
   */
   void ReplaceProperty(const std::string& propertyKey, const BaseProperty::Pointer& property, const mitk::BaseRenderer* renderer = NULL);
 
   /**
   * @brief Add the property (instance of BaseProperty) if it does
   * not exist (or always if \a overwrite is \a true)
   * with key @a propertyKey in the PropertyList
   * of the @a renderer (if NULL, use BaseRenderer-independent
   * PropertyList). This is set-by-value.
   *
   * For \a overwrite == \a false the property is \em not changed
   * if it already exists. For \a overwrite == \a true the method
   * is identical to SetProperty.
   *
   * @sa SetProperty
   * @sa GetProperty
   * @sa m_PropertyList
   * @sa m_MapOfPropertyLists
   */
   void AddProperty(const std::string& propertyKey, const BaseProperty::Pointer& property, const mitk::BaseRenderer* renderer = NULL, bool overwrite = false);
 
   /**
   * @brief Get the PropertyList of the @a renderer. If @a renderer is @a
   * NULL, the BaseRenderer-independent PropertyList of this Overlay
   * is returned.
   * @sa GetProperty
   * @sa m_PropertyList
   * @sa m_MapOfPropertyLists
   */
   mitk::PropertyList* GetPropertyList(const mitk::BaseRenderer* renderer = NULL) const;
 
   /**
   * @brief Add values from another PropertyList.
   *
   * Overwrites values in m_PropertyList only when possible (i.e. when types are compatible).
   * If you want to allow for object type changes (replacing a "visible":BoolProperty with "visible":IntProperty,
   * set the @param replace.
   *
   * @param replace true: if @param pList contains a property "visible" of type ColorProperty and our m_PropertyList also has a "visible" property of a different type (e.g. BoolProperty), change the type, i.e. replace the objects behind the pointer.
   *
   * @sa SetProperty
   * @sa ReplaceProperty
   * @sa m_PropertyList
   */
   void ConcatenatePropertyList(PropertyList* pList, bool replace = false);
 
   /**
   * @brief Get the property (instance of BaseProperty) with key @a propertyKey from the PropertyList
   * of the @a renderer, if available there, otherwise use the BaseRenderer-independent PropertyList.
   *
   * If @a renderer is @a NULL or the @a propertyKey cannot be found
   * in the PropertyList specific to @a renderer or is disabled there, the BaseRenderer-independent
   * PropertyList of this Overlay is queried.
   * @sa GetPropertyList
   * @sa m_PropertyList
   * @sa m_MapOfPropertyLists
   */
   mitk::BaseProperty* GetProperty(const std::string& propertyKey, const mitk::BaseRenderer* renderer = NULL) const;
 
   /**
   * @brief Get the property of type T with key @a propertyKey from the PropertyList
   * of the @a renderer, if available there, otherwise use the BaseRenderer-independent PropertyList.
   *
   * If @a renderer is @a NULL or the @a propertyKey cannot be found
   * in the PropertyList specific to @a renderer or is disabled there, the BaseRenderer-independent
   * PropertyList of this Overlay is queried.
   * @sa GetPropertyList
   * @sa m_PropertyList
   * @sa m_MapOfPropertyLists
   */
   template <typename T>
   bool GetProperty(itk::SmartPointer<T> &property, const std::string& propertyKey, const mitk::BaseRenderer* renderer = NULL) const
   {
     property = dynamic_cast<T *>(GetProperty(propertyKey, renderer));
     return property.IsNotNull();
   }
 
   /**
   * @brief Get the property of type T with key @a propertyKey from the PropertyList
   * of the @a renderer, if available there, otherwise use the BaseRenderer-independent PropertyList.
   *
   * If @a renderer is @a NULL or the @a propertyKey cannot be found
   * in the PropertyList specific to @a renderer or is disabled there, the BaseRenderer-independent
   * PropertyList of this Overlay is queried.
   * @sa GetPropertyList
   * @sa m_PropertyList
   * @sa m_MapOfPropertyLists
   */
   template <typename T>
   bool GetProperty(T* &property, const std::string& propertyKey, const mitk::BaseRenderer* renderer = NULL) const
   {
     property = dynamic_cast<T *>(GetProperty(propertyKey, renderer));
     return property!=NULL;
   }
 
   /**
   * @brief Convenience access method for GenericProperty<T> properties
   * (T being the type of the second parameter)
   * @return @a true property was found
   */
   template <typename T>
   bool GetPropertyValue(const std::string&  propertyKey, T & value, mitk::BaseRenderer* renderer=NULL) const
   {
     GenericProperty<T>* gp= dynamic_cast<GenericProperty<T>*>(GetProperty(propertyKey, renderer));
     if ( gp != NULL )
     {
       value = gp->GetValue();
       return true;
     }
     return false;
   }
 
   /**
   * @brief Convenience access method for bool properties (instances of
   * BoolProperty)
   * @return @a true property was found
   */
   bool GetBoolProperty(const std::string&  propertyKey, bool &boolValue, mitk::BaseRenderer* renderer = NULL) const;
 
   /**
   * @brief Convenience access method for int properties (instances of
   * IntProperty)
   * @return @a true property was found
   */
   bool GetIntProperty(const std::string&  propertyKey, int &intValue, mitk::BaseRenderer* renderer=NULL) const;
 
   /**
   * @brief Convenience access method for float properties (instances of
   * FloatProperty)
   * @return @a true property was found
   */
   bool GetFloatProperty(const std::string&  propertyKey, float &floatValue, mitk::BaseRenderer* renderer = NULL) const;
 
   /**
   * @brief Convenience access method for string properties (instances of
   * StringProperty)
   * @return @a true property was found
   */
   bool GetStringProperty(const std::string&  propertyKey, std::string& string, mitk::BaseRenderer* renderer = NULL) const;
 
   /**
   * @brief Convenience method for setting int properties (instances of
   * IntProperty)
   */
   void SetIntProperty(const std::string&  propertyKey, int intValue, mitk::BaseRenderer* renderer=NULL);
 
   /**
   * @brief Convenience method for setting int properties (instances of
   * IntProperty)
   */
   void SetBoolProperty(const std::string&  propertyKey, bool boolValue, mitk::BaseRenderer* renderer=NULL);
 
   /**
   * @brief Convenience method for setting int properties (instances of
   * IntProperty)
   */
   void SetFloatProperty(const std::string&  propertyKey, float floatValue, mitk::BaseRenderer* renderer=NULL);
 
   /**
   * @brief Convenience method for setting int properties (instances of
   * IntProperty)
   */
   void SetStringProperty(const std::string&  propertyKey, const std::string&  string, mitk::BaseRenderer* renderer=NULL);
 
   /**
   * @brief Convenience access method for boolean properties (instances
   * of BoolProperty). Return value is the value of the property. If the property is
   * not found, the value of @a defaultIsOn is returned.
   *
   * Thus, the return value has a different meaning than in the
   * GetBoolProperty method!
   * @sa GetBoolProperty
   */
   bool IsOn(const std::string&  propertyKey, mitk::BaseRenderer* renderer, bool defaultIsOn = true) const
   {
     GetBoolProperty(propertyKey, defaultIsOn, renderer);
     return defaultIsOn;
   }
 
   /**
   * @brief Convenience access method for accessing the name of an object (instance of
   * StringProperty with property-key "name")
   * @return @a true property was found
   */
   bool GetName(std::string& nodeName, mitk::BaseRenderer* renderer = NULL, const std::string&  propertyKey = "name") const;
 
   /**
   * @brief Extra convenience access method for accessing the name of an object (instance of
   * StringProperty with property-key "name").
   *
   * This method does not take the renderer specific
   * propertylists into account, because the name of an object should never be renderer specific.
   * @returns a std::string with the name of the object (content of "name" Property).
   * If there is no "name" Property, an empty string will be returned.
   */
   virtual std::string GetName() const;
 
   /**
   * @brief Extra convenience access method to set the name of an object.
   *
   * The name will be stored in the non-renderer-specific PropertyList in a StringProperty named "name".
   */
   virtual void SetName( const std::string&  name);
 
   /**
   * @brief Convenience access method for color properties (instances of
   * ColorProperty)
   * @return @a true property was found
   */
   bool GetColor(float rgb[], mitk::BaseRenderer* renderer = NULL, const std::string&  propertyKey = "color") const;
   /**
   * @brief Convenience method for setting color properties (instances of
   * ColorProperty)
   */
   void SetColor(const mitk::Color &color, mitk::BaseRenderer* renderer = NULL, const std::string&  propertyKey = "color");
   /**
   * @brief Convenience method for setting color properties (instances of
   * ColorProperty)
   */
   void SetColor(float red, float green, float blue, mitk::BaseRenderer* renderer = NULL, const std::string&  propertyKey = "color");
   /**
   * @brief Convenience method for setting color properties (instances of
   * ColorProperty)
   */
   void SetColor(const float rgb[], mitk::BaseRenderer* renderer = NULL, const std::string&  propertyKey = "color");
   /**
   * @brief Convenience access method for opacity properties (instances of
   * FloatProperty)
   * @return @a true property was found
   */
   bool GetOpacity(float &opacity, mitk::BaseRenderer* renderer, const std::string&  propertyKey = "opacity") const;
   /**
   * @brief Convenience method for setting opacity properties (instances of
   * FloatProperty)
   */
   void SetOpacity(float opacity, mitk::BaseRenderer* renderer = NULL, const std::string&  propertyKey = "opacity");
 
   void SetText(std::string text);
 
   std::string GetText() const;
 
   void SetFontSize(int fontSize);
 
   int GetFontSize() const;
 
   /**
   * @brief Convenience access method for visibility properties (instances
   * of BoolProperty with property-key "visible")
   * @return @a true property was found
   * @sa IsVisible
   */
   bool GetVisibility(bool &visible, mitk::BaseRenderer* renderer, const std::string&  propertyKey = "visible") const;
 
   /**
   * @brief Convenience access method for visibility properties (instances
   * of BoolProperty). Return value is the visibility. Default is
   * visible==true, i.e., true is returned even if the property (@a
   * propertyKey) is not found.
   *
   * Thus, the return value has a different meaning than in the
   * GetVisibility method!
   * @sa GetVisibility
   * @sa IsOn
   */
   bool IsVisible(mitk::BaseRenderer* renderer, const std::string&  propertyKey = "visible", bool defaultIsOn = true) const;
 
   /**
   * @brief Convenience method for setting visibility properties (instances
   * of BoolProperty)
   * @param visible If set to true, the data will be rendered. If false, the render will skip this data.
   * @param renderer Specify a renderer if the visibility shall be specific to a renderer
   * @param propertykey Can be used to specify a user defined name of the visibility propery.
   */
   void SetVisibility(bool visible, mitk::BaseRenderer* renderer = NULL, const std::string&  propertyKey = "visible");
 
   /** \brief Adds the overlay to the specified renderer. Update Overlay should be called soon in order to apply all properties*/
   virtual void AddToBaseRenderer(BaseRenderer *renderer) = 0;
 
   /** \brief Removes the overlay from the specified renderer. It is not visible anymore then.*/
   virtual void RemoveFromBaseRenderer(BaseRenderer *renderer) = 0;
 
   /** \brief Applies all properties and should be called before the rendering procedure.*/
   virtual void Update(BaseRenderer *renderer) = 0;
 
   /** \brief Returns position and size of the overlay on the display.*/
   virtual Bounds GetBoundsOnDisplay(BaseRenderer *renderer) const;
 
   /** \brief Sets position and size of the overlay on the display.*/
   virtual void SetBoundsOnDisplay(BaseRenderer *renderer, const Bounds&);
 
   mitkClassMacro(Overlay, itk::Object);
 
+  static mitk::Point2D TransformDisplayPointToViewport(mitk::Point2D point, mitk::BaseRenderer *renderer);
+
 protected:
 
   /** \brief explicit constructor which disallows implicit conversions */
   explicit Overlay();
 
   /** \brief virtual destructor in order to derive from this class */
   virtual ~Overlay();
 
   /**
   * @brief BaseRenderer-independent PropertyList
   *
   * Properties herein can be overwritten specifically for each BaseRenderer
   * by the BaseRenderer-specific properties defined in m_MapOfPropertyLists.
   */
   PropertyList::Pointer m_PropertyList;
 
   /**
   * @brief Map associating each BaseRenderer with its own PropertyList
   */
   mutable MapOfPropertyLists m_MapOfPropertyLists;
 
   /**
   * @brief Timestamp of the last change of m_Data
   */
   itk::TimeStamp m_DataReferenceChangedTime;
 
 private:
 
   /** \brief copy constructor */
   Overlay( const Overlay &);
 
   /** \brief assignment operator */
   Overlay &operator=(const Overlay &);
 
   /** \brief Reference to the layouter in which this overlay is managed. */
   AbstractOverlayLayouter* m_LayoutedBy;
 
 };
 
 } // namespace mitk
 #endif // OVERLAY_H