diff --git a/Core/Code/Controllers/mitkPlanePositionManager.h b/Core/Code/Controllers/mitkPlanePositionManager.h
index f74e1dbc8b..2733cf35e2 100644
--- a/Core/Code/Controllers/mitkPlanePositionManager.h
+++ b/Core/Code/Controllers/mitkPlanePositionManager.h
@@ -1,104 +1,104 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #ifndef mitkPlanePositionManager_h_Included
 #define mitkPlanePositionManager_h_Included
 
 #include "mitkCommon.h"
-#include "MitkExtExports.h"
+//#include "MitkExtExports.h"
 #include "mitkRestorePlanePositionOperation.h"
 #include "mitkDataStorage.h"
 #include <mitkServiceReference.h>
 #include <mitkModuleContext.h>
 #include <mitkServiceInterface.h>
 
 class MitkCoreActivator;
 
 namespace mitk
 {
 
 /**
     The mitk::PlanePositionManagerService holds and manages a list of certain planepositions.
     To store a new position you need to specify the first slice of your slicestack and the
     slicenumber you want to restore in the mitk::PlanePositionManager::AddNewPlanePosition() function.
 
     To restore a position call mitk::PlanePositionManagerService::GetPlanePosition(ID) where ID is the position
     in the plane positionlist (returned by AddNewPlanePostion). This will give a mitk::RestorePlanePositionOperation
     which can be executed by the SliceNavigationController of the slicestack.
 
     \sa QmitkSegmentationView.cpp
   */
  class MITK_CORE_EXPORT PlanePositionManagerService : public itk::LightObject
  {
 
   public:
 
     /**
       \brief Adds a new plane position to the list. If this geometry is identical to one of the list nothing will be added
 
       \a plane THE FIRST! slice of the slice stack
       \a sliceIndex the slice number of the selected slice
       \return returns the ID i.e. the position in the positionlist. If the PlaneGeometry which is to be added already exists the existing
               ID will be returned.
     */
     unsigned int AddNewPlanePosition(const mitk::Geometry2D* plane, unsigned int sliceIndex = 0);
 
     /**
       \brief Removes the plane at the position \a ID from the list.
 
       \a ID the plane ID which should be removed, i.e. its position in the list
       \return true if the plane was removed successfully and false if it is an invalid ID
     */
     bool RemovePlanePosition(unsigned int ID);
 
     /// \brief Clears the complete positionlist
     void RemoveAllPlanePositions();
 
     /**
       \brief Getter for a specific plane position with a given ID
 
       \a ID the ID of the plane position
       \return Returns a RestorePlanePositionOperation which can be executed by th SliceNavigationController or NULL for an invalid ID
     */
     mitk::RestorePlanePositionOperation* GetPlanePosition( unsigned int ID);
 
     /// \brief Getting the number of all stored planes
     unsigned int GetNumberOfPlanePositions();
 
     friend class ::MitkCoreActivator;
 
  private:
 
 
    mitkClassMacro(PlanePositionManagerService, LightObject);
 
    itkFactorylessNewMacro(PlanePositionManagerService);
 
    PlanePositionManagerService();
    ~PlanePositionManagerService();
 
    // Disable copy constructor and assignment operator.
    PlanePositionManagerService(const PlanePositionManagerService&);
    PlanePositionManagerService& operator=(const PlanePositionManagerService&);
 
    static PlanePositionManagerService* m_Instance;
    std::vector<mitk::RestorePlanePositionOperation*> m_PositionList;
  };
 }
 MITK_DECLARE_SERVICE_INTERFACE(mitk::PlanePositionManagerService, "org.mitk.PlanePositionManagerService")
 
 #endif
diff --git a/Modules/PlanarFigure/Interactions/mitkPlanarFigureInteractor.cpp b/Modules/PlanarFigure/Interactions/mitkPlanarFigureInteractor.cpp
index 38dc5e1939..b1a4f38aa7 100644
--- a/Modules/PlanarFigure/Interactions/mitkPlanarFigureInteractor.cpp
+++ b/Modules/PlanarFigure/Interactions/mitkPlanarFigureInteractor.cpp
@@ -1,941 +1,952 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2008-10-02 16:21:08 +0200 (Do, 02 Okt 2008) $
 Version:   $Revision: 13129 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 
 #include "mitkPlanarFigureInteractor.h"
 #include "mitkPointOperation.h"
 #include "mitkPositionEvent.h"
 #include "mitkPlanarFigure.h"
 #include "mitkStatusBar.h"
 #include "mitkDataNode.h"
 #include "mitkInteractionConst.h"
 #include "mitkAction.h"
 #include "mitkStateEvent.h"
 #include "mitkOperationEvent.h"
 #include "mitkUndoController.h"
 #include "mitkStateMachineFactory.h"
 #include "mitkStateTransitionOperation.h"
 #include "mitkBaseRenderer.h"
 #include "mitkRenderingManager.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkNodePredicateOr.h"
 
 
 //how precise must the user pick the point
 //default value
 mitk::PlanarFigureInteractor
 ::PlanarFigureInteractor(const char * type, DataNode* dataNode, int /* n */ )
 : Interactor( type, dataNode ),
 m_Precision( 6.5 ),
 m_MinimumPointDistance( 25.0 ),
 m_IsHovering( false ),
 m_LastPointWasValid( false )
 {
 }
 
 mitk::PlanarFigureInteractor::~PlanarFigureInteractor()
 {
 }
 
 void mitk::PlanarFigureInteractor::SetPrecision( mitk::ScalarType precision )
 {
   m_Precision = precision;
 }
 
 
 void mitk::PlanarFigureInteractor::SetMinimumPointDistance( ScalarType minimumDistance )
 {
   m_MinimumPointDistance = minimumDistance;
 }
 
 
 // Overwritten since this class can handle it better!
 float mitk::PlanarFigureInteractor
 ::CanHandleEvent(StateEvent const* stateEvent) const
 {
   float returnValue = 0.5;
 
 
   // If it is a key event that can be handled in the current state,
   // then return 0.5
   mitk::DisplayPositionEvent const *disPosEvent =
     dynamic_cast <const mitk::DisplayPositionEvent *> (stateEvent->GetEvent());
 
   // Key event handling:
   if (disPosEvent == NULL)
   {
     // Check if the current state has a transition waiting for that key event.
     if (this->GetCurrentState()->GetTransition(stateEvent->GetId())!=NULL)
     {
       return 0.5;
     }
     else
     {
       return 0.0;
     }
   }
 
   mitk::PlanarFigure *planarFigure = dynamic_cast<mitk::PlanarFigure *>(
     m_DataNode->GetData() );
 
   if ( planarFigure != NULL )
   {
     // Give higher priority if this figure is currently selected
     if ( planarFigure->GetSelectedControlPoint() >= 0 )
     {
       return 1.0;
     }
 
   }
   return returnValue;
 }
 
 
 bool mitk::PlanarFigureInteractor
 ::ExecuteAction( Action *action, mitk::StateEvent const *stateEvent )
 {
   bool ok = false;
 
   // Check corresponding data; has to be sub-class of mitk::PlanarFigure
   mitk::PlanarFigure *planarFigure = 
     dynamic_cast< mitk::PlanarFigure * >( m_DataNode->GetData() );
 
   if ( planarFigure == NULL )
   {
     return false;
   }
 
   // Get the timestep to also support 3D+t
   const mitk::Event *theEvent = stateEvent->GetEvent();
   int timeStep = 0;
   mitk::ScalarType timeInMS = 0.0;
 
   if ( theEvent )
   {
     if (theEvent->GetSender() != NULL)
     {
       timeStep = theEvent->GetSender()->GetTimeStep( planarFigure );
       timeInMS = theEvent->GetSender()->GetTime();
     }
   }
 
   // Get Geometry2D of PlanarFigure
   mitk::Geometry2D *planarFigureGeometry =
     dynamic_cast< mitk::Geometry2D * >( planarFigure->GetGeometry( timeStep ) );
 
   // Get the Geometry2D of the window the user interacts with (for 2D point 
   // projection)
   mitk::BaseRenderer *renderer = NULL;
   const Geometry2D *projectionPlane = NULL;
   if ( theEvent )
   {
     renderer = theEvent->GetSender();
     projectionPlane = renderer->GetCurrentWorldGeometry2D();
   }
 
   // TODO: Check if display and PlanarFigure geometries are parallel (if they are PlaneGeometries)
 
 
 
   switch (action->GetActionId())
   {
   case AcDONOTHING:
     ok = true;
     break;
 
   case AcCHECKOBJECT:
     {
       if ( planarFigure->IsPlaced() )
       {
         this->HandleEvent( new mitk::StateEvent( EIDYES, NULL ) );
       }
       else
       {
         this->HandleEvent( new mitk::StateEvent( EIDNO, NULL ) );
       }
       ok = false;
       break;
     }
 
   case AcADD:
     {
       // Invoke event to notify listeners that placement of this PF starts now
       planarFigure->InvokeEvent( StartPlacementPlanarFigureEvent() );
 
       // Use Geometry2D of the renderer clicked on for this PlanarFigure
       mitk::PlaneGeometry *planeGeometry = const_cast< mitk::PlaneGeometry * >(
         dynamic_cast< const mitk::PlaneGeometry * >(
         renderer->GetSliceNavigationController()->GetCurrentPlaneGeometry() ) );
       if ( planeGeometry != NULL )
       {
         planarFigureGeometry = planeGeometry;
         planarFigure->SetGeometry2D( planeGeometry );
       }
       else
       {
         ok = false;
         break;
       }
 
       // Extract point in 2D world coordinates (relative to Geometry2D of
       // PlanarFigure)
       Point2D point2D;
       if ( !this->TransformPositionEventToPoint2D( stateEvent, point2D,
         planarFigureGeometry ) )
       {
         ok = false;
         break;
       }
 
       // Place PlanarFigure at this point
       planarFigure->PlaceFigure( point2D );
 
       // Re-evaluate features
       planarFigure->EvaluateFeatures();
       //this->LogPrintPlanarFigureQuantities( planarFigure );
 
       // Set a bool property indicating that the figure has been placed in
       // the current RenderWindow. This is required so that the same render
       // window can be re-aligned to the Geometry2D of the PlanarFigure later
       // on in an application.
       m_DataNode->SetBoolProperty( "PlanarFigureInitializedWindow", true, renderer );
 
       // Update rendered scene
       renderer->GetRenderingManager()->RequestUpdateAll();
 
       ok = true;
       break;
     }
 
   case AcMOVEPOINT:
     {
       bool isEditable = true;
       m_DataNode->GetBoolProperty( "planarfigure.iseditable", isEditable );
 
       // Extract point in 2D world coordinates (relative to Geometry2D of
       // PlanarFigure)
       Point2D point2D;
       if ( !this->TransformPositionEventToPoint2D( stateEvent, point2D,
         planarFigureGeometry ) || !isEditable )
       {
         ok = false;
         break;
       }
 
+      // check if the control points shall be hidden during interaction
+      bool hidecontrolpointsduringinteraction = false;
+      m_DataNode->GetBoolProperty( "planarfigure.hidecontrolpointsduringinteraction", hidecontrolpointsduringinteraction );
+
+      // hide the control points if necessary
+      m_DataNode->SetBoolProperty( "planarfigure.drawcontrolpoints", !hidecontrolpointsduringinteraction );
+
       // Move current control point to this point
       planarFigure->SetCurrentControlPoint( point2D );
 
       // Re-evaluate features
       planarFigure->EvaluateFeatures();
       //this->LogPrintPlanarFigureQuantities( planarFigure );
 
       // Update rendered scene
       renderer->GetRenderingManager()->RequestUpdateAll();
 
       ok = true;
       break;
     }
 
 
   case AcCHECKNMINUS1:
     {
       if ( planarFigure->GetNumberOfControlPoints() >=
         planarFigure->GetMaximumNumberOfControlPoints() )
       {
         // Initial placement finished: deselect control point and send an
         // event to notify application listeners
         planarFigure->Modified();
         planarFigure->DeselectControlPoint();
         planarFigure->InvokeEvent( EndPlacementPlanarFigureEvent() );
         planarFigure->InvokeEvent( EndInteractionPlanarFigureEvent() );
         planarFigure->SetProperty( "initiallyplaced", mitk::BoolProperty::New( true ) );
+        m_DataNode->SetBoolProperty( "planarfigure.drawcontrolpoints", true );
         m_DataNode->Modified();
         this->HandleEvent( new mitk::StateEvent( EIDYES, stateEvent->GetEvent() ) );
       }
       else
       {
         this->HandleEvent( new mitk::StateEvent( EIDNO, stateEvent->GetEvent() ) );
       }
 
       // Update rendered scene
       renderer->GetRenderingManager()->RequestUpdateAll();
 
       ok = true;
       break;
     }
 
 
   case AcCHECKEQUALS1:
     {
       // NOTE: Action name is a bit misleading; this action checks whether
       // the figure has already the minimum number of required points to
       // be finished (by double-click)
 
       const mitk::PositionEvent *positionEvent =
         dynamic_cast< const mitk::PositionEvent * > ( stateEvent->GetEvent() );
       if ( positionEvent == NULL )
       {
         ok = false;
         break;
       }
 
       if ( m_LastPointWasValid && planarFigure->GetNumberOfControlPoints() > planarFigure->GetMinimumNumberOfControlPoints()  )
       {
         // Initial placement finished: deselect control point and send an
         // event to notify application listeners
         planarFigure->Modified();
         planarFigure->DeselectControlPoint();
         planarFigure->RemoveLastControlPoint();
         planarFigure->SetProperty( "initiallyplaced", mitk::BoolProperty::New( true ) );
+        m_DataNode->SetBoolProperty( "planarfigure.drawcontrolpoints", true );
         m_DataNode->Modified();
         planarFigure->InvokeEvent( EndPlacementPlanarFigureEvent() );
         planarFigure->InvokeEvent( EndInteractionPlanarFigureEvent() );
 
         this->HandleEvent( new mitk::StateEvent( EIDYES, NULL ) );
       }
       else
       {
         this->HandleEvent( new mitk::StateEvent( EIDNO, NULL ) );
       }
 
       // Update rendered scene
       renderer->GetRenderingManager()->RequestUpdateAll();
 
       ok = true;
       break;
     }
 
 
   case AcCHECKPOINT:
     {
       // Check if the distance of the current point to the previously set point in display coordinates
       // is sufficient (if a previous point exists)
 
       // Extract display position
       const mitk::PositionEvent *positionEvent =
         dynamic_cast< const mitk::PositionEvent * > ( stateEvent->GetEvent() );
       if ( positionEvent == NULL )
       {
         ok = false;
         break;
       }
 
       m_LastPointWasValid = IsMousePositionAcceptableAsNewControlPoint( positionEvent, planarFigure );
       if (m_LastPointWasValid)
       {
         this->HandleEvent( new mitk::StateEvent( EIDYES, stateEvent->GetEvent() ) );
       }
       else
       {
         this->HandleEvent( new mitk::StateEvent( EIDNO, stateEvent->GetEvent() ) );
       }
 
       ok = true;
       break;
     }
 
 
   case AcADDPOINT:
     {
       bool selected = false;
       bool isEditable = true;
       m_DataNode->GetBoolProperty("selected", selected);
       m_DataNode->GetBoolProperty( "planarfigure.iseditable", isEditable );
 
       if ( !selected || !isEditable )
       {
         ok = false;
         break;
       }
 
       // Extract point in 2D world coordinates (relative to Geometry2D of
       // PlanarFigure)
       Point2D point2D, projectedPoint;
       if ( !this->TransformPositionEventToPoint2D( stateEvent, point2D,
         planarFigureGeometry ) )
       {
         ok = false;
         break;
       }
 
       // TODO: check segement of polyline we clicked in
       int nextIndex = this->IsPositionOverFigure(
         stateEvent, 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();
 
       ok = true;
       break;
     }
 
 
   case AcDESELECTPOINT:
     {
       planarFigure->DeselectControlPoint();
 
       // Issue event so that listeners may update themselves
       planarFigure->Modified();
       planarFigure->InvokeEvent( EndInteractionPlanarFigureEvent() );
 
+      m_DataNode->SetBoolProperty( "planarfigure.drawcontrolpoints", true );
       m_DataNode->Modified();
 
       // falls through
     }
 
   case AcCHECKHOVERING:
     {
       mitk::Point2D pointProjectedOntoLine;
       int previousControlPoint = mitk::PlanarFigureInteractor::IsPositionOverFigure(
         stateEvent, planarFigure,
         planarFigureGeometry,
         projectionPlane,
         renderer->GetDisplayGeometry(),
         pointProjectedOntoLine
         );
       bool isHovering = ( previousControlPoint != -1 );
 
       int pointIndex = mitk::PlanarFigureInteractor::IsPositionInsideMarker(
         stateEvent, planarFigure,
         planarFigureGeometry,
         projectionPlane,
         renderer->GetDisplayGeometry() );
 
       int initiallySelectedControlPoint = planarFigure->GetSelectedControlPoint();
 
       if ( pointIndex >= 0 )
       {
         // If mouse is above control point, mark it as selected
         planarFigure->SelectControlPoint( pointIndex );
 
         // If mouse is hovering above a marker, it is also hovering above the figure
         isHovering = true;
       }
       else
       {
         // Mouse in not above control point --> deselect point
         planarFigure->DeselectControlPoint();
       }
 
       bool renderingUpdateNeeded = true;
       if ( isHovering )
       {
         if ( !m_IsHovering )
         {
           // Invoke hover event once when the mouse is entering the figure area
           m_IsHovering = true;
           planarFigure->InvokeEvent( StartHoverPlanarFigureEvent() );
 
           // Set bool property to indicate that planar figure is currently in "hovering" mode
           m_DataNode->SetBoolProperty( "planarfigure.ishovering", true );
 
           renderingUpdateNeeded = true;
         }
 
         bool selected = false;
         bool isExtendable = false;
         bool isEditable = true;
         m_DataNode->GetBoolProperty("selected", selected);
         m_DataNode->GetBoolProperty("planarfigure.isextendable", isExtendable);
         m_DataNode->GetBoolProperty( "planarfigure.iseditable", isEditable );
 
         if ( selected && isHovering && isExtendable && pointIndex == -1 && isEditable )
         {
           const mitk::PositionEvent *positionEvent =
             dynamic_cast< const mitk::PositionEvent * > ( stateEvent->GetEvent() );
           if ( positionEvent != NULL )
           {
             renderer->GetDisplayGeometry()->DisplayToWorld( pointProjectedOntoLine, pointProjectedOntoLine );
             planarFigure->SetPreviewControlPoint( pointProjectedOntoLine );
 
             renderingUpdateNeeded = true;
           }
         }
         else
         {
           planarFigure->ResetPreviewContolPoint();
         }
 
         if ( planarFigure->GetSelectedControlPoint() != initiallySelectedControlPoint  )
         {
           // the selected control point has changed -> rendering update necessary
           renderingUpdateNeeded = true;
         }
 
         this->HandleEvent( new mitk::StateEvent( EIDYES, stateEvent->GetEvent() ) );
 
         // Return true: only this interactor is eligible to react on this event
         ok = true;
       }
       else
       {
         if ( m_IsHovering )
         {
           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
           m_DataNode->SetBoolProperty( "planarfigure.ishovering", false );
 
           renderingUpdateNeeded = true;
         }
 
         this->HandleEvent( new mitk::StateEvent( EIDNO, NULL ) );
 
         // Return false so that other (PlanarFigure) Interactors may react on this
         // event as well
         ok = false;
       }
 
       // Update rendered scene if necessray
       if ( renderingUpdateNeeded )
       {
         renderer->GetRenderingManager()->RequestUpdateAll();
       }
       break;
     }
 
   case AcCHECKSELECTED:
     {
       bool selected = false;
       m_DataNode->GetBoolProperty("selected", selected);
 
       if ( selected )
       {
         this->HandleEvent( new mitk::StateEvent( EIDYES, stateEvent->GetEvent() ) );
       }
       else
       {
         // Invoke event to notify listeners that this planar figure should be selected
         planarFigure->InvokeEvent( SelectPlanarFigureEvent() );
         this->HandleEvent( new mitk::StateEvent( EIDNO, NULL ) );
       }
     }
 
   case AcSELECTPICKEDOBJECT:
     {
       //// Invoke event to notify listeners that this planar figure should be selected
       //planarFigure->InvokeEvent( SelectPlanarFigureEvent() );
 
       // Check if planar figure is marked as "editable"
       bool isEditable = true;
       m_DataNode->GetBoolProperty( "planarfigure.iseditable", isEditable );
 
       int pointIndex = -1;
 
       if ( isEditable )
       {
         // If planar figure is editable, check if mouse is over a control point
         pointIndex = mitk::PlanarFigureInteractor::IsPositionInsideMarker(
           stateEvent, planarFigure,
           planarFigureGeometry,
           projectionPlane,
           renderer->GetDisplayGeometry() );
       }
 
       // If editing is enabled and the mouse is currently over a control point, select it
       if ( pointIndex >= 0 )
       {
         this->HandleEvent( new mitk::StateEvent( EIDYES, stateEvent->GetEvent() ) );
 
         // Return true: only this interactor is eligible to react on this event
         ok = true;
       }
       else
       {
         this->HandleEvent( new mitk::StateEvent( EIDNO, stateEvent->GetEvent() ) );
 
         // Return false so that other (PlanarFigure) Interactors may react on this
         // event as well
         ok = false;
       }
 
       ok = true;
       break;
     }
 
 
   case AcSELECTPOINT:
     {
       // Invoke event to notify listeners that interaction with this PF starts now
       planarFigure->InvokeEvent( StartInteractionPlanarFigureEvent() );
 
       // Reset the PlanarFigure if required
       if ( planarFigure->ResetOnPointSelect() )
       {
         this->HandleEvent( new mitk::StateEvent( EIDYES, stateEvent->GetEvent() ) );
       }
       else
       {
         this->HandleEvent( new mitk::StateEvent( EIDNO, stateEvent->GetEvent() ) );
       }
 
       ok = true;
       break;
     }
 
   case AcREMOVEPOINT:
     {
       bool isExtendable = false;
       m_DataNode->GetBoolProperty("planarfigure.isextendable", isExtendable);
 
       if ( isExtendable )
       {
         int selectedControlPoint = planarFigure->GetSelectedControlPoint();
         planarFigure->RemoveControlPoint( selectedControlPoint );
 
         // Re-evaluate features
         planarFigure->EvaluateFeatures();
         planarFigure->Modified();
 
+        m_DataNode->SetBoolProperty( "planarfigure.drawcontrolpoints", true );
         planarFigure->InvokeEvent( EndInteractionPlanarFigureEvent() );
         renderer->GetRenderingManager()->RequestUpdateAll();
         this->HandleEvent( new mitk::StateEvent( EIDYES, NULL ) );
       }
       else
       {
         this->HandleEvent( new mitk::StateEvent( EIDNO, NULL ) );
       }
     }
 
     //case AcMOVEPOINT:
     //case AcMOVESELECTED:
     //  {
     //    // Update the display
     //    renderer->GetRenderingManager()->RequestUpdateAll();
 
     //    ok = true;
     //    break;
     //  }
 
     //case AcFINISHMOVE:
     //  {
     //    ok = true;
     //    break;
     //  }
 
   default:
     return Superclass::ExecuteAction( action, stateEvent );
   }
 
 
 
 
   return ok;
 }
 
 bool mitk::PlanarFigureInteractor::TransformPositionEventToPoint2D(
   const StateEvent *stateEvent, Point2D &point2D,
   const Geometry2D *planarFigureGeometry )
 {
   // Extract world position, and from this position on geometry, if
   // available
   const mitk::PositionEvent *positionEvent = 
     dynamic_cast< const mitk::PositionEvent * > ( stateEvent->GetEvent() );
   if ( positionEvent == NULL )
   {
     return false;
   }
 
   mitk::Point3D worldPoint3D = positionEvent->GetWorldPosition();
 
   // TODO: proper handling of distance tolerance
   if ( planarFigureGeometry->Distance( worldPoint3D ) > 0.1 )
   {
     return false;
   }
 
   // Project point onto plane of this PlanarFigure
   planarFigureGeometry->Map( worldPoint3D, point2D );
   return true;
 }
 
 
 bool mitk::PlanarFigureInteractor::TransformObjectToDisplay(
   const mitk::Point2D &point2D,
   mitk::Point2D &displayPoint,
   const mitk::Geometry2D *objectGeometry,
   const mitk::Geometry2D *rendererGeometry,
   const mitk::DisplayGeometry *displayGeometry ) const
 {
   mitk::Point3D point3D;
 
   // Map circle point from local 2D geometry into 3D world space
   objectGeometry->Map( point2D, point3D );
 
   // TODO: proper handling of distance tolerance
   if ( displayGeometry->Distance( point3D ) < 0.1 )
   {
     // Project 3D world point onto display geometry
     rendererGeometry->Map( point3D, displayPoint );
     displayGeometry->WorldToDisplay( displayPoint, displayPoint );
     return true;
   }
 
   return false;
 }
 
 
 bool mitk::PlanarFigureInteractor::IsPointNearLine(
   const mitk::Point2D& point,
   const mitk::Point2D& startPoint, 
   const mitk::Point2D& endPoint,
   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 StateEvent *stateEvent, PlanarFigure *planarFigure,
   const Geometry2D *planarFigureGeometry,
   const Geometry2D *rendererGeometry,
   const DisplayGeometry *displayGeometry,
   Point2D& pointProjectedOntoLine ) const
 {
   // Extract display position
   const mitk::PositionEvent *positionEvent = 
     dynamic_cast< const mitk::PositionEvent * > ( stateEvent->GetEvent() );
   if ( positionEvent == NULL )
   {
     return -1;
   }
 
   mitk::Point2D displayPosition = positionEvent->GetDisplayPosition();
 
 
   // Iterate over all polylines of planar figure, and check if
   // any one is close to the current display position
   typedef mitk::PlanarFigure::PolyLineType VertexContainerType;
 
   mitk::Point2D worldPoint2D, displayControlPoint;
   mitk::Point3D worldPoint3D;
   int previousControlPoint = -1;
 
   for ( unsigned short loop = 0; loop < planarFigure->GetPolyLinesSize(); ++loop )
   {
     const VertexContainerType polyLine = planarFigure->GetPolyLine( loop );
 
     Point2D polyLinePoint;
     Point2D firstPolyLinePoint;
     Point2D previousPolyLinePoint;
 
     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, 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 it->Index;
       }
       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 StateEvent *stateEvent, const PlanarFigure *planarFigure,
   const Geometry2D *planarFigureGeometry,
   const Geometry2D *rendererGeometry,
   const DisplayGeometry *displayGeometry ) const
 {
   // Extract display position
   const mitk::PositionEvent *positionEvent = 
     dynamic_cast< const mitk::PositionEvent * > ( stateEvent->GetEvent() );
   if ( positionEvent == NULL )
   {
     return -1;
   }
 
   mitk::Point2D displayPosition = positionEvent->GetDisplayPosition();
 
 
   // Iterate over all control points of planar figure, and check if
   // any one is close to the current display position
   mitk::Point2D worldPoint2D, displayControlPoint;
   mitk::Point3D worldPoint3D;
 
   int numberOfControlPoints = planarFigure->GetNumberOfControlPoints();
   for ( int i=0; i<numberOfControlPoints; i++ )
   {
     Point2D displayControlPoint;
     if ( this->TransformObjectToDisplay( planarFigure->GetControlPoint(i), displayControlPoint,
       planarFigureGeometry, rendererGeometry, displayGeometry ) )
     {
       // TODO: variable size of markers
       if ( displayPosition.SquaredEuclideanDistanceTo( displayControlPoint ) < 20.0 )
       {
         return i;
       }
     }
   }
 
 
   //for ( it = controlPoints.begin(); it != controlPoints.end(); ++it )
   //{
   //  Point2D displayControlPoint;
   //  if ( this->TransformObjectToDisplay( it->Point, displayControlPoint,
   //    planarFigureGeometry, rendererGeometry, displayGeometry ) )
   //  {
   //    // TODO: variable size of markers
   //    if ( (abs(displayPosition[0] - displayControlPoint[0]) < 4 )
   //      && (abs(displayPosition[1] - displayControlPoint[1]) < 4 ) )
   //    {
   //      return index;
   //    }
   //  }
   //}
 
   return -1;
 }
 
 
 void mitk::PlanarFigureInteractor::LogPrintPlanarFigureQuantities( 
   const PlanarFigure *planarFigure )
 {
   MITK_INFO << "PlanarFigure: " << planarFigure->GetNameOfClass();
   for ( unsigned int i = 0; i < planarFigure->GetNumberOfFeatures(); ++i )
   {
     MITK_INFO << "* " << planarFigure->GetFeatureName( i ) << ": "
       << planarFigure->GetQuantity( i ) << " " << planarFigure->GetFeatureUnit( i );
   }
 }
 
 bool
 mitk::PlanarFigureInteractor::IsMousePositionAcceptableAsNewControlPoint(
     const PositionEvent* 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 ) );
 
   // Get current display position of the mouse
   Point2D currentDisplayPosition = positionEvent->GetDisplayPosition();
 
   // Check if a previous point has been set
   bool tooClose = false;
 
   for( int i=0; i<planarFigure->GetNumberOfControlPoints(); i++ )
   {
     if ( i != planarFigure->GetSelectedControlPoint() )
     {
       // Try to convert previous point to current display coordinates
       mitk::Geometry2D *planarFigureGeometry =
         dynamic_cast< mitk::Geometry2D * >( planarFigure->GetGeometry( timeStep ) );
 
       const Geometry2D *projectionPlane = renderer->GetCurrentWorldGeometry2D();
 
       mitk::Point3D previousPoint3D;
       planarFigureGeometry->Map( planarFigure->GetControlPoint( i ), previousPoint3D );
       if ( renderer->GetDisplayGeometry()->Distance( previousPoint3D ) < 0.1 ) // ugly, but assert makes this work
       {
         mitk::Point2D previousDisplayPosition;
         projectionPlane->Map( previousPoint3D, previousDisplayPosition );
         renderer->GetDisplayGeometry()->WorldToDisplay( previousDisplayPosition, previousDisplayPosition );
 
         double a = currentDisplayPosition[0] - previousDisplayPosition[0];
         double b = currentDisplayPosition[1] - previousDisplayPosition[1];
 
         // If point is to close, do not set a new point
         tooClose = (a * a + b * b < m_MinimumPointDistance );
       }
       if ( tooClose )
         return false; // abort loop early
     }
   }
 
   return !tooClose; // default
 }
diff --git a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp
index 4102cde262..78765132a4 100644
--- a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp
+++ b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.cpp
@@ -1,683 +1,688 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-04-23 13:50:34 +0200 (Do, 23 Apr 2009) $
 Version:   $Revision: 16947 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 
 #include "mitkPlanarFigureMapper2D.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "mitkGL.h"
 #include "mitkVtkPropRenderer.h"
 
 #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()
 {
   this->InitializeDefaultPlanarFigureProperties();
 }
 
 
 mitk::PlanarFigureMapper2D::~PlanarFigureMapper2D()
 {
 }
 
 
 void mitk::PlanarFigureMapper2D::Paint( mitk::BaseRenderer *renderer )
 {
   if ( !this->IsVisible( renderer ) ) 
   {
     return;
   }
 
   // Get PlanarFigure from input
   mitk::PlanarFigure *planarFigure = const_cast< mitk::PlanarFigure * >(
     static_cast< const mitk::PlanarFigure * >( this->GetData() ) );
 
   // Check if PlanarFigure has already been placed; otherwise, do nothing
   if ( !planarFigure->IsPlaced() )
   {
     return;
   }
 
   // Get 2D geometry frame of PlanarFigure
   mitk::Geometry2D *planarFigureGeometry2D = 
     dynamic_cast< Geometry2D * >( planarFigure->GetGeometry( 0 ) );
   if ( planarFigureGeometry2D == NULL )
   {
     MITK_ERROR << "PlanarFigure does not have valid Geometry2D!";
     return;
   }
 
   // Get current world 2D geometry from renderer
   const mitk::Geometry2D *rendererGeometry2D = renderer->GetCurrentWorldGeometry2D();
 
   // If the PlanarFigure geometry is a plane geometry, check if current
   // world plane is parallel to and within the planar figure geometry bounds
   // (otherwise, display nothing)
   mitk::PlaneGeometry *planarFigurePlaneGeometry = 
     dynamic_cast< PlaneGeometry * >( planarFigureGeometry2D );
   const mitk::PlaneGeometry *rendererPlaneGeometry = 
     dynamic_cast< const PlaneGeometry * >( rendererGeometry2D );
 
   if ( (planarFigurePlaneGeometry != NULL) && (rendererPlaneGeometry != NULL) )
   {
     double planeThickness = planarFigurePlaneGeometry->GetExtentInMM( 2 );
     if ( !planarFigurePlaneGeometry->IsParallel( rendererPlaneGeometry )
       || !(planarFigurePlaneGeometry->DistanceFromPlane( 
-           rendererPlaneGeometry ) < planeThickness / 3.0) )
+      rendererPlaneGeometry ) < planeThickness / 3.0) )
     {
       // Planes are not parallel or renderer plane is not within PlanarFigure
       // geometry bounds --> exit
       return;
     }
   }
   else
   {
     // Plane is not valid (curved reformations are not possible yet)
     return;
   }
 
 
   // Get display geometry
   mitk::DisplayGeometry *displayGeometry = renderer->GetDisplayGeometry();
   assert( displayGeometry != NULL );
 
 
   // Apply visual appearance properties from the PropertyList
   this->ApplyProperties( renderer );
 
   // Enable line antialiasing
   glEnable( GL_LINE_SMOOTH );
   glHint( GL_LINE_SMOOTH_HINT, GL_NICEST );
   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 firstPoint; firstPoint[0] = 0; firstPoint[1] = 1;
 
   if ( m_DrawOutline )
   {
     // Draw the outline for all polylines if requested
     this->DrawMainLines( planarFigure,
       m_OutlineColor[lineDisplayMode],
       m_OutlineOpacity[lineDisplayMode],
       m_DrawShadow,
       m_OutlineWidth,
       m_ShadowWidthFactor,
       firstPoint,
       planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
 
     // Draw the outline for all helper objects if requested
     this->DrawHelperLines( planarFigure,
       m_OutlineColor[lineDisplayMode],
       m_OutlineOpacity[lineDisplayMode],
       m_DrawShadow,
       m_OutlineWidth,
       m_ShadowWidthFactor,
       firstPoint,
       planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
   }
 
 
   // Draw the main line for all polylines
   this->DrawMainLines( planarFigure,
     m_LineColor[lineDisplayMode],
     m_LineOpacity[lineDisplayMode],
     m_DrawShadow,
     m_LineWidth,
     m_ShadowWidthFactor,
     firstPoint,
     planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
 
   double annotationOffset = 0.0;
 
   // draw name near the first point (if present)
   std::string name = node->GetName();
   if ( !name.empty() )
   {
     mitk::VtkPropRenderer* openGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
     if ( openGLrenderer )
     {
       if ( m_IsSelected || m_IsHovering )
       {
         openGLrenderer->WriteSimpleText( name,
           firstPoint[0] + 6.0, firstPoint[1] + 4.0,
           0,
           0,
           0); //this is a shadow 
         openGLrenderer->WriteSimpleText( name,
           firstPoint[0] + 5.0, firstPoint[1] + 5.0,
           m_LineColor[lineDisplayMode][0],
           m_LineColor[lineDisplayMode][1],
           m_LineColor[lineDisplayMode][2] );
       }
-      
+
       // If drawing is successful, add approximate height to annotation offset
       annotationOffset -= 15.0;
     }
   }
 
   // draw feature quantities (if requested) new the first point
   if ( m_DrawQuantities )
   {
     std::stringstream quantityString;
     quantityString.setf( ios::fixed, ios::floatfield );
     quantityString.precision( 1 );
 
     bool firstActiveFeature = true;
     for ( unsigned int i = 0; i < planarFigure->GetNumberOfFeatures(); ++i )
     {     
       if( planarFigure->IsFeatureActive(i) && planarFigure->IsFeatureVisible( i ) )
       {
         if ( ! firstActiveFeature ) 
         {
           quantityString << " / ";
         }
         quantityString << planarFigure->GetQuantity( i ) << " ";
         quantityString << planarFigure->GetFeatureUnit( i );
         firstActiveFeature = false;
       }
     }
 
     mitk::VtkPropRenderer* openGLrenderer = dynamic_cast<mitk::VtkPropRenderer*>( renderer );
     if ( openGLrenderer )
     {
       openGLrenderer->WriteSimpleText( quantityString.str().c_str(), 
         firstPoint[0] + 6.0, firstPoint[1] + 4.0 + annotationOffset,
         0,
         0,
         0); //this is a shadow 
 
       openGLrenderer->WriteSimpleText( quantityString.str().c_str(),
         firstPoint[0] + 5.0, firstPoint[1] + 5.0 + annotationOffset,
         m_LineColor[lineDisplayMode][0],
         m_LineColor[lineDisplayMode][1],
         m_LineColor[lineDisplayMode][2] );
 
       // If drawing is successful, add approximate height to annotation offset
       annotationOffset -= 15.0;
     }
   }
 
 
   // Draw helper objects
   this->DrawHelperLines( planarFigure,
     m_HelperlineColor[lineDisplayMode],
     m_HelperlineOpacity[lineDisplayMode],
     m_DrawShadow,
     m_LineWidth,
     m_ShadowWidthFactor,
     firstPoint,
     planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
 
 
-
-  // Draw markers at control points (selected control point will be colored)
-  for ( unsigned int i = 0; i < planarFigure->GetNumberOfControlPoints(); ++i )
+  if ( m_DrawControlPoints )
   {
-    
-    bool isEditable = true;
-    m_DataNode->GetBoolProperty( "planarfigure.iseditable", isEditable );
-    
-    PlanarFigureDisplayMode pointDisplayMode = PF_DEFAULT;
-
-    // Only if planar figure is marked as editable: display markers (control points) in a
-    // different style if mouse is over them or they are selected
-    if ( isEditable )
+    // Draw markers at control points (selected control point will be colored)
+    for ( unsigned int i = 0; i < planarFigure->GetNumberOfControlPoints(); ++i )
     {
-      if ( i == (unsigned int) planarFigure->GetSelectedControlPoint() )
-      {
-        pointDisplayMode = PF_SELECTED;
-      }
-      else if ( m_IsHovering )
+
+      bool isEditable = true;
+      m_DataNode->GetBoolProperty( "planarfigure.iseditable", isEditable );
+
+      PlanarFigureDisplayMode pointDisplayMode = PF_DEFAULT;
+
+      // Only if planar figure is marked as editable: display markers (control points) in a
+      // different style if mouse is over them or they are selected
+      if ( isEditable )
       {
-        pointDisplayMode = PF_HOVER;
+        if ( i == (unsigned int) planarFigure->GetSelectedControlPoint() )
+        {
+          pointDisplayMode = PF_SELECTED;
+        }
+        else if ( m_IsHovering )
+        {
+          pointDisplayMode = PF_HOVER;
+        }
       }
-    }
 
-    this->DrawMarker( planarFigure->GetControlPoint( i ),
-      m_MarkerlineColor[pointDisplayMode],
-      m_MarkerlineOpacity[pointDisplayMode],
-      m_MarkerColor[pointDisplayMode],
-      m_MarkerOpacity[pointDisplayMode],
-      m_LineWidth,
-      m_ControlPointShape,
-      planarFigureGeometry2D, 
-      rendererGeometry2D, 
-      displayGeometry );
-  }
+      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 
-      );
+    if ( planarFigure->IsPreviewControlPointVisible() )
+    {
+      this->DrawMarker( planarFigure->GetPreviewControlPoint(),
+        m_MarkerlineColor[PF_HOVER],
+        m_MarkerlineOpacity[PF_HOVER],
+        m_MarkerColor[PF_HOVER],
+        m_MarkerOpacity[PF_HOVER],
+        m_LineWidth,
+        m_ControlPointShape,
+        planarFigureGeometry2D, 
+        rendererGeometry2D, 
+        displayGeometry 
+        );
+    }
   }
 
   glLineWidth( 1.0f );
 }
 
 
 void mitk::PlanarFigureMapper2D::PaintPolyLine(
   mitk::PlanarFigure::PolyLineType vertices,  
   bool closed,
   float* color, 
   float opacity, 
   float lineWidth, 
   Point2D& firstPoint, 
   const Geometry2D* planarFigureGeometry2D, 
   const Geometry2D* rendererGeometry2D, 
   const DisplayGeometry* displayGeometry)
 {
   glColor4f( color[0], color[1], color[2], opacity );
   glLineWidth(lineWidth);
 
   if ( closed )
   {
     glBegin( GL_LINE_LOOP );
   }
   else 
   {
     glBegin( GL_LINE_STRIP );
   }
 
   for ( PlanarFigure::PolyLineType::iterator iter = vertices.begin(); iter!=vertices.end(); iter++ )
   {
     // Draw this 2D point as OpenGL vertex
     mitk::Point2D displayPoint;
     this->TransformObjectToDisplay( iter->Point, displayPoint,
       planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
 
     if(iter == vertices.begin())
       firstPoint = displayPoint;
 
     glVertex3f( displayPoint[0], displayPoint[1],PLANAR_OFFSET);
   }
 
   glEnd();
 }
 
 
 void mitk::PlanarFigureMapper2D::DrawMainLines( 
   mitk::PlanarFigure* figure, 
   float* color, 
   float opacity, 
   bool drawShadow,
   float lineWidth, 
   float shadowWidthFactor,
   Point2D& firstPoint,
   const Geometry2D* planarFigureGeometry2D, 
   const Geometry2D* rendererGeometry2D, 
   const DisplayGeometry* displayGeometry)
 {
   for ( unsigned short loop = 0; loop < figure->GetPolyLinesSize(); ++loop )
   {
     PlanarFigure::PolyLineType polyline = figure->GetPolyLine(loop);
 
     if ( drawShadow )
     {
       float* shadow = new float[3];
       shadow[0] = 0;
       shadow[1] = 0;
       shadow[2] = 0;
 
       this->PaintPolyLine( polyline, 
         figure->IsClosed(),    
         shadow, 0.8, lineWidth*shadowWidthFactor, firstPoint,
         planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
 
       delete shadow;
     }
 
     this->PaintPolyLine( polyline, 
       figure->IsClosed(),    
       color, opacity, lineWidth, firstPoint,
       planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
   }
 }
 
 void mitk::PlanarFigureMapper2D::DrawHelperLines(
   mitk::PlanarFigure* figure,
   float* color, 
   float opacity, 
   bool drawShadow,
   float lineWidth,
   float shadowWidthFactor,
   Point2D& firstPoint,
   const Geometry2D* planarFigureGeometry2D, 
   const Geometry2D* rendererGeometry2D, 
   const DisplayGeometry* displayGeometry)
 {
   // Draw helper objects
   for ( unsigned int loop = 0; loop < figure->GetHelperPolyLinesSize(); ++loop )
   {
     const mitk::PlanarFigure::PolyLineType helperPolyLine = figure->GetHelperPolyLine(loop,
       displayGeometry->GetScaleFactorMMPerDisplayUnit(),
       displayGeometry->GetDisplayHeight() );
 
     // Check if the current helper objects is to be painted
     if ( !figure->IsHelperToBePainted( loop ) )
     {
       continue;
     }
 
     // check if shadow shall be painted around the figure
     if ( drawShadow )
     {
       float* shadow = new float[3];
       shadow[0] = 0;
       shadow[1] = 0;
       shadow[2] = 0;
 
       // paint shadow by painting the figure twice
       // one in black with a slightly broader line-width ...
       this->PaintPolyLine( helperPolyLine, false,
         shadow, 0.8, lineWidth*shadowWidthFactor, firstPoint,
         planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
-    
+
       delete shadow;
     }
 
     // ... and once normally above the shadow.
     this->PaintPolyLine( helperPolyLine, false,
       color, opacity, lineWidth, firstPoint,
       planarFigureGeometry2D, rendererGeometry2D, displayGeometry );
   }
 }
 
 
 
 void mitk::PlanarFigureMapper2D::TransformObjectToDisplay(
   const mitk::Point2D &point2D,
   mitk::Point2D &displayPoint,
   const mitk::Geometry2D *objectGeometry,
   const mitk::Geometry2D *rendererGeometry,
   const mitk::DisplayGeometry *displayGeometry )
 {
   mitk::Point3D point3D;
 
   // Map circle point from local 2D geometry into 3D world space
   objectGeometry->Map( point2D, point3D );
 
   // Project 3D world point onto display geometry
   rendererGeometry->Map( point3D, displayPoint );
   displayGeometry->WorldToDisplay( displayPoint, displayPoint );
 }
 
 
 void mitk::PlanarFigureMapper2D::DrawMarker(
   const mitk::Point2D &point,
   float* lineColor,
   float lineOpacity,
   float* markerColor,
   float markerOpacity,
   float lineWidth,
   PlanarFigureControlPointStyleProperty::Shape shape,
   const mitk::Geometry2D *objectGeometry,
   const mitk::Geometry2D *rendererGeometry,
   const mitk::DisplayGeometry *displayGeometry )
 {
   mitk::Point2D displayPoint;
 
   this->TransformObjectToDisplay(
     point, displayPoint,
     objectGeometry, rendererGeometry, displayGeometry );
 
   glColor4f( markerColor[0], markerColor[1], markerColor[2], markerOpacity );
   glLineWidth( lineWidth );
 
   switch ( shape )
   {
-    case PlanarFigureControlPointStyleProperty::Square:
-    default:
-      // Paint filled square
-
-      // Disable line antialiasing (does not look nice for squares)
-      glDisable( GL_LINE_SMOOTH );
-
-      glRectf(
-        displayPoint[0] - 4, displayPoint[1] - 4, 
-        displayPoint[0] + 4, displayPoint[1] + 4 );
-
-      // Paint outline
-      glColor4f( lineColor[0], lineColor[1], lineColor[2], lineOpacity );
-      glBegin( GL_LINE_LOOP );
-      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:
-      // Paint filled circle
-      glBegin( GL_POLYGON );
-      float radius = 4.0;
-      for ( int angle = 0; angle < 8; ++angle )
-      {
-        float angleRad = angle * (float) M_PI / 4.0;
-        float x = displayPoint[0] + radius * (float)cos( angleRad );
-        float y = displayPoint[1] + radius * (float)sin( angleRad );
-        glVertex3f(x,y,PLANAR_OFFSET);
-      }
-      glEnd();
+  case PlanarFigureControlPointStyleProperty::Square:
+  default:
+    // Paint filled square
 
-      // 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) M_PI / 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;
+    // Disable line antialiasing (does not look nice for squares)
+    glDisable( GL_LINE_SMOOTH );
+
+    glRectf(
+      displayPoint[0] - 4, displayPoint[1] - 4, 
+      displayPoint[0] + 4, displayPoint[1] + 4 );
 
-    } // end switch
+    // Paint outline
+    glColor4f( lineColor[0], lineColor[1], lineColor[2], lineOpacity );
+    glBegin( GL_LINE_LOOP );
+    glVertex2f( displayPoint[0] - 4, displayPoint[1] - 4 );
+    glVertex2f( displayPoint[0] - 4, displayPoint[1] + 4 );
+    glVertex2f( displayPoint[0] + 4, displayPoint[1] + 4 );
+    glVertex2f( displayPoint[0] + 4, displayPoint[1] - 4 );
+    glEnd();
+    break;
+
+  case PlanarFigureControlPointStyleProperty::Circle:
+    // Paint filled circle
+    glBegin( GL_POLYGON );
+    float radius = 4.0;
+    for ( int angle = 0; angle < 8; ++angle )
+    {
+      float angleRad = angle * (float) 3.14159 / 4.0;
+      float x = displayPoint[0] + radius * (float)cos( angleRad );
+      float y = displayPoint[1] + radius * (float)sin( angleRad );
+      glVertex2f(x,y);
+    }
+    glEnd();
+
+    // Paint outline
+    glColor4f( lineColor[0], lineColor[1], lineColor[2], lineOpacity );
+    glBegin( GL_LINE_LOOP );
+    for ( int angle = 0; angle < 8; ++angle )
+    {
+      float angleRad = angle * (float) 3.14159 / 4.0;
+      float x = displayPoint[0] + radius * (float)cos( angleRad );
+      float y = displayPoint[1] + radius * (float)sin( angleRad );
+      glVertex2f(x,y);
+    }
+    glEnd();
+    break;
+
+  } // end switch
 }
 
 
 void mitk::PlanarFigureMapper2D::InitializeDefaultPlanarFigureProperties()
 {
   m_IsSelected = false;
   m_IsHovering = false;
   m_DrawOutline = false;
   m_DrawQuantities = false;
   m_DrawShadow = false;
+  m_DrawControlPoints = 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;
   }
 
   node->GetBoolProperty( "selected", m_IsSelected );
   node->GetBoolProperty( "planarfigure.ishovering", m_IsHovering );
   node->GetBoolProperty( "planarfigure.drawoutline", m_DrawOutline );
   node->GetBoolProperty( "planarfigure.drawquantities", m_DrawQuantities );
   node->GetBoolProperty( "planarfigure.drawshadow", m_DrawShadow );
-  
+  node->GetBoolProperty( "planarfigure.drawcontrolpoints", m_DrawControlPoints );
+
   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();
   }
 
   node->GetColor( m_LineColor[PF_DEFAULT], NULL, "planarfigure.default.line.color" );
   node->GetFloatProperty( "planarfigure.default.line.opacity", m_LineOpacity[PF_DEFAULT] );
   node->GetColor( m_OutlineColor[PF_DEFAULT], NULL, "planarfigure.default.outline.color" );
   node->GetFloatProperty( "planarfigure.default.outline.opacity", m_OutlineOpacity[PF_DEFAULT] );
   node->GetColor( m_HelperlineColor[PF_DEFAULT], NULL, "planarfigure.default.helperline.color" );
   node->GetFloatProperty( "planarfigure.default.helperline.opacity", m_HelperlineOpacity[PF_DEFAULT] );
   node->GetColor( m_MarkerlineColor[PF_DEFAULT], NULL, "planarfigure.default.markerline.color" );
   node->GetFloatProperty( "planarfigure.default.markerline.opacity", m_MarkerlineOpacity[PF_DEFAULT] );
   node->GetColor( m_MarkerColor[PF_DEFAULT], NULL, "planarfigure.default.marker.color" );
   node->GetFloatProperty( "planarfigure.default.marker.opacity", m_MarkerOpacity[PF_DEFAULT] );
 
   node->GetColor( m_LineColor[PF_HOVER], NULL, "planarfigure.hover.line.color" );
   node->GetFloatProperty( "planarfigure.hover.line.opacity", m_LineOpacity[PF_HOVER] );
   node->GetColor( m_OutlineColor[PF_HOVER], NULL, "planarfigure.hover.outline.color" );
   node->GetFloatProperty( "planarfigure.hover.outline.opacity", m_OutlineOpacity[PF_HOVER] );
   node->GetColor( m_HelperlineColor[PF_HOVER], NULL, "planarfigure.hover.helperline.color" );
   node->GetFloatProperty( "planarfigure.hover.helperline.opacity", m_HelperlineOpacity[PF_HOVER] );
   node->GetColor( m_MarkerlineColor[PF_HOVER], NULL, "planarfigure.hover.markerline.color" );
   node->GetFloatProperty( "planarfigure.hover.markerline.opacity", m_MarkerlineOpacity[PF_HOVER] );
   node->GetColor( m_MarkerColor[PF_HOVER], NULL, "planarfigure.hover.marker.color" );
   node->GetFloatProperty( "planarfigure.hover.marker.opacity", m_MarkerOpacity[PF_HOVER] );
 
   node->GetColor( m_LineColor[PF_SELECTED], NULL, "planarfigure.selected.line.color" );
   node->GetFloatProperty( "planarfigure.selected.line.opacity", m_LineOpacity[PF_SELECTED] );
   node->GetColor( m_OutlineColor[PF_SELECTED], NULL, "planarfigure.selected.outline.color" );
   node->GetFloatProperty( "planarfigure.selected.outline.opacity", m_OutlineOpacity[PF_SELECTED] );
   node->GetColor( m_HelperlineColor[PF_SELECTED], NULL, "planarfigure.selected.helperline.color" );
   node->GetFloatProperty( "planarfigure.selected.helperline.opacity", m_HelperlineOpacity[PF_SELECTED] );
   node->GetColor( m_MarkerlineColor[PF_SELECTED], NULL, "planarfigure.selected.markerline.color" );
   node->GetFloatProperty( "planarfigure.selected.markerline.opacity", m_MarkerlineOpacity[PF_SELECTED] );
   node->GetColor( m_MarkerColor[PF_SELECTED], NULL, "planarfigure.selected.marker.color" );
   node->GetFloatProperty( "planarfigure.selected.marker.opacity", m_MarkerOpacity[PF_SELECTED] );
 
 }
 
 
 void mitk::PlanarFigureMapper2D::SetDefaultProperties( mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite )
 {
   node->AddProperty( "visible", mitk::BoolProperty::New(true), renderer, overwrite );
 
   //node->SetProperty("planarfigure.iseditable",mitk::BoolProperty::New(true));
   //node->SetProperty("planarfigure.isextendable",mitk::BoolProperty::New(true));
   //node->AddProperty( "planarfigure.ishovering", mitk::BoolProperty::New(true) );
   node->AddProperty( "planarfigure.drawoutline", mitk::BoolProperty::New(true) );
   //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.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(2.0) );
 
   node->AddProperty( "planarfigure.default.line.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
   node->AddProperty( "planarfigure.default.line.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.default.outline.color", mitk::ColorProperty::New(1.0,1.0,1.0) );
   node->AddProperty( "planarfigure.default.outline.opacity", mitk::FloatProperty::New(1.0) );
   node->AddProperty( "planarfigure.default.helperline.color", mitk::ColorProperty::New(1.0,1.0,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));
 }
diff --git a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.h b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.h
index a76386d8c6..ee7d25e874 100644
--- a/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.h
+++ b/Modules/PlanarFigure/Rendering/mitkPlanarFigureMapper2D.h
@@ -1,240 +1,241 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-05-13 18:06:46 +0200 (Mi, 13 Mai 2009) $
 Version:   $Revision: 17258 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 
 #ifndef MITK_PLANAR_FIGURE_MAPPER_2D_H_
 #define MITK_PLANAR_FIGURE_MAPPER_2D_H_
 
 #include "mitkCommon.h"
 #include "PlanarFigureExports.h"
 #include "mitkGLMapper2D.h"
 #include "mitkPlanarFigure.h"
 #include "mitkPlanarFigureControlPointStyleProperty.h"
 
 namespace mitk {
 
 class BaseRenderer;
 class Contour;
 
 
 /**
 * \brief OpenGL-based mapper to render display sub-class instances of mitk::PlanarFigure
 * 
 * The appearance of planar figures can be configured through  properties. If no properties are specified,
 * default values will be used. There are four elements a planar figure consists of:
 * 
 * <ol>
 * <li>"line": the main line segments of the planar figure (note: text is drawn in the same style)
 * <li>"helperline": additional line segments of planar figures, such as arrow tips, arches of angles, etc.
 * <li>"outline": background which is drawn behind the lines and helperlines of the planar figure (optional)
 * <li>"marker": the markers (control points) of a planar figure
 * <li>"markerline": the lines by which markers (control points) are surrounded
 * </ol>
 * 
 * In the following, all appearance-related planar figure properties are listed:
 * 
 * <ol>
 * <li>General properties for the planar figure
 *   <ul>
 *     <li>"planarfigure.drawoutline": if true, the "outline" lines is drawn
 *     <li>"planarfigure.drawquantities": if true, the quantities (text) associated with the planar figure is drawn
 *     <li>"planarfigure.drawshadow": if true, a black shadow is drawn around the planar figure
 *     <li>"planarfigure.controlpointshape": style of the control points (enum)
 *   </ul>
 * <li>Line widths of planar figure elements
 *   <ul>
 *     <li>"planarfigure.line.width": width of "line" segments (float value, in mm)
 *     <li>"planarfigure.shadow.widthmodifier": the width of the shadow is defined by width of the "line" * this modifier
 *     <li>"planarfigure.outline.width": width of "outline" segments (float value, in mm)
 *     <li>"planarfigure.helperline.width": width of "helperline" segments (float value, in mm)
 *   </ul>
 * <li>Color/opacity of planar figure elements in normal mode (unselected)
 *   <ul>
 *     <li>"planarfigure.default.line.color"
 *     <li>"planarfigure.default.line.opacity"
 *     <li>"planarfigure.default.outline.color"
 *     <li>"planarfigure.default.outline.opacity"
 *     <li>"planarfigure.default.helperline.color"
 *     <li>"planarfigure.default.helperline.opacity"
 *     <li>"planarfigure.default.markerline.color"
 *     <li>"planarfigure.default.markerline.opacity"
 *     <li>"planarfigure.default.marker.color"
 *     <li>"planarfigure.default.marker.opacity"
 *   </ul>
 * <li>Color/opacity of planar figure elements in hover mode (mouse-over)
 *   <ul>
 *     <li>"planarfigure.hover.line.color"
 *     <li>"planarfigure.hover.line.opacity"
 *     <li>"planarfigure.hover.outline.color"
 *     <li>"planarfigure.hover.outline.opacity"
 *     <li>"planarfigure.hover.helperline.color"
 *     <li>"planarfigure.hover.helperline.opacity"
 *     <li>"planarfigure.hover.markerline.color"
 *     <li>"planarfigure.hover.markerline.opacity"
 *     <li>"planarfigure.hover.marker.color"
 *     <li>"planarfigure.hover.marker.opacity"
 *   </ul>
 * <li>Color/opacity of planar figure elements in selected mode
 *   <ul>
 *     <li>"planarfigure.selected.line.color"
 *     <li>"planarfigure.selected.line.opacity"
 *     <li>"planarfigure.selected.outline.color"
 *     <li>"planarfigure.selected.outline.opacity"
 *     <li>"planarfigure.selected.helperline.color"
 *     <li>"planarfigure.selected.helperline.opacity"
 *     <li>"planarfigure.selected.markerline.color;"
 *     <li>"planarfigure.selected.markerline.opacity"
 *     <li>"planarfigure.selected.marker.color"
 *     <li>"planarfigure.selected.marker.opacity"
 *   </ul>
 * </ol>
 *
 * \ingroup Mapper
 */
 
 class PlanarFigure_EXPORT PlanarFigureMapper2D : public GLMapper2D
 {
 public:
     
   mitkClassMacro(PlanarFigureMapper2D, Mapper2D);
 
   itkNewMacro(Self);
 
   /**
   * reimplemented from Baseclass
   */
   virtual void Paint(BaseRenderer * renderer);
 
   static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = NULL, bool overwrite = false);
 
 
 protected:
   
   enum PlanarFigureDisplayMode
   {
     PF_DEFAULT = 0,
     PF_HOVER,
     PF_SELECTED
   };
 
   PlanarFigureMapper2D();
 
   virtual ~PlanarFigureMapper2D();
 
   void TransformObjectToDisplay(
     const mitk::Point2D &point2D,
     mitk::Point2D &displayPoint,
     const mitk::Geometry2D *objectGeometry,
     const mitk::Geometry2D *rendererGeometry,
     const mitk::DisplayGeometry *displayGeometry );
 
   void DrawMarker(
     const mitk::Point2D &point,
     float* lineColor,
     float lineOpacity,
     float* markerColor,
     float markerOpacity,
     float lineWidth,
     PlanarFigureControlPointStyleProperty::Shape shape,
     const mitk::Geometry2D *objectGeometry,
     const mitk::Geometry2D *rendererGeometry,
     const mitk::DisplayGeometry *displayGeometry );
 
   void PaintPolyLine( mitk::PlanarFigure::PolyLineType vertices,
     bool closed,
     float* color, 
     float opacity, 
     float lineWidth, 
     Point2D& firstPoint,
     const Geometry2D* planarFigureGeometry2D, 
     const Geometry2D* rendererGeometry2D, 
     const DisplayGeometry* displayGeometry);
 
   void DrawMainLines( mitk::PlanarFigure* figure, 
     float* color, 
     float opacity, 
     bool drawShadow,
     float lineWidth, 
     float shadowWidthFactor,
     Point2D& firstPoint,
     const Geometry2D* planarFigureGeometry2D, 
     const Geometry2D* rendererGeometry2D, 
     const DisplayGeometry* displayGeometry) ;
 
   void DrawHelperLines( mitk::PlanarFigure* figure,
     float* color, 
     float opacity, 
     bool drawShadow,
     float lineWidth, 
     float shadowWidthFactor,
     Point2D& firstPoint,
     const Geometry2D* planarFigureGeometry2D, 
     const Geometry2D* rendererGeometry2D, 
     const DisplayGeometry* displayGeometry) ;
 
   void InitializeDefaultPlanarFigureProperties();
 
   void InitializePlanarFigurePropertiesFromDataNode( const mitk::DataNode* node );
 
   void SetColorProperty( float property[3][3], PlanarFigureDisplayMode mode, float red, float green, float blue )
   {
     property[mode][0] = red;
     property[mode][1] = green;
     property[mode][2] = blue;
   }
 
   void SetFloatProperty( float* property, PlanarFigureDisplayMode mode, float value )
   {
     property[mode] = value;
   }
 
 
 
 private:
   bool m_IsSelected;
   bool m_IsHovering;
   bool m_DrawOutline;
   bool m_DrawQuantities;
   bool m_DrawShadow;
+  bool m_DrawControlPoints;
 
   // the width of the shadow is defined as 'm_LineWidth * m_ShadowWidthFactor'
   float m_LineWidth;
   float m_ShadowWidthFactor;
   float m_OutlineWidth;
   float m_HelperlineWidth;
   float m_PointWidth;
 
   PlanarFigureControlPointStyleProperty::Shape m_ControlPointShape;
 
   float m_LineColor[3][3];
   float m_LineOpacity[3];
   float m_OutlineColor[3][3];
   float m_OutlineOpacity[3];
   float m_HelperlineColor[3][3];
   float m_HelperlineOpacity[3];
   float m_MarkerlineColor[3][3];
   float m_MarkerlineOpacity[3];
   float m_MarkerColor[3][3];
   float m_MarkerOpacity[3];
 
 };
 
 } // namespace mitk
 
 
 
 #endif /* MITK_PLANAR_FIGURE_MAPPER_2D_H_ */