diff --git a/Modules/PlanarFigure/DataManagement/mitkPlanarCross.cpp b/Modules/PlanarFigure/DataManagement/mitkPlanarCross.cpp
index 53a172f81e..a37c5ae1fc 100644
--- a/Modules/PlanarFigure/DataManagement/mitkPlanarCross.cpp
+++ b/Modules/PlanarFigure/DataManagement/mitkPlanarCross.cpp
@@ -1,395 +1,392 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2010-02-17 23:03:29 +0100 (Mi, 17 Feb 2010) $
 Version:   $Revision: 18029 $
 
 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 "mitkPlanarCross.h"
 #include "mitkGeometry2D.h"
 #include "mitkProperties.h"
 
 
 mitk::PlanarCross::PlanarCross()
 : FEATURE_ID_LONGESTDIAMETER( this->AddFeature( "Longest Axis", "mm" ) ),
   FEATURE_ID_SHORTAXISDIAMETER( this->AddFeature( "Short Axis", "mm" ) )
 {
   // Cross has two control points at the beginning
   this->ResetNumberOfControlPoints( 2 );
 
   // Create property for SingleLineMode (default: false)
   this->SetProperty( "SingleLineMode", mitk::BoolProperty::New( false ) );
 
   // Create helper polyline object (for drawing the orthogonal orientation line)
   this->SetNumberOfHelperPolyLines( 1 );
-  //m_HelperPolyLines->InsertElement( 0, VertexContainerType::New());
-  //m_HelperPolyLines->ElementAt( 0 )->Reserve( 2 );
   m_HelperPolyLinesToBePainted->InsertElement( 0, false );
 }
 
 
 mitk::PlanarCross::~PlanarCross()
 {
 }
 
 
 void mitk::PlanarCross::SetSingleLineMode( bool singleLineMode )
 {
   this->SetProperty( "SingleLineMode", mitk::BoolProperty::New( singleLineMode ) );
   this->Modified();
 }
 
 
 bool mitk::PlanarCross::GetSingleLineMode() const
 {
   mitk::BoolProperty* singleLineMode = dynamic_cast< mitk::BoolProperty* >( 
     this->GetProperty( "SingleLineMode" ).GetPointer() );
 
   if ( singleLineMode != NULL )
   {
     return singleLineMode->GetValue();
   }
   return false;
 }
 
 
 bool mitk::PlanarCross::ResetOnPointSelect()
 {
   if ( this->GetSingleLineMode() )
   {
     // In single line mode --> nothing to reset
     return false;
   }
 
   switch ( m_SelectedControlPoint )
   {
   default:
     // Nothing selected --> nothing to reset
     return false;
 
   case 0:
     {
       // Control point 0 selected: exchange points 0 and 1
       Point2D tmpPoint = this->GetControlPoint( 0 );
-      //Point2D tmpPoint = m_ControlPoints->ElementAt( 0 );
       this->SetControlPoint( 0, this->GetControlPoint( 1 ) );
       this->SetControlPoint( 1, tmpPoint );
       //m_ControlPoints->InsertElement( 0, m_ControlPoints->ElementAt( 1 ) );
       //m_ControlPoints->InsertElement( 1, tmpPoint );
       // FALLS THROUGH!
     }
 
   case 1:
     {
       // Control point 0 or 1 selected: reset number of control points to two 
       this->ResetNumberOfControlPoints( 2 );
       this->SelectControlPoint( 1 );
       return true;
     }
 
   case 2:
     {
       // Control point 2 selected: replace point 0 with point 3 and point 1 with point 2
       this->SetControlPoint( 0, this->GetControlPoint( 3 ) );
       this->SetControlPoint( 1, this->GetControlPoint( 2 ) );
 
       //m_ControlPoints->InsertElement( 0, m_ControlPoints->ElementAt( 3 ) );
       //m_ControlPoints->InsertElement( 1, m_ControlPoints->ElementAt( 2 ) );
 
       // Adjust selected control point, reset number of control points to two
       this->ResetNumberOfControlPoints( 2 );
       this->SelectControlPoint( 1 );
       return true;
     }
 
   case 3:
     {
       // Control point 3 selected: replace point 0 with point 2 and point 1 with point 3
 
       this->SetControlPoint( 0, this->GetControlPoint( 2 ) );
       this->SetControlPoint( 1, this->GetControlPoint( 3 ) );
 
       //m_ControlPoints->InsertElement( 0, m_ControlPoints->ElementAt( 2 ) );
       //m_ControlPoints->InsertElement( 1, m_ControlPoints->ElementAt( 3 ) );
 
       // Adjust selected control point, reset number of control points to two
       this->ResetNumberOfControlPoints( 2 );
       this->SelectControlPoint( 1 );
       return true;
     }
   }
 }
 
 
 unsigned int mitk::PlanarCross::GetNumberOfFeatures() const
 {
   if ( this->GetSingleLineMode() || (this->GetNumberOfControlPoints() < 4) )
   {
     return 1;
   }
   else
   {
     return 2;
   }
 }
 
 
 mitk::Point2D mitk::PlanarCross::ApplyControlPointConstraints( unsigned int index, const Point2D& point )
 {
   // Apply spatial constraints from superclass and from this class until the resulting constrained
   // point converges. Although not an optimal implementation, this iterative approach
   // helps to respect both constraints from the superclass and from this class. Without this,
   // situations may occur where control points are constrained by the superclass, but again
   // moved out of the superclass bounds by the subclass, or vice versa.
   
   unsigned int count = 0; // ensures stop of approach if point does not converge in reasonable time
   Point2D confinedPoint = point;
   Point2D superclassConfinedPoint;
   do 
   {
     superclassConfinedPoint = Superclass::ApplyControlPointConstraints( index, confinedPoint );
     confinedPoint = this->InternalApplyControlPointConstraints( index, superclassConfinedPoint );
     ++count;
   } while ( (confinedPoint.EuclideanDistanceTo( superclassConfinedPoint ) > mitk::eps)
          && (count < 32) );
   
   return confinedPoint;
 }
 
 
 mitk::Point2D mitk::PlanarCross::InternalApplyControlPointConstraints( unsigned int index, const Point2D& point )
 {
   // Apply constraints depending on current interaction state
   switch ( index )
   {
   case 2:
     {
       // Check if 3rd control point is outside of the range (2D area) defined by the first
       // line (via the first two control points); if it is outside, clip it to the bounds
       const Point2D p1 = this->GetControlPoint( 0 );
       const Point2D p2 = this->GetControlPoint( 1 );
 
       //const Point2D& p1 = m_ControlPoints->ElementAt( 0 );
       //const Point2D& p2 = m_ControlPoints->ElementAt( 1 );
 
       Vector2D n1 = p2 - p1;
       n1.Normalize();
 
       Vector2D v1 = point - p1;
       double dotProduct = n1 * v1;
       Point2D crossPoint = p1 + n1 * dotProduct;;
       Vector2D crossVector = point - crossPoint;
 
       if ( dotProduct < 0.0 )
       {
         // Out-of-bounds on the left: clip point to left boundary
         return (p1 + crossVector);
       }
       else if ( dotProduct > p2.EuclideanDistanceTo( p1 ) )
       {
         // Out-of-bounds on the right: clip point to right boundary
         return (p2 + crossVector);
       }
       else
       {
         // Pass back original point
         return point;
       }
     }
 
   case 3:
     {
       // Constrain 4th control point so that with the 3rd control point it forms
       // a line orthogonal to the first line (constraint 1); the 4th control point
       // must lie on the opposite side of the line defined by the first two control
       // points than the 3rd control point (constraint 2)
       const Point2D p1 = this->GetControlPoint( 0 );
       const Point2D p2 = this->GetControlPoint( 1 );
       const Point2D p3 = this->GetControlPoint( 2 );
      
       //const Point2D& p1 = m_ControlPoints->ElementAt( 0 );
       //const Point2D& p2 = m_ControlPoints->ElementAt( 1 );
       //const Point2D& p3 = m_ControlPoints->ElementAt( 2 );
 
       // Calculate distance of original point from orthogonal line the corrected
       // point should lie on to project the point onto this line
       Vector2D n1 = p2 - p1;
       n1.Normalize();
 
       Vector2D v1 = point - p3;
       double dotProduct1 = n1 * v1;
 
       Point2D pointOnLine = point - n1 * dotProduct1;
 
       // Project new point onto line [p1, p2]
       Vector2D v2 = pointOnLine - p1;
       double dotProduct2 = n1 * v2;
 
       Point2D crossingPoint = p1 + n1 * dotProduct2;
 
       // Determine whether the projected point on the line, or the crossing point should be
       // used (according to the second constraint in the comment above)
       if ( (pointOnLine.SquaredEuclideanDistanceTo( p3 ) > crossingPoint.SquaredEuclideanDistanceTo( p3 ))
         && (pointOnLine.SquaredEuclideanDistanceTo( p3 ) > pointOnLine.SquaredEuclideanDistanceTo( crossingPoint )) )
       {
         return pointOnLine;
       }
       else
       {
         return crossingPoint;
       }
     }
 
   default:
     return point;
   }
 }
 
 
 void mitk::PlanarCross::GeneratePolyLine()
 {
   this->SetNumberOfPolyLines( 1 );
 
   this->ClearPolyLines();
 
   //m_PolyLines->Initialize();
 
   //m_PolyLines->InsertElement( 0, VertexContainerType::New() );
   //m_PolyLines->ElementAt( 0 )->Reserve( 2 );
   if ( this->GetNumberOfControlPoints() > 2)
   {
     this->SetNumberOfPolyLines( 2 );
     //m_PolyLines->InsertElement( 1, VertexContainerType::New() );
     //m_PolyLines->ElementAt( 1 )->Reserve( this->GetNumberOfControlPoints() - 2 );
   }
 
   for ( unsigned int i = 0; i < this->GetNumberOfControlPoints(); ++i )
   {
     if (i < 2)
     {
       this->AppendPointToPolyLine( 0, mitk::PlanarFigure::PolyLineElement( this->GetControlPoint( i ), i ) );
     }
     if (i > 1)
     {
       this->AppendPointToPolyLine( 1, mitk::PlanarFigure::PolyLineElement( this->GetControlPoint( i ), i ) );
     }
 
 
     //if (i < 2)
     //{
     //  m_PolyLines->ElementAt( 0 )->ElementAt( i ) = m_ControlPoints->ElementAt( i );
     //}
     //if (i > 1)
     //{
     //  m_PolyLines->ElementAt( 1 )->ElementAt( i-2 ) = m_ControlPoints->ElementAt( i );
     //}
   }
 }
 
 void mitk::PlanarCross::GenerateHelperPolyLine(double /*mmPerDisplayUnit*/, unsigned int /*displayHeight*/)
 {
   // Generate helper polyline (orientation line orthogonal to first line)
   // if the third control point is currently being set
   if ( this->GetNumberOfControlPoints() != 3 )
   {
     m_HelperPolyLinesToBePainted->SetElement( 0, false );
     return;
   }
 
   m_HelperPolyLinesToBePainted->SetElement( 0, true );
 
   this->ClearHelperPolyLines();
 
   // Calculate cross point of first line (p1 to p2) and orthogonal line through
   // the third control point (p3)
   const Point2D p1 = this->GetControlPoint( 0 );
   const Point2D p2 = this->GetControlPoint( 1 );
   const Point2D p3 = this->GetControlPoint( 2 );
 
   //const Point2D& p1 = m_ControlPoints->ElementAt( 0 );
   //const Point2D& p2 = m_ControlPoints->ElementAt( 1 );
   //const Point2D& p3 = m_ControlPoints->ElementAt( 2 );
 
   Vector2D n1 = p2 - p1;
   n1.Normalize();
 
   Vector2D v1 = p3 - p1;
   Point2D crossPoint = p1 + n1 * (n1 * v1);
 
   Vector2D v2 = crossPoint - p3;
   if ( v2.GetNorm() < 1.0 )
   {
     // If third point is on the first line, draw orthogonal "infinite" line
     // through cross point on line
     Vector2D v0;
     v0[0] = n1[1];
     v0[1] = -n1[0];
     this->AppendPointToHelperPolyLine( 0, mitk::PlanarFigure::PolyLineElement( p3 - v0 * 10000.0, 0 ) ) ;
     this->AppendPointToHelperPolyLine( 0, mitk::PlanarFigure::PolyLineElement( p3 + v0 * 10000.0, 0 ) ) ;
 
     //m_HelperPolyLines->ElementAt( 0 )->ElementAt( 0 ) = p3 - v0 * 10000.0;
     //m_HelperPolyLines->ElementAt( 0 )->ElementAt( 1 ) = p3 + v0 * 10000.0;
   }
   else
   {
     // Else, draw orthogonal line starting from third point and crossing the
     // first line, open-ended only on the other side
     this->AppendPointToHelperPolyLine( 0, mitk::PlanarFigure::PolyLineElement( p3, 0 ) ) ;
     this->AppendPointToHelperPolyLine( 0, mitk::PlanarFigure::PolyLineElement( p3 + v2 * 10000.0, 0 ) ) ;
 
     //m_HelperPolyLines->ElementAt( 0 )->ElementAt( 0 ) = p3;
     //m_HelperPolyLines->ElementAt( 0 )->ElementAt( 1 ) = p3 + v2 * 10000.0;
   }
 }
 
   
 void mitk::PlanarCross::EvaluateFeaturesInternal()
 {
   // Calculate length of first line
   const Point3D &p0 = this->GetWorldControlPoint( 0 );
   const Point3D &p1 = this->GetWorldControlPoint( 1 );
   double l1 = p0.EuclideanDistanceTo( p1 );
 
   // Calculate length of second line
   double l2 = 0.0;
   if ( !this->GetSingleLineMode() && (this->GetNumberOfControlPoints() > 3) )
   {
     const Point3D &p2 = this->GetWorldControlPoint( 2 );
     const Point3D &p3 = this->GetWorldControlPoint( 3 );
     l2 = p2.EuclideanDistanceTo( p3 );
   }
 
   double longestDiameter;
   double shortAxisDiameter;
   if ( l1 > l2 )
   {
     longestDiameter = l1;
     shortAxisDiameter = l2;
   }
   else
   {
     longestDiameter = l2;
     shortAxisDiameter = l1;
   }
 
 
   this->SetQuantity( FEATURE_ID_LONGESTDIAMETER, longestDiameter );
   this->SetQuantity( FEATURE_ID_SHORTAXISDIAMETER, shortAxisDiameter );
 }
 
 
 void mitk::PlanarCross::PrintSelf( std::ostream& os, itk::Indent indent) const
 {
   Superclass::PrintSelf( os, indent );
 }
diff --git a/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.cpp b/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.cpp
index 4a0e215b21..cf6d0688f2 100644
--- a/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.cpp
+++ b/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.cpp
@@ -1,645 +1,647 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-07-08 11:04:08 +0200 (Mi, 08 Jul 2009) $
 Version:   $Revision: 18029 $
 
 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 "mitkPlanarFigure.h"
 #include "mitkGeometry2D.h"
 #include "mitkProperties.h"
 
 #include "algorithm"
 
 
 mitk::PlanarFigure::PlanarFigure()
 : m_FigurePlaced( false ),
 m_PreviewControlPointVisible( false ),
 m_SelectedControlPoint( -1 ),
 m_Geometry2D( NULL ),
 m_PolyLineUpToDate(false),
 m_HelperLinesUpToDate(false),
 m_FeaturesUpToDate(false),
 m_FeaturesMTime( 0 )
 {
   m_HelperPolyLinesToBePainted = BoolContainerType::New();
 
   this->SetProperty( "closed", mitk::BoolProperty::New( false ) );
 
   // Currently only single-time-step geometries are supported
   this->InitializeTimeSlicedGeometry( 1 );
 }
 
 
 mitk::PlanarFigure::~PlanarFigure()
 {
 }
 
 
 void mitk::PlanarFigure::SetGeometry2D( mitk::Geometry2D *geometry )
 {
   this->SetGeometry( geometry );
   m_Geometry2D = geometry;
 }
 
 
 const mitk::Geometry2D *mitk::PlanarFigure::GetGeometry2D() const
 {
   return m_Geometry2D;
 }
 
 
 bool mitk::PlanarFigure::IsClosed() const
 {
   mitk::BoolProperty* closed = dynamic_cast< mitk::BoolProperty* >( this->GetProperty( "closed" ).GetPointer() );
   if ( closed != NULL )
   {
     return closed->GetValue();
   }
   return false;
 }
 
 
 void mitk::PlanarFigure::PlaceFigure( const mitk::Point2D& point )
 {
   for ( unsigned int i = 0; i < this->GetNumberOfControlPoints(); ++i )
   {
     m_ControlPoints.push_back( point );
   }
 
   m_FigurePlaced = true;
   m_SelectedControlPoint = 1;
 }
 
 
 bool mitk::PlanarFigure::AddControlPoint( const mitk::Point2D& point, int position )
 {
   if ( m_NumberOfControlPoints < this->GetMaximumNumberOfControlPoints() )
   {
     if ( position == -1 || position > m_NumberOfControlPoints-1 )
     {
       m_ControlPoints.push_back( this->ApplyControlPointConstraints( m_NumberOfControlPoints, point ) );
       m_SelectedControlPoint = m_NumberOfControlPoints;
     }
     else
     {
       ControlPointListType::iterator iter = m_ControlPoints.begin() + position;
       m_ControlPoints.insert( iter, this->ApplyControlPointConstraints( m_NumberOfControlPoints, point ) );
       m_SelectedControlPoint = m_NumberOfControlPoints;
     }
 
     m_PolyLineUpToDate = false;
     m_HelperLinesUpToDate = false;
     m_FeaturesUpToDate = false;
 
     ++m_NumberOfControlPoints;
     return true;
   }
   else
   {
     return false;
   }
 }
 
 
 bool mitk::PlanarFigure::SetControlPoint( unsigned int index, const Point2D& point, bool createIfDoesNotExist )
 {
   bool controlPointSetCorrectly = false;
   if (createIfDoesNotExist)
   {
     if ( m_NumberOfControlPoints <= index )
     {
       m_ControlPoints.push_back( this->ApplyControlPointConstraints( index, point ) );
       m_NumberOfControlPoints++;
     }
     else
     {
       m_ControlPoints.at( index ) = this->ApplyControlPointConstraints( index, point );
     }
     controlPointSetCorrectly = true;
   }
   else if ( index < m_NumberOfControlPoints )
   {
     m_ControlPoints.at( index ) = this->ApplyControlPointConstraints( index, point );
     controlPointSetCorrectly = true;
   }
   else
   {
     return false;
   }
 
   if ( controlPointSetCorrectly )
   {
     m_PolyLineUpToDate = false;
     m_HelperLinesUpToDate = false;
     m_FeaturesUpToDate = false;
   }
 
   return controlPointSetCorrectly;
 }
 
 
 bool mitk::PlanarFigure::SetCurrentControlPoint( const Point2D& point )
 {
   if ( (m_SelectedControlPoint < 0) || (m_SelectedControlPoint >= (int)m_NumberOfControlPoints) )
   {
     return false;
   }
 
   return this->SetControlPoint(m_SelectedControlPoint, point, false);
 }
 
 
 unsigned int mitk::PlanarFigure::GetNumberOfControlPoints() const
 {
   return m_NumberOfControlPoints;
 }
 
 
 bool mitk::PlanarFigure::SelectControlPoint( unsigned int index )
 {
   if ( index < this->GetNumberOfControlPoints() )
   {
     m_SelectedControlPoint = index;
     return true;
   }
   else
   {
     return false;
   }
 }
 
 
 void mitk::PlanarFigure::DeselectControlPoint()
 {
   m_SelectedControlPoint = -1;
 }
 
 void mitk::PlanarFigure::SetPreviewControlPoint( const Point2D& point )
 {
   m_PreviewControlPoint = point;
   m_PreviewControlPointVisible = true;
 }
 
 void mitk::PlanarFigure::ResetPreviewContolPoint()
 {
   m_PreviewControlPointVisible = false;
 }
 
 mitk::Point2D mitk::PlanarFigure::GetPreviewControlPoint()
 {
   return m_PreviewControlPoint;
 }
 
 bool mitk::PlanarFigure::IsPreviewControlPointVisible()
 {
   return m_PreviewControlPointVisible;
 }
 
 mitk::Point2D mitk::PlanarFigure::GetControlPoint( unsigned int index ) const
 {
   if ( index < m_NumberOfControlPoints )
   {
     return m_ControlPoints.at( index );
   }
 
   itkExceptionMacro( << "GetControlPoint(): Invalid index!" );
 }
 
 
 mitk::Point3D mitk::PlanarFigure::GetWorldControlPoint( unsigned int index ) const
 {
   Point3D point3D;
   if ( (m_Geometry2D != NULL) && (index < m_NumberOfControlPoints) )
   {
     m_Geometry2D->Map( m_ControlPoints.at( index ), point3D );
     return point3D;
   }
 
   itkExceptionMacro( << "GetWorldControlPoint(): Invalid index!" );
 }
 
 
 const mitk::PlanarFigure::PolyLineType
 mitk::PlanarFigure::GetPolyLine(unsigned int index)
 {
   mitk::PlanarFigure::PolyLineType polyLine;
   if ( m_PolyLines.size() > index )
   {
     if ( !m_PolyLineUpToDate )
     {
       this->GeneratePolyLine();
       m_PolyLineUpToDate = true;
     }
 
     polyLine = m_PolyLines.at( index );
   }
 
   return polyLine;
 }
 
 
 const mitk::PlanarFigure::PolyLineType
 mitk::PlanarFigure::GetPolyLine(unsigned int index) const
 {
   return m_PolyLines.at( index );
 }
 
 void mitk::PlanarFigure::ClearPolyLines()
 {
   for ( int i=0; i<m_PolyLines.size(); i++ )
   {
     m_PolyLines.at( i ).clear();
   }
   m_PolyLineUpToDate = false;  
 }
 
 const mitk::PlanarFigure::PolyLineType mitk::PlanarFigure::GetHelperPolyLine( unsigned int index, double mmPerDisplayUnit, unsigned int displayHeight )
 {
   mitk::PlanarFigure::PolyLineType helperPolyLine;
   if ( index < m_HelperPolyLines.size() )
   {
     if ( !m_HelperLinesUpToDate )
     {
       this->GenerateHelperPolyLine(mmPerDisplayUnit, displayHeight);
       m_HelperLinesUpToDate = true;
     }
 
     helperPolyLine = m_HelperPolyLines.at(index);
   }
 
   return helperPolyLine;
 }
 
 void mitk::PlanarFigure::ClearHelperPolyLines()
 {
   for ( int i=0; i<m_HelperPolyLines.size(); i++ )
   {
     m_HelperPolyLines.at(i).clear();
   }
   m_HelperLinesUpToDate = false;
 }
 
 /** \brief Returns the number of features available for this PlanarFigure
 * (such as, radius, area, ...). */
 unsigned int mitk::PlanarFigure::GetNumberOfFeatures() const
 {
   return m_Features.size();
 }
 
 
 const char *mitk::PlanarFigure::GetFeatureName( unsigned int index ) const
 {
   if ( index < m_Features.size() )
   {
     return m_Features[index].Name.c_str();
   }
   else
   {
     return NULL;
   }
 }
 
 
 const char *mitk::PlanarFigure::GetFeatureUnit( unsigned int index ) const
 {
   if ( index < m_Features.size() )
   {
     return m_Features[index].Unit.c_str();
   }
   else
   {
     return NULL;
   }
 }
 
 
 double mitk::PlanarFigure::GetQuantity( unsigned int index ) const
 {
   if ( index < m_Features.size() )
   {
     return m_Features[index].Quantity;
   }
   else
   {
     return 0.0;
   }
 }
 
 
 bool mitk::PlanarFigure::IsFeatureActive( unsigned int index ) const
 {
   if ( index < m_Features.size() )
   {
     return m_Features[index].Active;
   }
   else
   {
     return false;
   }
 }
 
 
 void mitk::PlanarFigure::EvaluateFeatures()
 {
   if ( !m_FeaturesUpToDate )
   {
     this->EvaluateFeaturesInternal();
 
     m_FeaturesUpToDate = true;
   }
 }
 
 
 void mitk::PlanarFigure::UpdateOutputInformation()
 {
   // Bounds are NOT calculated here, since the Geometry2D defines a fixed
   // frame (= bounds) for the planar figure.
   Superclass::UpdateOutputInformation();
   this->GetTimeSlicedGeometry()->UpdateInformation();
 }
 
 
 void mitk::PlanarFigure::SetRequestedRegionToLargestPossibleRegion()
 {
 }
 
 
 bool mitk::PlanarFigure::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
   return false;
 }
 
 
 bool mitk::PlanarFigure::VerifyRequestedRegion()
 {
   return true;
 }
 
 
 void mitk::PlanarFigure::SetRequestedRegion( itk::DataObject * /*data*/ )
 {
 
 }
 
 
 void mitk::PlanarFigure::ResetNumberOfControlPoints( int numberOfControlPoints )
 {
   m_NumberOfControlPoints = numberOfControlPoints;
 }
 
 
 mitk::Point2D mitk::PlanarFigure::ApplyControlPointConstraints( unsigned int /*index*/, const Point2D& point )
 {
   if ( m_Geometry2D ==  NULL )
   {
     return point;
   }
 
   Point2D indexPoint;
   m_Geometry2D->WorldToIndex( point, indexPoint );
 
   BoundingBox::BoundsArrayType bounds = m_Geometry2D->GetBounds();
   if ( indexPoint[0] < bounds[0] ) { indexPoint[0] = bounds[0]; }
   if ( indexPoint[0] > bounds[1] ) { indexPoint[0] = bounds[1]; }
   if ( indexPoint[1] < bounds[2] ) { indexPoint[1] = bounds[2]; }
   if ( indexPoint[1] > bounds[3] ) { indexPoint[1] = bounds[3]; }
 
   Point2D constrainedPoint;
   m_Geometry2D->IndexToWorld( indexPoint, constrainedPoint );
 
   return constrainedPoint;
 }
 
 
 unsigned int mitk::PlanarFigure::AddFeature( const char *featureName, const char *unitName )
 {
   unsigned int index = m_Features.size();
 
   Feature newFeature( featureName, unitName );
   m_Features.push_back( newFeature );
 
   return index;
 }
 
 
 void mitk::PlanarFigure::SetFeatureName( unsigned int index, const char *featureName )
 {
   if ( index < m_Features.size() )
   {
     m_Features[index].Name = featureName;
   }
 }
 
 
 void mitk::PlanarFigure::SetFeatureUnit( unsigned int index, const char *unitName )
 {
   if ( index < m_Features.size() )
   {
     m_Features[index].Unit = unitName;
   }
 }
 
 
 void mitk::PlanarFigure::SetQuantity( unsigned int index, double quantity )
 {
   if ( index < m_Features.size() )
   {
     m_Features[index].Quantity = quantity;
   }
 }
 
 
 void mitk::PlanarFigure::ActivateFeature( unsigned int index )
 {
   if ( index < m_Features.size() )
   {
     m_Features[index].Active = true;
   }
 }
 
 
 void mitk::PlanarFigure::DeactivateFeature( unsigned int index )
 {
   if ( index < m_Features.size() )
   {
     m_Features[index].Active = false;
   }
 }
 
 
 void mitk::PlanarFigure::InitializeTimeSlicedGeometry( unsigned int timeSteps )
 {
   mitk::TimeSlicedGeometry::Pointer timeGeometry = this->GetTimeSlicedGeometry();
 
   mitk::Geometry2D::Pointer geometry2D = mitk::Geometry2D::New();
   geometry2D->Initialize();
 
   if ( timeSteps > 1 )
   {
     mitk::ScalarType timeBounds[] = {0.0, 1.0};
     geometry2D->SetTimeBounds( timeBounds );
   }
 
   // The geometry is propagated automatically to all time steps,
   // if EvenlyTimed is true...
   timeGeometry->InitializeEvenlyTimed( geometry2D, timeSteps );
 }
 
 
 void mitk::PlanarFigure::PrintSelf( std::ostream& os, itk::Indent indent) const
 {
   Superclass::PrintSelf( os, indent );
   os << indent << this->GetNameOfClass() << ":\n";
 
   if (this->IsClosed())
     os << indent << "This figure is closed\n";
   else
     os << indent << "This figure is not closed\n";
   os << indent << "Minimum number of control points: " << this->GetMinimumNumberOfControlPoints() << std::endl;
   os << indent << "Maximum number of control points: " << this->GetMaximumNumberOfControlPoints() << std::endl;
   os << indent << "Current number of control points: " << this->GetNumberOfControlPoints() << std::endl;
   os << indent << "Control points:" << std::endl;
-  mitk::PlanarFigure::VertexContainerType::ConstIterator it;  
+
   for ( unsigned int i = 0; i < this->GetNumberOfControlPoints(); ++i )
   {
     //os << indent.GetNextIndent() << i << ": " << m_ControlPoints->ElementAt( i ) << std::endl;
     os << indent.GetNextIndent() << i << ": " << m_ControlPoints.at( i ) << std::endl;
   }
   os << indent << "Geometry:\n";
   this->GetGeometry2D()->Print(os, indent.GetNextIndent());
 }
 
 
 unsigned short mitk::PlanarFigure::GetPolyLinesSize()
 {
   if ( !m_PolyLineUpToDate )
   {
     this->GeneratePolyLine();
     m_PolyLineUpToDate = true;
   }
   return m_PolyLines.size();
 }
 
 
 unsigned short mitk::PlanarFigure::GetHelperPolyLinesSize()
 {
   return m_HelperPolyLines.size();
 }
 
 
 bool mitk::PlanarFigure::IsHelperToBePainted(unsigned int index)
 {
   return m_HelperPolyLinesToBePainted->GetElement( index );
 }
 
 
 bool mitk::PlanarFigure::ResetOnPointSelect()
 {
   return false;
 }
 
 void mitk::PlanarFigure::RemoveControlPoint( unsigned int index )
 {
   if ( index > m_ControlPoints.size() )
     return;
 
   if ( (m_ControlPoints.size() -1)  < this->GetMinimumNumberOfControlPoints() )
     return;
 
   ControlPointListType::iterator iter;
   iter = m_ControlPoints.begin() + index;
 
   m_ControlPoints.erase( iter );
 
   m_PolyLineUpToDate = false;
   m_HelperLinesUpToDate = false;
   m_FeaturesUpToDate = false;
 
   --m_NumberOfControlPoints;
 }
 
 void mitk::PlanarFigure::RemoveLastControlPoint()
 {
   RemoveControlPoint( m_ControlPoints.size()-1 );
 }
 
 void mitk::PlanarFigure::DeepCopy(Self::Pointer oldFigure)
 {
   //DeepCopy only same types of planar figures 
   //Notice to get typeid polymorph you have to use the *operator
   if(typeid(*oldFigure) != typeid(*this))
   {
     itkExceptionMacro( << "DeepCopy(): Inconsistent type of source and destination figure!" );
     return;
   }
 
   m_ControlPoints.clear();
   this->ClearPolyLines();
   this->ClearHelperPolyLines();
 
   // clone base data members
   SetPropertyList(oldFigure->GetPropertyList()->Clone());  
 
   /// deep copy members
   m_FigurePlaced                = oldFigure->m_FigurePlaced;
   m_SelectedControlPoint        = oldFigure->m_SelectedControlPoint;
   m_FeaturesMTime               = oldFigure->m_FeaturesMTime;
   m_Features                    = oldFigure->m_Features;
   m_NumberOfControlPoints       = oldFigure->m_NumberOfControlPoints;
 
   //copy geometry 2D of planar figure
   SetGeometry2D((mitk::Geometry2D*)oldFigure->m_Geometry2D->Clone().GetPointer());
 
   for(unsigned long index=0; index < oldFigure->GetNumberOfControlPoints(); index++)
   {
     m_ControlPoints.push_back( oldFigure->GetControlPoint( index ));
   }
 
   //After setting the control points we can generate the polylines
   this->GeneratePolyLine();
 }
 
 void mitk::PlanarFigure::SetNumberOfPolyLines( unsigned int numberOfPolyLines )
 {
   m_PolyLines.resize(numberOfPolyLines);
 }
 
 void mitk::PlanarFigure::SetNumberOfHelperPolyLines( unsigned int numberOfHerlperPolyLines )
 {
   m_HelperPolyLines.resize(numberOfHerlperPolyLines);
 }
 
 
 void mitk::PlanarFigure::AppendPointToPolyLine( unsigned int index, PolyLineElement element )
 {
   if ( index < m_PolyLines.size() )
+  {
     m_PolyLines.at( index ).push_back( element );
+  }
   else
+  {
     MITK_ERROR << "Tried to add point to PolyLine " << index+1 << ", although only " << m_PolyLines.size() << " exists";
+  }
 }
 
 void mitk::PlanarFigure::AppendPointToHelperPolyLine( unsigned int index, PolyLineElement element )
 {
   if ( index < m_HelperPolyLines.size() )
+  {
     m_HelperPolyLines.at( index ).push_back( element );
+  }
   else
+  {
     MITK_ERROR << "Tried to add point to HelperPolyLine " << index+1 << ", although only " << m_HelperPolyLines.size() << " exists";
+  }
 }
-
-const mitk::PlanarFigure::PolyLineType mitk::PlanarFigure::GetPolyline( int index ) const
-{
-  return m_PolyLines.at( index );
-}
-
diff --git a/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.h b/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.h
index 6fe71c7a46..e44f860130 100644
--- a/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.h
+++ b/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.h
@@ -1,389 +1,384 @@
 /*=========================================================================
 
 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_H_
 #define _MITK_PLANAR_FIGURE_H_
 
 #include "PlanarFigureExports.h"
 #include "mitkBaseData.h"
 #include "mitkCommon.h"
 
 #include <deque>
 
 
 namespace mitk 
 {
 
 class Geometry2D;
 
 /**
  * \brief Base-class for geometric planar (2D) figures, such as
  * lines, circles, rectangles, polygons, etc.
  *
  * \warning Currently does not support time-resolved data handling
  *
  * Behavior and appearance of PlanarFigures are controlled by various properties; for a detailed
  * list of appearance properties see mitk::PlanarFigureMapper2D
  *
  * The following properties control general PlanarFigure behavior:
  *
  * <ul>
  *   <li>"selected": true if the planar figure is selected
  *   <li>"planarfigure.ishovering": true if the mouse "hovers" over the planar figure
  *   <li>"planarfigure.iseditable": true if the planar figure can be edited (otherwise,
  *       it can only be picked/selected, but its control points cannot be edited); default is true
  *   <li>"planarfigure.isextendable": true if new control points can be inserted into the list of control points;
  *        default is false
  * </ul>
  *
  *
  * TODO: Implement local 2D transform (including center of rotation...)
  *
  */
 class PlanarFigure_EXPORT PlanarFigure : public BaseData
 {
 public:
   mitkClassMacro( PlanarFigure, BaseData );
 
   struct PolyLineElement
   {
     PolyLineElement( Point2D point, int index )
       : Point( point ), Index( index )
     {
     };
 
     Point2D Point;
     int Index;
   };
 
-  typedef itk::VectorContainer< unsigned long, mitk::Point2D > VertexContainerType;
-  typedef itk::VectorContainer< unsigned long, VertexContainerType::Pointer> VertexContainerVectorType;
   typedef itk::VectorContainer< unsigned long, bool>  BoolContainerType;
 
   typedef std::deque< Point2D > ControlPointListType;
   typedef std::list< PolyLineElement > PolyLineType;
 
 
   /** \brief Sets the 2D geometry on which this figure will be placed.
    *
    * In most cases, this is a Geometry already owned by another object, e.g.
    * describing the slice of the image on which measurements will be
    * performed.
    */
   virtual void SetGeometry2D( mitk::Geometry2D *geometry );
 
 
   /** \brief Returns (previously set) 2D geometry of this figure. */
   virtual const Geometry2D *GetGeometry2D() const;
 
 
   /** \brief True if the planar figure is closed.
    *
    * Default is false. The "closed" boolean property must be set in sub-classes. */
   virtual bool IsClosed() const;
 
   
   /** \brief True if the planar figure has been placed (and can be
    * displayed/interacted with). */
   virtual bool IsPlaced() const { return m_FigurePlaced; };
 
 
   /** \brief Place figure at the given point (in 2D index coordinates) onto
    * the given 2D geometry.
    *
    * By default, the first two control points of the figure are set to the
    * passed point. Further points can be set via AddControlPoint(), if the
    * current number of control points is below the maximum number of control
    * points.
    *
    * Can be re-implemented in sub-classes as needed.
    */
   virtual void PlaceFigure( const Point2D& point );
 
 
   virtual bool AddControlPoint( const Point2D& point, int index = -1 );
 
   virtual bool SetControlPoint( unsigned int index, const Point2D& point, bool createIfDoesNotExist = false);
 
   virtual bool SetCurrentControlPoint( const Point2D& point );
 
    
   /** \brief Returns the current number of 2D control points defining this figure. */
   unsigned int GetNumberOfControlPoints() const;
 
 
   /** \brief Returns the minimum number of control points needed to represent
    * this figure.
    *
    * Must be implemented in sub-classes.
    */
   virtual unsigned int GetMinimumNumberOfControlPoints() const = 0;
 
 
   /** \brief Returns the maximum number of control points allowed for
   * this figure (e.g. 3 for triangles).
   *
   * Must be implemented in sub-classes.
   */
   virtual unsigned int GetMaximumNumberOfControlPoints() const = 0;
 
 
   /** \brief Selects currently active control points. */
   virtual bool SelectControlPoint( unsigned int index );
 
   
   /** \brief Deselect control point; no control point active. */
   virtual void DeselectControlPoint();
 
 
   /** \brief Return currently selected control point. */
   virtual int GetSelectedControlPoint() const { return m_SelectedControlPoint; }
 
   /** \brief Returns specified control point in 2D world coordinates. */
   Point2D GetControlPoint( unsigned int index ) const;
 
 
   /** \brief Returns specified control point in world coordinates. */
   Point3D GetWorldControlPoint( unsigned int index ) const;
 
 
-  /** \brief defines the number of PolyLines that will be available */
-  void SetNumberOfPolyLines( unsigned int numberOfPolyLines );
-
-  /** \brief returns the PolyLine for the given index. */
-  const PolyLineType GetPolyline( int index ) const;
-
-  /** \brief Append a point to the PolyLine # index */
-  void AppendPointToPolyLine( unsigned int index, PolyLineElement element );
-
-  /** \brief clears the list of PolyLines. Call before re-calculating a new Polyline. */
-  void ClearPolyLines();
-
-
-  /** \brief defines the number of HelperPolyLines that will be available */
-  void SetNumberOfHelperPolyLines( unsigned int numberOfHelperPolyLines );
-
-  /** \brief Append a point to the HelperPolyLine # index */
-  void AppendPointToHelperPolyLine( unsigned int index, PolyLineElement element );
-
-  /** \brief clears the list of HelperPolyLines. Call before re-calculating a new HelperPolyline. */
-  void ClearHelperPolyLines();
-
-
-
   /** \brief Returns the polyline representing the planar figure
    * (for rendering, measurements, etc.). */
   const PolyLineType GetPolyLine(unsigned int index);
 
   /** \brief Returns the polyline representing the planar figure
    * (for rendering, measurments, etc.). */
   const PolyLineType GetPolyLine(unsigned int index) const;
 
   /** \brief Returns the polyline that should be drawn the same size at every scale
    * (for text, angles, etc.). */
   const PolyLineType GetHelperPolyLine( unsigned int index, double mmPerDisplayUnit, unsigned int displayHeight );
  
   
   /** \brief Sets the position of the PreviewControlPoint. Automatically sets it visible.*/
   void SetPreviewControlPoint( const Point2D& point );
   
   /** \brief Marks the PreviewControlPoint as invisible.*/
   void ResetPreviewContolPoint();
   
   /** \brief Returns whether or not the PreviewControlPoint is visible.*/
   bool IsPreviewControlPointVisible();
 
   /** \brief Returns the coordinates of the PreviewControlPoint. */
   Point2D GetPreviewControlPoint();
 
 
   
   /** \brief Returns the number of features available for this PlanarFigure
    * (such as, radius, area, ...). */
   virtual unsigned int GetNumberOfFeatures() const;
 
 
   /** \brief Returns the name (identifier) of the specified features. */
   const char *GetFeatureName( unsigned int index ) const;
 
 
   /** \brief Returns the physical unit of the specified features. */
   const char *GetFeatureUnit( unsigned int index ) const;
 
 
   /** Returns quantity of the specified feature (e.g., length, radius,
    * area, ... ) */
   double GetQuantity( unsigned int index ) const;
 
   
   /** \brief Returns true if the feature with the specified index exists and
   * is active (an inactive feature may e.g. be the area of a non-closed
   * polygon. */
   bool IsFeatureActive( unsigned int index ) const;
 
 
   /** \brief Calculates quantities of all features of this planar figure. */
   virtual void EvaluateFeatures();
 
 
   /** \brief Intherited from parent */
   virtual void UpdateOutputInformation();
 
   /** \brief Intherited from parent */
   virtual void SetRequestedRegionToLargestPossibleRegion();
 
   /** \brief Intherited from parent */
   virtual bool RequestedRegionIsOutsideOfTheBufferedRegion();
 
   /** \brief Intherited from parent */
   virtual bool VerifyRequestedRegion();
 
   /** \brief Intherited from parent */
   virtual void SetRequestedRegion(itk::DataObject *data);
  
   /** \brief  Returns the current number of polylines  */
   virtual unsigned short GetPolyLinesSize();
 
   /** \brief  Returns the current number of helperpolylines  */
   virtual unsigned short GetHelperPolyLinesSize();
 
   /** \brief Returns whether a helper polyline should be painted or not */
   virtual bool IsHelperToBePainted(unsigned int index);
 
   /** \brief Returns true if the planar figure is reset to "add points" mode
    * when a point is selected.
    *
    * Default return value is false. Subclasses can overwrite this method and
    * execute any reset / initialization statements required. */
   virtual bool ResetOnPointSelect();
 
   virtual void RemoveControlPoint( unsigned int index );
 
   /** \brief Removes last control point */
   virtual void RemoveLastControlPoint();
 
   /** \brief Copies contents and state of a figre provided as parameter to the current object. 
              Requires a matching type of both figures. */
   void DeepCopy(Self::Pointer oldFigure);
 
 
 protected:
   PlanarFigure();
   virtual ~PlanarFigure();
 
   /** \brief Set the initial number of control points of the planar figure */
   void ResetNumberOfControlPoints( int numberOfControlPoints );
 
   /** \brief Allow sub-classes to apply constraints on control points.
   *
   * Sub-classes can define spatial constraints to certain control points by
   * overwriting this method and returning a constrained point. By default,
   * the points are constrained by the image bounds. */
   virtual Point2D ApplyControlPointConstraints( unsigned int /*index*/, const Point2D& point );
 
   /** Adds feature (e.g., circumference, radius, angle, ...) to feature vector
    * of a planar figure object and returns integer ID for the feature element.
    * Should be called in sub-class constructors. */
   virtual unsigned int AddFeature( const char *featureName, const char *unitName );
 
   /** Sets the name of the specified feature. INTERNAL METHOD. */
   void SetFeatureName( unsigned int index, const char *featureName );
 
   /** Sets the physical unit of the specified feature. INTERNAL METHOD. */
   void SetFeatureUnit( unsigned int index, const char *unitName );
 
   /** Sets quantity of the specified feature. INTERNAL METHOD. */
   void SetQuantity( unsigned int index, double quantity );
 
   /** Sets the specified feature as active. INTERAL METHOD. */
   void ActivateFeature( unsigned int index );
 
   /** Sets the specified feature as active. INTERAL METHOD. */
   void DeactivateFeature( unsigned int index );
 
   /** \brief Generates the poly-line representation of the planar figure.
    * Must be implemented in sub-classes. */
   virtual void GeneratePolyLine() = 0;
 
     /** \brief Generates the poly-lines that should be drawn the same size regardless of zoom.
    * Must be implemented in sub-classes. */
   virtual void GenerateHelperPolyLine(double mmPerDisplayUnit, unsigned int displayHeight) = 0;
 
   /** \brief Calculates quantities of all features of this planar figure.
    * Must be implemented in sub-classes. */
   virtual void EvaluateFeaturesInternal() = 0;
 
   /** \brief Initializes the TimeSlicedGeometry describing the (time-resolved)
    * geometry of this figure. Note that each time step holds one Geometry2D. */
   virtual void InitializeTimeSlicedGeometry( unsigned int timeSteps = 1 );
 
+  /** \brief defines the number of PolyLines that will be available */
+  void SetNumberOfPolyLines( unsigned int numberOfPolyLines );
+
+  /** \brief Append a point to the PolyLine # index */
+  void AppendPointToPolyLine( unsigned int index, PolyLineElement element );
+
+  /** \brief clears the list of PolyLines. Call before re-calculating a new Polyline. */
+  void ClearPolyLines();
+
+
+  /** \brief defines the number of HelperPolyLines that will be available */
+  void SetNumberOfHelperPolyLines( unsigned int numberOfHelperPolyLines );
+
+  /** \brief Append a point to the HelperPolyLine # index */
+  void AppendPointToHelperPolyLine( unsigned int index, PolyLineElement element );
+
+  /** \brief clears the list of HelperPolyLines. Call before re-calculating a new HelperPolyline. */
+  void ClearHelperPolyLines();
+
+
+
   virtual void PrintSelf( std::ostream& os, itk::Indent indent ) const;
 
   ControlPointListType m_ControlPoints;
   unsigned int m_NumberOfControlPoints;
 
   // Currently selected control point; -1 means no point selected
   int m_SelectedControlPoint;
 
 
   std::vector<PolyLineType> m_PolyLines;
   std::vector<PolyLineType> m_HelperPolyLines;
   BoolContainerType::Pointer m_HelperPolyLinesToBePainted;
 
   // this point is used to store the coordiantes an additional 'ControlPoint' that is rendered
   // when the mouse cursor is above the figure (and not a control-point) and when the 
   // property 'planarfigure.isextendable' is set to true
   Point2D m_PreviewControlPoint;
   bool m_PreviewControlPointVisible;
 
   bool m_FigurePlaced;
 
 private:
 
   struct Feature
   {
     Feature( const char *name, const char *unit ) 
     : Name( name ), Unit( unit ), Quantity( 0.0 ), Active( true )
     {
     };
 
     std::string Name;
     std::string Unit;
     double Quantity;
     bool Active;
   };
 
   Geometry2D *m_Geometry2D;
 
 
   bool m_PolyLineUpToDate;
   bool m_HelperLinesUpToDate;
   bool m_FeaturesUpToDate;
 
 
   // Vector of features available for this geometric figure
   typedef std::vector< Feature > FeatureVectorType;
   FeatureVectorType m_Features;
 
   unsigned long m_FeaturesMTime;
 
 };
 
 } // namespace mitk
 
 #endif //_MITK_PLANAR_FIGURE_H_
diff --git a/Modules/PlanarFigure/DataManagement/mitkPlanarLine.cpp b/Modules/PlanarFigure/DataManagement/mitkPlanarLine.cpp
index 00c2b98125..51f256d4f7 100644
--- a/Modules/PlanarFigure/DataManagement/mitkPlanarLine.cpp
+++ b/Modules/PlanarFigure/DataManagement/mitkPlanarLine.cpp
@@ -1,73 +1,67 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision: 18029 $
 
 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 "mitkPlanarLine.h"
 #include "mitkGeometry2D.h"
 
 
 mitk::PlanarLine::PlanarLine()
 : FEATURE_ID_LENGTH( this->AddFeature( "Length", "mm" ) )
 {
   // Line has two control points
   this->ResetNumberOfControlPoints( 2 );
 
   this->SetNumberOfPolyLines( 1 );
-
-  //m_PolyLines->InsertElement( 0, VertexContainerType::New());
 }
 
 
 mitk::PlanarLine::~PlanarLine()
 {
 }
 
 
 void mitk::PlanarLine::GeneratePolyLine()
 {
   this->ClearPolyLines();
   // TODO: start line at specified start point...
   // Generate poly-line 
   this->AppendPointToPolyLine( 0 , mitk::PlanarFigure::PolyLineElement( this->GetControlPoint(0), 0) );
   this->AppendPointToPolyLine( 0 , mitk::PlanarFigure::PolyLineElement( this->GetControlPoint(1), 0) );
-  
-  //m_PolyLines->ElementAt( 0 )->Reserve( 2 );
-  //m_PolyLines->ElementAt( 0 )->ElementAt( 0 ) = m_ControlPoints->ElementAt( 0 );
-  //m_PolyLines->ElementAt( 0 )->ElementAt( 1 ) = m_ControlPoints->ElementAt( 1 );
 }
 
 void mitk::PlanarLine::GenerateHelperPolyLine(double /*mmPerDisplayUnit*/, unsigned int /*displayHeight*/)
 {
   // A line does not require a helper object
 }
 
   
 void mitk::PlanarLine::EvaluateFeaturesInternal()
 {
   // Calculate line length
   const Point3D &p0 = this->GetWorldControlPoint( 0 );
   const Point3D &p1 = this->GetWorldControlPoint( 1 );
   double length = p0.EuclideanDistanceTo( p1 );
 
   this->SetQuantity( FEATURE_ID_LENGTH, length );
 }
 
 
 void mitk::PlanarLine::PrintSelf( std::ostream& os, itk::Indent indent) const
 {
   Superclass::PrintSelf( os, indent );
 }
diff --git a/Modules/PlanarFigure/DataManagement/mitkPlanarRectangle.cpp b/Modules/PlanarFigure/DataManagement/mitkPlanarRectangle.cpp
index 9e4cd23ed8..e1a101f9a2 100644
--- a/Modules/PlanarFigure/DataManagement/mitkPlanarRectangle.cpp
+++ b/Modules/PlanarFigure/DataManagement/mitkPlanarRectangle.cpp
@@ -1,154 +1,152 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-11-06 14:14:29 +0100 (Fri, 06 Nov 2009) $
 Version:   $Revision: 18029 $
 
 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 "mitkProperties.h"
 
 #include "mitkPlanarRectangle.h"
 #include "mitkGeometry2D.h"
 
 
 mitk::PlanarRectangle::PlanarRectangle()
 : FEATURE_ID_CIRCUMFERENCE( this->AddFeature( "Circumference", "mm" ) ),
   FEATURE_ID_AREA( this->AddFeature( "Area", "mm2" ) )
 {
   // Rectangle has four control points
   this->ResetNumberOfControlPoints( 4 );
   this->SetProperty( "closed", mitk::BoolProperty::New(true) );
   this->SetNumberOfPolyLines( 1 );
 }
 
 
 mitk::PlanarRectangle::~PlanarRectangle()
 {
 }
 
 
 bool mitk::PlanarRectangle::SetControlPoint( unsigned int index, const Point2D &point, bool createIfDoesNotExist )
 {
   // heres the deal with the rectangle:
   // when a point is moved all corresponding corner points are moved with him
   // e.g. if the lower right point (index=3) is moved the upper right point (index=1)
   // is moved in the same x direction
   // and the lower left point (index=2) is moved in the same y direction
   // the upper left point (index=0) is left untouched
   bool set = PlanarFigure::SetControlPoint( index, point, createIfDoesNotExist );
 
   if(set)
   {
     // can be made better ...
     unsigned int horizontalCorrespondingPointIndex = 1;
     unsigned int verticalCorrespondingPointIndex = 3;
     if(index == 1)
     {
       horizontalCorrespondingPointIndex = 0;
       verticalCorrespondingPointIndex = 2;
     }
     else if(index == 2)
     {
       horizontalCorrespondingPointIndex = 3;
       verticalCorrespondingPointIndex = 1;
     }
     else if(index == 3)
     {
       horizontalCorrespondingPointIndex = 2;
       verticalCorrespondingPointIndex = 0;
     }
 
     Point2D verticalCorrespondingPoint = GetControlPoint( verticalCorrespondingPointIndex );
     verticalCorrespondingPoint[0] = point[0];
     PlanarFigure::SetControlPoint( verticalCorrespondingPointIndex, verticalCorrespondingPoint );
 
     Point2D horizontalCorrespondingPoint = GetControlPoint( horizontalCorrespondingPointIndex );
     horizontalCorrespondingPoint[1] = point[1];
     PlanarFigure::SetControlPoint( horizontalCorrespondingPointIndex, horizontalCorrespondingPoint );
   }
 
   return set;
 }
 
 void mitk::PlanarRectangle::PlaceFigure( const mitk::Point2D &point )
 {
   PlanarFigure::PlaceFigure( point );
   m_SelectedControlPoint = 3;
 }
 
 void mitk::PlanarRectangle::GeneratePolyLine()
 {
   // TODO: start polygon at specified initalize point...
 
   ClearPolyLines();
-  PolyLineType polyLine = GetPolyline( 0 );
+  PolyLineType polyLine = GetPolyLine( 0 );
  
   for ( unsigned int i = 0; i < this->GetNumberOfControlPoints(); ++i )
   {
     AppendPointToPolyLine( 0, PolyLineElement( GetControlPoint(i), i ) );
   }
 }
 
 void mitk::PlanarRectangle::GenerateHelperPolyLine(double /*mmPerDisplayUnit*/, unsigned int /*displayHeight*/)
 {
   // A polygon does not require helper objects
 }
 
 void mitk::PlanarRectangle::EvaluateFeaturesInternal()
 {
   // Calculate circumference
   double circumference = 0.0;
   unsigned int i;
   for ( i = 0; i < this->GetNumberOfControlPoints(); ++i )
   {
     circumference += this->GetWorldControlPoint( i ).EuclideanDistanceTo( 
       this->GetWorldControlPoint( (i + 1) % this->GetNumberOfControlPoints() ) );
   }
 
   this->SetQuantity( FEATURE_ID_CIRCUMFERENCE, circumference );
 
 
   // Calculate rectangle area (well, done a bit clumsy...)
   double area = 0.0;
   if ( this->GetGeometry2D() != NULL )
   {
     for ( i = 0; i < this->GetNumberOfControlPoints(); ++i )
     {
       Point2D p0 = this->GetControlPoint( i );
       Point2D p1 = this->GetControlPoint( (i + 1) % this->GetNumberOfControlPoints() );
 
       area += p0[0] * p1[1] - p1[0] * p0[1];
     }
     area /= 2.0;
   }
   
   this->SetQuantity( FEATURE_ID_AREA, abs(area) );
 
 }
 
 
 void mitk::PlanarRectangle::PrintSelf( std::ostream& os, itk::Indent indent) const
 {
   Superclass::PrintSelf( os, indent );
 
   os << indent << "Number of control points: " << this->GetNumberOfControlPoints() << std::endl;
 
   os << indent << "Control points:" << std::endl;
 
-  mitk::PlanarFigure::VertexContainerType::ConstIterator it;
-
   for ( unsigned int i = 0; i < this->GetNumberOfControlPoints(); ++i )
   {
     os << indent << indent << i << ": " <<GetControlPoint( i ) << std::endl;
   }
 }
diff --git a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp
index 230b4d848e..e4407e4a66 100644
--- a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp
+++ b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp
@@ -1,581 +1,581 @@
 /*=========================================================================
 
 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 );
   }
 
   if ( planarFigure->IsPreviewControlPointVisible() )
   {
     this->DrawMarker( planarFigure->GetPreviewControlPoint(),
       m_MarkerlineColor[PF_HOVER],
       m_MarkerlineOpacity[PF_HOVER],
       m_MarkerColor[PF_HOVER],
       m_MarkerOpacity[PF_HOVER],
       m_LineWidth,
       m_ControlPointShape,
       planarFigureGeometry2D, 
       rendererGeometry2D, 
       displayGeometry 
       );
   }
 
   glLineWidth( 1.0f );
 }
 
 
 void mitk::PlanarFigureMapper2D::PaintPolyLine(
   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 ( PlanarFigure::PolyLineType::iterator iter = vertices.begin(); iter!=vertices.end(); iter++ )
   {
     // Draw this 2D point as OpenGL vertex
     mitk::Point2D displayPoint;
     this->TransformObjectToDisplay( iter->Point, displayPoint,
       planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
 
     if(iter == 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 )
   {
-    PlanarFigure::PolyLineType polyline = figure->GetPolyline(loop);
+    PlanarFigure::PolyLineType 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 )
   {
     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( helperPolyLine, 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 324287807e..3ab0d54ca5 100644
--- a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.h
+++ b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.h
@@ -1,233 +1,231 @@
 /*=========================================================================
 
 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( 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_ */