diff --git a/Modules/PlanarFigure/Interactions/mitkPlanarFigureInteractor.cpp b/Modules/PlanarFigure/Interactions/mitkPlanarFigureInteractor.cpp
index 264761fe1f..99656972f0 100644
--- a/Modules/PlanarFigure/Interactions/mitkPlanarFigureInteractor.cpp
+++ b/Modules/PlanarFigure/Interactions/mitkPlanarFigureInteractor.cpp
@@ -1,768 +1,768 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2008-10-02 16:21:08 +0200 (Do, 02 Okt 2008) $
 Version:   $Revision: 13129 $
 
 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 "mitkPlanarFigureInteractor.h"
 #include "mitkPointOperation.h"
 #include "mitkPositionEvent.h"
 #include "mitkPlanarFigure.h"
 #include "mitkStatusBar.h"
 #include "mitkDataNode.h"
 #include "mitkInteractionConst.h"
 #include "mitkAction.h"
 #include "mitkStateEvent.h"
 #include "mitkOperationEvent.h"
 #include "mitkUndoController.h"
 #include "mitkStateMachineFactory.h"
 #include "mitkStateTransitionOperation.h"
 #include "mitkBaseRenderer.h"
 #include "mitkRenderingManager.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkNodePredicateOr.h"
 
 
 //how precise must the user pick the point
 //default value
 mitk::PlanarFigureInteractor
 ::PlanarFigureInteractor(const char * type, DataNode* dataNode, int /* n */ )
 : Interactor( type, dataNode ),
   m_Precision( 6.5 ),
   m_IsHovering( false )
 {
 }
 
 mitk::PlanarFigureInteractor::~PlanarFigureInteractor()
 {
 }
 
 void mitk::PlanarFigureInteractor::SetPrecision( mitk::ScalarType precision )
 {
   m_Precision = precision;
 }
 
 // Overwritten since this class can handle it better!
 float mitk::PlanarFigureInteractor
 ::CanHandleEvent(StateEvent const* stateEvent) const
 {
   float returnValue = 0.5;
   
 
   // If it is a key event that can be handled in the current state,
   // then return 0.5
   mitk::DisplayPositionEvent const *disPosEvent =
     dynamic_cast <const mitk::DisplayPositionEvent *> (stateEvent->GetEvent());
 
   // Key event handling:
   if (disPosEvent == NULL)
   {
     // Check if the current state has a transition waiting for that key event.
     if (this->GetCurrentState()->GetTransition(stateEvent->GetId())!=NULL)
     {
       return 0.5;
     }
     else
     {
       return 0.0;
     }
   }
 
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>(
     m_DataNode->GetData() );
 
   if ( planarFigure != NULL )
   {
     // Give higher priority if this figure is currently selected
     if ( planarFigure->GetSelectedControlPoint() >= 0 )
     {
       return 1.0;
     }
 
   }
   return returnValue;
 }
 
 
 bool mitk::PlanarFigureInteractor
 ::ExecuteAction( Action *action, mitk::StateEvent const *stateEvent )
 {
   bool ok = false;
 
   // Check corresponding data; has to be sub-class of mitk::PlanarFigure
   mitk::PlanarFigure *planarFigure = 
     dynamic_cast< mitk::PlanarFigure * >( m_DataNode->GetData() );
 
   if ( planarFigure == NULL )
   {
     return false;
   }
 
   // Get the timestep to also support 3D+t
   const mitk::Event *theEvent = stateEvent->GetEvent();
   int timeStep = 0;
   mitk::ScalarType timeInMS = 0.0;
 
   if ( theEvent )
   {
     if (theEvent->GetSender() != NULL)
     {
       timeStep = theEvent->GetSender()->GetTimeStep( planarFigure );
       timeInMS = theEvent->GetSender()->GetTime();
     }
   }
 
   // Get Geometry2D of PlanarFigure
   mitk::Geometry2D *planarFigureGeometry =
     dynamic_cast< mitk::Geometry2D * >( planarFigure->GetGeometry( timeStep ) );
 
   // Get the Geometry2D of the window the user interacts with (for 2D point 
   // projection)
   mitk::BaseRenderer *renderer = NULL;
   const Geometry2D *projectionPlane = NULL;
   if ( theEvent )
   {
     renderer = theEvent->GetSender();
     projectionPlane = renderer->GetCurrentWorldGeometry2D();
   }
 
   // TODO: Check if display and PlanarFigure geometries are parallel (if they are PlaneGeometries)
 
 
   switch (action->GetActionId())
   {
   case AcDONOTHING:
     ok = true;
     break;
 
   case AcCHECKOBJECT:
     {
       if ( planarFigure->IsPlaced() )
       {
         this->HandleEvent( new mitk::StateEvent( EIDYES, NULL ) );
       }
       else
       {
         this->HandleEvent( new mitk::StateEvent( EIDNO, NULL ) );
       }
       ok = false;
       break;
     }
 
   case AcADD:
     {
       // Invoke event to notify listeners that placement of this PF starts now
       planarFigure->InvokeEvent( StartPlacementPlanarFigureEvent() );
 
       // Use Geometry2D of the renderer clicked on for this PlanarFigure
       mitk::PlaneGeometry *planeGeometry = const_cast< mitk::PlaneGeometry * >(
         dynamic_cast< const mitk::PlaneGeometry * >(
           renderer->GetSliceNavigationController()->GetCurrentPlaneGeometry() ) );
       if ( planeGeometry != NULL )
       {
         planarFigureGeometry = planeGeometry;
         planarFigure->SetGeometry2D( planeGeometry );
       }
       else
       {
         ok = false;
         break;
       }
 
       // Extract point in 2D world coordinates (relative to Geometry2D of
       // PlanarFigure)
       Point2D point2D;
       if ( !this->TransformPositionEventToPoint2D( stateEvent, point2D,
         planarFigureGeometry ) )
       {
         ok = false;
         break;
       }
 
       // Place PlanarFigure at this point
       planarFigure->PlaceFigure( point2D );
 
       // Re-evaluate features
       planarFigure->EvaluateFeatures();
       //this->LogPrintPlanarFigureQuantities( planarFigure );
 
       // Set a bool property indicating that the figure has been placed in
       // the current RenderWindow. This is required so that the same render
       // window can be re-aligned to the Geometry2D of the PlanarFigure later
       // on in an application.
       m_DataNode->SetBoolProperty( "PlanarFigureInitializedWindow", true, renderer );
 
       // Update rendered scene
       renderer->GetRenderingManager()->RequestUpdateAll();
 
       ok = true;
       break;
     }
 
   case AcMOVEPOINT:
     {
       // Extract point in 2D world coordinates (relative to Geometry2D of
       // PlanarFigure)
       Point2D point2D;
       if ( !this->TransformPositionEventToPoint2D( stateEvent, point2D,
         planarFigureGeometry ) )
       {
         ok = false;
         break;
       }
 
       // Move current control point to this point
       planarFigure->SetCurrentControlPoint( point2D );
 
       // Re-evaluate features
       planarFigure->EvaluateFeatures();
       //this->LogPrintPlanarFigureQuantities( planarFigure );
 
       // Update rendered scene
       renderer->GetRenderingManager()->RequestUpdateAll();
 
       ok = true;
       break;
     }
 
 
   case AcCHECKNMINUS1:
     {
       if ( planarFigure->GetNumberOfControlPoints() >=
            planarFigure->GetMaximumNumberOfControlPoints() )
       {
         // Initial placement finished: deselect control point and send an
         // event to notify application listeners
         planarFigure->Modified();
         planarFigure->DeselectControlPoint();
         planarFigure->InvokeEvent( EndPlacementPlanarFigureEvent() );
         planarFigure->InvokeEvent( EndInteractionPlanarFigureEvent() );
         m_DataNode->Modified();
         this->HandleEvent( new mitk::StateEvent( EIDYES, stateEvent->GetEvent() ) );
       }
       else
       {
         this->HandleEvent( new mitk::StateEvent( EIDNO, stateEvent->GetEvent() ) );
       }
 
       // Update rendered scene
       renderer->GetRenderingManager()->RequestUpdateAll();
 
       ok = true;
       break;
     }
 
 
   case AcCHECKEQUALS1:
     {
       // NOTE: Action name is a bit misleading; this action checks whether
       // the figure has already the minimum number of required points to
       // be finished.
 
       if ( planarFigure->GetNumberOfControlPoints() >=
         planarFigure->GetMinimumNumberOfControlPoints() )
       {
         // Initial placement finished: deselect control point and send an
         // event to notify application listeners
         planarFigure->Modified();
         planarFigure->DeselectControlPoint();
         if ( planarFigure->GetNumberOfControlPoints()-1 >= planarFigure->GetMinimumNumberOfControlPoints() )
         {
           planarFigure->RemoveLastControlPoint();
         }
         planarFigure->InvokeEvent( EndPlacementPlanarFigureEvent() );
         planarFigure->InvokeEvent( EndInteractionPlanarFigureEvent() );
         m_DataNode->Modified();
         this->HandleEvent( new mitk::StateEvent( EIDYES, NULL ) );
       }
       else
       {
         this->HandleEvent( new mitk::StateEvent( EIDNO, NULL ) );
       }
 
       // Update rendered scene
       renderer->GetRenderingManager()->RequestUpdateAll();
 
       ok = true;
       break;
     }
 
 
   case AcCHECKPOINT:
     {
       // Check if the distance of the current point to the previously set point in display coordinates
       // is sufficient (if a previous point exists)
 
       // Extract display position
       const mitk::PositionEvent *positionEvent = 
         dynamic_cast< const mitk::PositionEvent * > ( stateEvent->GetEvent() );
       if ( positionEvent == NULL )
       {
         ok = false;
         break;
       }
 
       // Get current display position of the mouse
       mitk::Point2D currentDisplayPosition = positionEvent->GetDisplayPosition();
 
       // Check if a previous point has been set
       int previousIndex = planarFigure->GetNumberOfControlPoints() - 2;
       if ( previousIndex >= 0 )
       {
         
         // Try to convert previous point to current display coordinates
         mitk::Point3D previousPoint3D;
         planarFigureGeometry->Map( planarFigure->GetControlPoint( previousIndex ), previousPoint3D );
         if ( renderer->GetDisplayGeometry()->Distance( previousPoint3D ) < 0.1 )
         {
           mitk::Point2D previousDisplayPosition;
           projectionPlane->Map( previousPoint3D, previousDisplayPosition );
           renderer->GetDisplayGeometry()->WorldToDisplay( previousDisplayPosition, previousDisplayPosition );
 
           double a = currentDisplayPosition[0] - previousDisplayPosition[0];
           double b = currentDisplayPosition[1] - previousDisplayPosition[1];
 
           // If point is to close, do not set a new point
           if ( a * a + b * b < 25.0 )
           {
             this->HandleEvent( new mitk::StateEvent( EIDNO, stateEvent->GetEvent() ) );
 
             ok = true;
             break;
           }
         }
       }
 
       this->HandleEvent( new mitk::StateEvent( EIDYES, stateEvent->GetEvent() ) );    
       ok = true;
       break;
     }
 
   
   case AcADDPOINT:
     {
       // Extract point in 2D world coordinates (relative to Geometry2D of
       // PlanarFigure)
       Point2D point2D;
       if ( !this->TransformPositionEventToPoint2D( stateEvent, point2D,
         planarFigureGeometry ) )
       {
         ok = false;
         break;
       }
 
       // Add point as new control point
       planarFigure->AddControlPoint( point2D );
 
       // Re-evaluate features
       planarFigure->EvaluateFeatures();
       //this->LogPrintPlanarFigureQuantities( planarFigure );
 
       // Update rendered scene
       renderer->GetRenderingManager()->RequestUpdateAll();
 
       ok = true;
       break;
     }
 
 
   case AcDESELECTPOINT:
     {
       planarFigure->DeselectControlPoint();
 
       // Issue event so that listeners may update themselves
       planarFigure->Modified();
       planarFigure->InvokeEvent( EndInteractionPlanarFigureEvent() );
 
       m_DataNode->Modified();
 
       // falls through
     }
 
   case AcCHECKSELECTED:
     {
       bool isHovering = mitk::PlanarFigureInteractor::IsPositionOverFigure(
         stateEvent, planarFigure,
         planarFigureGeometry,
         projectionPlane,
         renderer->GetDisplayGeometry() );
 
       int pointIndex = mitk::PlanarFigureInteractor::IsPositionInsideMarker(
         stateEvent, planarFigure,
         planarFigureGeometry,
         projectionPlane,
         renderer->GetDisplayGeometry() );
 
       int initiallySelectedControlPoint = planarFigure->GetSelectedControlPoint();
 
       if ( pointIndex >= 0 )
       {
         // If mouse is above control point, mark it as selected
         planarFigure->SelectControlPoint( pointIndex );     
 
         // If mouse is hovering above a marker, it is also hovering above the figure
         isHovering = true;
       }
       else
       {
         // Mouse in not above control point --> deselect point
         planarFigure->DeselectControlPoint();
       }
 
       bool renderingUpdateNeeded = false;
       if ( isHovering )
       {
         if ( !m_IsHovering )
         {
           // Invoke hover event once when the mouse is entering the figure area
           m_IsHovering = true;
           planarFigure->InvokeEvent( StartHoverPlanarFigureEvent() );
 
           // Set bool property to indicate that planar figure is currently in "hovering" mode
           m_DataNode->SetBoolProperty( "planarfigure.ishovering", true );
           
           renderingUpdateNeeded = true;
         }
 
         if ( planarFigure->GetSelectedControlPoint() != initiallySelectedControlPoint  )
         {
           // the selected control point has changed -> rendering update necessary
           renderingUpdateNeeded = true;
         }
 
         this->HandleEvent( new mitk::StateEvent( EIDYES, NULL ) );
 
         // Return true: only this interactor is eligible to react on this event
         ok = true;
       }
       else
       {
         if ( m_IsHovering )
         {
           // Invoke end-hover event once the mouse is exiting the figure area
           m_IsHovering = false;
           planarFigure->InvokeEvent( EndHoverPlanarFigureEvent() );
 
           // Set bool property to indicate that planar figure is no longer in "hovering" mode
           m_DataNode->SetBoolProperty( "planarfigure.ishovering", false );
           
           renderingUpdateNeeded = true;
         }
 
         this->HandleEvent( new mitk::StateEvent( EIDNO, NULL ) );
 
         // Return false so that other (PlanarFigure) Interactors may react on this
         // event as well
         ok = false;
       }
 
       // Update rendered scene if necessray
       if ( renderingUpdateNeeded )
       {
         renderer->GetRenderingManager()->RequestUpdateAll();
       }
       break;
     }
 
   case AcSELECTPICKEDOBJECT:
     {
       // Invoke event to notify listeners that this planar figure should be selected
       planarFigure->InvokeEvent( SelectPlanarFigureEvent() );
 
       // Check if planar figure is marked as "editable"
       bool isEditable = true;
       m_DataNode->GetBoolProperty( "planarfigure.iseditable", isEditable );
 
       int pointIndex = -1;
 
       if ( isEditable )
       {
         // If planar figure is editable, check if mouse is over a control point
         pointIndex = mitk::PlanarFigureInteractor::IsPositionInsideMarker(
           stateEvent, planarFigure,
           planarFigureGeometry,
           projectionPlane,
           renderer->GetDisplayGeometry() );
       }
 
       // If editing is enabled and the mouse is currently over a control point, select it
       if ( pointIndex >= 0 )
       {
         this->HandleEvent( new mitk::StateEvent( EIDYES, NULL ) );
 
         // Return true: only this interactor is eligible to react on this event
         ok = true;
       }
       else
       {
         this->HandleEvent( new mitk::StateEvent( EIDNO, NULL ) );
 
         // Return false so that other (PlanarFigure) Interactors may react on this
         // event as well
         ok = false;
       }
 
       ok = true;  
       break;
     }
 
 
   case AcSELECTPOINT:
     {
       // Invoke event to notify listeners that interaction with this PF starts now
       planarFigure->InvokeEvent( StartInteractionPlanarFigureEvent() );
 
       // Reset the PlanarFigure if required
       if ( planarFigure->ResetOnPointSelect() )
       {
         this->HandleEvent( new mitk::StateEvent( EIDYES, stateEvent->GetEvent() ) );
       }
       else
       {
         this->HandleEvent( new mitk::StateEvent( EIDNO, stateEvent->GetEvent() ) );
       }
 
       ok = true;  
       break;
     }
 
   //case AcMOVEPOINT:
   //case AcMOVESELECTED:
   //  {
   //    // Update the display
   //    renderer->GetRenderingManager()->RequestUpdateAll();
 
   //    ok = true;
   //    break;
   //  }
 
   //case AcFINISHMOVE:
   //  {
   //    ok = true;
   //    break;
   //  }
 
 
 
 
   default:
     return Superclass::ExecuteAction( action, stateEvent );
   }
 
   return ok;
 }
 
 bool mitk::PlanarFigureInteractor::TransformPositionEventToPoint2D(
   const StateEvent *stateEvent, Point2D &point2D,
   const Geometry2D *planarFigureGeometry )
 {
   // Extract world position, and from this position on geometry, if
   // available
   const mitk::PositionEvent *positionEvent = 
     dynamic_cast< const mitk::PositionEvent * > ( stateEvent->GetEvent() );
   if ( positionEvent == NULL )
   {
     return false;
   }
 
   mitk::Point3D worldPoint3D = positionEvent->GetWorldPosition();
 
   // TODO: proper handling of distance tolerance
   if ( planarFigureGeometry->Distance( worldPoint3D ) > 0.1 )
   {
     return false;
   }
 
   // Project point onto plane of this PlanarFigure
   planarFigureGeometry->Map( worldPoint3D, point2D );
   return true;
 }
 
 
 bool mitk::PlanarFigureInteractor::TransformObjectToDisplay(
   const mitk::Point2D &point2D,
   mitk::Point2D &displayPoint,
   const mitk::Geometry2D *objectGeometry,
   const mitk::Geometry2D *rendererGeometry,
   const mitk::DisplayGeometry *displayGeometry ) const
 {
   mitk::Point3D point3D;
 
   // Map circle point from local 2D geometry into 3D world space
   objectGeometry->Map( point2D, point3D );
 
   // TODO: proper handling of distance tolerance
   if ( displayGeometry->Distance( point3D ) < 0.1 )
   {
     // Project 3D world point onto display geometry
     rendererGeometry->Map( point3D, displayPoint );
     displayGeometry->WorldToDisplay( displayPoint, displayPoint );
     return true;
   }
 
   return false;
 }
 
 
 bool mitk::PlanarFigureInteractor::IsPointNearLine(
   const mitk::Point2D& point,
   const mitk::Point2D& startPoint, const mitk::Point2D& endPoint ) const
 {
   mitk::Vector2D n1 = endPoint - startPoint;
   n1.Normalize();
 
   // Determine dot products between line vector and startpoint-point / endpoint-point vectors
   double l1 = n1 * (point - startPoint);
   double l2 = -n1 * (point - endPoint);
 
   // Determine projection of specified point onto line defined by start / end point
   mitk::Point2D crossPoint = startPoint + n1 * l1;
 
   // Point is inside encompassing rectangle IF
   // - its distance to its projected point is small enough
   // - it is not further outside of the line than the defined tolerance
   if ( (crossPoint.SquaredEuclideanDistanceTo( point ) < 20.0 )
     && ( l1 > -5.0 ) && ( l2 > -5.0 ) )
   {
     return true;
   }
 
   return false;
 }
 
 
 bool mitk::PlanarFigureInteractor::IsPositionOverFigure(
   const StateEvent *stateEvent, PlanarFigure *planarFigure,
   const Geometry2D *planarFigureGeometry,
   const Geometry2D *rendererGeometry,
   const DisplayGeometry *displayGeometry ) const
 {
   // Extract display position
   const mitk::PositionEvent *positionEvent = 
     dynamic_cast< const mitk::PositionEvent * > ( stateEvent->GetEvent() );
   if ( positionEvent == NULL )
   {
     return -1;
   }
 
   mitk::Point2D displayPosition = positionEvent->GetDisplayPosition();
 
 
   // Iterate over all polylines of planar figure, and check if
   // any one is close to the current display position
-  typedef mitk::PlanarFigure::VertexContainerType VertexContainerType;
+  typedef mitk::PlanarFigure::PolyLineType VertexContainerType;
 
   mitk::Point2D worldPoint2D, displayControlPoint;
   mitk::Point3D worldPoint3D;
 
   for ( unsigned short loop = 0; loop < planarFigure->GetPolyLinesSize(); ++loop )
   {
-    const VertexContainerType* polyLine = planarFigure->GetPolyLine( loop );
+    const VertexContainerType polyLine = planarFigure->GetPolyLine( loop );
 
     Point2D polyLinePoint;
     Point2D firstPolyLinePoint;
     Point2D previousPolyLinePoint;
 
     bool firstPoint = true;
-    for ( VertexContainerType::ConstIterator it = polyLine->Begin(); it != polyLine->End(); ++it )
+    for ( VertexContainerType::const_iterator it = polyLine.begin(); it != polyLine.end(); ++it )
     {
       // Get plane coordinates of this point of polyline (if possible)
-      if ( !this->TransformObjectToDisplay( it->Value(), polyLinePoint,
+      if ( !this->TransformObjectToDisplay( it->Point, polyLinePoint,
         planarFigureGeometry, rendererGeometry, displayGeometry ) )
       {
         break; // Poly line invalid (not on current 2D plane) --> skip it
       }
 
       if ( firstPoint )
       {
         firstPolyLinePoint = polyLinePoint;
         firstPoint = false;
       }
       else if ( this->IsPointNearLine( displayPosition, previousPolyLinePoint, polyLinePoint ) )
       {
         // Return true if the display position is close enough to this line segment
         return true;
       }
       previousPolyLinePoint = polyLinePoint;
     }
 
     // For closed figures, also check last line segment
     if ( planarFigure->IsClosed()
       && this->IsPointNearLine( displayPosition, polyLinePoint, firstPolyLinePoint ) )
     {
       return true;
     }
   }
 
   return false;
 }
 
 
 int mitk::PlanarFigureInteractor::IsPositionInsideMarker(
   const StateEvent *stateEvent, const PlanarFigure *planarFigure,
   const Geometry2D *planarFigureGeometry,
   const Geometry2D *rendererGeometry,
   const DisplayGeometry *displayGeometry ) const
 {
   // Extract display position
   const mitk::PositionEvent *positionEvent = 
     dynamic_cast< const mitk::PositionEvent * > ( stateEvent->GetEvent() );
   if ( positionEvent == NULL )
   {
     return -1;
   }
 
   mitk::Point2D displayPosition = positionEvent->GetDisplayPosition();
 
 
   // Iterate over all control points of planar figure, and check if
   // any one is close to the current display position
   typedef mitk::PlanarFigure::VertexContainerType VertexContainerType;
   const VertexContainerType *controlPoints = planarFigure->GetControlPoints();
 
   mitk::Point2D worldPoint2D, displayControlPoint;
   mitk::Point3D worldPoint3D;
 
   VertexContainerType::ConstIterator it;
   for ( it = controlPoints->Begin(); it != controlPoints->End(); ++it )
   {
     Point2D displayControlPoint;
     if ( this->TransformObjectToDisplay( it->Value(), displayControlPoint,
       planarFigureGeometry, rendererGeometry, displayGeometry ) )
     {
       // TODO: variable size of markers
       if ( (abs(displayPosition[0] - displayControlPoint[0]) < 4 )
         && (abs(displayPosition[1] - displayControlPoint[1]) < 4 ) )
       {
         return it->Index();
       }
     }
   }
 
   return -1;
 }
 
 
 void mitk::PlanarFigureInteractor::LogPrintPlanarFigureQuantities( 
   const PlanarFigure *planarFigure )
 {
   MITK_INFO << "PlanarFigure: " << planarFigure->GetNameOfClass();
   for ( unsigned int i = 0; i < planarFigure->GetNumberOfFeatures(); ++i )
   {
     MITK_INFO << "* " << planarFigure->GetFeatureName( i ) << ": "
       << planarFigure->GetQuantity( i ) << " " << planarFigure->GetFeatureUnit( i );
   }
 }
 
diff --git a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp
index f41aeb7a63..14f853d3cd 100644
--- a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp
+++ b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp
@@ -1,568 +1,605 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-04-23 13:50:34 +0200 (Do, 23 Apr 2009) $
 Version:   $Revision: 16947 $
 
 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 "mitkPlanarFigureMapper2D.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "mitkGL.h"
 #include "mitkVtkPropRenderer.h"
 
 mitk::PlanarFigureMapper2D::PlanarFigureMapper2D()
 {
   this->InitializeDefaultPlanarFigureProperties();
 }
 
 
 mitk::PlanarFigureMapper2D::~PlanarFigureMapper2D()
 {
 }
 
 
 void mitk::PlanarFigureMapper2D::Paint( mitk::BaseRenderer *renderer )
 {
   if ( !this->IsVisible( renderer ) ) 
   {
     return;
   }
 
   // Get PlanarFigure from input
   mitk::PlanarFigure *planarFigure = const_cast< mitk::PlanarFigure * >(
     static_cast< const mitk::PlanarFigure * >( this->GetData() ) );
 
   // Check if PlanarFigure has already been placed; otherwise, do nothing
   if ( !planarFigure->IsPlaced() )
   {
     return;
   }
 
   // Get 2D geometry frame of PlanarFigure
   mitk::Geometry2D *planarFigureGeometry2D = 
     dynamic_cast< Geometry2D * >( planarFigure->GetGeometry( 0 ) );
   if ( planarFigureGeometry2D == NULL )
   {
     MITK_ERROR << "PlanarFigure does not have valid Geometry2D!";
     return;
   }
 
   // Get current world 2D geometry from renderer
   const mitk::Geometry2D *rendererGeometry2D = renderer->GetCurrentWorldGeometry2D();
 
   // If the PlanarFigure geometry is a plane geometry, check if current
   // world plane is parallel to and within the planar figure geometry bounds
   // (otherwise, display nothing)
   mitk::PlaneGeometry *planarFigurePlaneGeometry = 
     dynamic_cast< PlaneGeometry * >( planarFigureGeometry2D );
   const mitk::PlaneGeometry *rendererPlaneGeometry = 
     dynamic_cast< const PlaneGeometry * >( rendererGeometry2D );
 
   if ( (planarFigurePlaneGeometry != NULL) && (rendererPlaneGeometry != NULL) )
   {
     double planeThickness = planarFigurePlaneGeometry->GetExtentInMM( 2 );
     if ( !planarFigurePlaneGeometry->IsParallel( rendererPlaneGeometry )
       || !(planarFigurePlaneGeometry->DistanceFromPlane( 
            rendererPlaneGeometry ) < planeThickness / 3.0) )
     {
       // Planes are not parallel or renderer plane is not within PlanarFigure
       // geometry bounds --> exit
       return;
     }
   }
   else
   {
     // Plane is not valid (curved reformations are not possible yet)
     return;
   }
 
 
   // Get display geometry
   mitk::DisplayGeometry *displayGeometry = renderer->GetDisplayGeometry();
   assert( displayGeometry != NULL );
 
 
   // Apply visual appearance properties from the PropertyList
   this->ApplyProperties( renderer );
 
   // Enable line antialiasing
   glEnable( GL_LINE_SMOOTH );
   glHint( GL_LINE_SMOOTH_HINT, GL_NICEST );
   
   // Get properties from node (if present)
   const mitk::DataNode* node=this->GetDataNode();
   this->InitializePlanarFigurePropertiesFromDataNode( node );
 
   PlanarFigureDisplayMode lineDisplayMode = PF_DEFAULT;
 
   if ( m_IsSelected )
   {
     lineDisplayMode = PF_SELECTED;
   }
   else if ( m_IsHovering )
   {
     lineDisplayMode = PF_HOVER;
   }
  
   mitk::Point2D firstPoint; firstPoint[0] = 0; firstPoint[1] = 1;
 
   if ( m_DrawOutline )
   {
     // Draw the outline for all polylines if requested
     this->DrawMainLines( planarFigure,
       m_OutlineColor[lineDisplayMode],
       m_OutlineOpacity[lineDisplayMode],
       m_OutlineWidth,
       firstPoint,
       planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
 
     // Draw the outline for all helper objects if requested
     this->DrawHelperLines( planarFigure,
       m_OutlineColor[lineDisplayMode],
       m_OutlineOpacity[lineDisplayMode],
       m_OutlineWidth,
       firstPoint,
       planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
   }
 
 
   // Draw the main line for all polylines
   this->DrawMainLines( planarFigure,
     m_LineColor[lineDisplayMode],
     m_LineOpacity[lineDisplayMode],
     m_LineWidth,
     firstPoint,
     planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
 
   double annotationOffset = 0.0;
 
   // draw name near the first point (if present)
   std::string name = node->GetName();
   if ( !name.empty() )
   {
     mitk::VtkPropRenderer* openGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
     if ( openGLrenderer )
     {
       if ( m_IsSelected || m_IsHovering )
       {
         openGLrenderer->WriteSimpleText( name,
           firstPoint[0] + 6.0, firstPoint[1] + 4.0,
           0,
           0,
           0); //this is a shadow 
         openGLrenderer->WriteSimpleText( name,
           firstPoint[0] + 5.0, firstPoint[1] + 5.0,
           m_LineColor[lineDisplayMode][0],
           m_LineColor[lineDisplayMode][1],
           m_LineColor[lineDisplayMode][2] );
       }
       
       // If drawing is successful, add approximate height to annotation offset
       annotationOffset -= 15.0;
     }
   }
 
   // draw feature quantities (if requested) new the first point
   if ( m_DrawQuantities )
   {
     std::stringstream quantityString;
     quantityString.setf( ios::fixed, ios::floatfield );
     quantityString.precision( 1 );
 
     bool firstActiveFeature = true;
     for ( unsigned int i = 0; i < planarFigure->GetNumberOfFeatures(); ++i )
     {     
       if( planarFigure->IsFeatureActive(i) )
       {
         if ( ! firstActiveFeature ) 
         {
           quantityString << " / ";
         }
         quantityString << planarFigure->GetQuantity( i ) << " ";
         quantityString << planarFigure->GetFeatureUnit( i );
         firstActiveFeature = false;
       }
     }
 
     mitk::VtkPropRenderer* openGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
     if ( openGLrenderer )
     {
       openGLrenderer->WriteSimpleText( quantityString.str().c_str(), 
         firstPoint[0] + 6.0, firstPoint[1] + 4.0 + annotationOffset,
         0,
         0,
         0); //this is a shadow 
 
       openGLrenderer->WriteSimpleText( quantityString.str().c_str(),
         firstPoint[0] + 5.0, firstPoint[1] + 5.0 + annotationOffset,
         m_LineColor[lineDisplayMode][0],
         m_LineColor[lineDisplayMode][1],
         m_LineColor[lineDisplayMode][2] );
 
       // If drawing is successful, add approximate height to annotation offset
       annotationOffset -= 15.0;
     }
   }
 
 
   // Draw helper objects
   this->DrawHelperLines( planarFigure,
     m_HelperlineColor[lineDisplayMode],
     m_HelperlineOpacity[lineDisplayMode],
     m_LineWidth,
     firstPoint,
     planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
 
 
 
   // Draw markers at control points (selected control point will be colored)
   for ( unsigned int i = 0; i < planarFigure->GetNumberOfControlPoints(); ++i )
   {
     
     bool isEditable = true;
     m_DataNode->GetBoolProperty( "planarfigure.iseditable", isEditable );
     
     PlanarFigureDisplayMode pointDisplayMode = PF_DEFAULT;
 
     // Only if planar figure is marked as editable: display markers (control points) in a
     // different style if mouse is over them or they are selected
     if ( isEditable )
     {
       if ( i == (unsigned int) planarFigure->GetSelectedControlPoint() )
       {
         pointDisplayMode = PF_SELECTED;
       }
       else if ( m_IsHovering )
       {
         pointDisplayMode = PF_HOVER;
       }
     }
 
     this->DrawMarker( planarFigure->GetControlPoint( i ),
       m_MarkerlineColor[pointDisplayMode],
       m_MarkerlineOpacity[pointDisplayMode],
       m_MarkerColor[pointDisplayMode],
       m_MarkerOpacity[pointDisplayMode],
       m_LineWidth,
       m_ControlPointShape,
       planarFigureGeometry2D, 
       rendererGeometry2D, 
       displayGeometry );
   }
 
   glLineWidth( 1.0f );
 }
 
 
 void mitk::PlanarFigureMapper2D::PaintPolyLine(
-  const VertexContainerType* vertices, 
+  mitk::PlanarFigure::PolyLineType vertices,  
   bool closed,
   float* color, 
   float opacity, 
   float lineWidth, 
   Point2D& firstPoint, 
   const Geometry2D* planarFigureGeometry2D, 
   const Geometry2D* rendererGeometry2D, 
   const DisplayGeometry* displayGeometry)
 {
   glColor4f( color[0], color[1], color[2], opacity );
   glLineWidth(lineWidth);
 
   if ( closed )
   {
     glBegin( GL_LINE_LOOP );
   }
   else 
   {
     glBegin( GL_LINE_STRIP );
   }
 
-  for ( VertexContainerType::ConstIterator it = vertices->Begin(); it != vertices->End(); ++it )
+  for ( PlanarFigure::PolyLineType::iterator iter = vertices.begin(); iter!=vertices.end(); iter++ )
   {
     // Draw this 2D point as OpenGL vertex
     mitk::Point2D displayPoint;
-    this->TransformObjectToDisplay( it->Value(), displayPoint,
+    this->TransformObjectToDisplay( iter->Point, displayPoint,
       planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
 
-    if(it == vertices->Begin())
+    if(iter == vertices.begin())
       firstPoint = displayPoint;
 
     glVertex2f( displayPoint[0], displayPoint[1] );
 
   }
 
+  //for ( VertexContainerType::ConstIterator it = vertices->Begin(); it != vertices->End(); ++it )
+  //{
+  //  // Draw this 2D point as OpenGL vertex
+  //  mitk::Point2D displayPoint;
+  //  this->TransformObjectToDisplay( it->Value(), displayPoint,
+  //    planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
+
+  //  if(it == vertices->Begin())
+  //    firstPoint = displayPoint;
+
+  //  glVertex2f( displayPoint[0], displayPoint[1] );
+
+  //}
+
   glEnd();
 }
 
 
 void mitk::PlanarFigureMapper2D::DrawMainLines( 
   mitk::PlanarFigure* figure, 
   float* color, 
   float opacity, 
   float lineWidth, 
   Point2D& firstPoint,
   const Geometry2D* planarFigureGeometry2D, 
   const Geometry2D* rendererGeometry2D, 
   const DisplayGeometry* displayGeometry)
 {
   for ( unsigned short loop = 0; loop < figure->GetPolyLinesSize(); ++loop )
   {
-    const VertexContainerType* polyLine = figure->GetPolyLine(loop);
-    this->PaintPolyLine( polyLine,
+    PlanarFigure::PolyLineType polyline = figure->GetPolyline(loop);
+
+    this->PaintPolyLine( polyline, 
       figure->IsClosed(),    
       color, opacity, lineWidth, firstPoint,
       planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
+
+    //const VertexContainerType* polyLine = figure->GetPolyLine(loop);
+    //this->PaintPolyLine( polyLine,
+    //  figure->IsClosed(),    
+    //  color, opacity, lineWidth, firstPoint,
+    //  planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
   }
 }
 
 void mitk::PlanarFigureMapper2D::DrawHelperLines(
   mitk::PlanarFigure* figure,
   float* color, 
   float opacity, 
   float lineWidth, 
   Point2D& firstPoint,
   const Geometry2D* planarFigureGeometry2D, 
   const Geometry2D* rendererGeometry2D, 
   const DisplayGeometry* displayGeometry)
 {
   // Draw helper objects
   for ( unsigned int loop = 0; loop < figure->GetHelperPolyLinesSize(); ++loop )
-  {    
-    // Get (and possibly generate) helper polyline (this needs to be done before
-    // checking if the helper polyline has to be painted!)
-    const VertexContainerType *polyLine = figure->GetHelperPolyLine( loop,
+  {
+    const mitk::PlanarFigure::PolyLineType helperPolyLine = figure->GetHelperPolyLine(loop,
       displayGeometry->GetScaleFactorMMPerDisplayUnit(),
       displayGeometry->GetDisplayHeight() );
 
     // Check if the current helper objects is to be painted
     if ( !figure->IsHelperToBePainted( loop ) )
     {
       continue;
     }
 
-    this->PaintPolyLine( polyLine, false,
+    this->PaintPolyLine( helperPolyLine, false,
       color, opacity, lineWidth, firstPoint,
       planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
+
+
+
+    //// Get (and possibly generate) helper polyline (this needs to be done before
+    //// checking if the helper polyline has to be painted!)
+    //const VertexContainerType *polyLine = figure->GetHelperPolyLine( loop,
+    //  displayGeometry->GetScaleFactorMMPerDisplayUnit(),
+    //  displayGeometry->GetDisplayHeight() );
+
+    //// Check if the current helper objects is to be painted
+    //if ( !figure->IsHelperToBePainted( loop ) )
+    //{
+    //  continue;
+    //}
+
+    //this->PaintPolyLine( polyLine, false,
+    //  color, opacity, lineWidth, firstPoint,
+    //  planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
   }
 }
 
 
 
 void mitk::PlanarFigureMapper2D::TransformObjectToDisplay(
   const mitk::Point2D &point2D,
   mitk::Point2D &displayPoint,
   const mitk::Geometry2D *objectGeometry,
   const mitk::Geometry2D *rendererGeometry,
   const mitk::DisplayGeometry *displayGeometry )
 {
   mitk::Point3D point3D;
 
   // Map circle point from local 2D geometry into 3D world space
   objectGeometry->Map( point2D, point3D );
 
   // Project 3D world point onto display geometry
   rendererGeometry->Map( point3D, displayPoint );
   displayGeometry->WorldToDisplay( displayPoint, displayPoint );
 }
 
 
 void mitk::PlanarFigureMapper2D::DrawMarker(
   const mitk::Point2D &point,
   float* lineColor,
   float lineOpacity,
   float* markerColor,
   float markerOpacity,
   float lineWidth,
   PlanarFigureControlPointStyleProperty::Shape shape,
   const mitk::Geometry2D *objectGeometry,
   const mitk::Geometry2D *rendererGeometry,
   const mitk::DisplayGeometry *displayGeometry )
 {
   mitk::Point2D displayPoint;
 
   this->TransformObjectToDisplay(
     point, displayPoint,
     objectGeometry, rendererGeometry, displayGeometry );
 
   glColor4f( markerColor[0], markerColor[1], markerColor[2], markerOpacity );
   glLineWidth( lineWidth );
 
   switch ( shape )
   {
     case PlanarFigureControlPointStyleProperty::Square:
     default:
       // Paint filled square
 
       // Disable line antialiasing (does not look nice for squares)
       glDisable( GL_LINE_SMOOTH );
 
       glRectf(
         displayPoint[0] - 4, displayPoint[1] - 4, 
         displayPoint[0] + 4, displayPoint[1] + 4 );
 
       // Paint outline
       glColor4f( lineColor[0], lineColor[1], lineColor[2], lineOpacity );
       glBegin( GL_LINE_LOOP );
       glVertex2f( displayPoint[0] - 4, displayPoint[1] - 4 );
       glVertex2f( displayPoint[0] - 4, displayPoint[1] + 4 );
       glVertex2f( displayPoint[0] + 4, displayPoint[1] + 4 );
       glVertex2f( displayPoint[0] + 4, displayPoint[1] - 4 );
       glEnd();
       break;
 
     case PlanarFigureControlPointStyleProperty::Circle:
       // Paint filled circle
       glBegin( GL_POLYGON );
       float radius = 4.0;
       for ( int angle = 0; angle < 8; ++angle )
       {
         float angleRad = angle * (float) 3.14159 / 4.0;
         float x = displayPoint[0] + radius * (float)cos( angleRad );
         float y = displayPoint[1] + radius * (float)sin( angleRad );
         glVertex2f(x,y);
       }
       glEnd();
 
       // Paint outline
       glColor4f( lineColor[0], lineColor[1], lineColor[2], lineOpacity );
       glBegin( GL_LINE_LOOP );
       for ( int angle = 0; angle < 8; ++angle )
       {
         float angleRad = angle * (float) 3.14159 / 4.0;
         float x = displayPoint[0] + radius * (float)cos( angleRad );
         float y = displayPoint[1] + radius * (float)sin( angleRad );
         glVertex2f(x,y);
       }
       glEnd();
       break;
 
     } // end switch
 }
 
 
 void mitk::PlanarFigureMapper2D::InitializeDefaultPlanarFigureProperties()
 {
   m_IsSelected = false;
   m_IsHovering = false;
   m_DrawOutline = false;
   m_DrawQuantities = false;
 
   m_LineWidth = 1.0;
   m_OutlineWidth = 4.0;
   m_HelperlineWidth = 2.0;
 
   m_ControlPointShape = PlanarFigureControlPointStyleProperty::Square;
 
   this->SetColorProperty( m_LineColor, PF_DEFAULT, 1.0, 1.0, 1.0 );
   this->SetFloatProperty( m_LineOpacity, PF_DEFAULT, 1.0 );
   this->SetColorProperty( m_OutlineColor, PF_DEFAULT, 0.0, 0.0, 1.0 );
   this->SetFloatProperty( m_OutlineOpacity, PF_DEFAULT, 1.0 );
   this->SetColorProperty( m_HelperlineColor, PF_DEFAULT, 0.4, 0.8, 0.2 );
   this->SetFloatProperty( m_HelperlineOpacity, PF_DEFAULT, 0.4 );
   this->SetColorProperty( m_MarkerlineColor, PF_DEFAULT, 1.0, 1.0, 1.0 );
   this->SetFloatProperty( m_MarkerlineOpacity, PF_DEFAULT, 1.0 );
   this->SetColorProperty( m_MarkerColor, PF_DEFAULT, 1.0, 1.0, 1.0 );
   this->SetFloatProperty( m_MarkerOpacity, PF_DEFAULT, 0.0 );
 
   this->SetColorProperty( m_LineColor, PF_HOVER, 1.0, 0.7, 0.0 );
   this->SetFloatProperty( m_LineOpacity, PF_HOVER, 1.0 );
   this->SetColorProperty( m_OutlineColor, PF_HOVER, 0.0, 0.0, 1.0 );
   this->SetFloatProperty( m_OutlineOpacity, PF_HOVER, 1.0 );
   this->SetColorProperty( m_HelperlineColor, PF_HOVER, 0.4, 0.8, 0.2 );
   this->SetFloatProperty( m_HelperlineOpacity, PF_HOVER, 0.4 );
   this->SetColorProperty( m_MarkerlineColor, PF_HOVER, 1.0, 1.0, 1.0 );
   this->SetFloatProperty( m_MarkerlineOpacity, PF_HOVER, 1.0 );
   this->SetColorProperty( m_MarkerColor, PF_HOVER, 1.0, 0.6, 0.0 );
   this->SetFloatProperty( m_MarkerOpacity, PF_HOVER, 0.2 );
 
   this->SetColorProperty( m_LineColor, PF_SELECTED, 1.0, 0.0, 0.0 );
   this->SetFloatProperty( m_LineOpacity, PF_SELECTED, 1.0 );
   this->SetColorProperty( m_OutlineColor, PF_SELECTED, 0.0, 0.0, 1.0 );
   this->SetFloatProperty( m_OutlineOpacity, PF_SELECTED, 1.0 );
   this->SetColorProperty( m_HelperlineColor, PF_SELECTED, 0.4, 0.8, 0.2 );
   this->SetFloatProperty( m_HelperlineOpacity, PF_SELECTED, 0.4 );
   this->SetColorProperty( m_MarkerlineColor, PF_SELECTED, 1.0, 1.0, 1.0 );
   this->SetFloatProperty( m_MarkerlineOpacity, PF_SELECTED, 1.0 );
   this->SetColorProperty( m_MarkerColor, PF_SELECTED, 1.0, 0.6, 0.0 );
   this->SetFloatProperty( m_MarkerOpacity, PF_SELECTED, 1.0 );
 }
 
 
 void mitk::PlanarFigureMapper2D::InitializePlanarFigurePropertiesFromDataNode( const mitk::DataNode* node )
 {
   if ( node == NULL )
   {
     return;
   }
 
   node->GetBoolProperty( "selected", m_IsSelected );
   node->GetBoolProperty( "planarfigure.ishovering", m_IsHovering );
   node->GetBoolProperty( "planarfigure.drawoutline", m_DrawOutline );
   node->GetBoolProperty( "planarfigure.drawquantities", m_DrawQuantities );
 
   node->GetFloatProperty( "planarfigure.line.width", m_LineWidth );
   node->GetFloatProperty( "planarfigure.outline.width", m_OutlineWidth );
   node->GetFloatProperty( "planarfigure.helperline.width", m_HelperlineWidth );
 
   PlanarFigureControlPointStyleProperty::Pointer styleProperty = 
     dynamic_cast< PlanarFigureControlPointStyleProperty* >( node->GetProperty( "planarfigure.controlpointshape" ) );
   if ( styleProperty.IsNotNull() )
   {
     m_ControlPointShape = styleProperty->GetShape();
   }
 
   node->GetColor( m_LineColor[PF_DEFAULT], NULL, "planarfigure.default.line.color" );
   node->GetFloatProperty( "planarfigure.default.line.opacity", m_LineOpacity[PF_DEFAULT] );
   node->GetColor( m_OutlineColor[PF_DEFAULT], NULL, "planarfigure.default.outline.color" );
   node->GetFloatProperty( "planarfigure.default.outline.opacity", m_OutlineOpacity[PF_DEFAULT] );
   node->GetColor( m_HelperlineColor[PF_DEFAULT], NULL, "planarfigure.default.helperline.color" );
   node->GetFloatProperty( "planarfigure.default.helperline.opacity", m_HelperlineOpacity[PF_DEFAULT] );
   node->GetColor( m_MarkerlineColor[PF_DEFAULT], NULL, "planarfigure.default.markerline.color" );
   node->GetFloatProperty( "planarfigure.default.markerline.opacity", m_MarkerlineOpacity[PF_DEFAULT] );
   node->GetColor( m_MarkerColor[PF_DEFAULT], NULL, "planarfigure.default.marker.color" );
   node->GetFloatProperty( "planarfigure.default.marker.opacity", m_MarkerOpacity[PF_DEFAULT] );
 
   node->GetColor( m_LineColor[PF_HOVER], NULL, "planarfigure.hover.line.color" );
   node->GetFloatProperty( "planarfigure.hover.line.opacity", m_LineOpacity[PF_HOVER] );
   node->GetColor( m_OutlineColor[PF_HOVER], NULL, "planarfigure.hover.outline.color" );
   node->GetFloatProperty( "planarfigure.hover.outline.opacity", m_OutlineOpacity[PF_HOVER] );
   node->GetColor( m_HelperlineColor[PF_HOVER], NULL, "planarfigure.hover.helperline.color" );
   node->GetFloatProperty( "planarfigure.hover.helperline.opacity", m_HelperlineOpacity[PF_HOVER] );
   node->GetColor( m_MarkerlineColor[PF_HOVER], NULL, "planarfigure.hover.markerline.color" );
   node->GetFloatProperty( "planarfigure.hover.markerline.opacity", m_MarkerlineOpacity[PF_HOVER] );
   node->GetColor( m_MarkerColor[PF_HOVER], NULL, "planarfigure.hover.marker.color" );
   node->GetFloatProperty( "planarfigure.hover.marker.opacity", m_MarkerOpacity[PF_HOVER] );
 
   node->GetColor( m_LineColor[PF_SELECTED], NULL, "planarfigure.selected.line.color" );
   node->GetFloatProperty( "planarfigure.selected.line.opacity", m_LineOpacity[PF_SELECTED] );
   node->GetColor( m_OutlineColor[PF_SELECTED], NULL, "planarfigure.selected.outline.color" );
   node->GetFloatProperty( "planarfigure.selected.outline.opacity", m_OutlineOpacity[PF_SELECTED] );
   node->GetColor( m_HelperlineColor[PF_SELECTED], NULL, "planarfigure.selected.helperline.color" );
   node->GetFloatProperty( "planarfigure.selected.helperline.opacity", m_HelperlineOpacity[PF_SELECTED] );
   node->GetColor( m_MarkerlineColor[PF_SELECTED], NULL, "planarfigure.selected.markerline.color" );
   node->GetFloatProperty( "planarfigure.selected.markerline.opacity", m_MarkerlineOpacity[PF_SELECTED] );
   node->GetColor( m_MarkerColor[PF_SELECTED], NULL, "planarfigure.selected.marker.color" );
   node->GetFloatProperty( "planarfigure.selected.marker.opacity", m_MarkerOpacity[PF_SELECTED] );
 
 }
 
 
 void mitk::PlanarFigureMapper2D::SetDefaultProperties( mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite )
 {
   node->AddProperty( "visible", mitk::BoolProperty::New(true), renderer, overwrite );
 }
diff --git a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.h b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.h
index 43a5f29aa5..324287807e 100644
--- a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.h
+++ b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.h
@@ -1,234 +1,233 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-05-13 18:06:46 +0200 (Mi, 13 Mai 2009) $
 Version:   $Revision: 17258 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 
 #ifndef MITK_PLANAR_FIGURE_MAPPER_2D_H_
 #define MITK_PLANAR_FIGURE_MAPPER_2D_H_
 
 #include "mitkCommon.h"
 #include "PlanarFigureExports.h"
 #include "mitkGLMapper2D.h"
 #include "mitkPlanarFigure.h"
 #include "mitkPlanarFigureControlPointStyleProperty.h"
 
 namespace mitk {
 
 class BaseRenderer;
 class Contour;
 
 
 /**
 * \brief OpenGL-based mapper to render display sub-class instances of mitk::PlanarFigure
 * 
 * The appearance of planar figures can be configured through  properties. If no properties are specified,
 * default values will be used. There are four elements a planar figure consists of:
 * 
 * <ol>
 * <li>"line": the main line segments of the planar figure (note: text is drawn in the same style)
 * <li>"helperline": additional line segments of planar figures, such as arrow tips, arches of angles, etc.
 * <li>"outline": background which is drawn behind the lines and helperlines of the planar figure (optional)
 * <li>"marker": the markers (control points) of a planar figure
 * <li>"markerline": the lines by which markers (control points) are surrounded
 * </ol>
 * 
 * In the following, all appearance-related planar figure properties are listed:
 * 
 * <ol>
 * <li>General properties for the planar figure
 *   <ul>
 *     <li>"planarfigure.drawoutline": if true, the "outline" lines is drawn
 *     <li>"planarfigure.drawquantities": if true, the quantities (text) associated with the planar figure is drawn
 *     <li>"planarfigure.controlpointshape": style of the control points (enum)
 *   </ul>
 * <li>Line widths of planar figure elements
 *   <ul>
 *     <li>"planarfigure.line.width": width of "line" segments (float value, in mm)
 *     <li>"planarfigure.outline.width": width of "outline" segments (float value, in mm)
 *     <li>"planarfigure.helperline.width": width of "helperline" segments (float value, in mm)
 *   </ul>
 * <li>Color/opacity of planar figure elements in normal mode (unselected)
 *   <ul>
 *     <li>"planarfigure.default.line.color"
 *     <li>"planarfigure.default.line.opacity"
 *     <li>"planarfigure.default.outline.color"
 *     <li>"planarfigure.default.outline.opacity"
 *     <li>"planarfigure.default.helperline.color"
 *     <li>"planarfigure.default.helperline.opacity"
 *     <li>"planarfigure.default.markerline.color"
 *     <li>"planarfigure.default.markerline.opacity"
 *     <li>"planarfigure.default.marker.color"
 *     <li>"planarfigure.default.marker.opacity"
 *   </ul>
 * <li>Color/opacity of planar figure elements in hover mode (mouse-over)
 *   <ul>
 *     <li>"planarfigure.hover.line.color"
 *     <li>"planarfigure.hover.line.opacity"
 *     <li>"planarfigure.hover.outline.color"
 *     <li>"planarfigure.hover.outline.opacity"
 *     <li>"planarfigure.hover.helperline.color"
 *     <li>"planarfigure.hover.helperline.opacity"
 *     <li>"planarfigure.hover.markerline.color"
 *     <li>"planarfigure.hover.markerline.opacity"
 *     <li>"planarfigure.hover.marker.color"
 *     <li>"planarfigure.hover.marker.opacity"
 *   </ul>
 * <li>Color/opacity of planar figure elements in selected mode
 *   <ul>
 *     <li>"planarfigure.selected.line.color"
 *     <li>"planarfigure.selected.line.opacity"
 *     <li>"planarfigure.selected.outline.color"
 *     <li>"planarfigure.selected.outline.opacity"
 *     <li>"planarfigure.selected.helperline.color"
 *     <li>"planarfigure.selected.helperline.opacity"
 *     <li>"planarfigure.selected.markerline.color;"
 *     <li>"planarfigure.selected.markerline.opacity"
 *     <li>"planarfigure.selected.marker.color"
 *     <li>"planarfigure.selected.marker.opacity"
 *   </ul>
 * </ol>
 *
 * \ingroup Mapper
 */
 
 class PlanarFigure_EXPORT PlanarFigureMapper2D : public GLMapper2D
 {
 public:
     
   mitkClassMacro(PlanarFigureMapper2D, Mapper2D);
 
   itkNewMacro(Self);
 
   /**
   * reimplemented from Baseclass
   */
   virtual void Paint(BaseRenderer * renderer);
 
   static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = NULL, bool overwrite = false);
 
 
 protected:
   
   typedef PlanarFigure::VertexContainerType VertexContainerType;
 
   enum PlanarFigureDisplayMode
   {
     PF_DEFAULT = 0,
     PF_HOVER,
     PF_SELECTED
   };
 
   PlanarFigureMapper2D();
 
   virtual ~PlanarFigureMapper2D();
 
   void TransformObjectToDisplay(
     const mitk::Point2D &point2D,
     mitk::Point2D &displayPoint,
     const mitk::Geometry2D *objectGeometry,
     const mitk::Geometry2D *rendererGeometry,
     const mitk::DisplayGeometry *displayGeometry );
 
   void DrawMarker(
     const mitk::Point2D &point,
     float* lineColor,
     float lineOpacity,
     float* markerColor,
     float markerOpacity,
     float lineWidth,
     PlanarFigureControlPointStyleProperty::Shape shape,
     const mitk::Geometry2D *objectGeometry,
     const mitk::Geometry2D *rendererGeometry,
     const mitk::DisplayGeometry *displayGeometry );
 
-  void PaintPolyLine(
-    const VertexContainerType* vertices, 
+  void PaintPolyLine( mitk::PlanarFigure::PolyLineType vertices,
     bool closed,
     float* color, 
     float opacity, 
     float lineWidth, 
     Point2D& firstPoint,
     const Geometry2D* planarFigureGeometry2D, 
     const Geometry2D* rendererGeometry2D, 
     const DisplayGeometry* displayGeometry);
 
   void DrawMainLines( mitk::PlanarFigure* figure, 
     float* color, 
     float opacity, 
     float lineWidth, 
     Point2D& firstPoint,
     const Geometry2D* planarFigureGeometry2D, 
     const Geometry2D* rendererGeometry2D, 
     const DisplayGeometry* displayGeometry) ;
 
   void DrawHelperLines( mitk::PlanarFigure* figure,
     float* color, 
     float opacity, 
     float lineWidth, 
     Point2D& firstPoint,
     const Geometry2D* planarFigureGeometry2D, 
     const Geometry2D* rendererGeometry2D, 
     const DisplayGeometry* displayGeometry) ;
 
   void InitializeDefaultPlanarFigureProperties();
 
   void InitializePlanarFigurePropertiesFromDataNode( const mitk::DataNode* node );
 
   void SetColorProperty( float property[3][3], PlanarFigureDisplayMode mode, float red, float green, float blue )
   {
     property[mode][0] = red;
     property[mode][1] = green;
     property[mode][2] = blue;
   }
 
   void SetFloatProperty( float* property, PlanarFigureDisplayMode mode, float value )
   {
     property[mode] = value;
   }
 
 
 
 private:
   bool m_IsSelected;
   bool m_IsHovering;
   bool m_DrawOutline;
   bool m_DrawQuantities;
 
   float m_LineWidth;
   float m_OutlineWidth;
   float m_HelperlineWidth;
   float m_PointWidth;
 
   PlanarFigureControlPointStyleProperty::Shape m_ControlPointShape;
 
   float m_LineColor[3][3];
   float m_LineOpacity[3];
   float m_OutlineColor[3][3];
   float m_OutlineOpacity[3];
   float m_HelperlineColor[3][3];
   float m_HelperlineOpacity[3];
   float m_MarkerlineColor[3][3];
   float m_MarkerlineOpacity[3];
   float m_MarkerColor[3][3];
   float m_MarkerOpacity[3];
 
 };
 
 } // namespace mitk
 
 
 
 #endif /* MITK_PLANAR_FIGURE_MAPPER_2D_H_ */