diff --git a/Modules/PlanarFigure/Algorithms/mitkExtrudePlanarFigureFilter.cpp b/Modules/PlanarFigure/Algorithms/mitkExtrudePlanarFigureFilter.cpp
index 9caec5b63e..8ada2bdc35 100644
--- a/Modules/PlanarFigure/Algorithms/mitkExtrudePlanarFigureFilter.cpp
+++ b/Modules/PlanarFigure/Algorithms/mitkExtrudePlanarFigureFilter.cpp
@@ -1,323 +1,323 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkPlanarFigure.h"
 #include <mitkExtrudePlanarFigureFilter.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkSurface.h>
 #include <vtkCellArray.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataNormals.h>
 #include <vtkPoints.h>
 #include <vtkSmartPointer.h>
 
 static mitk::Point2D GetCenterPoint(const mitk::PlanarFigure::PolyLineType& polyLine)
 {
   mitk::Point2D centerPoint;
 
   centerPoint[0] = 0;
   centerPoint[1] = 0;
 
   mitk::PlanarFigure::PolyLineType::const_iterator polyLineEnd = polyLine.end();
 
   for (mitk::PlanarFigure::PolyLineType::const_iterator polyLineIter = polyLine.begin(); polyLineIter != polyLineEnd; ++polyLineIter)
   {
-    centerPoint[0] += polyLineIter->Point[0];
-    centerPoint[1] += polyLineIter->Point[1];
+    centerPoint[0] += static_cast<mitk::Point2D>(*polyLineIter)[0];
+    centerPoint[1] += static_cast<mitk::Point2D>(*polyLineIter)[1];
   }
 
   size_t numPoints = polyLine.size();
 
   centerPoint[0] /= numPoints;
   centerPoint[1] /= numPoints;
 
   return centerPoint;
 }
 
 static mitk::Point2D GetCenterPoint(mitk::PlanarFigure* planarFigure)
 {
   mitk::Point2D centerPoint;
 
   centerPoint[0] = 0;
   centerPoint[1] = 0;
 
   size_t numPolyLines = planarFigure->GetPolyLinesSize();
 
   for (size_t i = 0; i < numPolyLines; ++i)
   {
     mitk::Point2D polyLineCenterPoint = GetCenterPoint(planarFigure->GetPolyLine(i));
 
     centerPoint[0] += polyLineCenterPoint[0];
     centerPoint[1] += polyLineCenterPoint[1];
   }
 
   centerPoint[0] /= numPolyLines;
   centerPoint[1] /= numPolyLines;
 
   return centerPoint;
 }
 
 static mitk::Vector3D GetBendDirection(const mitk::PlaneGeometry* planeGeometry, const mitk::Point2D& centerPoint2d, const mitk::Vector2D& bendDirection2d)
 {
   mitk::Point2D point2d = centerPoint2d + bendDirection2d;
 
   mitk::Point3D point3d;
   planeGeometry->Map(point2d, point3d);
 
   mitk::Point3D centerPoint3d;
   planeGeometry->Map(centerPoint2d, centerPoint3d);
 
   mitk::Vector3D bendDirection3d = point3d - centerPoint3d;
   bendDirection3d.Normalize();
 
   return bendDirection3d;
 }
 
 mitk::ExtrudePlanarFigureFilter::ExtrudePlanarFigureFilter()
   : m_Length(1),
     m_NumberOfSegments(1),
     m_TwistAngle(0),
     m_BendAngle(0),
     m_FlipDirection(false),
     m_FlipNormals(false)
 {
   m_BendDirection[0] = 0;
   m_BendDirection[1] = 0;
 
   this->SetNumberOfRequiredInputs(1);
   this->SetNumberOfRequiredOutputs(1);
 
   this->SetNthOutput(0, this->MakeOutput(0));
 }
 
 mitk::ExtrudePlanarFigureFilter::~ExtrudePlanarFigureFilter()
 {
 }
 
 void mitk::ExtrudePlanarFigureFilter::GenerateData()
 {
   typedef PlanarFigure::PolyLineType PolyLine;
   typedef PolyLine::const_iterator PolyLineConstIter;
 
   if (m_Length <= 0)
     mitkThrow() << "Length is not positive!";
 
   if (m_NumberOfSegments == 0)
     mitkThrow() << "Number of segments is zero!";
 
   if (m_BendAngle != 0 && m_BendDirection[0] == 0 && m_BendDirection[1] == 0)
     mitkThrow() << "Bend direction is zero-length vector!";
 
   PlanarFigure* input = dynamic_cast<PlanarFigure*>(this->GetPrimaryInput());
 
   if (input == NULL)
     mitkThrow() << "Primary input is not a planar figure!";
 
   size_t numPolyLines = input->GetPolyLinesSize();
 
   if (numPolyLines == 0)
     mitkThrow() << "Primary input does not contain any poly lines!";
 
   const PlaneGeometry* planeGeometry = dynamic_cast<const PlaneGeometry*>(input->GetGeometry2D());
 
   if (planeGeometry == NULL)
     mitkThrow() << "Could not get plane geometry from primary input!";
 
   Vector3D planeNormal = planeGeometry->GetNormal();
   planeNormal.Normalize();
 
   Point2D centerPoint2d = GetCenterPoint(input);
 
   Point3D centerPoint3d;
   planeGeometry->Map(centerPoint2d, centerPoint3d);
 
   Vector3D bendDirection3d = m_BendAngle != 0
     ? ::GetBendDirection(planeGeometry, centerPoint2d, m_BendDirection)
     : Vector3D();
 
   ScalarType radius = m_Length * (360 / m_BendAngle) / (2 * vnl_math::pi);
   Vector3D scaledBendDirection3d = bendDirection3d * radius;
 
   Vector3D bendAxis = itk::CrossProduct(planeNormal, bendDirection3d);
   bendAxis.Normalize();
 
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
   vtkIdType baseIndex = 0;
 
   for (size_t i = 0; i < numPolyLines; ++i)
   {
     PolyLine polyLine = input->GetPolyLine(i);
     size_t numPoints = polyLine.size();
 
     if (numPoints < 2)
       mitkThrow() << "Poly line " << i << " of primary input consists of less than two points!";
 
     std::vector<mitk::Point3D> crossSection;
 
     PolyLineConstIter polyLineEnd = polyLine.end();
 
     for (PolyLineConstIter polyLineIter = polyLine.begin(); polyLineIter != polyLineEnd; ++polyLineIter)
     {
       Point3D point;
-      planeGeometry->Map(polyLineIter->Point, point);
+      planeGeometry->Map(*polyLineIter, point);
       crossSection.push_back(point);
     }
 
     ScalarType segmentLength = m_Length / m_NumberOfSegments;
     Vector3D translation = planeNormal * segmentLength;
 
     bool bend = std::abs(m_BendAngle) > mitk::eps;
     bool twist = std::abs(m_TwistAngle) > mitk::eps;
 
     ScalarType twistAngle = twist
       ? m_TwistAngle / m_NumberOfSegments * vnl_math::pi / 180
       : 0;
 
     ScalarType bendAngle = bend
       ? m_BendAngle / m_NumberOfSegments * vnl_math::pi / 180
       : 0;
 
     if (m_FlipDirection)
     {
       translation *= -1;
       bendAngle *= -1;
     }
 
     for (size_t k = 0; k < numPoints; ++k)
       points->InsertNextPoint(crossSection[k].GetDataPointer());
 
     for (size_t j = 1; j <= m_NumberOfSegments; ++j)
     {
       mitk::AffineTransform3D::Pointer transform = mitk::AffineTransform3D::New();
 
       if (bend || twist)
         transform->Translate(centerPoint3d.GetVectorFromOrigin(), true);
 
       if (bend)
       {
         transform->Translate(scaledBendDirection3d, true);
         transform->Rotate3D(bendAxis, bendAngle * j, true);
         transform->Translate(-scaledBendDirection3d, true);
       }
       else
       {
         transform->Translate(translation * j, true);
       }
 
       if (twist)
         transform->Rotate3D(planeNormal, twistAngle * j, true);
 
       if (bend || twist)
         transform->Translate(-centerPoint3d.GetVectorFromOrigin(), true);
 
       for (size_t k = 0; k < numPoints; ++k)
       {
         mitk::Point3D transformedPoint = transform->TransformPoint(crossSection[k]);
         points->InsertNextPoint(transformedPoint.GetDataPointer());
       }
     }
 
     for (size_t j = 0; j < m_NumberOfSegments; ++j)
     {
       for (size_t k = 1; k < numPoints; ++k)
       {
         vtkIdType cell[3];
         cell[0] = baseIndex + j * numPoints + (k - 1);
         cell[1] = baseIndex + (j + 1) * numPoints + (k - 1);
         cell[2] = baseIndex + j * numPoints + k;
 
         cells->InsertNextCell(3, cell);
 
         cell[0] = cell[1];
         cell[1] = baseIndex + (j + 1) * numPoints + k;
 
         cells->InsertNextCell(3, cell);
       }
 
       if (input->IsClosed() && numPoints > 2)
       {
         vtkIdType cell[3];
         cell[0] = baseIndex + j * numPoints + (numPoints - 1);
         cell[1] = baseIndex + (j + 1) * numPoints + (numPoints - 1);
         cell[2] = baseIndex + j * numPoints;
 
         cells->InsertNextCell(3, cell);
 
         cell[0] = cell[1];
         cell[1] = baseIndex + (j + 1) * numPoints;
 
         cells->InsertNextCell(3, cell);
       }
     }
 
     baseIndex += points->GetNumberOfPoints();
   }
 
   vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   polyData->SetPoints(points);
   polyData->SetPolys(cells);
 
   vtkSmartPointer<vtkPolyDataNormals> polyDataNormals = vtkSmartPointer<vtkPolyDataNormals>::New();
   polyDataNormals->SetFlipNormals(m_FlipNormals);
   polyDataNormals->SetInputData(polyData);
   polyDataNormals->SplittingOff();
 
   polyDataNormals->Update();
 
   Surface* output = static_cast<Surface*>(this->GetPrimaryOutput());
   output->SetVtkPolyData(polyDataNormals->GetOutput());
 }
 
 void mitk::ExtrudePlanarFigureFilter::GenerateOutputInformation()
 {
 }
 
 itk::ProcessObject::DataObjectPointer mitk::ExtrudePlanarFigureFilter::MakeOutput(DataObjectPointerArraySizeType idx)
 {
   return idx == 0
     ? Surface::New().GetPointer()
     : NULL;
 }
 
 itk::ProcessObject::DataObjectPointer mitk::ExtrudePlanarFigureFilter::MakeOutput(const DataObjectIdentifierType& name)
 {
   return this->IsIndexedOutputName(name)
     ? this->MakeOutput(this->MakeIndexFromOutputName(name))
     : NULL;
 }
 
 void mitk::ExtrudePlanarFigureFilter::PrintSelf(std::ostream& os, itk::Indent indent) const
 {
   Superclass::PrintSelf(os, indent);
 
   os << indent << "Length: " << m_Length << std::endl;
   os << indent << "Number of Segments: " << m_NumberOfSegments << std::endl;
   os << indent << "Twist Angle: " << m_TwistAngle << std::endl;
   os << indent << "Bend Angle: " << m_BendAngle << std::endl;
   os << indent << "Bend Direction: " << m_BendDirection << std::endl;
   os << indent << "Flip Normals: " << m_FlipNormals << std::endl;
 }
 
 void mitk::ExtrudePlanarFigureFilter::SetInput(PlanarFigure* planarFigure)
 {
   this->SetPrimaryInput(planarFigure);
 }
 
 mitk::Surface* mitk::ExtrudePlanarFigureFilter::GetOutput()
 {
   return static_cast<Surface*>(this->GetPrimaryOutput());
 }
diff --git a/Modules/PlanarFigure/DataManagement/mitkPlanarBezierCurve.cpp b/Modules/PlanarFigure/DataManagement/mitkPlanarBezierCurve.cpp
index 3690f4abda..fe6e689199 100644
--- a/Modules/PlanarFigure/DataManagement/mitkPlanarBezierCurve.cpp
+++ b/Modules/PlanarFigure/DataManagement/mitkPlanarBezierCurve.cpp
@@ -1,128 +1,120 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkPlanarBezierCurve.h"
 #include <mitkProperties.h>
 
 #include <limits>
 
 mitk::PlanarBezierCurve::PlanarBezierCurve()
   : FEATURE_ID_LENGTH(Superclass::AddFeature("Length", "mm")),
     m_NumberOfSegments(100)
 {
   this->ResetNumberOfControlPoints(2);
   this->SetNumberOfPolyLines(1);
   this->SetNumberOfHelperPolyLines(1);
 }
 
 mitk::PlanarBezierCurve::~PlanarBezierCurve()
 {
 }
 
 void mitk::PlanarBezierCurve::EvaluateFeaturesInternal()
 {
-  std::vector<Point2D> points;
-  points.reserve(m_NumberOfSegments + 1);
-
-  PolyLineType::const_iterator end = m_PolyLines[0].end();
-
-  for (PolyLineType::const_iterator it = m_PolyLines[0].begin(); it != end; ++it)
-    points.push_back(it->Point);
-
   double length = 0.0;
 
   for (unsigned int i = 0; i < m_NumberOfSegments; ++i)
-    length += points[i].EuclideanDistanceTo(points[i + 1]);
+    length += static_cast<Point2D>(m_PolyLines[0][i]).EuclideanDistanceTo(static_cast<Point2D>(m_PolyLines[0][i + 1]));
 
   this->SetQuantity(FEATURE_ID_LENGTH, length);
 }
 
 unsigned int mitk::PlanarBezierCurve::GetNumberOfSegments() const
 {
   return m_NumberOfSegments;
 }
 
 void mitk::PlanarBezierCurve::SetNumberOfSegments(unsigned int numSegments)
 {
   m_NumberOfSegments = std::max(1U, numSegments);
 
   if (this->IsPlaced())
   {
     this->GeneratePolyLine();
     this->Modified();
   }
 }
 
 void mitk::PlanarBezierCurve::GenerateHelperPolyLine(double, unsigned int)
 {
   this->ClearHelperPolyLines();
 
   unsigned int numHelperPolyLinePoints = m_ControlPoints.size();
 
   for (unsigned int i = 0; i < numHelperPolyLinePoints; ++i)
     this->AppendPointToHelperPolyLine(0, m_ControlPoints[i]);
 }
 
 void mitk::PlanarBezierCurve::GeneratePolyLine()
 {
   this->ClearPolyLines();
 
   const unsigned int numPolyLinePoints = m_NumberOfSegments + 1;
 
   for (unsigned int i = 0; i < numPolyLinePoints; ++i)
     this->AppendPointToPolyLine(0, this->ComputeDeCasteljauPoint(i / static_cast<ScalarType>(m_NumberOfSegments)));
 }
 
 mitk::Point2D mitk::PlanarBezierCurve::ComputeDeCasteljauPoint(mitk::ScalarType t)
 {
   unsigned int n = m_ControlPoints.size() - 1;
 
   if (m_DeCasteljauPoints.size() != n)
     m_DeCasteljauPoints.resize(n);
 
   for (unsigned int i = 0; i < n; ++i)
   {
     m_DeCasteljauPoints[i][0] = (1 - t) * m_ControlPoints[i][0] + t * m_ControlPoints[i + 1][0];
     m_DeCasteljauPoints[i][1] = (1 - t) * m_ControlPoints[i][1] + t * m_ControlPoints[i + 1][1];
   }
 
   for (--n; n > 0; --n)
   {
     for (unsigned int i = 0; i < n; ++i)
     {
       m_DeCasteljauPoints[i][0] = (1 - t) * m_DeCasteljauPoints[i][0] + t * m_DeCasteljauPoints[i + 1][0];
       m_DeCasteljauPoints[i][1] = (1 - t) * m_DeCasteljauPoints[i][1] + t * m_DeCasteljauPoints[i + 1][1];
     }
   }
 
   return m_DeCasteljauPoints[0];
 }
 
 unsigned int mitk::PlanarBezierCurve::GetMaximumNumberOfControlPoints() const
 {
   return std::numeric_limits<unsigned int>::max();
 }
 
 unsigned int mitk::PlanarBezierCurve::GetMinimumNumberOfControlPoints() const
 {
   return 2;
 }
 
 bool mitk::PlanarBezierCurve::IsHelperToBePainted(unsigned int index)
 {
   return index == 0 && m_ControlPoints.size() > 2;
 }
 
diff --git a/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.h b/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.h
index 5d54a93869..7caa75e3b2 100644
--- a/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.h
+++ b/Modules/PlanarFigure/DataManagement/mitkPlanarFigure.h
@@ -1,423 +1,423 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #ifndef _MITK_PLANAR_FIGURE_H_
 #define _MITK_PLANAR_FIGURE_H_
 
 #include <MitkPlanarFigureExports.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 MitkPlanarFigure_EXPORT PlanarFigure : public BaseData
 {
 public:
   mitkClassMacro( PlanarFigure, BaseData )
   itkCloneMacro( Self )
 
   /** \brief Treat as Point2D by implicitly using conversion operators.
     *
     * \deprecatedSince{2014_06} "struct PolyLineElement {...};" will be changed to "typedef Point2D PolyLineElement;".
     */
-  struct PolyLineElement
+  struct MitkPlanarFigure_EXPORT PolyLineElement
   {
     DEPRECATED(PolyLineElement(Point2D point, int index));
     PolyLineElement(const Point2D& point);
 
     operator Point2D&();
     operator const Point2D&() const;
 
     DEPRECATED(Point2D Point);
     DEPRECATED(int Index);
   };
 
   typedef itk::VectorContainer< unsigned long, bool>  BoolContainerType;
 
   typedef std::deque< Point2D > ControlPointListType;
   typedef std::vector< 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 );
 
   /**
   * \brief Adds / inserts new control-points
   *
   * This method adds a new control-point with the coordinates defined by point at the given index.
   * If 'index' == -1 or index is greater than the number of control-points the new point is appended
   * to the back of the list of control points.
   * If a control-point already exists for 'index', an additional point is inserted at that position.
   * It is not possible to add more points if the maximum number of control-points (GetMaximumNumberOfControlPoints())
   * has been reached.
   */
   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 bool 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 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 Returns true if the feature with the specified index exists and is set visible */
   bool IsFeatureVisible( unsigned int index ) const;
 
   /** \brief Defines if the feature with the specified index will be shown as an
   * overlay in the RenderWindow */
   void SetFeatureVisible( unsigned int index, bool visible );
 
 
   /** \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( const 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();
 
   /** \brief removes the point with the given index from the list of controlpoints. */
   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.
     *
     * \note Deprecated, use Clone() instead.
     */
   DEPRECATED(void DeepCopy(Self::Pointer oldFigure));
 
   /** \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 );
 
 
 
 protected:
   PlanarFigure();
   virtual ~PlanarFigure();
 
   PlanarFigure(const Self& other);
 
   /** \brief Set the initial number of control points of the planar figure */
   void ResetNumberOfControlPoints( int numberOfControlPoints );
 
   /** 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 TimeGeometry describing the (time-resolved)
    * geometry of this figure. Note that each time step holds one Geometry2D.
    */
   virtual void InitializeTimeGeometry( 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:
 
   // not implemented to prevent PlanarFigure::New() calls which would create an itk::Object.
   static Pointer New();
 
   struct Feature
   {
     Feature( const char *name, const char *unit )
     : Name( name ), Unit( unit ), Quantity( 0.0 ), Active( true ), Visible( true )
     {
     }
 
     std::string Name;
     std::string Unit;
     double Quantity;
     bool Active;
     bool Visible;
   };
 
   virtual itk::LightObject::Pointer InternalClone() const = 0;
 
   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;
 
   // this pair is used to store the mmInDisplayUnits (m_DisplaySize.first) and the displayHeight (m_DisplaySize.second)
   // that the helperPolyLines have been calculated for.
   // It's used to determine whether or not GetHelperPolyLine() needs to recalculate the HelperPolyLines.
   std::pair<double, unsigned int> m_DisplaySize;
 
 };
 
 } // namespace mitk
 
 #endif //_MITK_PLANAR_FIGURE_H_
diff --git a/Modules/PlanarFigure/DataManagement/mitkPlanarPolygon.cpp b/Modules/PlanarFigure/DataManagement/mitkPlanarPolygon.cpp
index 26c6ba3d1d..d206ab6fb3 100644
--- a/Modules/PlanarFigure/DataManagement/mitkPlanarPolygon.cpp
+++ b/Modules/PlanarFigure/DataManagement/mitkPlanarPolygon.cpp
@@ -1,280 +1,274 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #include "mitkPlanarPolygon.h"
 #include "mitkGeometry2D.h"
 #include "mitkProperties.h"
 
 // stl related includes
 #include <algorithm>
 
 
 mitk::PlanarPolygon::PlanarPolygon()
 : FEATURE_ID_CIRCUMFERENCE( this->AddFeature( "Circumference", "mm" ) ),
   FEATURE_ID_AREA( this->AddFeature( "Area", "mm2" ) )
 {
   // Polygon has at least two control points
   this->ResetNumberOfControlPoints( 2 );
   this->SetNumberOfPolyLines( 1 );
 
   // Polygon is closed by default
   this->SetProperty( "closed", mitk::BoolProperty::New( true ) );
   this->SetProperty( "subdivision", mitk::BoolProperty::New( false ) );
 }
 
 
 mitk::PlanarPolygon::~PlanarPolygon()
 {
 }
 
 
 void mitk::PlanarPolygon::SetClosed( bool closed )
 {
   this->SetProperty( "closed", mitk::BoolProperty::New( closed ) );
 
   if ( !closed )
   {
     // For non-closed polygons: use "Length" as feature name; disable area
     this->SetFeatureName( FEATURE_ID_CIRCUMFERENCE, "Length" );
     this->DeactivateFeature( FEATURE_ID_AREA );
   }
   else
   {
     // For closed polygons: use "Circumference" as feature name; enable area
     this->SetFeatureName( FEATURE_ID_CIRCUMFERENCE, "Circumference" );
     this->ActivateFeature( FEATURE_ID_AREA );
   }
 
   this->Modified();
 }
 
 
 void mitk::PlanarPolygon::GeneratePolyLine()
 {
   this->ClearPolyLines();
 
   for (ControlPointListType::size_type i = 0; i < m_ControlPoints.size(); ++i)
     this->AppendPointToPolyLine(0, this->GetControlPoint(i));
 }
 
 void mitk::PlanarPolygon::GenerateHelperPolyLine(double /*mmPerDisplayUnit*/, unsigned int /*displayHeight*/)
 {
   // A polygon does not require helper objects
 }
 
 void mitk::PlanarPolygon::EvaluateFeaturesInternal()
 {
   // Calculate circumference
   double circumference = 0.0;
   unsigned int i,j;
 
-  ControlPointListType polyLinePoints;
-  polyLinePoints.clear();
-  PolyLineType::iterator iter;
-  for( iter = m_PolyLines[0].begin(); iter != m_PolyLines[0].end(); ++iter )
-  {
-    polyLinePoints.push_back((*iter).Point);
-  }
+  PolyLineType polyLine = m_PolyLines[0];
 
-  if(polyLinePoints.empty())
+  if(polyLine.empty())
     return;
 
-  for ( i = 0; i <(polyLinePoints.size()-1); ++i )
+  for ( i = 0; i <(polyLine.size()-1); ++i )
   {
-    circumference += polyLinePoints[i].EuclideanDistanceTo(
-      polyLinePoints[i + 1] );
+    circumference += static_cast<Point2D>(polyLine[i]).EuclideanDistanceTo(
+      static_cast<Point2D>(polyLine[i + 1]) );
   }
 
   if ( this->IsClosed() )
   {
-    circumference += polyLinePoints[i].EuclideanDistanceTo(
-      polyLinePoints.front() );
+    circumference += static_cast<Point2D>(polyLine[i]).EuclideanDistanceTo(
+      static_cast<Point2D>(polyLine.front()) );
   }
 
   this->SetQuantity( FEATURE_ID_CIRCUMFERENCE, circumference );
 
 
   // Calculate polygon area (if closed)
   double area       = 0.0;
   bool intersection = false;
 
   if ( this->IsClosed() && (this->GetGeometry2D() != NULL) )
   {
     // does PlanarPolygon overlap/intersect itself?
-    unsigned int numberOfPoints = polyLinePoints.size();
+    unsigned int numberOfPoints = polyLine.size();
     if( numberOfPoints >= 4)
     {
       for ( i = 0; i < (numberOfPoints - 1); ++i )
       {
         // line 1
-        Point2D p0 = polyLinePoints[i];
-        Point2D p1 = polyLinePoints[i + 1];
+        Point2D p0 = polyLine[i];
+        Point2D p1 = polyLine[i + 1];
 
         // check for intersection with all other lines
         for (j = i+1; j < (numberOfPoints - 1); ++j )
         {
-          Point2D p2 = polyLinePoints[j];
-          Point2D p3 = polyLinePoints[j + 1];
+          Point2D p2 = polyLine[j];
+          Point2D p3 = polyLine[j + 1];
           intersection = CheckForLineIntersection(p0,p1,p2,p3);
           if (intersection) break;
         }
         if (intersection) break; // only because the inner loop might have changed "intersection"
 
         // last line from p_x to p_0
-        Point2D p2 = polyLinePoints.front();
-        Point2D p3 = polyLinePoints.back();
+        Point2D p2 = polyLine.front();
+        Point2D p3 = polyLine.back();
 
         intersection = CheckForLineIntersection(p0,p1,p2,p3);
         if (intersection) break;
       }
    }
 
     // calculate area
-    for ( i = 0; i < polyLinePoints.size(); ++i )
+    for ( i = 0; i < polyLine.size(); ++i )
     {
-      Point2D p0 = polyLinePoints[i];
-      Point2D p1 = polyLinePoints[ (i + 1) % polyLinePoints.size() ];
+      Point2D p0 = polyLine[i];
+      Point2D p1 = polyLine[ (i + 1) % polyLine.size() ];
 
       area += p0[0] * p1[1] - p1[0] * p0[1];
     }
     area /= 2.0;
   }
 
   // set area if appropiate (i.e. closed and not intersected)
   if(this->IsClosed() && !intersection)
   {
     SetQuantity( FEATURE_ID_AREA, fabs( area ) );
     this->ActivateFeature( FEATURE_ID_AREA );
   }
   else
   {
     SetQuantity( FEATURE_ID_AREA,  0  );
     this->DeactivateFeature( FEATURE_ID_AREA );
   }
 }
 
 
 void mitk::PlanarPolygon::PrintSelf( std::ostream& os, itk::Indent indent) const
 {
   Superclass::PrintSelf( os, indent );
 
   if (this->IsClosed())
     os << indent << "Polygon is closed\n";
   else
     os << indent << "Polygon is not closed\n";
 }
 
 // based on
 // http://flassari.is/2008/11/line-line-intersection-in-cplusplus/
 bool mitk::PlanarPolygon::CheckForLineIntersection( const mitk::Point2D& p1, const mitk::Point2D& p2, const mitk::Point2D& p3, const mitk::Point2D& p4, Point2D& intersection ) const
 {
   // do not check for intersections with control points
   if(p1 == p2 || p1 == p3 || p1 == p4 ||
      p2 == p3 || p2 == p4 ||
      p3 == p4)
     return false;
 
 
   // Store the values for fast access and easy
   // equations-to-code conversion
   double x1 = p1[0], x2 = p2[0], x3 = p3[0], x4 = p4[0];
   double y1 = p1[1], y2 = p2[1], y3 = p3[1], y4 = p4[1];
 
   double d = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
   // If d is zero, there is no intersection
   //if (d < mitk::eps) return false;
   if (d == 0) return false;
 
   // Get the x and y
   double pre = (x1*y2 - y1*x2);
   double post = (x3*y4 - y3*x4);
   double x = ( pre * (x3 - x4) - (x1 - x2) * post ) / d;
   double y = ( pre * (y3 - y4) - (y1 - y2) * post ) / d;
 
   double tolerance = 0.001;
   // Check if the x coordinates are within both lines, including tolerance
   if ( x < ( std::min(x1, x2) - tolerance )
     || x > ( std::max(x1, x2) + tolerance )
     || x < ( std::min(x3, x4) - tolerance )
     || x > ( std::max(x3, x4) + tolerance )
     )
   {
     return false;
   }
 
   // Check if the y coordinates are within both lines, including tolerance
   if ( y < ( std::min(y1, y2) - tolerance )
     || y > ( std::max(y1, y2) + tolerance )
     || y < ( std::min(y3, y4) - tolerance )
     || y > ( std::max(y3, y4) + tolerance )
     )
   {
     return false;
   }
 
   // point of intersection
   Point2D ret; ret[0] = x; ret[1] = y;
   intersection = ret;
   return true;
 }
 
 bool mitk::PlanarPolygon::CheckForLineIntersection( const mitk::Point2D& p1, const mitk::Point2D& p2, const mitk::Point2D& p3, const mitk::Point2D& p4 ) const
 {
   mitk::Point2D intersection;
   return mitk::PlanarPolygon::CheckForLineIntersection( p1, p2, p3, p4, intersection );
 
 }
 
 std::vector<mitk::Point2D> mitk::PlanarPolygon::CheckForLineIntersection( const mitk::Point2D& p1, const mitk::Point2D& p2 ) const
 {
   std::vector<mitk::Point2D> intersectionList;
 
   ControlPointListType polyLinePoints;
   PolyLineType tempList = m_PolyLines[0];
   PolyLineType::iterator iter;
   for( iter = tempList.begin(); iter != tempList.end(); ++iter )
   {
     polyLinePoints.push_back((*iter).Point);
   }
 
   for ( ControlPointListType::size_type i=0; i<polyLinePoints.size()-1; i++ )
   {
     mitk::Point2D pnt1 = polyLinePoints[i];
     mitk::Point2D pnt2 = polyLinePoints[i+1];
     mitk::Point2D intersection;
 
     if ( mitk::PlanarPolygon::CheckForLineIntersection( p1, p2, pnt1, pnt2, intersection ) )
     {
       intersectionList.push_back( intersection );
     }
   }
 
   if ( this->IsClosed() )
   {
     mitk::Point2D intersection, lastControlPoint, firstControlPoint;
     lastControlPoint = polyLinePoints.back();
     firstControlPoint = polyLinePoints.front();
 
     if ( mitk::PlanarPolygon::CheckForLineIntersection( lastControlPoint,
       firstControlPoint, p1, p2, intersection ) )
     {
       intersectionList.push_back( intersection );
     }
   }
 
   return intersectionList;
 }
diff --git a/Modules/PlanarFigure/Interactions/mitkPlanarFigureInteractor.cpp b/Modules/PlanarFigure/Interactions/mitkPlanarFigureInteractor.cpp
index fd29413b95..ec4245deeb 100644
--- a/Modules/PlanarFigure/Interactions/mitkPlanarFigureInteractor.cpp
+++ b/Modules/PlanarFigure/Interactions/mitkPlanarFigureInteractor.cpp
@@ -1,947 +1,947 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #define PLANARFIGUREINTERACTOR_DBG MITK_DEBUG("PlanarFigureInteractor") << __LINE__ << ": "
 
 #include "mitkPlanarFigureInteractor.h"
 #include "mitkPlanarFigure.h"
 #include "mitkPlanarPolygon.h"
 
 #include "mitkInteractionPositionEvent.h"
 #include "mitkInternalEvent.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkRenderingManager.h"
 
 
 //how precise must the user pick the point
 //default value
 mitk::PlanarFigureInteractor::PlanarFigureInteractor()
 : DataInteractor()
 , m_Precision( 6.5 )
 , m_MinimumPointDistance( 25.0 )
 , m_IsHovering( false )
 , m_LastPointWasValid( false )
 {
 }
 
 mitk::PlanarFigureInteractor::~PlanarFigureInteractor()
 {
 }
 
 void mitk::PlanarFigureInteractor::ConnectActionsAndFunctions()
 {
   CONNECT_CONDITION("figure_is_on_current_slice", CheckFigureOnRenderingGeometry);
   CONNECT_CONDITION("figure_is_placed", CheckFigurePlaced);
   CONNECT_CONDITION("minimal_figure_is_finished", CheckMinimalFigureFinished);
   CONNECT_CONDITION("hovering_above_figure", CheckFigureHovering);
   CONNECT_CONDITION("hovering_above_point", CheckControlPointHovering);
   CONNECT_CONDITION("figure_is_selected", CheckSelection);
   CONNECT_CONDITION("point_is_valid", CheckPointValidity);
   CONNECT_CONDITION("figure_is_finished", CheckFigureFinished);
   CONNECT_CONDITION("reset_on_point_select_needed", CheckResetOnPointSelect);
   CONNECT_CONDITION("points_can_be_added_or_removed", CheckFigureIsExtendable);
 
 
   CONNECT_FUNCTION( "finalize_figure", FinalizeFigure);
   CONNECT_FUNCTION( "hide_preview_point", HidePreviewPoint )
   CONNECT_FUNCTION( "hide_control_points", HideControlPoints )
   CONNECT_FUNCTION( "set_preview_point_position", SetPreviewPointPosition )
   CONNECT_FUNCTION( "move_current_point", MoveCurrentPoint);
   CONNECT_FUNCTION( "deselect_point", DeselectPoint);
   CONNECT_FUNCTION( "add_new_point", AddPoint);
   CONNECT_FUNCTION( "add_initial_point", AddInitialPoint);
   CONNECT_FUNCTION( "remove_selected_point", RemoveSelectedPoint);
   CONNECT_FUNCTION( "request_context_menu", RequestContextMenu);
   CONNECT_FUNCTION( "select_figure", SelectFigure );
   CONNECT_FUNCTION( "select_point", SelectPoint );
   CONNECT_FUNCTION( "end_interaction", EndInteraction );
   CONNECT_FUNCTION( "start_hovering", StartHovering )
   CONNECT_FUNCTION( "end_hovering", EndHovering );
 }
 
 
 bool mitk::PlanarFigureInteractor::CheckFigurePlaced( const InteractionEvent* /*interactionEvent*/ )
 {
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
 
   bool isFigureFinished = false;
   planarFigure->GetPropertyList()->GetBoolProperty( "initiallyplaced", isFigureFinished );
 
   return planarFigure->IsPlaced() && isFigureFinished;
 }
 
 bool mitk::PlanarFigureInteractor::MoveCurrentPoint(StateMachineAction*, InteractionEvent* interactionEvent)
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   if ( positionEvent == NULL )
     return false;
 
   bool isEditable = true;
   GetDataNode()->GetBoolProperty( "planarfigure.iseditable", isEditable );
 
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>(
     GetDataNode()->GetData() );
 
   mitk::Geometry2D *planarFigureGeometry =
     dynamic_cast< Geometry2D * >( planarFigure->GetGeometry( 0 ) );
 
   // Extract point in 2D world coordinates (relative to Geometry2D of
   // PlanarFigure)
   Point2D point2D;
   if ( !this->TransformPositionEventToPoint2D( positionEvent, planarFigureGeometry, point2D ) || !isEditable )
   {
     return false;
   }
 
   // check if the control points shall be hidden during interaction
   bool hidecontrolpointsduringinteraction = false;
   GetDataNode()->GetBoolProperty( "planarfigure.hidecontrolpointsduringinteraction", hidecontrolpointsduringinteraction );
 
   // hide the control points if necessary
   //interactionEvent->GetSender()->GetDataStorage()->BlockNodeModifiedEvents( true );
   GetDataNode()->SetBoolProperty( "planarfigure.drawcontrolpoints", !hidecontrolpointsduringinteraction );
   //interactionEvent->GetSender()->GetDataStorage()->BlockNodeModifiedEvents( false );
 
   // Move current control point to this point
   planarFigure->SetCurrentControlPoint( point2D );
 
   // Re-evaluate features
   planarFigure->EvaluateFeatures();
 
   // Update rendered scene
   interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
 
   return true;
 }
 
 bool mitk::PlanarFigureInteractor::FinalizeFigure( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
 
   planarFigure->Modified();
   planarFigure->DeselectControlPoint();
   planarFigure->RemoveLastControlPoint();
   planarFigure->SetProperty( "initiallyplaced", mitk::BoolProperty::New( true ) );
   GetDataNode()->SetBoolProperty( "planarfigure.drawcontrolpoints", true );
   GetDataNode()->Modified();
   planarFigure->InvokeEvent( EndPlacementPlanarFigureEvent() );
   planarFigure->InvokeEvent( EndInteractionPlanarFigureEvent() );
 
   interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
 
   return false;
 }
 
 bool mitk::PlanarFigureInteractor::EndInteraction( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   GetDataNode()->SetBoolProperty( "planarfigure.drawcontrolpoints", true );
   planarFigure->Modified();
   planarFigure->InvokeEvent( EndInteractionPlanarFigureEvent() );
   interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
 
   return false;
 }
 
 bool mitk::PlanarFigureInteractor::EndHovering( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   planarFigure->ResetPreviewContolPoint();
 
   // 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
   GetDataNode()->SetBoolProperty( "planarfigure.ishovering", false );
 
   interactionEvent->GetSender()->GetRenderingManager()->RequestUpdateAll();
 
   return false;
 }
 
 bool mitk::PlanarFigureInteractor::CheckMinimalFigureFinished( const InteractionEvent* /*interactionEvent*/ )
 {
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   return ( planarFigure->GetNumberOfControlPoints() >= planarFigure->GetMinimumNumberOfControlPoints()  );
 }
 
 bool mitk::PlanarFigureInteractor::CheckFigureFinished( const InteractionEvent* /*interactionEvent*/ )
 {
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   return ( planarFigure->GetNumberOfControlPoints() >= planarFigure->GetMaximumNumberOfControlPoints() );
 }
 
 
 bool mitk::PlanarFigureInteractor::CheckFigureIsExtendable( const InteractionEvent* /*interactionEvent*/ )
 {
   bool isExtendable = false;
   GetDataNode()->GetBoolProperty("planarfigure.isextendable", isExtendable);
 
   return isExtendable;
 }
 
 bool mitk::PlanarFigureInteractor::DeselectPoint(StateMachineAction*, InteractionEvent* /*interactionEvent*/)
 {
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>(
     GetDataNode()->GetData() );
 
   bool wasSelected = planarFigure->DeselectControlPoint();
   if ( wasSelected )
   {
     // Issue event so that listeners may update themselves
     planarFigure->Modified();
     planarFigure->InvokeEvent( EndInteractionPlanarFigureEvent() );
 
     GetDataNode()->SetBoolProperty( "planarfigure.drawcontrolpoints", true );
 //    GetDataNode()->SetBoolProperty( "planarfigure.ishovering", false );
     GetDataNode()->Modified();
   }
 
   return true;
 }
 
 bool mitk::PlanarFigureInteractor::AddPoint(StateMachineAction*, InteractionEvent* interactionEvent)
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   if ( positionEvent == NULL )
     return false;
 
   bool selected = false;
   bool isEditable = true;
   GetDataNode()->GetBoolProperty("selected", selected);
   GetDataNode()->GetBoolProperty( "planarfigure.iseditable", isEditable );
 
   if ( !selected || !isEditable )
   {
     return false;
   }
 
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>(
     GetDataNode()->GetData() );
 
   mitk::Geometry2D *planarFigureGeometry =
     dynamic_cast< Geometry2D * >( planarFigure->GetGeometry( 0 ) );
 
   // If the planarFigure already has reached the maximum number
   if ( planarFigure->GetNumberOfControlPoints() >= planarFigure->GetMaximumNumberOfControlPoints() )
   {
     return false;
   }
 
   // Extract point in 2D world coordinates (relative to Geometry2D of
   // PlanarFigure)
   Point2D point2D, projectedPoint;
   if ( !this->TransformPositionEventToPoint2D( positionEvent, planarFigureGeometry, point2D ) )
   {
     return false;
   }
 
   // TODO: check segment of polyline we clicked in
   int nextIndex = -1;
 
   // We only need to check which position to insert the control point
   // when interacting with a PlanarPolygon. For all other types
   // new control points will always be appended
 
   /*
   * Added check for "initiallyplaced" due to bug 13097:
   *
   * There are two possible cases in which a point can be inserted into a PlanarPolygon:
   *
   * 1. The figure is currently drawn -> the point will be appended at the end of the figure
   * 2. A point is inserted at a userdefined position after the initial placement of the figure is finished
   *
   * In the second case we need to determine the proper insertion index. In the first case the index always has
   * to be -1 so that the point is appended to the end.
   *
   * These changes are necessary because of a mac os x specific issue: If a users draws a PlanarPolygon then the
   * next point to be added moves according to the mouse position. If then the user left clicks in order to add
   * a point one would assume the last move position is identical to the left click position. This is actually the
   * case for windows and linux but somehow NOT for mac. Because of the insertion logic of a new point in the
   * PlanarFigure then for mac the wrong current selected point is determined.
   *
   * With this check here this problem can be avoided. However a redesign of the insertion logic should be considered
   */
   bool isFigureFinished = false;
   planarFigure->GetPropertyList()->GetBoolProperty( "initiallyplaced", isFigureFinished );
 
   mitk::BaseRenderer *renderer = interactionEvent->GetSender();
   const Geometry2D *projectionPlane = renderer->GetCurrentWorldGeometry2D();
 
   if ( dynamic_cast<mitk::PlanarPolygon*>( planarFigure ) && isFigureFinished)
   {
     nextIndex = this->IsPositionOverFigure(
       positionEvent,
       planarFigure,
       planarFigureGeometry,
       projectionPlane,
       renderer->GetDisplayGeometry(),
       projectedPoint
       );
   }
 
 
   // Add point as new control point
   renderer->GetDisplayGeometry()->DisplayToWorld( projectedPoint, projectedPoint );
 
   if ( planarFigure->IsPreviewControlPointVisible() )
   {
     point2D = planarFigure->GetPreviewControlPoint();
   }
 
   planarFigure->AddControlPoint( point2D, nextIndex );
 
   if ( planarFigure->IsPreviewControlPointVisible() )
   {
     planarFigure->SelectControlPoint( nextIndex );
     planarFigure->ResetPreviewContolPoint();
   }
 
   // Re-evaluate features
   planarFigure->EvaluateFeatures();
   //this->LogPrintPlanarFigureQuantities( planarFigure );
 
   // Update rendered scene
   renderer->GetRenderingManager()->RequestUpdateAll();
 
   return true;
 }
 
 
 bool mitk::PlanarFigureInteractor::AddInitialPoint(StateMachineAction*, InteractionEvent* interactionEvent)
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   if ( positionEvent == NULL )
     return false;
 
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   mitk::BaseRenderer *renderer = interactionEvent->GetSender();
   mitk::Geometry2D *planarFigureGeometry = dynamic_cast< Geometry2D * >( planarFigure->GetGeometry( 0 ) );
 
   // 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
   {
     return false;
   }
 
   // Extract point in 2D world coordinates (relative to Geometry2D of
   // PlanarFigure)
   Point2D point2D;
   if ( !this->TransformPositionEventToPoint2D( positionEvent, planarFigureGeometry, point2D ) )
   {
     return false;
   }
 
   // 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.
   GetDataNode()->SetBoolProperty( "PlanarFigureInitializedWindow", true, renderer );
 
   // Update rendered scene
   renderer->GetRenderingManager()->RequestUpdateAll();
 
   return true;
 }
 
 bool mitk::PlanarFigureInteractor::StartHovering( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   if ( positionEvent == NULL )
     return false;
 
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   mitk::BaseRenderer *renderer = interactionEvent->GetSender();
 
   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
     GetDataNode()->SetBoolProperty( "planarfigure.ishovering", true );
 
     renderer->GetRenderingManager()->RequestUpdateAll();
   }
 
   return true;
 }
 
 bool mitk::PlanarFigureInteractor::SetPreviewPointPosition( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   if ( positionEvent == NULL )
     return false;
 
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   mitk::BaseRenderer *renderer = interactionEvent->GetSender();
 
   planarFigure->DeselectControlPoint();
 
   mitk::Point2D pointProjectedOntoLine = positionEvent->GetPointerPositionOnScreen();
 
   bool selected(false);
   bool isExtendable(false);
   bool isEditable(true);
   GetDataNode()->GetBoolProperty("selected", selected);
   GetDataNode()->GetBoolProperty("planarfigure.isextendable", isExtendable);
   GetDataNode()->GetBoolProperty("planarfigure.iseditable", isEditable );
 
   if ( selected &&  isExtendable && isEditable )
   {
     renderer->GetDisplayGeometry()->DisplayToWorld( pointProjectedOntoLine, pointProjectedOntoLine );
     planarFigure->SetPreviewControlPoint( pointProjectedOntoLine );
   }
 
   renderer->GetRenderingManager()->RequestUpdateAll();
 
   return true;
 }
 
 bool mitk::PlanarFigureInteractor::HideControlPoints( StateMachineAction*, InteractionEvent* /*interactionEvent*/ )
 {
   GetDataNode()->SetBoolProperty( "planarfigure.drawcontrolpoints", false );
   return true;
 }
 
 bool mitk::PlanarFigureInteractor::HidePreviewPoint( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   planarFigure->ResetPreviewContolPoint();
 
   mitk::BaseRenderer *renderer = interactionEvent->GetSender();
   renderer->GetRenderingManager()->RequestUpdateAll();
 
   return true;
 }
 
 
 bool mitk::PlanarFigureInteractor::CheckFigureHovering( const InteractionEvent* interactionEvent )
 {
   const mitk::InteractionPositionEvent* positionEvent = dynamic_cast<const mitk::InteractionPositionEvent*>( interactionEvent );
   if ( positionEvent == NULL )
     return false;
 
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   mitk::BaseRenderer *renderer = interactionEvent->GetSender();
   mitk::Geometry2D *planarFigureGeometry = dynamic_cast< Geometry2D * >( planarFigure->GetGeometry( 0 ) );
   const Geometry2D *projectionPlane = renderer->GetCurrentWorldGeometry2D();
 
   mitk::Point2D pointProjectedOntoLine;
   int previousControlPoint = this->IsPositionOverFigure( positionEvent,
                                                          planarFigure,
                                                          planarFigureGeometry,
                                                          projectionPlane,
                                                          renderer->GetDisplayGeometry(),
                                                          pointProjectedOntoLine
                                                         );
 
   bool isHovering = (previousControlPoint != -1);
 
   if ( isHovering )
   {
     return true;
   }
   else
   {
     return false;
   }
 
   return false;
 }
 
 
 bool mitk::PlanarFigureInteractor::CheckControlPointHovering( const InteractionEvent* interactionEvent )
 {
   const mitk::InteractionPositionEvent* positionEvent = dynamic_cast<const mitk::InteractionPositionEvent*>( interactionEvent );
   if ( positionEvent == NULL )
     return false;
 
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   mitk::BaseRenderer *renderer = interactionEvent->GetSender();
   mitk::Geometry2D *planarFigureGeometry = dynamic_cast< Geometry2D * >( planarFigure->GetGeometry( 0 ) );
   const Geometry2D *projectionPlane = renderer->GetCurrentWorldGeometry2D();
 
 
   int pointIndex = -1;
   pointIndex = mitk::PlanarFigureInteractor::IsPositionInsideMarker(
     positionEvent,
     planarFigure,
     planarFigureGeometry,
     projectionPlane,
     renderer->GetDisplayGeometry() );
 
   if ( pointIndex >= 0 )
   {
     return true;
   }
   else
   {
     return false;
   }
 }
 
 bool mitk::PlanarFigureInteractor::CheckSelection( const InteractionEvent* /*interactionEvent*/ )
 {
   bool selected = false;
   GetDataNode()->GetBoolProperty("selected", selected);
 
   return selected;
 }
 
 bool mitk::PlanarFigureInteractor::SelectFigure( StateMachineAction*, InteractionEvent* /*interactionEvent*/ )
 {
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   planarFigure->InvokeEvent( SelectPlanarFigureEvent() );
   return false;
 }
 
 bool mitk::PlanarFigureInteractor::SelectPoint( StateMachineAction*, InteractionEvent* interactionEvent )
 {
   mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   if ( positionEvent == NULL )
     return false;
 
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   mitk::BaseRenderer *renderer = interactionEvent->GetSender();
   mitk::Geometry2D *planarFigureGeometry = dynamic_cast< Geometry2D * >( planarFigure->GetGeometry( 0 ) );
   const Geometry2D *projectionPlane = renderer->GetCurrentWorldGeometry2D();
 
 
   int pointIndex = -1;
   pointIndex = mitk::PlanarFigureInteractor::IsPositionInsideMarker(
     positionEvent,
     planarFigure,
     planarFigureGeometry,
     projectionPlane,
     renderer->GetDisplayGeometry() );
 
   if ( pointIndex >= 0 )
   {
     // If mouse is above control point, mark it as selected
     planarFigure->SelectControlPoint( pointIndex );
   }
   else
   {
     planarFigure->DeselectControlPoint();
   }
 
   return false;
 }
 
 
 bool mitk::PlanarFigureInteractor::CheckPointValidity( const InteractionEvent* interactionEvent )
 {
   // 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::InteractionPositionEvent* positionEvent = dynamic_cast<const mitk::InteractionPositionEvent*>( interactionEvent );
   if ( positionEvent == NULL )
     return false;
 
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
 
   m_LastPointWasValid = IsMousePositionAcceptableAsNewControlPoint( positionEvent, planarFigure );
   return m_LastPointWasValid;
 }
 
 
 
 bool mitk::PlanarFigureInteractor::RemoveSelectedPoint(StateMachineAction*, InteractionEvent* interactionEvent)
 {
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
   mitk::BaseRenderer *renderer = interactionEvent->GetSender();
 
   int selectedControlPoint = planarFigure->GetSelectedControlPoint();
   planarFigure->RemoveControlPoint( selectedControlPoint );
 
   // Re-evaluate features
   planarFigure->EvaluateFeatures();
   planarFigure->Modified();
 
   GetDataNode()->SetBoolProperty( "planarfigure.drawcontrolpoints", true );
   planarFigure->InvokeEvent( EndInteractionPlanarFigureEvent() );
   renderer->GetRenderingManager()->RequestUpdateAll();
 
   HandleEvent( mitk::InternalEvent::New( renderer, this, "Dummy-Event" ), GetDataNode() );
 
   return true;
 }
 
 
 bool mitk::PlanarFigureInteractor::RequestContextMenu(StateMachineAction*, InteractionEvent* /*interactionEvent*/)
 {
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
 
   bool selected = false;
   GetDataNode()->GetBoolProperty("selected", selected);
 
   // no need to invoke this if the figure is already selected
   if ( !selected )
   {
     planarFigure->InvokeEvent( SelectPlanarFigureEvent() );
   }
 
   planarFigure->InvokeEvent( ContextMenuPlanarFigureEvent() );
 
   return true;
 }
 
 
 bool mitk::PlanarFigureInteractor::CheckResetOnPointSelect( const InteractionEvent* /*interactionEvent*/ )
 {
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>( GetDataNode()->GetData() );
 
   // Invoke tmpEvent to notify listeners that interaction with this PF starts now
   planarFigure->InvokeEvent( StartInteractionPlanarFigureEvent() );
 
   // Reset the PlanarFigure if required
   return planarFigure->ResetOnPointSelect();
 }
 
 
 bool mitk::PlanarFigureInteractor::CheckFigureOnRenderingGeometry( const InteractionEvent* interactionEvent )
 {
   const mitk::InteractionPositionEvent* posEvent = dynamic_cast<const mitk::InteractionPositionEvent*>(interactionEvent);
 
   if ( posEvent == NULL )
     return false;
 
   mitk::Point3D worldPoint3D = posEvent->GetPositionInWorld();
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>(
     GetDataNode()->GetData() );
 
   mitk::Geometry2D *planarFigureGeometry2D = dynamic_cast< Geometry2D * >( planarFigure->GetGeometry( 0 ) );
 
   double planeThickness = planarFigureGeometry2D->GetExtentInMM( 2 );
 
   if ( planarFigureGeometry2D->Distance( worldPoint3D ) > planeThickness )
   {
     // don't react, when interaction is too far away
     return false;
   }
   return true;
 }
 
 void mitk::PlanarFigureInteractor::SetPrecision( mitk::ScalarType precision )
 {
   m_Precision = precision;
 }
 
 
 void mitk::PlanarFigureInteractor::SetMinimumPointDistance( ScalarType minimumDistance )
 {
   m_MinimumPointDistance = minimumDistance;
 }
 
 
 bool mitk::PlanarFigureInteractor::TransformPositionEventToPoint2D( const InteractionPositionEvent *positionEvent,
                                                                     const Geometry2D *planarFigureGeometry,
                                                                     Point2D &point2D )
 {
   mitk::Point3D worldPoint3D = positionEvent->GetPositionInWorld();
 
   // 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,
   mitk::Point2D& projectedPoint
   ) 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;
   projectedPoint = crossPoint;
 
   // 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 > 0.0) && (l2 > 0.0))
       || endPoint.SquaredEuclideanDistanceTo(point) < 20.0
       || startPoint.SquaredEuclideanDistanceTo(point) < 20.0)
   {
     return true;
   }
 
   return false;
 }
 
 
 int mitk::PlanarFigureInteractor::IsPositionOverFigure(
   const InteractionPositionEvent *positionEvent,
   PlanarFigure *planarFigure,
   const Geometry2D *planarFigureGeometry,
   const Geometry2D *rendererGeometry,
   const DisplayGeometry *displayGeometry,
   Point2D& pointProjectedOntoLine ) const
 {
   mitk::Point2D displayPosition = positionEvent->GetPointerPositionOnScreen();
 
   // Iterate over all polylines of planar figure, and check if
   // any one is close to the current display position
   typedef mitk::PlanarFigure::PolyLineType VertexContainerType;
 
   Point2D polyLinePoint;
   Point2D firstPolyLinePoint;
   Point2D previousPolyLinePoint;
 
   for ( unsigned short loop=0; loop<planarFigure->GetPolyLinesSize(); ++loop )
   {
     const VertexContainerType polyLine = planarFigure->GetPolyLine( loop );
 
     bool firstPoint( true );
     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->Point,
+      if ( !this->TransformObjectToDisplay( *it,
                                             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, pointProjectedOntoLine ) )
       {
         // Point is close enough to line segment --> Return index of the segment
         return std::distance(polyLine.begin(), it);
       }
       previousPolyLinePoint = polyLinePoint;
     }
 
     // For closed figures, also check last line segment
     if ( planarFigure->IsClosed()
       && this->IsPointNearLine( displayPosition, polyLinePoint, firstPolyLinePoint, pointProjectedOntoLine ) )
     {
       return 0; // Return index of first control point
     }
   }
   return -1;
 }
 
 
 int mitk::PlanarFigureInteractor::IsPositionInsideMarker(
   const InteractionPositionEvent* positionEvent,
   const PlanarFigure *planarFigure,
   const Geometry2D *planarFigureGeometry,
   const Geometry2D *rendererGeometry,
   const DisplayGeometry *displayGeometry ) const
 {
   mitk::Point2D displayPosition = positionEvent->GetPointerPositionOnScreen();
 
   // Iterate over all control points of planar figure, and check if
   // any one is close to the current display position
   mitk::Point2D displayControlPoint;
 
   int numberOfControlPoints = planarFigure->GetNumberOfControlPoints();
   for ( int i=0; i<numberOfControlPoints; i++ )
   {
     if ( this->TransformObjectToDisplay( planarFigure->GetControlPoint(i), displayControlPoint,
       planarFigureGeometry, rendererGeometry, displayGeometry ) )
     {
       // TODO: variable size of markers
       if ( displayPosition.SquaredEuclideanDistanceTo( displayControlPoint ) < 20.0 )
       {
         return i;
       }
     }
   }
 
   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 );
   }
 }
 
 bool
 mitk::PlanarFigureInteractor::IsMousePositionAcceptableAsNewControlPoint(
     const mitk::InteractionPositionEvent* positionEvent,
     const PlanarFigure* planarFigure )
 {
   assert(positionEvent && planarFigure);
 
   BaseRenderer* renderer = positionEvent->GetSender();
   assert(renderer);
 
   // Get the timestep to support 3D+t
   int timeStep( renderer->GetTimeStep( planarFigure ) );
 
   bool tooClose(false);
 
   const Geometry2D *renderingPlane = renderer->GetCurrentWorldGeometry2D();
 
   mitk::Geometry2D *planarFigureGeometry =
     dynamic_cast< mitk::Geometry2D * >( planarFigure->GetGeometry( timeStep ) );
 
   Point2D point2D, correctedPoint;
   // Get the point2D from the positionEvent
   if ( !this->TransformPositionEventToPoint2D( positionEvent, planarFigureGeometry, point2D ) )
   {
     return false;
   }
 
   // apply the controlPoint constraints of the planarFigure to get the
   // coordinates that would actually be used.
   correctedPoint = const_cast<PlanarFigure*>( planarFigure )->ApplyControlPointConstraints( 0, point2D );
 
   // map the 2D coordinates of the new point to world-coordinates
   // and transform those to display-coordinates
   mitk::Point3D newPoint3D;
   planarFigureGeometry->Map( correctedPoint, newPoint3D );
   mitk::Point2D newDisplayPosition;
   renderingPlane->Map( newPoint3D, newDisplayPosition );
   renderer->GetDisplayGeometry()->WorldToDisplay( newDisplayPosition, newDisplayPosition );
 
   for( int i=0; i < (int)planarFigure->GetNumberOfControlPoints(); i++ )
   {
     if ( i != planarFigure->GetSelectedControlPoint() )
     {
       // Try to convert previous point to current display coordinates
       mitk::Point3D previousPoint3D;
       // map the 2D coordinates of the control-point to world-coordinates
       planarFigureGeometry->Map( planarFigure->GetControlPoint( i ), previousPoint3D );
 
       if ( renderer->GetDisplayGeometry()->Distance( previousPoint3D ) < 0.1 ) // ugly, but assert makes this work
       {
         mitk::Point2D previousDisplayPosition;
         // transform the world-coordinates into display-coordinates
         renderingPlane->Map( previousPoint3D, previousDisplayPosition );
         renderer->GetDisplayGeometry()->WorldToDisplay( previousDisplayPosition, previousDisplayPosition );
 
         //Calculate the distance. We use display-coordinates here to make
         // the check independent of the zoom-level of the rendering scene.
         double a = newDisplayPosition[0] - previousDisplayPosition[0];
         double b = newDisplayPosition[1] - previousDisplayPosition[1];
 
         // If point is to close, do not set a new point
         tooClose = (a * a + b * b < m_MinimumPointDistance );
       }
       if ( tooClose )
         return false; // abort loop early
     }
   }
 
   return !tooClose; // default
 }
 
 void mitk::PlanarFigureInteractor::ConfigurationChanged()
 {
   mitk::PropertyList::Pointer properties = GetAttributes();
 
   std::string precision = "";
   if (properties->GetStringProperty("precision", precision))
   {
     m_Precision = atof(precision.c_str());
   }
   else
   {
     m_Precision = (ScalarType) 6.5;
   }
 
   std::string minPointDistance = "";
   if (properties->GetStringProperty("minPointDistance", minPointDistance))
   {
     m_MinimumPointDistance = atof(minPointDistance.c_str());
   }
   else
   {
     m_MinimumPointDistance = (ScalarType) 25.0;
   }
 }
 
 
diff --git a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp
index 7ab352459f..7dd447371a 100644
--- a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp
+++ b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp
@@ -1,927 +1,927 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #include "mitkPlanarFigureMapper2D.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "mitkGL.h"
 #include "mitkVtkPropRenderer.h"
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 // offset which moves the planarfigures on top of the other content
 // the crosshair is rendered into the z = 1 layer.
 static const float PLANAR_OFFSET = 0.5f;
 
 mitk::PlanarFigureMapper2D::PlanarFigureMapper2D()
   : m_NodeModified(true)
   , m_NodeModifiedObserverTag(0)
   , m_NodeModifiedObserverAdded(false)
 {
   this->InitializeDefaultPlanarFigureProperties();
 }
 
 
 mitk::PlanarFigureMapper2D::~PlanarFigureMapper2D()
 {
   if ( m_NodeModifiedObserverAdded && GetDataNode() != NULL )
   {
     GetDataNode()->RemoveObserver( m_NodeModifiedObserverTag );
   }
 }
 
 
 void mitk::PlanarFigureMapper2D::Paint( mitk::BaseRenderer *renderer )
 {
   bool visible = true;
 
   GetDataNode()->GetVisibility(visible, renderer, "visible");
   if ( !visible ) return;
 
 
   // Get PlanarFigure from input
   mitk::PlanarFigure *planarFigure = const_cast< mitk::PlanarFigure * >(
     static_cast< const mitk::PlanarFigure * >( GetDataNode()->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
   ApplyColorAndOpacityProperties( renderer );
 
   // Enable line antialiasing
   glEnable( GL_LINE_SMOOTH );
   glHint( GL_LINE_SMOOTH_HINT, GL_NICEST );
   glEnable(GL_DEPTH_TEST);
 
   // 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 anchorPoint; anchorPoint[0] = 0; anchorPoint[1] = 1;
 
   // render the actual lines of the PlanarFigure
   RenderLines(lineDisplayMode, planarFigure, anchorPoint, planarFigureGeometry2D, rendererGeometry2D, displayGeometry);
 
   // position-offset of the annotations, is set in RenderAnnotations() and
   // used in RenderQuantities()
   double annotationOffset = 0.0;
 
   //Get Global Opacity
   float globalOpacity = 1.0;
   node->GetFloatProperty("opacity", globalOpacity);
 
   // draw name near the anchor point (point located on the right)
   std::string name = node->GetName();
   if ( m_DrawName && !name.empty() )
   {
     RenderAnnotations(renderer, name, anchorPoint, globalOpacity, lineDisplayMode, annotationOffset);
   }
 
   // draw feature quantities (if requested) next to the anchor point,
   // but under the name (that is where 'annotationOffset' is used)
   if ( m_DrawQuantities )
   {
     RenderQuantities(planarFigure, renderer, anchorPoint, annotationOffset, globalOpacity, lineDisplayMode);
   }
 
   if ( m_DrawControlPoints )
   {
     // draw the control-points
     RenderControlPoints(planarFigure, lineDisplayMode, planarFigureGeometry2D, rendererGeometry2D, displayGeometry);
   }
 
   glLineWidth( 1.0f );
 }
 
 
 void mitk::PlanarFigureMapper2D::PaintPolyLine(
   mitk::PlanarFigure::PolyLineType vertices,
   bool closed,
   Point2D& anchorPoint,
   const Geometry2D* planarFigureGeometry2D,
   const Geometry2D* rendererGeometry2D,
   const DisplayGeometry* displayGeometry)
 {
   mitk::Point2D rightMostPoint;
   rightMostPoint.Fill( itk::NumericTraits<float>::min() );
 
   // transform all vertices into Point2Ds in display-Coordinates and store them in vector
   std::vector<mitk::Point2D> pointlist;
   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,
+    this->TransformObjectToDisplay( *iter, displayPoint,
       planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
 
     pointlist.push_back(displayPoint);
 
     if ( displayPoint[0] > rightMostPoint[0] )
       rightMostPoint = displayPoint;
   }
 
   // now paint all the points in one run
   std::vector<mitk::Point2D>::iterator pointIter;
 
   if ( closed )
   {
     glBegin( GL_LINE_LOOP );
   }
   else
   {
     glBegin( GL_LINE_STRIP );
   }
 
   for ( pointIter = pointlist.begin(); pointIter!=pointlist.end(); pointIter++ )
   {
     glVertex3f( (*pointIter)[0], (*pointIter)[1], PLANAR_OFFSET );
   }
   glEnd();
 
   anchorPoint = rightMostPoint;
 }
 
 
 void mitk::PlanarFigureMapper2D::DrawMainLines(
   mitk::PlanarFigure* figure,
   Point2D& anchorPoint,
   const Geometry2D* planarFigureGeometry2D,
   const Geometry2D* rendererGeometry2D,
   const DisplayGeometry* displayGeometry)
 {
   unsigned short numberOfPolyLines = figure->GetPolyLinesSize();
   for ( unsigned short loop=0; loop<numberOfPolyLines ; ++loop )
   {
     PlanarFigure::PolyLineType polyline = figure->GetPolyLine(loop);
 
     this->PaintPolyLine( polyline,
       figure->IsClosed(),
       anchorPoint, planarFigureGeometry2D,
       rendererGeometry2D, displayGeometry );
   }
 }
 
 void mitk::PlanarFigureMapper2D::DrawHelperLines(
   mitk::PlanarFigure* figure,
   Point2D& anchorPoint,
   const Geometry2D* planarFigureGeometry2D,
   const Geometry2D* rendererGeometry2D,
   const DisplayGeometry* displayGeometry)
 {
   unsigned short numberOfHelperPolyLines = figure->GetHelperPolyLinesSize();
 
   // Draw helper objects
   for ( unsigned int loop=0; loop<numberOfHelperPolyLines; ++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;
     }
 
     // ... and once normally above the shadow.
     this->PaintPolyLine( helperPolyLine, false,
       anchorPoint, 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;
 
   if ( markerOpacity == 0 && lineOpacity == 0 )
     return;
 
   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 );
       if ( markerOpacity > 0 )
       {
         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 );
       glVertex3f( displayPoint[0] - 4, displayPoint[1] - 4, PLANAR_OFFSET );
       glVertex3f( displayPoint[0] - 4, displayPoint[1] + 4, PLANAR_OFFSET );
       glVertex3f( displayPoint[0] + 4, displayPoint[1] + 4, PLANAR_OFFSET );
       glVertex3f( displayPoint[0] + 4, displayPoint[1] - 4, PLANAR_OFFSET );
       glEnd();
       break;
     }
 
   case PlanarFigureControlPointStyleProperty::Circle:
     {
       float radius = 4.0;
 
       if ( markerOpacity > 0 )
       {
         // Paint filled circle
         glBegin( GL_POLYGON );
         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 );
           glVertex3f(x, y, PLANAR_OFFSET);
         }
         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 );
         glVertex3f(x, y, PLANAR_OFFSET);
       }
       glEnd();
       break;
     }
 
   } // end switch
 }
 
 
 void mitk::PlanarFigureMapper2D::InitializeDefaultPlanarFigureProperties()
 {
   m_IsSelected = false;
   m_IsHovering = false;
   m_DrawOutline = false;
   m_DrawQuantities = false;
   m_DrawShadow = false;
   m_DrawControlPoints = false;
   m_DrawName = true;
   m_DrawDashed = false;
   m_DrawHelperDashed = false;
 
   m_ShadowWidthFactor = 1.2;
   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;
   }
 
   // if we have not added an observer for ModifiedEvents on the DataNode,
   // we add one now.
   if ( !m_NodeModifiedObserverAdded )
   {
     itk::SimpleMemberCommand<mitk::PlanarFigureMapper2D>::Pointer nodeModifiedCommand = itk::SimpleMemberCommand<mitk::PlanarFigureMapper2D>::New();
     nodeModifiedCommand->SetCallbackFunction(this, &mitk::PlanarFigureMapper2D::OnNodeModified);
     m_NodeModifiedObserverTag = node->AddObserver(itk::ModifiedEvent(), nodeModifiedCommand);
     m_NodeModifiedObserverAdded = true;
   }
 
   // If the DataNode has not been modified since the last execution of
   // this method, we do not run it now.
   if ( !m_NodeModified )
     return;
 
   // Mark the current properties as unmodified
   m_NodeModified = false;
 
   //Get Global Opacity
   float globalOpacity = 1.0;
   node->GetFloatProperty("opacity", globalOpacity);
 
   node->GetBoolProperty( "selected", m_IsSelected );
   node->GetBoolProperty( "planarfigure.ishovering", m_IsHovering );
   node->GetBoolProperty( "planarfigure.drawoutline", m_DrawOutline );
   node->GetBoolProperty( "planarfigure.drawshadow", m_DrawShadow );
   node->GetBoolProperty( "planarfigure.drawquantities", m_DrawQuantities );
   node->GetBoolProperty( "planarfigure.drawcontrolpoints", m_DrawControlPoints );
   node->GetBoolProperty( "planarfigure.drawname", m_DrawName );
 
   node->GetBoolProperty( "planarfigure.drawdashed", m_DrawDashed );
   node->GetBoolProperty( "planarfigure.helperline.drawdashed", m_DrawHelperDashed );
 
   node->GetFloatProperty( "planarfigure.line.width", m_LineWidth );
   node->GetFloatProperty( "planarfigure.shadow.widthmodifier", m_ShadowWidthFactor );
   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();
   }
 
   //Set default color and opacity
   //If property "planarfigure.default.*.color" exists, then use that color. Otherwise global "color" property is used.
   if( !node->GetColor( m_LineColor[PF_DEFAULT], NULL, "planarfigure.default.line.color"))
   {
     node->GetColor( m_LineColor[PF_DEFAULT], NULL, "color" );
   }
   node->GetFloatProperty( "planarfigure.default.line.opacity", m_LineOpacity[PF_DEFAULT] );
 
   if( !node->GetColor( m_OutlineColor[PF_DEFAULT], NULL, "planarfigure.default.outline.color"))
   {
     node->GetColor( m_OutlineColor[PF_DEFAULT], NULL, "color" );
   }
   node->GetFloatProperty( "planarfigure.default.outline.opacity", m_OutlineOpacity[PF_DEFAULT] );
 
   if( !node->GetColor( m_HelperlineColor[PF_DEFAULT], NULL, "planarfigure.default.helperline.color"))
   {
     node->GetColor( m_HelperlineColor[PF_DEFAULT], NULL, "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] );
 
   //Set hover color and opacity
   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] );
 
   //Set selected color and opacity
   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] );
 
   //adapt opacity values to global "opacity" property
   for( unsigned int i = 0; i < PF_COUNT; ++i )
   {
     m_LineOpacity[i] *= globalOpacity;
     m_OutlineOpacity[i] *= globalOpacity;
     m_HelperlineOpacity[i] *= globalOpacity;
     m_MarkerlineOpacity[i] *= globalOpacity;
     m_MarkerOpacity[i] *= globalOpacity;
   }
 
 }
 
 void mitk::PlanarFigureMapper2D::OnNodeModified()
 {
   m_NodeModified = true;
 }
 
 void mitk::PlanarFigureMapper2D::SetDefaultProperties( mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite )
 {
   node->AddProperty( "visible", mitk::BoolProperty::New(true), renderer, overwrite );
 
   //node->SetProperty("planarfigure.iseditable",mitk::BoolProperty::New(true));
   node->AddProperty("planarfigure.isextendable",mitk::BoolProperty::New(false));
   //node->AddProperty( "planarfigure.ishovering", mitk::BoolProperty::New(true) );
   node->AddProperty( "planarfigure.drawoutline", mitk::BoolProperty::New(false) );
   //node->AddProperty( "planarfigure.drawquantities", mitk::BoolProperty::New(true) );
   node->AddProperty( "planarfigure.drawshadow", mitk::BoolProperty::New(true) );
   node->AddProperty( "planarfigure.drawcontrolpoints", mitk::BoolProperty::New(true) );
   node->AddProperty( "planarfigure.drawname", mitk::BoolProperty::New(true) );
   node->AddProperty( "planarfigure.drawdashed", mitk::BoolProperty::New(false) );
   node->AddProperty( "planarfigure.helperline.drawdashed", mitk::BoolProperty::New(false) );
 
   node->AddProperty("planarfigure.line.width", mitk::FloatProperty::New(2.0) );
   node->AddProperty("planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(2.0) );
   node->AddProperty("planarfigure.outline.width", mitk::FloatProperty::New(2.0) );
   node->AddProperty("planarfigure.helperline.width", mitk::FloatProperty::New(1.0) );
 
   node->AddProperty( "planarfigure.default.line.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.default.outline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.default.helperline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.default.markerline.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
   node->AddProperty( "planarfigure.default.markerline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.default.marker.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
   node->AddProperty( "planarfigure.default.marker.opacity",mitk::FloatProperty::New(1.0) );
 
   node->AddProperty( "planarfigure.hover.line.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
   node->AddProperty( "planarfigure.hover.line.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.hover.outline.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
   node->AddProperty( "planarfigure.hover.outline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.hover.helperline.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
   node->AddProperty( "planarfigure.hover.helperline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.hover.markerline.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
   node->AddProperty( "planarfigure.hover.markerline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.hover.marker.color", mitk::ColorProperty::New(0.0,1.0,0.0)  );
   node->AddProperty( "planarfigure.hover.marker.opacity", mitk::FloatProperty::New(1.0) );
 
   node->AddProperty( "planarfigure.selected.line.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
   node->AddProperty( "planarfigure.selected.line.opacity",mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.selected.outline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
   node->AddProperty( "planarfigure.selected.outline.opacity", mitk::FloatProperty::New(1.0));
   node->AddProperty( "planarfigure.selected.helperline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
   node->AddProperty( "planarfigure.selected.helperline.opacity",mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.selected.markerline.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
   node->AddProperty( "planarfigure.selected.markerline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.selected.marker.color", mitk::ColorProperty::New(1.0,0.0,0.0)  );
   node->AddProperty( "planarfigure.selected.marker.opacity",mitk::FloatProperty::New(1.0));
 }
 
 
 void mitk::PlanarFigureMapper2D::RenderControlPoints( mitk::PlanarFigure * planarFigure,
                                                       PlanarFigureDisplayMode lineDisplayMode,
                                                       mitk::Geometry2D * planarFigureGeometry2D,
                                                       const mitk::Geometry2D * rendererGeometry2D,
                                                       mitk::DisplayGeometry * displayGeometry )
 {
   bool isEditable = true;
   m_DataNode->GetBoolProperty( "planarfigure.iseditable", isEditable );
 
   PlanarFigureDisplayMode pointDisplayMode = PF_DEFAULT;
 
 
   unsigned int selectedControlPointsIdx = (unsigned int) planarFigure->GetSelectedControlPoint();
   unsigned int numberOfControlPoints = planarFigure->GetNumberOfControlPoints();
   // Draw markers at control points (selected control point will be colored)
   for ( unsigned int i = 0; i < numberOfControlPoints ; ++i )
   {
     // 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 == selectedControlPointsIdx )
       {
         pointDisplayMode = PF_SELECTED;
       }
       else if ( m_IsHovering && isEditable )
       {
         pointDisplayMode = PF_HOVER;
       }
     }
 
     if ( m_MarkerOpacity[pointDisplayMode] == 0
       && m_MarkerlineOpacity[pointDisplayMode] == 0 )
     {
       continue;
     }
 
     if ( m_DrawOutline )
     {
       // draw outlines for markers as well
       // linewidth for the contour is only half, as full width looks
       // much too thick!
       this->DrawMarker( planarFigure->GetControlPoint( i ),
         m_OutlineColor[lineDisplayMode],
         m_MarkerlineOpacity[pointDisplayMode],
         m_OutlineColor[lineDisplayMode],
         m_MarkerOpacity[pointDisplayMode],
         m_OutlineWidth/2,
         m_ControlPointShape,
         planarFigureGeometry2D,
         rendererGeometry2D,
         displayGeometry );
     }
 
     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
       );
   }
 }
 
 void mitk::PlanarFigureMapper2D::RenderAnnotations( mitk::BaseRenderer * renderer,
                                                     std::string name,
                                                     mitk::Point2D anchorPoint,
                                                     float globalOpacity,
                                                     PlanarFigureDisplayMode lineDisplayMode,
                                                     double &annotationOffset )
 {
   mitk::VtkPropRenderer* openGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
   if ( openGLrenderer )
   {
     openGLrenderer->WriteSimpleText( name,
       anchorPoint[0] + 6.0, anchorPoint[1] + 4.0,
       0,
       0,
       0,
       globalOpacity ); //this is a shadow
 
     openGLrenderer->WriteSimpleText( name,
       anchorPoint[0] + 5.0, anchorPoint[1] + 5.0,
       m_LineColor[lineDisplayMode][0],
       m_LineColor[lineDisplayMode][1],
       m_LineColor[lineDisplayMode][2],
       globalOpacity );
 
     // If drawing is successful, add approximate height to annotation offset
     annotationOffset -= 15.0;
   }
 }
 
 void mitk::PlanarFigureMapper2D::RenderQuantities( mitk::PlanarFigure * planarFigure,
                                                    mitk::BaseRenderer * renderer,
                                                    mitk::Point2D anchorPoint,
                                                    double &annotationOffset,
                                                    float globalOpacity,
                                                    PlanarFigureDisplayMode lineDisplayMode )
 {
   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) && planarFigure->IsFeatureVisible( i ) )
     {
       if ( ! firstActiveFeature )
       {
         quantityString << " x ";
       }
       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(),
       anchorPoint[0] + 6.0, anchorPoint[1] + 4.0 + annotationOffset,
       0,
       0,
       0,
       globalOpacity ); //this is a shadow
 
     openGLrenderer->WriteSimpleText( quantityString.str().c_str(),
       anchorPoint[0] + 5.0, anchorPoint[1] + 5.0 + annotationOffset,
       m_LineColor[lineDisplayMode][0],
       m_LineColor[lineDisplayMode][1],
       m_LineColor[lineDisplayMode][2],
       globalOpacity );
 
     // If drawing is successful, add approximate height to annotation offset
     annotationOffset -= 15.0;
   }
 }
 
 void mitk::PlanarFigureMapper2D::RenderLines( PlanarFigureDisplayMode lineDisplayMode,
                                               mitk::PlanarFigure * planarFigure,
                                               mitk::Point2D &anchorPoint,
                                               mitk::Geometry2D * planarFigureGeometry2D,
                                               const mitk::Geometry2D * rendererGeometry2D,
                                               mitk::DisplayGeometry * displayGeometry )
 {
   glLineStipple(1, 0x00FF);
 
   // If we want to draw an outline, we do it here
   if ( m_DrawOutline )
   {
     float* color = m_OutlineColor[lineDisplayMode];
     float opacity = m_OutlineOpacity[lineDisplayMode];
 
     // convert to a float array that also contains opacity, faster GL
     float* colorVector = new float[4];
     colorVector[0] = color[0];
     colorVector[1] = color[1];
     colorVector[2] = color[2];
     colorVector[3] = opacity;
 
     // set the color and opacity here as it is common for all outlines
     glColor4fv( colorVector );
     glLineWidth(m_OutlineWidth);
 
     if (m_DrawDashed)
       glEnable(GL_LINE_STIPPLE);
     else
       glDisable(GL_LINE_STIPPLE);
 
     // Draw the outline for all polylines if requested
     this->DrawMainLines( planarFigure,
                          anchorPoint,
                          planarFigureGeometry2D,
                          rendererGeometry2D,
                          displayGeometry );
 
     glLineWidth( m_HelperlineWidth );
 
     if (m_DrawHelperDashed)
       glEnable(GL_LINE_STIPPLE);
     else
       glDisable(GL_LINE_STIPPLE);
 
     // Draw the outline for all helper objects if requested
     this->DrawHelperLines( planarFigure,
                            anchorPoint,
                            planarFigureGeometry2D,
                            rendererGeometry2D,
                            displayGeometry );
 
     // cleanup
     delete[] colorVector;
   }
 
   // If we want to draw a shadow, we do it here
   if ( m_DrawShadow )
   {
     // determine the shadow opacity
     float opacity = m_OutlineOpacity[lineDisplayMode];
     float shadowOpacity = 0.0f;
     if( opacity > 0.2f )
       shadowOpacity = opacity - 0.2f;
 
     // convert to a float array that also contains opacity, faster GL
     float* shadow = new float[4];
     shadow[0] = 0;
     shadow[1] = 0;
     shadow[2] = 0;
     shadow[3] = shadowOpacity;
 
     // set the color and opacity here as it is common for all shadows
     glColor4fv( shadow );
     glLineWidth( m_OutlineWidth * m_ShadowWidthFactor );
 
     if (m_DrawDashed)
       glEnable(GL_LINE_STIPPLE);
     else
       glDisable(GL_LINE_STIPPLE);
 
     // Draw the outline for all polylines if requested
     this->DrawMainLines( planarFigure,
                          anchorPoint,
                          planarFigureGeometry2D,
                          rendererGeometry2D,
                          displayGeometry );
 
     glLineWidth( m_HelperlineWidth );
 
     if (m_DrawHelperDashed)
       glEnable(GL_LINE_STIPPLE);
     else
       glDisable(GL_LINE_STIPPLE);
 
     // Draw the outline for all helper objects if requested
     this->DrawHelperLines( planarFigure,
                            anchorPoint,
                            planarFigureGeometry2D,
                            rendererGeometry2D,
                            displayGeometry );
 
     // cleanup
     delete[] shadow;
   }
 
   // set this in brackets to avoid duplicate variables in the same scope
   {
     float* color = m_LineColor[lineDisplayMode];
     float opacity = m_LineOpacity[lineDisplayMode];
 
     // convert to a float array that also contains opacity, faster GL
     float* colorVector = new float[4];
     colorVector[0] = color[0];
     colorVector[1] = color[1];
     colorVector[2] = color[2];
     colorVector[3] = opacity;
 
     // set the color and opacity here as it is common for all mainlines
     glColor4fv( colorVector );
     glLineWidth( m_LineWidth );
 
     if (m_DrawDashed)
       glEnable(GL_LINE_STIPPLE);
     else
       glDisable(GL_LINE_STIPPLE);
 
     // Draw the main line for all polylines
     this->DrawMainLines( planarFigure,
       anchorPoint,
       planarFigureGeometry2D,
       rendererGeometry2D,
       displayGeometry );
 
 
     float* helperColor = m_HelperlineColor[lineDisplayMode];
     float helperOpacity = m_HelperlineOpacity[lineDisplayMode];
     // convert to a float array that also contains opacity, faster GL
     float* helperColorVector = new float[4];
     helperColorVector[0] = helperColor[0];
     helperColorVector[1] = helperColor[1];
     helperColorVector[2] = helperColor[2];
     helperColorVector[3] = helperOpacity;
 
     // we only set the color for the helperlines as the linewidth is unchanged
     glColor4fv( helperColorVector );
 
     glLineWidth( m_HelperlineWidth );
 
     if (m_DrawHelperDashed)
       glEnable(GL_LINE_STIPPLE);
     else
       glDisable(GL_LINE_STIPPLE);
 
     // Draw helper objects
     this->DrawHelperLines( planarFigure,
       anchorPoint,
       planarFigureGeometry2D,
       rendererGeometry2D,
       displayGeometry );
 
     // cleanup
     delete[] colorVector;
     delete[] helperColorVector;
   }
 
   if ( m_DrawDashed || m_DrawHelperDashed )
     glDisable(GL_LINE_STIPPLE);
 }
diff --git a/Modules/PlanarFigure/Rendering/mitkPlanarFigureVtkMapper3D.cpp b/Modules/PlanarFigure/Rendering/mitkPlanarFigureVtkMapper3D.cpp
index 761030fd15..363cc8c46d 100644
--- a/Modules/PlanarFigure/Rendering/mitkPlanarFigureVtkMapper3D.cpp
+++ b/Modules/PlanarFigure/Rendering/mitkPlanarFigureVtkMapper3D.cpp
@@ -1,189 +1,189 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkPlanarFigureVtkMapper3D.h"
 #include <mitkPlanarFigure.h>
 #include <vtkCellArray.h>
 #include <vtkIdList.h>
 #include <vtkPoints.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkPolyLine.h>
 
 mitk::PlanarFigureVtkMapper3D::LocalStorage::LocalStorage()
   : m_Actor(vtkSmartPointer<vtkActor>::New()),
     m_LastMTime(0)
 {
 }
 
 mitk::PlanarFigureVtkMapper3D::LocalStorage::~LocalStorage()
 {
 }
 
 void mitk::PlanarFigureVtkMapper3D::SetDefaultProperties(DataNode*, BaseRenderer*, bool)
 {
 }
 
 mitk::PlanarFigureVtkMapper3D::PlanarFigureVtkMapper3D()
 {
 }
 
 mitk::PlanarFigureVtkMapper3D::~PlanarFigureVtkMapper3D()
 {
 }
 
 void mitk::PlanarFigureVtkMapper3D::ApplyColorAndOpacityProperties(BaseRenderer* renderer, vtkActor* actor)
 {
   if (actor == NULL)
     return;
 
   mitk::DataNode* dataNode = this->GetDataNode();
 
   if (dataNode == NULL)
     return;
 
   bool selected = false;
   dataNode->GetBoolProperty("selected", selected, renderer);
 
   float color[3];
   dataNode->GetColor(color, renderer, selected ? "planarfigure.selected.line.color" : "color");
 
   float opacity = 1.0f;
   dataNode->GetOpacity(opacity, renderer);
 
   vtkProperty* property = actor->GetProperty();
   property->SetColor(color[0], color[1], color[2]);
   property->SetOpacity(opacity);
 }
 
 void mitk::PlanarFigureVtkMapper3D::ApplyPlanarFigureProperties(BaseRenderer* renderer, vtkActor* actor)
 {
   if (actor == NULL)
     return;
 
   mitk::DataNode* dataNode = this->GetDataNode();
 
   if (dataNode == NULL)
     return;
 
   bool render = false;
   dataNode->GetBoolProperty("planarfigure.3drendering", render);
 
   actor->SetVisibility(render);
 
   float lineWidth = 1.0f;
   dataNode->GetFloatProperty("planarfigure.line.width", lineWidth, renderer);
 
   vtkProperty* property = actor->GetProperty();
   property->SetLineWidth(lineWidth);
 }
 
 void mitk::PlanarFigureVtkMapper3D::GenerateDataForRenderer(BaseRenderer* renderer)
 {
   typedef PlanarFigure::PolyLineType PolyLine;
 
   DataNode* node = this->GetDataNode();
 
   if (node == NULL)
     return;
 
   PlanarFigure* planarFigure = dynamic_cast<PlanarFigure*>(node->GetData());
 
   if (planarFigure == NULL || !planarFigure->IsPlaced())
     return;
 
   LocalStorage* localStorage = m_LocalStorageHandler.GetLocalStorage(renderer);
   unsigned long mTime = planarFigure->GetMTime();
 
   if (mTime > localStorage->m_LastMTime)
   {
     localStorage->m_LastMTime = mTime;
 
     const PlaneGeometry* planeGeometry = dynamic_cast<const PlaneGeometry*>(planarFigure->GetGeometry2D());
 
     if (planeGeometry == NULL)
       return;
 
     size_t numPolyLines = planarFigure->GetPolyLinesSize();
 
     if (numPolyLines == 0)
       return;
 
     vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
     vtkIdType baseIndex = 0;
 
     for (size_t i = 0; i < numPolyLines; ++i)
     {
       PolyLine polyLine = planarFigure->GetPolyLine(i);
       vtkIdType numPoints = polyLine.size();
 
       if (numPoints < 2)
         continue;
 
       PolyLine::const_iterator polyLineEnd = polyLine.end();
 
       for (PolyLine::const_iterator polyLineIt = polyLine.begin(); polyLineIt != polyLineEnd; ++polyLineIt)
       {
         Point3D point;
-        planeGeometry->Map(polyLineIt->Point, point);
+        planeGeometry->Map(*polyLineIt, point);
         points->InsertNextPoint(point.GetDataPointer());
       }
 
       vtkSmartPointer<vtkPolyLine> line = vtkSmartPointer<vtkPolyLine>::New();
 
       vtkIdList* pointIds = line->GetPointIds();
 
       if (planarFigure->IsClosed() && numPoints > 2)
       {
         pointIds->SetNumberOfIds(numPoints + 1);
         pointIds->SetId(numPoints, baseIndex);
       }
       else
       {
         pointIds->SetNumberOfIds(numPoints);
       }
 
       for (vtkIdType j = 0; j < numPoints; ++j)
         pointIds->SetId(j, baseIndex + j);
 
       cells->InsertNextCell(line);
 
       baseIndex += points->GetNumberOfPoints();
     }
 
     vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
     polyData->SetPoints(points);
     polyData->SetLines(cells);
 
     vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
     mapper->SetInputData(polyData);
 
     localStorage->m_Actor->SetMapper(mapper);
   }
 
   this->ApplyColorAndOpacityProperties(renderer, localStorage->m_Actor);
   this->ApplyPlanarFigureProperties(renderer, localStorage->m_Actor);
 }
 
 vtkProp* mitk::PlanarFigureVtkMapper3D::GetVtkProp(BaseRenderer* renderer)
 {
   return m_LocalStorageHandler.GetLocalStorage(renderer)->m_Actor;
 }
 
 void mitk::PlanarFigureVtkMapper3D::UpdateVtkTransform(BaseRenderer*)
 {
 }