diff --git a/Modules/Core/include/mitkRenderingManager.h b/Modules/Core/include/mitkRenderingManager.h
index 4245adfa70..eb9d212a89 100644
--- a/Modules/Core/include/mitkRenderingManager.h
+++ b/Modules/Core/include/mitkRenderingManager.h
@@ -1,403 +1,401 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef MITKRENDERINGMANAGER_H_HEADER_INCLUDED_C135A197
 #define MITKRENDERINGMANAGER_H_HEADER_INCLUDED_C135A197
 
 #include <MitkCoreExports.h>
 
 #include <vtkCallbackCommand.h>
-#include <vtkWeakPointer.h>
 
 #include <string>
 #include <itkObject.h>
-#include <itkEventObject.h>
 #include <itkObjectFactory.h>
 
 #include "mitkPropertyList.h"
 #include "mitkProperties.h"
 #include "mitkTimeGeometry.h"
 
 class vtkRenderWindow;
 class vtkObject;
 
 namespace mitk
 {
 class RenderingManager;
 class RenderingManagerFactory;
 class BaseGeometry;
 class SliceNavigationController;
 class BaseRenderer;
 class DataStorage;
 
 /**
  * \brief Manager for coordinating the rendering process.
  *
  * RenderingManager is a central instance retrieving and executing
  * RenderWindow update requests. Its main purpose is to coordinate
  * distributed requests which cannot be aware of each other - lacking the
  * knowledge of whether they are really necessary or not. For example, two
  * objects might determine that a specific RenderWindow needs to be updated.
  * This would result in one unnecessary update, if both executed the update
  * on their own.
  *
  * The RenderingManager addresses this by letting each such object
  * <em>request</em> an update, and waiting for other objects to possibly
  * issue the same request. The actual update will then only be executed at a
  * well-defined point in the main event loop (this may be each time after
  * event processing is done).
  *
  * Convinience methods for updating all RenderWindows which have been
  * registered with the RenderingManager exist. If theses methods are not
  * used, it is not required to register (add) RenderWindows prior to using
  * the RenderingManager.
  *
  * The methods #ForceImmediateUpdate() and #ForceImmediateUpdateAll() can
  * be used to force the RenderWindow update execution without any delay,
  * bypassing the request functionality.
  *
  * The interface of RenderingManager is platform independent. Platform
  * specific subclasses have to be implemented, though, to supply an
  * appropriate event issueing for controlling the update execution process.
  * See method documentation for a description of how this can be done.
  *
  * \sa TestingRenderingManager An "empty" RenderingManager implementation which
  * can be used in tests etc.
  *
  */
 class MITKCORE_EXPORT RenderingManager : public itk::Object
 {
 public:
 
   mitkClassMacroItkParent(RenderingManager,itk::Object);
 
   typedef std::vector< vtkRenderWindow* > RenderWindowVector;
   typedef std::vector< float > FloatVector;
   typedef std::vector< bool > BoolVector;
 
   typedef itk::SmartPointer< DataStorage > DataStoragePointer;
 
   enum RequestType
   {
     REQUEST_UPDATE_ALL = 0,
     REQUEST_UPDATE_2DWINDOWS,
     REQUEST_UPDATE_3DWINDOWS
   };
 
   static Pointer New();
 
   /** Set the object factory which produces the desired platform specific
    * RenderingManager singleton instance. */
   static void SetFactory( RenderingManagerFactory *factory );
 
   /** Get the object factory which produces the platform specific
    * RenderingManager instances. */
   static const RenderingManagerFactory *GetFactory();
 
   /** Returns true if a factory has already been set. */
   static bool HasFactory();
 
   /** Get the RenderingManager singleton instance. */
   static RenderingManager *GetInstance();
 
   /** Returns true if the singleton instance does already exist. */
   static bool IsInstantiated();
 
   /** Adds a RenderWindow. This is required if the methods #RequestUpdateAll
    * or #ForceImmediateUpdate are to be used. */
   void AddRenderWindow( vtkRenderWindow *renderWindow );
 
   /** Removes a RenderWindow. */
   void RemoveRenderWindow( vtkRenderWindow *renderWindow );
 
   /** Get a list of all registered RenderWindows */
   const RenderWindowVector &GetAllRegisteredRenderWindows();
 
     /** Requests an update for the specified RenderWindow, to be executed as
    * soon as the main loop is ready for rendering. */
   void RequestUpdate( vtkRenderWindow *renderWindow );
 
   /** Immediately executes an update of the specified RenderWindow. */
   void ForceImmediateUpdate( vtkRenderWindow *renderWindow );
 
   /** Requests all currently registered RenderWindows to be updated.
    * If only 2D or 3D windows should be updated, this can be specified
    * via the parameter requestType. */
   void RequestUpdateAll( RequestType type = REQUEST_UPDATE_ALL );
 
   /** Immediately executes an update of all registered RenderWindows.
    * If only 2D or 3D windows should be updated, this can be specified
    * via the parameter requestType. */
   void ForceImmediateUpdateAll( RequestType type = REQUEST_UPDATE_ALL );
 
   /** Initializes the windows specified by requestType to the geometry of the
    * given DataStorage. */
   //virtual bool InitializeViews( const DataStorage *storage, const DataNode* node = NULL,
   //   RequestType type = REQUEST_UPDATE_ALL, bool preserveRoughOrientationInWorldSpace = false );
 
   /** Initializes the windows specified by requestType to the given
    * geometry. PLATFORM SPECIFIC. TODO: HOW IS THIS PLATFORM SPECIFIC?
    * Throws an exception if bounding box has 0 extent due to exceeding
    * double precision range. */
   virtual bool InitializeViews( const BaseGeometry *geometry,
     RequestType type = REQUEST_UPDATE_ALL, bool preserveRoughOrientationInWorldSpace = false );
   virtual bool InitializeViews( const TimeGeometry *geometry,
     RequestType type = REQUEST_UPDATE_ALL, bool preserveRoughOrientationInWorldSpace = false );
 
   /** Initializes the windows to the default viewing direction
    * (geomtry information is NOT changed). PLATFORM SPECIFIC. */
   virtual bool InitializeViews( RequestType type = REQUEST_UPDATE_ALL );
 
   /** Initializes the specified window to the geometry of the given
    * DataNode. Set "initializeGlobalTimeSNC" to true in order to use this
    * geometry as global TimeGeometry. PLATFORM SPECIFIC. */
   //virtual bool InitializeView( vtkRenderWindow *renderWindow, const DataStorage* ds, const DataNode* node = NULL, bool initializeGlobalTimeSNC = false );
 
   /** Initializes the specified window to the given geometry. Set
    * "initializeGlobalTimeSNC" to true in order to use this geometry as
    * global TimeGeometry. PLATFORM SPECIFIC. */
   virtual bool InitializeView( vtkRenderWindow *renderWindow, const BaseGeometry *geometry, bool initializeGlobalTimeSNC = false);
   virtual bool InitializeView( vtkRenderWindow *renderWindow, const TimeGeometry *geometry, bool initializeGlobalTimeSNC = false);
 
   /** Initializes the specified window to the default viewing direction
    * (geomtry information is NOT changed). PLATFORM SPECIFIC. */
   virtual bool InitializeView( vtkRenderWindow *renderWindow );
 
   /**
    * @brief Initializes the renderwindows by the aggregated geometry of
    *        all objects that are held in the data storage.
    * This is basically a global reinit
    * @param The data storage from which the bounding object can be retrieved
    */
   virtual void InitializeViewsByBoundingObjects(const DataStorage * );
 
   /** Gets the (global) SliceNavigationController responsible for
    * time-slicing. */
   const SliceNavigationController *GetTimeNavigationController() const;
 
   /** Gets the (global) SliceNavigationController responsible for
    * time-slicing. */
   SliceNavigationController *GetTimeNavigationController();
 
   virtual ~RenderingManager();
 
   /** Executes all pending requests. This method has to be called by the
    * system whenever a RenderingManager induced request event occurs in
    * the system pipeline (see concrete RenderingManager implementations). */
   virtual void ExecutePendingRequests();
 
   bool IsRendering() const;
   void AbortRendering();
 
   /** En-/Disable LOD increase globally. */
   itkSetMacro( LODIncreaseBlocked, bool );
 
   /** En-/Disable LOD increase globally. */
   itkGetMacro( LODIncreaseBlocked, bool );
 
   /** En-/Disable LOD increase globally. */
   itkBooleanMacro( LODIncreaseBlocked );
 
   /** En-/Disable LOD abort mechanism. */
   itkSetMacro( LODAbortMechanismEnabled, bool );
 
   /** En-/Disable LOD abort mechanism. */
   itkGetMacro( LODAbortMechanismEnabled, bool );
 
   /** En-/Disable LOD abort mechanism. */
   itkBooleanMacro( LODAbortMechanismEnabled );
 
   /** Force a sub-class to start a timer for a pending hires-rendering request */
   virtual void StartOrResetTimer() {};
 
   /** To be called by a sub-class from a timer callback */
   void ExecutePendingHighResRenderingRequest();
 
   virtual void DoStartRendering() {};
   virtual void DoMonitorRendering() {};
   virtual void DoFinishAbortRendering() {};
 
   int GetNextLOD( BaseRenderer* renderer );
 
   /** Set current LOD (NULL means all renderers)*/
   void SetMaximumLOD( unsigned int max );
 
   void SetShading( bool state, unsigned int lod );
   bool GetShading( unsigned int lod );
 
   void SetClippingPlaneStatus( bool status );
   bool GetClippingPlaneStatus();
 
   void SetShadingValues( float ambient, float diffuse,
     float specular, float specpower );
 
   FloatVector &GetShadingValues();
 
   /** Returns a property list */
   PropertyList::Pointer GetPropertyList() const;
 
   /** Returns a property from m_PropertyList */
   BaseProperty* GetProperty(const char *propertyKey) const;
 
   /** Sets or adds (if not present) a property in m_PropertyList  */
   void SetProperty(const char *propertyKey, BaseProperty* propertyValue);
 
   /**
   * \brief Setter / Getter for internal DataStorage
   *
   * Sets / returns the mitk::DataStorage that is used internally. This instance holds all mitk::DataNodes that are
   * rendered by the registered BaseRenderers.
   *
   * If this DataStorage is changed at runtime by calling SetDataStorage(),
   * all currently registered BaseRenderers are automatically given the correct instance.
   * When a new BaseRenderer is added, it is automatically initialized with the currently active DataStorage.
   */
   void SetDataStorage( mitk::DataStorage* storage );
 
   /**
   * \brief Setter / Getter for internal DataStorage
   *
   * Sets / returns the mitk::DataStorage that is used internally. This instance holds all mitk::DataNodes that are
   * rendered by the registered BaseRenderers.
   *
   * If this DataStorage is changed at runtime by calling SetDataStorage(),
   * all currently registered BaseRenderers are automatically given the correct instance.
   * When a new BaseRenderer is added, it is automatically initialized with the currently active DataStorage.
   */
   mitk::DataStorage* GetDataStorage();
 
   /**
    * @brief Sets a flag to the given renderwindow to indicated that it has the focus e.g. has been clicked recently.
    * @param focusWindow
    */
   void SetRenderWindowFocus(vtkRenderWindow* focusWindow);
 
   itkGetMacro(FocusedRenderWindow, vtkRenderWindow*)
 
   itkSetMacro(ConstrainedPanningZooming, bool);
 
 protected:
   enum
   {
     RENDERING_INACTIVE = 0,
     RENDERING_REQUESTED,
     RENDERING_INPROGRESS
   };
 
   RenderingManager();
 
   /** Abstract method for generating a system specific event for rendering
    * request. This method is called whenever an update is requested */
   virtual void GenerateRenderingRequestEvent() = 0;
 
   virtual void InitializePropertyList();
 
   bool m_UpdatePending;
 
   typedef std::map< BaseRenderer *, unsigned int > RendererIntMap;
   typedef std::map< BaseRenderer *, bool > RendererBoolMap;
 
   RendererBoolMap m_RenderingAbortedMap;
 
   RendererIntMap m_NextLODMap;
 
   unsigned int m_MaxLOD;
 
   bool m_LODIncreaseBlocked;
 
   bool m_LODAbortMechanismEnabled;
 
   BoolVector m_ShadingEnabled;
 
   bool m_ClippingPlaneEnabled;
 
   FloatVector m_ShadingValues;
 
   static void RenderingStartCallback(
     vtkObject *caller, unsigned long eid, void *clientdata, void *calldata );
   static void RenderingProgressCallback(
     vtkObject *caller, unsigned long eid, void *clientdata, void *calldata );
   static void RenderingEndCallback(
     vtkObject *caller, unsigned long eid, void *clientdata, void *calldata );
 
   typedef std::map< vtkRenderWindow *, int > RenderWindowList;
 
   RenderWindowList m_RenderWindowList;
   RenderWindowVector m_AllRenderWindows;
 
   struct RenderWindowCallbacks
   {
     vtkCallbackCommand* commands[3u];
   };
 
   typedef std::map<vtkRenderWindow*, RenderWindowCallbacks> RenderWindowCallbacksList;
 
   RenderWindowCallbacksList m_RenderWindowCallbacksList;
 
   itk::SmartPointer<SliceNavigationController> m_TimeNavigationController;
 
   static RenderingManager::Pointer s_Instance;
   static RenderingManagerFactory *s_RenderingManagerFactory;
 
   PropertyList::Pointer m_PropertyList;
 
   DataStoragePointer m_DataStorage;
 
 
   bool m_ConstrainedPanningZooming;
 
 private:
 
   void InternalViewInitialization(
       mitk::BaseRenderer *baseRenderer, const mitk::TimeGeometry *geometry,
       bool boundingBoxInitialized, int mapperID );
 
   vtkRenderWindow* m_FocusedRenderWindow;
 };
 
 #pragma GCC visibility push(default)
 
 itkEventMacro( RenderingManagerEvent, itk::AnyEvent );
 itkEventMacro( RenderingManagerViewsInitializedEvent, RenderingManagerEvent );
 
 #pragma GCC visibility pop
 
 itkEventMacroDeclaration(FocusChangedEvent, itk::AnyEvent)
 
 /**
  * Generic RenderingManager implementation for "non-rendering-plattform",
  * e.g. for tests. Its factory (TestingRenderingManagerFactory) is
  * automatically on start-up and is used by default if not other
  * RenderingManagerFactory is instantiated explicitly thereafter.
  * (see mitkRenderingManager.cpp)
  */
 class MITKCORE_EXPORT TestingRenderingManager : public RenderingManager
 {
 public:
   mitkClassMacro(TestingRenderingManager,RenderingManager);
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
 protected:
   virtual void GenerateRenderingRequestEvent() override
   {
    // ForceImmediateUpdateAll();
   };
 };
 
 } // namespace mitk
 
 #endif /* MITKRenderingManager_H_HEADER_INCLUDED_C135A197 */
diff --git a/Modules/Core/src/Rendering/mitkSurfaceVtkMapper2D.cpp b/Modules/Core/src/Rendering/mitkSurfaceVtkMapper2D.cpp
index 7ddb86d21d..6ace9c9ef0 100644
--- a/Modules/Core/src/Rendering/mitkSurfaceVtkMapper2D.cpp
+++ b/Modules/Core/src/Rendering/mitkSurfaceVtkMapper2D.cpp
@@ -1,388 +1,388 @@
 /*===================================================================
 
 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 "mitkSurfaceVtkMapper2D.h"
 
 //mitk includes
 #include <mitkDataNode.h>
 #include <mitkProperties.h>
 #include "mitkVtkPropRenderer.h"
 #include <mitkSurface.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkVtkScalarModeProperty.h>
 #include <mitkTransferFunctionProperty.h>
 #include <mitkCoreServices.h>
 #include <mitkIPropertyAliases.h>
 #include <mitkIPropertyDescriptions.h>
 
 //vtk includes
 #include <vtkActor.h>
 #include <vtkCutter.h>
 #include <vtkLookupTable.h>
 #include <vtkPlane.h>
 #include <vtkPolyData.h>
 #include <vtkAssembly.h>
 #include <vtkPointData.h>
 #include <vtkGlyph3D.h>
 #include <vtkReverseSense.h>
 #include <vtkArrowSource.h>
 #include <vtkTransformPolyDataFilter.h>
 
 // constructor LocalStorage
 mitk::SurfaceVtkMapper2D::LocalStorage::LocalStorage()
 {
   m_Mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   m_Mapper->ScalarVisibilityOff();
   m_Actor = vtkSmartPointer<vtkActor>::New();
   m_PropAssembly = vtkSmartPointer <vtkAssembly>::New();
   m_PropAssembly->AddPart( m_Actor );
   m_CuttingPlane = vtkSmartPointer<vtkPlane>::New();
   m_Cutter = vtkSmartPointer<vtkCutter>::New();
   m_Cutter->SetCutFunction(m_CuttingPlane);
   m_Mapper->SetInputConnection( m_Cutter->GetOutputPort() );
 
   m_NormalGlyph = vtkSmartPointer<vtkGlyph3D>::New();
 
   m_InverseNormalGlyph = vtkSmartPointer<vtkGlyph3D>::New();
 
   // Source for the glyph filter
   m_ArrowSource = vtkSmartPointer<vtkArrowSource>::New();
   //set small default values for fast rendering
   m_ArrowSource->SetTipRadius(0.05);
   m_ArrowSource->SetTipLength(0.20);
   m_ArrowSource->SetTipResolution(5);
   m_ArrowSource->SetShaftResolution(5);
   m_ArrowSource->SetShaftRadius(0.01);
 
   m_NormalGlyph->SetSourceConnection(m_ArrowSource->GetOutputPort());
   m_NormalGlyph->SetVectorModeToUseNormal();
   m_NormalGlyph->OrientOn();
 
   m_InverseNormalGlyph->SetSourceConnection(m_ArrowSource->GetOutputPort());
   m_InverseNormalGlyph->SetVectorModeToUseNormal();
   m_InverseNormalGlyph->OrientOn();
 
   m_NormalMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   m_NormalMapper->SetInputConnection(m_NormalGlyph->GetOutputPort());
   m_NormalMapper->ScalarVisibilityOff();
 
   m_InverseNormalMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   m_InverseNormalMapper->SetInputConnection(m_NormalGlyph->GetOutputPort());
   m_InverseNormalMapper->ScalarVisibilityOff();
 
   m_NormalActor = vtkSmartPointer<vtkActor>::New();
   m_NormalActor->SetMapper(m_NormalMapper);
 
   m_InverseNormalActor = vtkSmartPointer<vtkActor>::New();
   m_InverseNormalActor->SetMapper(m_InverseNormalMapper);
 
   m_ReverseSense = vtkSmartPointer<vtkReverseSense>::New();
 }
 
 // destructor LocalStorage
 mitk::SurfaceVtkMapper2D::LocalStorage::~LocalStorage()
 {
 }
 
 const mitk::Surface* mitk::SurfaceVtkMapper2D::GetInput() const
 {
   return static_cast<const mitk::Surface * > ( GetDataNode()->GetData() );
 }
 
 // constructor PointSetVtkMapper2D
 mitk::SurfaceVtkMapper2D::SurfaceVtkMapper2D()
 {
 }
 
 mitk::SurfaceVtkMapper2D::~SurfaceVtkMapper2D()
 {
 }
 
 // reset mapper so that nothing is displayed e.g. toggle visiblity of the propassembly
 void mitk::SurfaceVtkMapper2D::ResetMapper( BaseRenderer* renderer )
 {
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
   ls->m_PropAssembly->VisibilityOff();
 }
 
 vtkProp* mitk::SurfaceVtkMapper2D::GetVtkProp(mitk::BaseRenderer * renderer)
 {
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
   return ls->m_PropAssembly;
 }
 
 void mitk::SurfaceVtkMapper2D::Update(mitk::BaseRenderer* renderer)
 {
   const mitk::DataNode* node = GetDataNode();
   if( node == NULL )
     return;
   bool visible = true;
   node->GetVisibility(visible, renderer, "visible");
   if ( !visible )
     return;
 
   mitk::Surface* surface  = static_cast<mitk::Surface *>( node->GetData() );
   if ( surface == NULL )
     return;
 
   // Calculate time step of the input data for the specified renderer (integer value)
   this->CalculateTimeStep( renderer );
 
   // Check if time step is valid
   const mitk::TimeGeometry *dataTimeGeometry = surface->GetTimeGeometry();
   if ( ( dataTimeGeometry == NULL )
        || ( dataTimeGeometry->CountTimeSteps() == 0 )
        || ( !dataTimeGeometry->IsValidTimeStep( this->GetTimestep() ) ) )
   {
     return;
   }
 
   surface->UpdateOutputInformation();
   LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
 
   //check if something important has changed and we need to rerender
   if ( (localStorage->m_LastUpdateTime < node->GetMTime()) //was the node modified?
        || (localStorage->m_LastUpdateTime < surface->GetPipelineMTime()) //Was the data modified?
        || (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldPlaneGeometryUpdateTime()) //was the geometry modified?
        || (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldPlaneGeometry()->GetMTime())
        || (localStorage->m_LastUpdateTime < node->GetPropertyList()->GetMTime()) //was a property modified?
        || (localStorage->m_LastUpdateTime < node->GetPropertyList(renderer)->GetMTime()) )
   {
     this->GenerateDataForRenderer( renderer );
   }
 
   // since we have checked that nothing important has changed, we can set
   // m_LastUpdateTime to the current time
   localStorage->m_LastUpdateTime.Modified();
 }
 
 void mitk::SurfaceVtkMapper2D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
 {
   const DataNode* node = GetDataNode();
   Surface* surface  = static_cast<Surface *>( node->GetData() );
   const TimeGeometry *dataTimeGeometry = surface->GetTimeGeometry();
   LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
 
   ScalarType time =renderer->GetTime();
   int timestep=0;
 
   if( time > itk::NumericTraits<ScalarType>::NonpositiveMin() )
     timestep = dataTimeGeometry->TimePointToTimeStep( time );
 
   vtkSmartPointer<vtkPolyData> inputPolyData = surface->GetVtkPolyData( timestep );
   if ((inputPolyData == NULL) || (inputPolyData->GetNumberOfPoints() < 1))
     return;
 
   //apply color and opacity read from the PropertyList
   this->ApplyAllProperties(renderer);
 
   const PlaneGeometry* planeGeometry = renderer->GetCurrentWorldPlaneGeometry();
   if( ( planeGeometry == NULL ) || ( !planeGeometry->IsValid() ) || ( !planeGeometry->HasReferenceGeometry() ))
   {
     return;
   }
 
   if (localStorage->m_Actor->GetMapper() == NULL)
     localStorage->m_Actor->SetMapper(localStorage->m_Mapper);
 
   double origin[3];
   origin[0] = planeGeometry->GetOrigin()[0];
   origin[1] = planeGeometry->GetOrigin()[1];
   origin[2] = planeGeometry->GetOrigin()[2];
 
   double normal[3];
   normal[0] = planeGeometry->GetNormal()[0];
   normal[1] = planeGeometry->GetNormal()[1];
   normal[2] = planeGeometry->GetNormal()[2];
 
   localStorage->m_CuttingPlane->SetOrigin(origin);
   localStorage->m_CuttingPlane->SetNormal(normal);
   //Transform the data according to its geometry.
   //See UpdateVtkTransform documentation for details.
   vtkSmartPointer<vtkLinearTransform> vtktransform = GetDataNode()->GetVtkTransform(this->GetTimestep());
   vtkSmartPointer<vtkTransformPolyDataFilter> filter = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
   filter->SetTransform(vtktransform);
   filter->SetInputData(inputPolyData);
   localStorage->m_Cutter->SetInputConnection(filter->GetOutputPort());
   localStorage->m_Cutter->Update();
 
   bool generateNormals = false;
   node->GetBoolProperty("draw normals 2D", generateNormals);
   if(generateNormals)
   {
     localStorage->m_NormalGlyph->SetInputConnection( localStorage->m_Cutter->GetOutputPort() );
     localStorage->m_NormalGlyph->Update();
 
     localStorage->m_NormalMapper->SetInputConnection( localStorage->m_NormalGlyph->GetOutputPort() );
 
     localStorage->m_PropAssembly->AddPart( localStorage->m_NormalActor );
   }
   else
   {
     localStorage->m_NormalGlyph->SetInputConnection( NULL );
     localStorage->m_PropAssembly->RemovePart( localStorage->m_NormalActor );
   }
 
   bool generateInverseNormals = false;
   node->GetBoolProperty("invert normals", generateInverseNormals);
   if(generateInverseNormals)
   {
 
     localStorage->m_ReverseSense->SetInputConnection( localStorage->m_Cutter->GetOutputPort() );
     localStorage->m_ReverseSense->ReverseCellsOff();
     localStorage->m_ReverseSense->ReverseNormalsOn();
 
     localStorage->m_InverseNormalGlyph->SetInputConnection( localStorage->m_ReverseSense->GetOutputPort() );
     localStorage->m_InverseNormalGlyph->Update();
 
     localStorage->m_InverseNormalMapper->SetInputConnection( localStorage->m_InverseNormalGlyph->GetOutputPort() );
 
     localStorage->m_PropAssembly->AddPart( localStorage->m_InverseNormalActor );
   }
   else
   {
     localStorage->m_ReverseSense->SetInputConnection( NULL );
     localStorage->m_PropAssembly->RemovePart( localStorage->m_InverseNormalActor );
   }
 }
 
 void mitk::SurfaceVtkMapper2D::ApplyAllProperties(mitk::BaseRenderer* renderer)
 {
   const DataNode * node = GetDataNode();
 
   if(node == NULL)
   {
     return;
   }
 
   float lineWidth = 1.0f;
   node->GetFloatProperty("line width", lineWidth, renderer);
 
   LocalStorage* localStorage = m_LSH.GetLocalStorage(renderer);
 
   // check for color and opacity properties, use it for rendering if they exists
   float color[3]= { 1.0f, 1.0f, 1.0f };
   node->GetColor(color, renderer, "color");
   float opacity = 1.0f;
   node->GetOpacity(opacity, renderer, "opacity");
 
   //Pass properties to VTK
   localStorage->m_Actor->GetProperty()->SetColor(color[0], color[1], color[2]);
   localStorage->m_Actor->GetProperty()->SetOpacity(opacity);
   localStorage->m_NormalActor->GetProperty()->SetOpacity(opacity);
   localStorage->m_InverseNormalActor->GetProperty()->SetOpacity(opacity);
   localStorage->m_Actor->GetProperty()->SetLineWidth(lineWidth);
   //By default, the cutter will also copy/compute normals of the cut
   //to the output polydata. The normals will influence the
   //vtkPolyDataMapper lightning. To view a clean cut the lighting has
   //to be disabled.
   localStorage->m_Actor->GetProperty()->SetLighting(0);
 
   // same block for scalar data rendering as in 3D mapper
   mitk::TransferFunctionProperty::Pointer transferFuncProp;
   this->GetDataNode()->GetProperty(transferFuncProp, "Surface.TransferFunction", renderer);
   if (transferFuncProp.IsNotNull() )
   {
     localStorage->m_Mapper->SetLookupTable(transferFuncProp->GetValue()->GetColorTransferFunction());
   }
 
   mitk::LookupTableProperty::Pointer lookupTableProp;
   this->GetDataNode()->GetProperty(lookupTableProp, "LookupTable", renderer);
   if (lookupTableProp.IsNotNull() )
   {
     localStorage->m_Mapper->SetLookupTable(lookupTableProp->GetLookupTable()->GetVtkLookupTable());
   }
 
   mitk::LevelWindow levelWindow;
   if(this->GetDataNode()->GetLevelWindow(levelWindow, renderer, "levelWindow"))
   {
     localStorage->m_Mapper->SetScalarRange(levelWindow.GetLowerWindowBound(),levelWindow.GetUpperWindowBound());
   }
   else
     if(this->GetDataNode()->GetLevelWindow(levelWindow, renderer))
     {
       localStorage->m_Mapper->SetScalarRange(levelWindow.GetLowerWindowBound(),levelWindow.GetUpperWindowBound());
     }
 
-    bool scalarVisibility = false;
-    this->GetDataNode()->GetBoolProperty("scalar visibility", scalarVisibility);
-    localStorage->m_Mapper->SetScalarVisibility( (scalarVisibility ? 1 : 0) );
+  bool scalarVisibility = false;
+  this->GetDataNode()->GetBoolProperty("scalar visibility", scalarVisibility);
+  localStorage->m_Mapper->SetScalarVisibility( (scalarVisibility ? 1 : 0) );
 
-    if(scalarVisibility)
-    {
-      mitk::VtkScalarModeProperty* scalarMode;
-      if(this->GetDataNode()->GetProperty(scalarMode, "scalar mode", renderer))
-        localStorage->m_Mapper->SetScalarMode(scalarMode->GetVtkScalarMode());
-      else
-        localStorage->m_Mapper->SetScalarModeToDefault();
+  if(scalarVisibility)
+  {
+    mitk::VtkScalarModeProperty* scalarMode;
+    if(this->GetDataNode()->GetProperty(scalarMode, "scalar mode", renderer))
+      localStorage->m_Mapper->SetScalarMode(scalarMode->GetVtkScalarMode());
+    else
+      localStorage->m_Mapper->SetScalarModeToDefault();
 
-      bool colorMode = false;
-      this->GetDataNode()->GetBoolProperty("color mode", colorMode);
-      localStorage->m_Mapper->SetColorMode( (colorMode ? 1 : 0) );
+    bool colorMode = false;
+    this->GetDataNode()->GetBoolProperty("color mode", colorMode);
+    localStorage->m_Mapper->SetColorMode( (colorMode ? 1 : 0) );
 
-      double scalarsMin = 0;
-      this->GetDataNode()->GetDoubleProperty("ScalarsRangeMinimum", scalarsMin, renderer);
+    double scalarsMin = 0;
+    this->GetDataNode()->GetDoubleProperty("ScalarsRangeMinimum", scalarsMin, renderer);
 
-      double scalarsMax = 1.0;
-      this->GetDataNode()->GetDoubleProperty("ScalarsRangeMaximum", scalarsMax, renderer);
+    double scalarsMax = 1.0;
+    this->GetDataNode()->GetDoubleProperty("ScalarsRangeMaximum", scalarsMax, renderer);
 
-      localStorage->m_Mapper->SetScalarRange(scalarsMin,scalarsMax);
-    }
+    localStorage->m_Mapper->SetScalarRange(scalarsMin,scalarsMax);
+  }
 
   //color for inverse normals
   float inverseNormalsColor[3]= { 1.0f, 0.0f, 0.0f };
   node->GetColor(inverseNormalsColor, renderer, "back color");
   localStorage->m_InverseNormalActor->GetProperty()->SetColor(inverseNormalsColor[0],
       inverseNormalsColor[1], inverseNormalsColor[2]);
 
   //color for normals
   float normalsColor[3]= { 0.0f, 1.0f, 0.0f };
   node->GetColor(normalsColor, renderer, "front color");
   localStorage->m_NormalActor->GetProperty()->SetColor(normalsColor[0],
       normalsColor[1], normalsColor[2]);
 
   //normals scaling
   float normalScaleFactor = 10.0f;
   node->GetFloatProperty( "front normal lenth (px)", normalScaleFactor, renderer );
   localStorage->m_NormalGlyph->SetScaleFactor(normalScaleFactor);
 
   //inverse normals scaling
   float inverseNormalScaleFactor = 10.0f;
   node->GetFloatProperty( "back normal lenth (px)", inverseNormalScaleFactor, renderer );
   localStorage->m_InverseNormalGlyph->SetScaleFactor(inverseNormalScaleFactor);
 }
 
 void mitk::SurfaceVtkMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   mitk::IPropertyAliases* aliases = mitk::CoreServices::GetPropertyAliases();
   node->AddProperty( "line width", FloatProperty::New(2.0f), renderer, overwrite );
   aliases->AddAlias( "line width", "Surface.2D.Line Width", "Surface");
   node->AddProperty( "scalar mode", VtkScalarModeProperty::New(), renderer, overwrite );
   node->AddProperty( "draw normals 2D", BoolProperty::New(false), renderer, overwrite );
   aliases->AddAlias( "draw normals 2D", "Surface.2D.Normals.Draw Normals", "Surface");
   node->AddProperty( "invert normals", BoolProperty::New(false), renderer, overwrite );
   aliases->AddAlias( "invert normals", "Surface.2D.Normals.Draw Inverse Normals", "Surface");
   node->AddProperty( "front color", ColorProperty::New(0.0, 1.0, 0.0), renderer, overwrite );
   aliases->AddAlias( "front color", "Surface.2D.Normals.Normals Color", "Surface");
   node->AddProperty( "back color", ColorProperty::New(1.0, 0.0, 0.0), renderer, overwrite );
   aliases->AddAlias( "back color", "Surface.2D.Normals.Inverse Normals Color", "Surface");
   node->AddProperty( "front normal lenth (px)", FloatProperty::New(10.0), renderer, overwrite );
   aliases->AddAlias( "front normal lenth (px)", "Surface.2D.Normals.Normals Scale Factor", "Surface");
   node->AddProperty( "back normal lenth (px)", FloatProperty::New(10.0), renderer, overwrite );
   aliases->AddAlias( "back normal lenth (px)", "Surface.2D.Normals.Inverse Normals Scale Factor", "Surface");
   node->AddProperty( "layer", IntProperty::New(100), renderer, overwrite);
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }