diff --git a/Modules/PlanarFigure/src/DataManagement/mitkPlanarBezierCurve.cpp b/Modules/PlanarFigure/src/DataManagement/mitkPlanarBezierCurve.cpp
index b9b5bd5e2e..62cb9e8139 100644
--- a/Modules/PlanarFigure/src/DataManagement/mitkPlanarBezierCurve.cpp
+++ b/Modules/PlanarFigure/src/DataManagement/mitkPlanarBezierCurve.cpp
@@ -1,162 +1,162 @@
 /*===================================================================
 
 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);
 }
 
 
 void mitk::PlanarBezierCurve::EvaluateFeaturesInternal()
 {
   double length = 0.0;
 
   for (unsigned int i = 0; i < m_NumberOfSegments; ++i)
     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];
 }
 
 int mitk::PlanarBezierCurve::GetControlPointForPolylinePoint( int indexOfPolylinePoint, int polyLineIndex ) const
 {
   mitk::PlanarFigure::PolyLineType polyLine = GetPolyLine( polyLineIndex );
-  if ( indexOfPolylinePoint > polyLine.size() )
+  if ( indexOfPolylinePoint > static_cast<int>(polyLine.size()) )
   {
     return -1;
   }
 
   mitk::PlanarFigure::ControlPointListType::const_iterator elem;
   mitk::PlanarFigure::ControlPointListType::const_iterator first = m_ControlPoints.cbegin();
   mitk::PlanarFigure::ControlPointListType::const_iterator end = m_ControlPoints.cend();
 
   mitk::PlanarFigure::PolyLineType::const_iterator polyLineIter;
   mitk::PlanarFigure::PolyLineType::const_iterator polyLineEnd = polyLine.cend();
   mitk::PlanarFigure::PolyLineType::const_iterator polyLineStart = polyLine.cbegin();
   polyLineStart += indexOfPolylinePoint;
 
   for ( polyLineIter = polyLineStart; polyLineIter != polyLineEnd; ++polyLineIter )
   {
     elem = std::find( first, end, *polyLineIter );
     if ( elem != end )
     {
       return std::distance( first, elem );
     }
   }
 
   return GetNumberOfControlPoints();
 }
 
 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;
 }
 
 bool mitk::PlanarBezierCurve::Equals(const PlanarFigure &other) const
 {
   const mitk::PlanarBezierCurve* otherBezierCurve = dynamic_cast<const mitk::PlanarBezierCurve*>(&other);
   if ( otherBezierCurve )
   {
     if( this->m_NumberOfSegments != otherBezierCurve->m_NumberOfSegments )
       return false;
     if( this->m_DeCasteljauPoints != otherBezierCurve->m_DeCasteljauPoints )
       return false;
     return Superclass::Equals(other);
   }
   else
   {
     return false;
   }
 }
diff --git a/Modules/PlanarFigure/src/DataManagement/mitkPlanarFigure.cpp b/Modules/PlanarFigure/src/DataManagement/mitkPlanarFigure.cpp
index f11113a8ed..8497eeb702 100644
--- a/Modules/PlanarFigure/src/DataManagement/mitkPlanarFigure.cpp
+++ b/Modules/PlanarFigure/src/DataManagement/mitkPlanarFigure.cpp
@@ -1,798 +1,798 @@
 /*===================================================================
 
 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 "mitkPlaneGeometry.h"
 #include <mitkProperties.h>
 #include <mitkProportionalTimeGeometry.h>
 
 #include <algorithm>
 
 mitk::PlanarFigure::PlanarFigure()
 : m_SelectedControlPoint( -1 ),
   m_PreviewControlPointVisible( false ),
   m_FigurePlaced( false ),
   m_PlaneGeometry( nullptr ),
   m_PolyLineUpToDate(false),
   m_HelperLinesUpToDate(false),
   m_FeaturesUpToDate(false),
   m_FeaturesMTime( 0 )
 {
   m_HelperPolyLinesToBePainted = BoolContainerType::New();
 
   m_DisplaySize.first = 0.0;
   m_DisplaySize.second = 0;
 
   this->SetProperty( "closed", mitk::BoolProperty::New( false ) );
 
   // Currently only single-time-step geometries are supported
   this->InitializeTimeGeometry( 1 );
 }
 
 
 mitk::PlanarFigure::PlanarFigure(const Self& other)
   : BaseData(other),
     m_ControlPoints(other.m_ControlPoints),
     m_NumberOfControlPoints(other.m_NumberOfControlPoints),
     m_SelectedControlPoint(other.m_SelectedControlPoint),
     m_PolyLines(other.m_PolyLines),
     m_HelperPolyLines(other.m_HelperPolyLines),
     m_HelperPolyLinesToBePainted(other.m_HelperPolyLinesToBePainted->Clone()),
     m_PreviewControlPoint(other.m_PreviewControlPoint),
     m_PreviewControlPointVisible(other.m_PreviewControlPointVisible),
     m_FigurePlaced(other.m_FigurePlaced),
     m_PlaneGeometry(other.m_PlaneGeometry), // do not clone since SetPlaneGeometry() doesn't clone either
     m_PolyLineUpToDate(other.m_PolyLineUpToDate),
     m_HelperLinesUpToDate(other.m_HelperLinesUpToDate),
     m_FeaturesUpToDate(other.m_FeaturesUpToDate),
     m_Features(other.m_Features),
     m_FeaturesMTime(other.m_FeaturesMTime),
     m_DisplaySize(other.m_DisplaySize)
 {
 }
 
 
 void mitk::PlanarFigure::SetPlaneGeometry( mitk::PlaneGeometry *geometry )
 {
   this->SetGeometry( geometry );
   m_PlaneGeometry = dynamic_cast<PlaneGeometry *>(GetGeometry(0));//geometry;
 }
 
 
 const mitk::PlaneGeometry *mitk::PlanarFigure::GetPlaneGeometry() const
 {
   return m_PlaneGeometry;
 }
 
 
 bool mitk::PlanarFigure::IsClosed() const
 {
   mitk::BoolProperty* closed = dynamic_cast< mitk::BoolProperty* >( this->GetProperty( "closed" ).GetPointer() );
   if ( closed != nullptr )
   {
     return closed->GetValue();
   }
   return false;
 }
 
 
 void mitk::PlanarFigure::PlaceFigure( const mitk::Point2D& point )
 {
   for ( unsigned int i = 0; i < this->GetNumberOfControlPoints(); ++i )
   {
     m_ControlPoints.push_back( this->ApplyControlPointConstraints( i, point ) );
   }
 
   m_FigurePlaced = true;
   m_SelectedControlPoint = 1;
 }
 
 
 bool mitk::PlanarFigure::AddControlPoint( const mitk::Point2D& point, int position )
 {
   // if we already have the maximum number of control points, do nothing
   if ( m_NumberOfControlPoints < this->GetMaximumNumberOfControlPoints() )
   {
     // if position has not been defined or position would be the last control point, just append the new one
     // we also append a new point if we click onto the line between the first two control-points if the second control-point is selected
     // -> special case for PlanarCross
     if ( position == -1 || position > (int)m_NumberOfControlPoints-1 || (position == 1 && m_SelectedControlPoint == 2) )
     {
       if ( m_ControlPoints.size() > this->GetMaximumNumberOfControlPoints()-1 )
       {
         // get rid of deprecated control points in the list. This is necessary
         // as ::ResetNumberOfControlPoints() only sets the member, does not resize the list!
         m_ControlPoints.resize( this->GetNumberOfControlPoints() );
       }
 
       m_ControlPoints.push_back( this->ApplyControlPointConstraints( m_NumberOfControlPoints, point ) );
       m_SelectedControlPoint = m_NumberOfControlPoints;
     }
     else
     {
       // insert the point at the given position and set it as selected point
       auto iter = m_ControlPoints.begin() + position;
       m_ControlPoints.insert( iter, this->ApplyControlPointConstraints( position, point ) );
       for( unsigned int i = 0; i < m_ControlPoints.size(); ++i )
       {
         if( point == m_ControlPoints.at(i) )
         {
           m_SelectedControlPoint = i;
         }
       }
     }
 
     // polylines & helperpolylines need to be repainted
     m_PolyLineUpToDate = false;
     m_HelperLinesUpToDate = false;
     m_FeaturesUpToDate = false;
 
     // one control point more
     ++m_NumberOfControlPoints;
     return true;
   }
   else
   {
     return false;
   }
 }
 
 
 bool mitk::PlanarFigure::SetControlPoint( unsigned int index, const Point2D& point, bool createIfDoesNotExist )
 {
   bool controlPointSetCorrectly = false;
   if (createIfDoesNotExist)
   {
     if ( m_NumberOfControlPoints <= index )
     {
       m_ControlPoints.push_back( this->ApplyControlPointConstraints( index, point ) );
       m_NumberOfControlPoints++;
     }
     else
     {
       m_ControlPoints.at( index ) = this->ApplyControlPointConstraints( index, point );
     }
     controlPointSetCorrectly = true;
   }
   else if ( index < m_NumberOfControlPoints )
   {
     m_ControlPoints.at( index ) = this->ApplyControlPointConstraints( index, point );
     controlPointSetCorrectly = true;
   }
   else
   {
     return false;
   }
 
   if ( controlPointSetCorrectly )
   {
     m_PolyLineUpToDate = false;
     m_HelperLinesUpToDate = false;
     m_FeaturesUpToDate = false;
   }
 
   return controlPointSetCorrectly;
 }
 
 
 bool mitk::PlanarFigure::SetCurrentControlPoint( const Point2D& point )
 {
   if ( (m_SelectedControlPoint < 0) || (m_SelectedControlPoint >= (int)m_NumberOfControlPoints) )
   {
     return false;
   }
 
   return this->SetControlPoint(m_SelectedControlPoint, point, false);
 }
 
 
 unsigned int mitk::PlanarFigure::GetNumberOfControlPoints() const
 {
   return m_NumberOfControlPoints;
 }
 
 
 bool mitk::PlanarFigure::SelectControlPoint( unsigned int index )
 {
   if ( index < this->GetNumberOfControlPoints() )
   {
     m_SelectedControlPoint = index;
     return true;
   }
   else
   {
     return false;
   }
 }
 
 
 bool mitk::PlanarFigure::DeselectControlPoint()
 {
   bool wasSelected = ( m_SelectedControlPoint != -1);
 
   m_SelectedControlPoint = -1;
 
   return wasSelected;
 }
 
 void mitk::PlanarFigure::SetPreviewControlPoint( const Point2D& point )
 {
   m_PreviewControlPoint = point;
   m_PreviewControlPointVisible = true;
 }
 
 void mitk::PlanarFigure::ResetPreviewContolPoint()
 {
   m_PreviewControlPointVisible = false;
 }
 
 mitk::Point2D mitk::PlanarFigure::GetPreviewControlPoint()
 {
   return m_PreviewControlPoint;
 }
 
 bool mitk::PlanarFigure::IsPreviewControlPointVisible()
 {
   return m_PreviewControlPointVisible;
 }
 
 mitk::Point2D mitk::PlanarFigure::GetControlPoint( unsigned int index ) const
 {
   if ( index < m_NumberOfControlPoints )
   {
     return m_ControlPoints.at( index );
   }
 
   itkExceptionMacro( << "GetControlPoint(): Invalid index!" );
 }
 
 
 mitk::Point3D mitk::PlanarFigure::GetWorldControlPoint( unsigned int index ) const
 {
   Point3D point3D;
   if ( (m_PlaneGeometry != nullptr) && (index < m_NumberOfControlPoints) )
   {
     m_PlaneGeometry->Map( m_ControlPoints.at( index ), point3D );
     return point3D;
   }
 
   itkExceptionMacro( << "GetWorldControlPoint(): Invalid index!" );
 }
 
 
 const mitk::PlanarFigure::PolyLineType
 mitk::PlanarFigure::GetPolyLine(unsigned int index)
 {
   mitk::PlanarFigure::PolyLineType polyLine;
   if ( index > m_PolyLines.size() || !m_PolyLineUpToDate )
     {
       this->GeneratePolyLine();
       m_PolyLineUpToDate = true;
     }
 
   return m_PolyLines.at( index );
 }
 
 
 const mitk::PlanarFigure::PolyLineType
 mitk::PlanarFigure::GetPolyLine(unsigned int index) const
 {
   return m_PolyLines.at( index );
 }
 
 void mitk::PlanarFigure::ClearPolyLines()
 {
   for ( std::vector<PolyLineType>::size_type i=0; i<m_PolyLines.size(); i++ )
   {
     m_PolyLines.at( i ).clear();
   }
   m_PolyLineUpToDate = false;
 }
 
 const mitk::PlanarFigure::PolyLineType mitk::PlanarFigure::GetHelperPolyLine( unsigned int index,
                                                                              double mmPerDisplayUnit,
                                                                              unsigned int displayHeight )
 {
   mitk::PlanarFigure::PolyLineType helperPolyLine;
   if ( index < m_HelperPolyLines.size() )
   {
     // m_HelperLinesUpToDate does not cover changes in zoom-level, so we have to check previous values of the
     // two parameters as well
     if ( !m_HelperLinesUpToDate || m_DisplaySize.first != mmPerDisplayUnit || m_DisplaySize.second != displayHeight )
     {
       this->GenerateHelperPolyLine(mmPerDisplayUnit, displayHeight);
       m_HelperLinesUpToDate = true;
 
       // store these parameters to be able to check next time if somebody zoomed in or out
       m_DisplaySize.first = mmPerDisplayUnit;
       m_DisplaySize.second = displayHeight;
     }
 
     helperPolyLine = m_HelperPolyLines.at(index);
   }
 
   return helperPolyLine;
 }
 
 void mitk::PlanarFigure::ClearHelperPolyLines()
 {
   for ( std::vector<PolyLineType>::size_type i=0; i<m_HelperPolyLines.size(); i++ )
   {
     m_HelperPolyLines.at(i).clear();
   }
   m_HelperLinesUpToDate = false;
 }
 
 /** \brief Returns the number of features available for this PlanarFigure
 * (such as, radius, area, ...). */
 unsigned int mitk::PlanarFigure::GetNumberOfFeatures() const
 {
   return m_Features.size();
 }
 
 
-int mitk::PlanarFigure::GetControlPointForPolylinePoint( int indexOfPolylinePoint, int polyLineIndex ) const
+int mitk::PlanarFigure::GetControlPointForPolylinePoint( int indexOfPolylinePoint, int /*polyLineIndex*/ ) const
 {
   return indexOfPolylinePoint;
 }
 
 
 const char *mitk::PlanarFigure::GetFeatureName( unsigned int index ) const
 {
   if ( index < m_Features.size() )
   {
     return m_Features[index].Name.c_str();
   }
   else
   {
     return nullptr;
   }
 }
 
 
 const char *mitk::PlanarFigure::GetFeatureUnit( unsigned int index ) const
 {
   if ( index < m_Features.size() )
   {
     return m_Features[index].Unit.c_str();
   }
   else
   {
     return nullptr;
   }
 }
 
 
 double mitk::PlanarFigure::GetQuantity( unsigned int index ) const
 {
   if ( index < m_Features.size() )
   {
     return m_Features[index].Quantity;
   }
   else
   {
     return 0.0;
   }
 }
 
 
 bool mitk::PlanarFigure::IsFeatureActive( unsigned int index ) const
 {
   if ( index < m_Features.size() )
   {
     return m_Features[index].Active;
   }
   else
   {
     return false;
   }
 }
 
 bool mitk::PlanarFigure::IsFeatureVisible( unsigned int index ) const
 {
   if ( index < m_Features.size() )
   {
     return m_Features[index].Visible;
   }
   else
   {
     return false;
   }
 }
 
 void mitk::PlanarFigure::SetFeatureVisible( unsigned int index, bool visible )
 {
   if ( index < m_Features.size() )
   {
     m_Features[index].Visible = visible;
   }
 }
 
 
 void mitk::PlanarFigure::EvaluateFeatures()
 {
   if ( !m_FeaturesUpToDate || !m_PolyLineUpToDate )
   {
     if ( !m_PolyLineUpToDate )
     {
       this->GeneratePolyLine();
     }
 
     this->EvaluateFeaturesInternal();
 
     m_FeaturesUpToDate = true;
   }
 }
 
 
 void mitk::PlanarFigure::UpdateOutputInformation()
 {
   // Bounds are NOT calculated here, since the PlaneGeometry defines a fixed
   // frame (= bounds) for the planar figure.
   Superclass::UpdateOutputInformation();
   this->GetTimeGeometry()->Update();
 }
 
 
 void mitk::PlanarFigure::SetRequestedRegionToLargestPossibleRegion()
 {
 }
 
 
 bool mitk::PlanarFigure::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
   return false;
 }
 
 
 bool mitk::PlanarFigure::VerifyRequestedRegion()
 {
   return true;
 }
 
 
 void mitk::PlanarFigure::SetRequestedRegion(const itk::DataObject * /*data*/ )
 {
 }
 
 
 void mitk::PlanarFigure::ResetNumberOfControlPoints( int numberOfControlPoints )
 {
   // DO NOT resize the list here, will cause crash!!
   m_NumberOfControlPoints = numberOfControlPoints;
 }
 
 
 mitk::Point2D mitk::PlanarFigure::ApplyControlPointConstraints( unsigned int /*index*/, const Point2D& point )
 {
   if ( m_PlaneGeometry ==  nullptr )
   {
     return point;
   }
 
   Point2D indexPoint;
   m_PlaneGeometry->WorldToIndex( point, indexPoint );
 
   BoundingBox::BoundsArrayType bounds = m_PlaneGeometry->GetBounds();
   if ( indexPoint[0] < bounds[0] ) { indexPoint[0] = bounds[0]; }
   if ( indexPoint[0] > bounds[1] ) { indexPoint[0] = bounds[1]; }
   if ( indexPoint[1] < bounds[2] ) { indexPoint[1] = bounds[2]; }
   if ( indexPoint[1] > bounds[3] ) { indexPoint[1] = bounds[3]; }
 
   Point2D constrainedPoint;
   m_PlaneGeometry->IndexToWorld( indexPoint, constrainedPoint );
 
   return constrainedPoint;
 }
 
 
 unsigned int mitk::PlanarFigure::AddFeature( const char *featureName, const char *unitName )
 {
   unsigned int index = m_Features.size();
 
   Feature newFeature( featureName, unitName );
   m_Features.push_back( newFeature );
 
   return index;
 }
 
 
 void mitk::PlanarFigure::SetFeatureName( unsigned int index, const char *featureName )
 {
   if ( index < m_Features.size() )
   {
     m_Features[index].Name = featureName;
   }
 }
 
 
 void mitk::PlanarFigure::SetFeatureUnit( unsigned int index, const char *unitName )
 {
   if ( index < m_Features.size() )
   {
     m_Features[index].Unit = unitName;
   }
 }
 
 
 void mitk::PlanarFigure::SetQuantity( unsigned int index, double quantity )
 {
   if ( index < m_Features.size() )
   {
     m_Features[index].Quantity = quantity;
   }
 }
 
 
 void mitk::PlanarFigure::ActivateFeature( unsigned int index )
 {
   if ( index < m_Features.size() )
   {
     m_Features[index].Active = true;
   }
 }
 
 
 void mitk::PlanarFigure::DeactivateFeature( unsigned int index )
 {
   if ( index < m_Features.size() )
   {
     m_Features[index].Active = false;
   }
 }
 
 void mitk::PlanarFigure::InitializeTimeGeometry( unsigned int timeSteps )
 {
   mitk::PlaneGeometry::Pointer geometry2D = mitk::PlaneGeometry::New();
   geometry2D->Initialize();
 
   // The geometry is propagated automatically to all time steps,
   // if EvenlyTimed is true...
   ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
   timeGeometry->Initialize(geometry2D, timeSteps);
   SetTimeGeometry(timeGeometry);
 }
 
 
 void mitk::PlanarFigure::PrintSelf( std::ostream& os, itk::Indent indent) const
 {
   Superclass::PrintSelf( os, indent );
   os << indent << this->GetNameOfClass() << ":\n";
 
   if (this->IsClosed())
     os << indent << "This figure is closed\n";
   else
     os << indent << "This figure is not closed\n";
   os << indent << "Minimum number of control points: " << this->GetMinimumNumberOfControlPoints() << std::endl;
   os << indent << "Maximum number of control points: " << this->GetMaximumNumberOfControlPoints() << std::endl;
   os << indent << "Current number of control points: " << this->GetNumberOfControlPoints() << std::endl;
   os << indent << "Control points:" << std::endl;
 
   for ( unsigned int i = 0; i < this->GetNumberOfControlPoints(); ++i )
   {
     //os << indent.GetNextIndent() << i << ": " << m_ControlPoints->ElementAt( i ) << std::endl;
     os << indent.GetNextIndent() << i << ": " << m_ControlPoints.at( i ) << std::endl;
   }
   os << indent << "Geometry:\n";
   this->GetPlaneGeometry()->Print(os, indent.GetNextIndent());
 }
 
 
 unsigned short mitk::PlanarFigure::GetPolyLinesSize()
 {
   if ( !m_PolyLineUpToDate )
   {
     this->GeneratePolyLine();
     m_PolyLineUpToDate = true;
   }
   return m_PolyLines.size();
 }
 
 
 unsigned short mitk::PlanarFigure::GetHelperPolyLinesSize()
 {
   return m_HelperPolyLines.size();
 }
 
 
 bool mitk::PlanarFigure::IsHelperToBePainted(unsigned int index)
 {
   return m_HelperPolyLinesToBePainted->GetElement( index );
 }
 
 
 bool mitk::PlanarFigure::ResetOnPointSelect()
 {
   return false;
 }
 
 void mitk::PlanarFigure::RemoveControlPoint( unsigned int index )
 {
   if ( index > m_ControlPoints.size() )
     return;
 
   if ( (m_ControlPoints.size() -1)  < this->GetMinimumNumberOfControlPoints() )
     return;
 
   ControlPointListType::iterator iter;
   iter = m_ControlPoints.begin() + index;
 
   m_ControlPoints.erase( iter );
 
   m_PolyLineUpToDate = false;
   m_HelperLinesUpToDate = false;
   m_FeaturesUpToDate = false;
 
   --m_NumberOfControlPoints;
 }
 
 void mitk::PlanarFigure::RemoveLastControlPoint()
 {
   RemoveControlPoint( m_ControlPoints.size()-1 );
 }
 
 void mitk::PlanarFigure::SetNumberOfPolyLines( unsigned int numberOfPolyLines )
 {
   m_PolyLines.resize(numberOfPolyLines);
 }
 
 void mitk::PlanarFigure::SetNumberOfHelperPolyLines( unsigned int numberOfHerlperPolyLines )
 {
   m_HelperPolyLines.resize(numberOfHerlperPolyLines);
 }
 
 void mitk::PlanarFigure::AppendPointToPolyLine( unsigned int index, PolyLineElement element )
 {
   if ( index < m_PolyLines.size() )
   {
     m_PolyLines[index].push_back(element);
     m_PolyLineUpToDate = false;
   }
   else
   {
     MITK_ERROR << "Tried to add point to PolyLine " << index+1 << ", although only " << m_PolyLines.size() << " exists";
   }
 }
 
 void mitk::PlanarFigure::AppendPointToHelperPolyLine( unsigned int index, PolyLineElement element )
 {
   if ( index < m_HelperPolyLines.size() )
   {
     m_HelperPolyLines[index].push_back(element);
     m_HelperLinesUpToDate = false;
   }
   else
   {
     MITK_ERROR << "Tried to add point to HelperPolyLine " << index+1 << ", although only " << m_HelperPolyLines.size() << " exists";
   }
 }
 
 bool mitk::PlanarFigure::Equals(const mitk::PlanarFigure& other) const
 {
   //check geometries
   if ( this->GetPlaneGeometry() && other.GetPlaneGeometry() )
   {
     if( !Equal(*(this->GetPlaneGeometry()), *(other.GetPlaneGeometry()), mitk::eps, true))
     {
       return false;
     }
   }
   else
   {
     MITK_ERROR << "Geometry is not equal";
     return false;
   }
 
   //check isPlaced member
   if ( this->m_FigurePlaced != other.m_FigurePlaced)
   {
     MITK_ERROR << "Is_Placed is not equal";
     return false;
   }
 
   //check closed property
   if (this->IsClosed() != other.IsClosed())
   {
     MITK_ERROR << "Is_closed is not equal";
     return false;
   }
 
   //check poly lines
   if (this->m_PolyLines.size() != other.m_PolyLines.size())
   {
     return false;
   }
   else
   {
     auto itThis = this->m_PolyLines.begin();
     auto itEnd = this->m_PolyLines.end();
     auto itOther = other.m_PolyLines.begin();
 
     while( itThis != itEnd )
     {
       if(itThis->size() != itOther->size())
         return false;
       else
       {
         auto itLineThis = itThis->begin();
         auto itLineEnd = itThis->end();
         auto itLineOther = itOther->begin();
 
         while(itLineThis != itLineEnd)
         {
           Point2D p1 = *itLineThis;
           Point2D p2 = *itLineOther;
           ScalarType delta = fabs(p1[0]-p2[0])+fabs(p1[1]-p2[1]);
           if(delta > .001)
           {
             MITK_ERROR << "Poly line is not equal";
             MITK_ERROR << p1 << "/" << p2;
             return false;
           }
 
           ++itLineThis;
           ++itLineOther;
         }
       }
       ++itThis;
       ++itOther;
     }
   }
 
   //check features
   if (this->GetNumberOfFeatures() != other.GetNumberOfFeatures())
   {
     MITK_ERROR << "Number of Features is Different";
     return false;
   }
   else
   {
     auto itThis = m_Features.begin();
     auto itEnd = m_Features.end();
     auto itOther = other.m_Features.begin();
 
     while(itThis != itEnd)
     {
       if(( itThis->Quantity - itOther->Quantity) > .001 )
       {
         MITK_ERROR << "Quantity is Different" << itThis->Quantity << "/" << itOther->Quantity;
         return false;
       }
       if( itThis->Unit.compare(itOther->Unit) != 0 )
       {
         MITK_ERROR << "Unit is Different" << itThis->Unit << "/" << itOther->Unit;
         return false;
       }
       if( itThis->Name.compare(itOther->Name) != 0 )
       {
         MITK_ERROR << "Name of Measure is Different " << itThis->Name << "/ " << itOther->Name;;
         return false;
       }
 
       ++itThis;
       ++itOther;
     }
   }
 
   return true;
 }
 
 bool mitk::Equal( const mitk::PlanarFigure& leftHandSide, const mitk::PlanarFigure& rightHandSide, ScalarType /*eps*/, bool /*verbose*/ )
 {
   // FIXME: use eps and verbose
   return leftHandSide.Equals(rightHandSide);
 }
diff --git a/Modules/PlanarFigure/src/DataManagement/mitkPlanarSubdivisionPolygon.cpp b/Modules/PlanarFigure/src/DataManagement/mitkPlanarSubdivisionPolygon.cpp
index b05e089f60..80d8626b77 100644
--- a/Modules/PlanarFigure/src/DataManagement/mitkPlanarSubdivisionPolygon.cpp
+++ b/Modules/PlanarFigure/src/DataManagement/mitkPlanarSubdivisionPolygon.cpp
@@ -1,173 +1,173 @@
 /*===================================================================
 
 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 "mitkPlanarSubdivisionPolygon.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkProperties.h"
 
 // stl related includes
 #include <algorithm>
 
 mitk::PlanarSubdivisionPolygon::PlanarSubdivisionPolygon():
   m_TensionParameter(0.0625),
   m_SubdivisionRounds(5)
 {
   // Polygon is subdivision (in contrast to parent class PlanarPolygon
   this->SetProperty( "closed", mitk::BoolProperty::New( true ) );
   this->SetProperty( "subdivision", mitk::BoolProperty::New( true ) );
 
   // Other properties are inherited / already initialized by parent class PlanarPolygon
 }
 
 
 void mitk::PlanarSubdivisionPolygon::GeneratePolyLine()
 {
   this->ClearPolyLines();
   ControlPointListType subdivisionPoints;
   ControlPointListType newSubdivisionPoints;
   subdivisionPoints.clear();
   subdivisionPoints = m_ControlPoints;
 
   if( m_ControlPoints.size() >= GetMinimumNumberOfControlPoints() )
   {
 
     for( unsigned int i=0; i < GetSubdivisionRounds(); i++ )
     {
       // Indices
       unsigned int index, indexPrev, indexNext, indexNextNext;
 
       unsigned int numberOfPoints = subdivisionPoints.size();
 
       Point2D newPoint;
 
       // Keep cycling our array indices forward until they wrap around at the end
       for ( index = 0; index < numberOfPoints; ++index )
       {
         // Create new subdivision point according to formula
         // p_new = (0.5 + tension) * (p_here + p_next) - tension * (p_prev + p_nextnext)
         indexPrev = (numberOfPoints + index - 1) % numberOfPoints;
         indexNext = (index + 1) % numberOfPoints;
         indexNextNext = (index + 2) % numberOfPoints;
 
         newPoint[0] = (0.5 + GetTensionParameter()) * (double)( subdivisionPoints[index][0] + subdivisionPoints[indexNext][0] )
             - GetTensionParameter() * (double)( subdivisionPoints[indexPrev][0] + subdivisionPoints[indexNextNext][0]);
         newPoint[1] = (0.5 + GetTensionParameter()) * (double)( subdivisionPoints[index][1] + subdivisionPoints[indexNext][1] )
             - GetTensionParameter() * (double)( subdivisionPoints[indexPrev][1] + subdivisionPoints[indexNextNext][1]);
 
         newSubdivisionPoints.push_back( newPoint );
       }
 
       ControlPointListType mergedSubdivisionPoints;
       ControlPointListType::iterator it, itNew;
 
 
       for ( it = subdivisionPoints.begin() , itNew = newSubdivisionPoints.begin();
             it != subdivisionPoints.end();
             ++it, ++itNew )
       {
         mergedSubdivisionPoints.push_back( *it );
         mergedSubdivisionPoints.push_back( *itNew );
       }
 
       subdivisionPoints = mergedSubdivisionPoints;
 
       newSubdivisionPoints.clear();
     }
   }
 
   bool isInitiallyPlaced = this->GetProperty("initiallyplaced");
 
   unsigned int i;
   ControlPointListType::iterator it;
   for ( it = subdivisionPoints.begin(), i = 0;
         it != subdivisionPoints.end();
         ++it, ++i )
   {
     // Determine the index of the control point FOLLOWING this poly-line element
     // (this is needed by PlanarFigureInteractor to insert new points at the correct position,
     // namely BEFORE the next control point)
     unsigned int nextIndex;
     if ( i == 0 )
     {
       // For the FIRST polyline point, use the index of the LAST control point
       // (it will used to check if the mouse is near the very last polyline element)
       nextIndex = m_ControlPoints.size() - 1;
     }
     else
     {
       // For all other polyline points, use the index of the control point succeeding it
       // (for polyline points lying on control points, the index of the previous control point
       // is used)
       nextIndex = (((i - 1) >> this->GetSubdivisionRounds()) + 1) % m_ControlPoints.size();
       if(!isInitiallyPlaced && nextIndex > m_ControlPoints.size()-2)
       {
         this->AppendPointToPolyLine( 0, m_ControlPoints[m_ControlPoints.size()-1] );
         break;
       }
     }
 
     this->AppendPointToPolyLine( 0, *it );
   }
   subdivisionPoints.clear();
 }
 
 bool mitk::PlanarSubdivisionPolygon::Equals(const mitk::PlanarFigure& other) const
  {
    const mitk::PlanarSubdivisionPolygon* otherSubDivPoly = dynamic_cast<const mitk::PlanarSubdivisionPolygon*>(&other);
    if ( otherSubDivPoly )
    {
      if ( this->m_SubdivisionRounds != otherSubDivPoly->m_SubdivisionRounds)
        return false;
      if ( std::abs(this->m_TensionParameter - otherSubDivPoly->m_TensionParameter) > mitk::eps)
        return false;
      return Superclass::Equals(other);
    }
    else
    {
      return false;
    }
  }
 
 
 int mitk::PlanarSubdivisionPolygon::GetControlPointForPolylinePoint( int indexOfPolylinePoint, int polyLineIndex ) const
 {
   mitk::PlanarFigure::PolyLineType polyLine = GetPolyLine( polyLineIndex );
-  if ( indexOfPolylinePoint > polyLine.size() )
+  if ( indexOfPolylinePoint > static_cast<int>(polyLine.size()) )
   {
     return -1;
   }
 
   mitk::PlanarFigure::ControlPointListType::const_iterator elem;
   mitk::PlanarFigure::ControlPointListType::const_iterator first = m_ControlPoints.cbegin();
   mitk::PlanarFigure::ControlPointListType::const_iterator end = m_ControlPoints.cend();
 
   mitk::PlanarFigure::PolyLineType::const_iterator polyLineIter;
   mitk::PlanarFigure::PolyLineType::const_iterator polyLineEnd = polyLine.cend();
   mitk::PlanarFigure::PolyLineType::const_iterator polyLineStart = polyLine.cbegin();
   polyLineStart += indexOfPolylinePoint;
 
   for ( polyLineIter = polyLineStart; polyLineIter != polyLineEnd; ++polyLineIter )
   {
     elem = std::find( first, end, *polyLineIter );
     if ( elem != end )
     {
       return std::distance( first, elem );
     }
   }
 
   return GetNumberOfControlPoints();
 }