diff --git a/Core/Code/Rendering/mitkGeometry2DDataMapper2D.cpp b/Core/Code/Rendering/mitkGeometry2DDataMapper2D.cpp
index 039d8395e6..e6de21c3fc 100644
--- a/Core/Code/Rendering/mitkGeometry2DDataMapper2D.cpp
+++ b/Core/Code/Rendering/mitkGeometry2DDataMapper2D.cpp
@@ -1,449 +1,452 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 
 #include "mitkGL.h"
 #include "mitkGeometry2DDataMapper2D.h"
 #include "mitkBaseRenderer.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "mitkSmartPointerProperty.h"
 #include "mitkPlaneOrientationProperty.h"
 #include "mitkGeometry2DDataToSurfaceFilter.h"
 #include "mitkSurfaceGLMapper2D.h"
 #include "mitkLine.h"
 #include "mitkNodePredicateDataType.h"
 
 
 mitk::Geometry2DDataMapper2D::Geometry2DDataMapper2D()
 : m_SurfaceMapper( NULL ), m_DataStorage(NULL), m_ParentNode(NULL),
   m_OtherGeometry2Ds(), m_RenderOrientationArrows( false ),
   m_ArrowOrientationPositive( true )
 {
 }
 
 
 mitk::Geometry2DDataMapper2D::~Geometry2DDataMapper2D()
 {
 }
 
 
 const mitk::Geometry2DData* mitk::Geometry2DDataMapper2D::GetInput(void)
 {
   return static_cast<const Geometry2DData * > ( GetData() );
 }
 
 
 void mitk::Geometry2DDataMapper2D::GenerateData()
 {
   // collect all Geometry2DDatas accessible from the DataStorage
   m_OtherGeometry2Ds.clear();
   if (m_DataStorage.IsNull())
     return;
   
   mitk::NodePredicateDataType::Pointer p = mitk::NodePredicateDataType::New("Geometry2DData");
   mitk::DataStorage::SetOfObjects::ConstPointer all = m_DataStorage->GetDerivations(m_ParentNode, p, false);
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
   {
     if(it->Value().IsNull())
       continue;
 
     BaseData* data = it->Value()->GetData();
     if (data == NULL)
       continue;
 
     Geometry2DData* geometry2dData = dynamic_cast<Geometry2DData*>(data);
     if(geometry2dData == NULL)
       continue;
 
     PlaneGeometry* planegeometry = dynamic_cast<PlaneGeometry*>(geometry2dData->GetGeometry2D());
     if (planegeometry != NULL)
       m_OtherGeometry2Ds.push_back(it->Value());
   }
 }
 
 
 void mitk::Geometry2DDataMapper2D::Paint(BaseRenderer *renderer)
 {
   if ( !this->IsVisible(renderer) )
   {
     return;
   }
   
   Geometry2DData::Pointer input = const_cast< Geometry2DData * >(this->GetInput());
 
   // intersecting with ourself?
   if ( input.IsNull() || (this->GetInput()->GetGeometry2D() == 
        renderer->GetCurrentWorldGeometry2D()) )
   {
     return; // do nothing!
   }
   
   const PlaneGeometry *inputPlaneGeometry = 
     dynamic_cast< const PlaneGeometry * >( input->GetGeometry2D() );
 
   const PlaneGeometry *worldPlaneGeometry =
     dynamic_cast< const PlaneGeometry* >( 
       renderer->GetCurrentWorldGeometry2D() );
 
   if ( worldPlaneGeometry && inputPlaneGeometry 
     && inputPlaneGeometry->GetReferenceGeometry() )
   {
     DisplayGeometry *displayGeometry = renderer->GetDisplayGeometry();
     assert( displayGeometry );
 
     const Geometry3D *referenceGeometry = 
       inputPlaneGeometry->GetReferenceGeometry();
 
     // calculate intersection of the plane data with the border of the 
     // world geometry rectangle
     Point2D lineFrom, lineTo;
     
     typedef Geometry3D::TransformType TransformType;
     const TransformType *transform = dynamic_cast< const TransformType * >(
       referenceGeometry->GetIndexToWorldTransform() );
 
     TransformType::Pointer inverseTransform = TransformType::New();
     transform->GetInverse( inverseTransform );
 
     Line3D crossLine, otherCrossLine;
 
     // Calculate the intersection line of the input plane with the world plane
     if ( worldPlaneGeometry->IntersectionLine( 
           inputPlaneGeometry, crossLine ) )
     {
       BoundingBox::PointType boundingBoxMin, boundingBoxMax;
       boundingBoxMin = referenceGeometry->GetBoundingBox()->GetMinimum();
       boundingBoxMax = referenceGeometry->GetBoundingBox()->GetMaximum();
       if(referenceGeometry->GetImageGeometry())
       {
         for(unsigned int i = 0; i < 3; ++i)
         {
           boundingBoxMin[i]-=0.5;
           boundingBoxMax[i]-=0.5;
         }
       }
 
       crossLine.Transform( *inverseTransform );
       Point3D point1, point2;
 
       // Then, clip this line with the (transformed) bounding box of the 
       // reference geometry.
       if ( crossLine.BoxLineIntersection(
         boundingBoxMin[0], boundingBoxMin[1], boundingBoxMin[2],
         boundingBoxMax[0], boundingBoxMax[1], boundingBoxMax[2],
         crossLine.GetPoint(), crossLine.GetDirection(),
         point1, point2 ) == 2 )
       {
         // Transform the resulting line start and end points into display
         // coordinates.
         worldPlaneGeometry->Map( 
           transform->TransformPoint( point1 ), lineFrom );
         worldPlaneGeometry->Map( 
           transform->TransformPoint( point2 ), lineTo );
 
         Line< ScalarType, 2 > line, otherLine;
         line.SetPoints( lineFrom, lineTo );
 
         displayGeometry->WorldToDisplay( lineFrom, lineFrom );
         displayGeometry->WorldToDisplay( lineTo, lineTo );
 
         ScalarType lengthInDisplayUnits = (lineTo - lineFrom).GetNorm();
 
         // lineParams stores the individual segments of the line, which are
         // separated by a gap each (to mark the intersection with another
         // displayed line)
         std::vector< ScalarType > lineParams;
         lineParams.reserve( m_OtherGeometry2Ds.size() + 2 );
         lineParams.push_back( 0.0 );
         lineParams.push_back( 1.0 );
 
         Vector2D d, dOrth;
         
         // Now iterate through all other lines displayed in this window and
         // calculate the positions of intersection with the line to be
         // rendered; these positions will be stored in lineParams to form a
         // gap afterwards.
         NodesVectorType::iterator otherPlanesIt = m_OtherGeometry2Ds.begin();
         NodesVectorType::iterator otherPlanesEnd = m_OtherGeometry2Ds.end();
         while ( otherPlanesIt != otherPlanesEnd )
         {
           PlaneGeometry *otherPlane = static_cast< PlaneGeometry * >(
             static_cast< Geometry2DData * >(
               (*otherPlanesIt)->GetData() )->GetGeometry2D() );
 
           // Just as with the original line, calculate the intersaction with
           // the world geometry...
           if ( (otherPlane != inputPlaneGeometry)
             && worldPlaneGeometry->IntersectionLine( 
                  otherPlane, otherCrossLine ) )
           {
             // ... and clip the resulting line segment with the reference 
             // geometry bounding box.
             otherCrossLine.Transform( *inverseTransform );
             if ( otherCrossLine.BoxLineIntersection(
               boundingBoxMin[0], boundingBoxMin[1], boundingBoxMin[2],
               boundingBoxMax[0], boundingBoxMax[1], boundingBoxMax[2],
               otherCrossLine.GetPoint(), otherCrossLine.GetDirection(),
               point1, point2 ) == 2 )
             {
               worldPlaneGeometry->Map( 
                 transform->TransformPoint( point1 ), lineFrom );
               worldPlaneGeometry->Map( 
                 transform->TransformPoint( point2 ), lineTo );
 
               // By means of the dot product, calculate the gap position as
               // parametric value in the range [0, 1]
               otherLine.SetPoints( lineFrom, lineTo );
               d = otherLine.GetDirection();
               dOrth[0] = -d[1]; dOrth[1] = d[0];
               
               ScalarType t, norm; 
               t = ( otherLine.GetPoint1() - line.GetPoint1() ) * dOrth;
               norm = line.GetDirection() * dOrth;
 
               if ( fabs( norm ) > eps )
               {
                 t /= norm;
                 if ( (t > 0.0) && (t < 1.0) )
                 {
                   lineParams.push_back(t);
                 }
               }
             }
           }
           ++otherPlanesIt;
         }
 
         // Apply color and opacity read from the PropertyList.
         this->ApplyProperties( renderer );
 
         ScalarType gapSizeInPixel = 10.0;
         ScalarType gapSizeInParamUnits = 
           1.0 / lengthInDisplayUnits * gapSizeInPixel;
 
         std::sort( lineParams.begin(), lineParams.end() );
 
         Point2D p1, p2;
         ScalarType p1Param, p2Param; 
         
         p1Param = lineParams[0];
         p1 = line.GetPoint( p1Param );
         displayGeometry->WorldToDisplay( p1, p1 );
 
+        //Work arround to show the crosshair always on top of a 2D render window
+        //The image is usually located at depth = 0 or negative depth values, and thus,
+        //the crosshair with depth = 1 is always on top.
         float depthPosition = 1.0f;
 
         // Iterate over all line segments and display each, with a gap
         // inbetween.
         unsigned int i, preLastLineParam = lineParams.size() - 1;
         for ( i = 1; i < preLastLineParam; ++i )
         {
           p2Param = lineParams[i] - gapSizeInParamUnits * 0.5;
           p2 = line.GetPoint( p2Param );
 
           if ( p2Param > p1Param )
           {
             // Convert intersection points (until now mm) to display 
             // coordinates (units).
             displayGeometry->WorldToDisplay( p2, p2 );
 
             // draw
             glEnable(GL_DEPTH_TEST);
             glBegin (GL_LINES);
             glVertex3f(p1[0],p1[1], depthPosition);
             glVertex3f(p2[0],p2[1], depthPosition);
             glEnd ();
 
             if ( (i == 1) && (m_RenderOrientationArrows) )
             {
               // Draw orientation arrow for first line segment
               this->DrawOrientationArrow( p1, p2, 
                 inputPlaneGeometry, worldPlaneGeometry, displayGeometry,
                 m_ArrowOrientationPositive );
             }
           }
 
           p1Param = p2Param + gapSizeInParamUnits;
           p1 = line.GetPoint( p1Param );
           displayGeometry->WorldToDisplay( p1, p1 );
         }
 
         // Draw last line segment
         p2Param = lineParams[i];
         p2 = line.GetPoint( p2Param );
         displayGeometry->WorldToDisplay( p2, p2 );
         glBegin( GL_LINES );
         glVertex3f( p1[0], p1[1], depthPosition);
         glVertex3f( p2[0], p2[1], depthPosition);
         glEnd();
 
 
         // Draw orientation arrows
         if ( m_RenderOrientationArrows )
         {
           this->DrawOrientationArrow( p2, p1, 
             inputPlaneGeometry, worldPlaneGeometry, displayGeometry,
             m_ArrowOrientationPositive );
           if ( preLastLineParam < 2 )
           {
             // If we only have one line segment, draw other arrow, too
             this->DrawOrientationArrow( p1, p2, 
               inputPlaneGeometry, worldPlaneGeometry, displayGeometry,
               m_ArrowOrientationPositive );
           }
         }
       }
     }
   }
   else
   {
     Geometry2DDataToSurfaceFilter::Pointer surfaceCreator;
     SmartPointerProperty::Pointer surfacecreatorprop;
     surfacecreatorprop = dynamic_cast< SmartPointerProperty * >(
       GetDataNode()->GetProperty(
         "surfacegeometry", renderer));
 
     if( (surfacecreatorprop.IsNull()) || 
         (surfacecreatorprop->GetSmartPointer().IsNull()) ||
         ((surfaceCreator = dynamic_cast< Geometry2DDataToSurfaceFilter * >(
           surfacecreatorprop->GetSmartPointer().GetPointer())).IsNull())
       )
     {
       surfaceCreator = Geometry2DDataToSurfaceFilter::New();
       surfacecreatorprop = SmartPointerProperty::New(surfaceCreator);
       surfaceCreator->PlaceByGeometryOn();
       GetDataNode()->SetProperty( "surfacegeometry", surfacecreatorprop );
     }
     
     surfaceCreator->SetInput( input );
 
     // Clip the Geometry2D with the reference geometry bounds (if available)
     if ( input->GetGeometry2D()->HasReferenceGeometry() )
     {
       surfaceCreator->SetBoundingBox(
         input->GetGeometry2D()->GetReferenceGeometry()->GetBoundingBox()
       );
     }
 
     int res;
     bool usegeometryparametricbounds = true;
     if ( GetDataNode()->GetIntProperty("xresolution", res, renderer))
     {
       surfaceCreator->SetXResolution(res);
       usegeometryparametricbounds=false;        
     }
     if (GetDataNode()->GetIntProperty("yresolution", res, renderer))
     {
       surfaceCreator->SetYResolution(res);
       usegeometryparametricbounds=false;        
     }
     surfaceCreator->SetUseGeometryParametricBounds(usegeometryparametricbounds);
 
     // Calculate the surface of the Geometry2D
     surfaceCreator->Update();
     
     if (m_SurfaceMapper.IsNull())
     {
       m_SurfaceMapper=SurfaceGLMapper2D::New();
     }
     m_SurfaceMapper->SetSurface(surfaceCreator->GetOutput());
     m_SurfaceMapper->SetDataNode(GetDataNode());
     
     m_SurfaceMapper->Paint(renderer);
   }
 }
 
 void mitk::Geometry2DDataMapper2D::DrawOrientationArrow( mitk::Point2D &outerPoint, mitk::Point2D &innerPoint, 
   const mitk::PlaneGeometry *planeGeometry,
   const mitk::PlaneGeometry *rendererPlaneGeometry,
   const mitk::DisplayGeometry *displayGeometry,
   bool positiveOrientation )
 {
   // Draw arrows to indicate plane orientation
   // Vector along line
   Vector2D v1 = innerPoint - outerPoint;
   v1.Normalize();
   v1 *= 7.0;
 
   // Orthogonal vector
   Vector2D v2;
   v2[0] = v1[1];
   v2[1] = -v1[0];
 
   // Calculate triangle tip for one side and project it back into world
   // coordinates to determine whether it is above or below the plane
   Point2D worldPoint2D;
   Point3D worldPoint;
   displayGeometry->DisplayToWorld( outerPoint + v1 + v2, worldPoint2D );
   rendererPlaneGeometry->Map( worldPoint2D, worldPoint );
 
   // Initialize remaining triangle coordinates accordingly
   // (above/below state is XOR'ed with orientation flag)
   Point2D p1 = outerPoint + v1 * 2.0;
   Point2D p2 = outerPoint + v1 
     + ((positiveOrientation ^ planeGeometry->IsAbove( worldPoint )) 
     ? v2 : -v2);
 
   // Draw the arrow (triangle)
   glBegin( GL_TRIANGLES );
   glVertex2f( outerPoint[0], outerPoint[1] );
   glVertex2f( p1[0], p1[1] );
   glVertex2f( p2[0], p2[1] );
   glEnd();
 }
 
 
 void mitk::Geometry2DDataMapper2D::ApplyProperties( BaseRenderer *renderer )
 {
   Superclass::ApplyProperties(renderer);
 
   PlaneOrientationProperty* decorationProperty;
   this->GetDataNode()->GetProperty( decorationProperty, "decoration", renderer );
   if ( decorationProperty != NULL )
   {
     if ( decorationProperty->GetPlaneDecoration() == 
       PlaneOrientationProperty::PLANE_DECORATION_POSITIVE_ORIENTATION )
     {
       m_RenderOrientationArrows = true;
       m_ArrowOrientationPositive = true;
     }
     else if ( decorationProperty->GetPlaneDecoration() == 
       PlaneOrientationProperty::PLANE_DECORATION_NEGATIVE_ORIENTATION )
     {
       m_RenderOrientationArrows = true;
       m_ArrowOrientationPositive = false;
     }
     else
     {
       m_RenderOrientationArrows = false;
     }
   }
 }
 
 
 void mitk::Geometry2DDataMapper2D::SetDatastorageAndGeometryBaseNode( mitk::DataStorage::Pointer ds, mitk::DataNode::Pointer parent )
 {
   if (ds.IsNotNull())
   {
     m_DataStorage = ds;
   }
   if (parent.IsNotNull())
   {
     m_ParentNode = parent;
   }
 }