diff --git a/Core/Code/Rendering/mitkGeometry2DDataVtkMapper3D.cpp b/Core/Code/Rendering/mitkGeometry2DDataVtkMapper3D.cpp
index 6c0475058c..4c3fdf0a8f 100644
--- a/Core/Code/Rendering/mitkGeometry2DDataVtkMapper3D.cpp
+++ b/Core/Code/Rendering/mitkGeometry2DDataVtkMapper3D.cpp
@@ -1,582 +1,582 @@
 /*===================================================================
 
 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 "mitkGeometry2DDataVtkMapper3D.h"
 
 #include "mitkImageVtkMapper2D.h"
 #include "mitkSmartPointerProperty.h"
 #include "mitkSurface.h"
 #include "mitkVtkRepresentationProperty.h"
 #include "mitkWeakPointerProperty.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkNodePredicateOr.h"
 #include "vtkNeverTranslucentTexture.h"
 #include "vtkMitkLevelWindowFilter.h"
 
 #include <vtkAssembly.h>
 #include <vtkDataSetMapper.h>
 #include <vtkFeatureEdges.h>
 #include <vtkHedgeHog.h>
 #include <vtkImageData.h>
 #include <vtkLinearTransform.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkProp3DCollection.h>
 #include <vtkProperty.h>
 #include <vtkTransformPolyDataFilter.h>
 #include <vtkTubeFilter.h>
 
 namespace mitk
 {
 
   Geometry2DDataVtkMapper3D::Geometry2DDataVtkMapper3D()
     : m_NormalsActorAdded(false),
     m_DataStorage(NULL)
   {
     m_EdgeTuber = vtkTubeFilter::New();
     m_EdgeMapper = vtkPolyDataMapper::New();
 
     m_SurfaceCreator = Geometry2DDataToSurfaceFilter::New();
     m_SurfaceCreatorBoundingBox = BoundingBox::New();
     m_SurfaceCreatorPointsContainer = BoundingBox::PointsContainer::New();
     m_Edges = vtkFeatureEdges::New();
 
     m_Edges->BoundaryEdgesOn();
     m_Edges->FeatureEdgesOff();
     m_Edges->NonManifoldEdgesOff();
     m_Edges->ManifoldEdgesOff();
 
     m_EdgeTransformer = vtkTransformPolyDataFilter::New();
     m_NormalsTransformer = vtkTransformPolyDataFilter::New();
     m_EdgeActor = vtkActor::New();
     m_BackgroundMapper = vtkPolyDataMapper::New();
     m_BackgroundActor = vtkActor::New();
     m_Prop3DAssembly = vtkAssembly::New();
     m_ImageAssembly = vtkAssembly::New();
 
     m_SurfaceCreatorBoundingBox->SetPoints( m_SurfaceCreatorPointsContainer );
 
     m_Cleaner = vtkCleanPolyData::New();
 
     m_Cleaner->PieceInvariantOn();
     m_Cleaner->ConvertLinesToPointsOn();
     m_Cleaner->ConvertPolysToLinesOn();
     m_Cleaner->ConvertStripsToPolysOn();
     m_Cleaner->PointMergingOn();
 
     // Make sure that the FeatureEdge algorithm is initialized with a "valid"
     // (though empty) input
     vtkPolyData *emptyPolyData = vtkPolyData::New();
-    m_Cleaner->SetInput( emptyPolyData );
+    m_Cleaner->SetInputData( emptyPolyData );
     emptyPolyData->Delete();
 
-    m_Edges->SetInput(m_Cleaner->GetOutput());
-    m_EdgeTransformer->SetInput( m_Edges->GetOutput() );
+    m_Edges->SetInputData(m_Cleaner->GetOutput());
+    m_EdgeTransformer->SetInputData( m_Edges->GetOutput() );
 
-    m_EdgeTuber->SetInput( m_EdgeTransformer->GetOutput() );
+    m_EdgeTuber->SetInputData( m_EdgeTransformer->GetOutput() );
     m_EdgeTuber->SetVaryRadiusToVaryRadiusOff();
     m_EdgeTuber->SetNumberOfSides( 12 );
     m_EdgeTuber->CappingOn();
 
-    m_EdgeMapper->SetInput( m_EdgeTuber->GetOutput() );
+    m_EdgeMapper->SetInputData( m_EdgeTuber->GetOutput() );
     m_EdgeMapper->ScalarVisibilityOff();
 
-    m_BackgroundMapper->SetInput(emptyPolyData);
+    m_BackgroundMapper->SetInputData(emptyPolyData);
 
     m_EdgeActor->SetMapper( m_EdgeMapper );
 
     m_BackgroundActor->GetProperty()->SetAmbient( 0.5 );
     m_BackgroundActor->GetProperty()->SetColor( 0.0, 0.0, 0.0 );
     m_BackgroundActor->GetProperty()->SetOpacity( 0.0 );
     m_BackgroundActor->SetMapper( m_BackgroundMapper );
 
     vtkProperty * backfaceProperty = m_BackgroundActor->MakeProperty();
     backfaceProperty->SetColor( 0.0, 0.0, 0.0 );
     m_BackgroundActor->SetBackfaceProperty( backfaceProperty );
     backfaceProperty->Delete();
 
     m_FrontHedgeHog = vtkHedgeHog::New();
     m_BackHedgeHog  = vtkHedgeHog::New();
 
     m_FrontNormalsMapper = vtkPolyDataMapper::New();
-    m_FrontNormalsMapper->SetInput( m_FrontHedgeHog->GetOutput() );
+    m_FrontNormalsMapper->SetInputData( m_FrontHedgeHog->GetOutput() );
     m_BackNormalsMapper = vtkPolyDataMapper::New();
 
     m_Prop3DAssembly->AddPart( m_EdgeActor );
     m_Prop3DAssembly->AddPart( m_ImageAssembly );
     m_FrontNormalsActor = vtkActor::New();
     m_FrontNormalsActor->SetMapper(m_FrontNormalsMapper);
     m_BackNormalsActor = vtkActor::New();
     m_BackNormalsActor->SetMapper(m_BackNormalsMapper);
 
     m_ImageMapperDeletedCommand = MemberCommandType::New();
     m_ImageMapperDeletedCommand->SetCallbackFunction(
         this, &Geometry2DDataVtkMapper3D::ImageMapperDeletedCallback );
   }
 
   Geometry2DDataVtkMapper3D::~Geometry2DDataVtkMapper3D()
   {
     m_ImageAssembly->Delete();
     m_Prop3DAssembly->Delete();
     m_EdgeTuber->Delete();
     m_EdgeMapper->Delete();
     m_EdgeTransformer->Delete();
     m_Cleaner->Delete();
     m_Edges->Delete();
     m_NormalsTransformer->Delete();
     m_EdgeActor->Delete();
     m_BackgroundMapper->Delete();
     m_BackgroundActor->Delete();
     m_FrontNormalsMapper->Delete();
     m_FrontNormalsActor->Delete();
     m_FrontHedgeHog->Delete();
     m_BackNormalsMapper->Delete();
     m_BackNormalsActor->Delete();
     m_BackHedgeHog->Delete();
 
     // Delete entries in m_ImageActors list one by one
     m_ImageActors.clear();
 
     m_DataStorage = NULL;
   }
 
   vtkProp* Geometry2DDataVtkMapper3D::GetVtkProp(mitk::BaseRenderer * /*renderer*/)
   {
     if ( (this->GetDataNode() != NULL )
       && (m_ImageAssembly != NULL) )
       {
       // Do not transform the entire Prop3D assembly, but only the image part
       // here. The colored frame is transformed elsewhere (via m_EdgeTransformer),
       // since only vertices should be transformed there, not the poly data
       // itself, to avoid distortion for anisotropic datasets.
       m_ImageAssembly->SetUserTransform( this->GetDataNode()->GetVtkTransform() );
     }
     return m_Prop3DAssembly;
   }
 
   void Geometry2DDataVtkMapper3D::UpdateVtkTransform(mitk::BaseRenderer * /*renderer*/)
   {
     m_ImageAssembly->SetUserTransform(
         this->GetDataNode()->GetVtkTransform(this->GetTimestep()) );
   }
 
   const Geometry2DData* Geometry2DDataVtkMapper3D::GetInput()
   {
     return static_cast<const Geometry2DData * > ( GetDataNode()->GetData() );
   }
 
   void Geometry2DDataVtkMapper3D::SetDataStorageForTexture(mitk::DataStorage* storage)
   {
     if(storage != NULL && m_DataStorage != storage )
     {
       m_DataStorage = storage;
       this->Modified();
     }
   }
 
   void Geometry2DDataVtkMapper3D::ImageMapperDeletedCallback(
       itk::Object *caller, const itk::EventObject& /*event*/ )
   {
     ImageVtkMapper2D *imageMapper = dynamic_cast< ImageVtkMapper2D * >( caller );
     if ( (imageMapper != NULL) )
     {
       if ( m_ImageActors.count( imageMapper ) > 0)
       {
         m_ImageActors[imageMapper].m_Sender = NULL; // sender is already destroying itself
         m_ImageActors.erase( imageMapper );
       }
     }
   }
 
   void Geometry2DDataVtkMapper3D::GenerateDataForRenderer(BaseRenderer* renderer)
   {
     SetVtkMapperImmediateModeRendering(m_EdgeMapper);
     SetVtkMapperImmediateModeRendering(m_BackgroundMapper);
 
     // Remove all actors from the assembly, and re-initialize it with the
     // edge actor
     m_ImageAssembly->GetParts()->RemoveAllItems();
 
     bool visible = true;
     GetDataNode()->GetVisibility(visible, renderer, "visible");
 
     if ( !visible )
     {
       // visibility has explicitly to be set in the single actors
       // due to problems when using cell picking:
       // even if the assembly is invisible, the renderer contains
       // references to the assemblies parts. During picking the
       // visibility of each part is checked, and not only for the
       // whole assembly.
       m_ImageAssembly->VisibilityOff();
       m_EdgeActor->VisibilityOff();
       return;
     }
 
     // visibility has explicitly to be set in the single actors
     // due to problems when using cell picking:
     // even if the assembly is invisible, the renderer contains
     // references to the assemblies parts. During picking the
     // visibility of each part is checked, and not only for the
     // whole assembly.
     m_ImageAssembly->VisibilityOn();
     bool drawEdges = true;
     this->GetDataNode()->GetBoolProperty("draw edges", drawEdges, renderer);
     m_EdgeActor->SetVisibility(drawEdges);
 
     Geometry2DData::Pointer input = const_cast< Geometry2DData * >(this->GetInput());
 
     if (input.IsNotNull() && (input->GetGeometry2D() != NULL))
     {
       SmartPointerProperty::Pointer surfacecreatorprop;
       surfacecreatorprop = dynamic_cast< SmartPointerProperty * >(GetDataNode()->GetProperty("surfacegeometry", renderer));
 
       if ( (surfacecreatorprop.IsNull())
         || (surfacecreatorprop->GetSmartPointer().IsNull())
         || ((m_SurfaceCreator = dynamic_cast<Geometry2DDataToSurfaceFilter*>
              (surfacecreatorprop->GetSmartPointer().GetPointer())).IsNull() ) )
         {
         m_SurfaceCreator->PlaceByGeometryOn();
         surfacecreatorprop = SmartPointerProperty::New( m_SurfaceCreator );
         GetDataNode()->SetProperty("surfacegeometry", surfacecreatorprop);
       }
 
       m_SurfaceCreator->SetInput(input);
 
       int res;
       if (GetDataNode()->GetIntProperty("xresolution", res, renderer))
       {
         m_SurfaceCreator->SetXResolution(res);
       }
       if (GetDataNode()->GetIntProperty("yresolution", res, renderer))
       {
         m_SurfaceCreator->SetYResolution(res);
       }
 
       double tubeRadius = 1.0; // Radius of tubular edge surrounding plane
 
       // Clip the Geometry2D with the reference geometry bounds (if available)
       if ( input->GetGeometry2D()->HasReferenceGeometry() )
       {
         Geometry3D *referenceGeometry =
             input->GetGeometry2D()->GetReferenceGeometry();
 
         BoundingBox::PointType boundingBoxMin, boundingBoxMax;
         boundingBoxMin = referenceGeometry->GetBoundingBox()->GetMinimum();
         boundingBoxMax = referenceGeometry->GetBoundingBox()->GetMaximum();
 
         if ( referenceGeometry->GetImageGeometry() )
         {
           for ( unsigned int i = 0; i < 3; ++i )
           {
             boundingBoxMin[i] -= 0.5;
             boundingBoxMax[i] -= 0.5;
           }
         }
 
         m_SurfaceCreatorPointsContainer->CreateElementAt( 0 ) = boundingBoxMin;
         m_SurfaceCreatorPointsContainer->CreateElementAt( 1 ) = boundingBoxMax;
 
         m_SurfaceCreatorBoundingBox->ComputeBoundingBox();
 
         m_SurfaceCreator->SetBoundingBox( m_SurfaceCreatorBoundingBox );
 
         tubeRadius = referenceGeometry->GetDiagonalLength() / 450.0;
       }
 
       // If no reference geometry is available, clip with the current global
       // bounds
       else if (m_DataStorage.IsNotNull())
       {
         m_SurfaceCreator->SetBoundingBox(m_DataStorage->ComputeVisibleBoundingBox(NULL, "includeInBoundingBox"));
         tubeRadius = sqrt( m_SurfaceCreator->GetBoundingBox()->GetDiagonalLength2() ) / 450.0;
       }
 
       // Calculate the surface of the Geometry2D
       m_SurfaceCreator->Update();
       Surface *surface = m_SurfaceCreator->GetOutput();
 
       // Check if there's something to display, otherwise return
       if ( (surface->GetVtkPolyData() == 0 )
         || (surface->GetVtkPolyData()->GetNumberOfCells() == 0) )
         {
         m_ImageAssembly->VisibilityOff();
         return;
       }
 
       // add a graphical representation of the surface normals if requested
       DataNode* node = this->GetDataNode();
       bool displayNormals = false;
       bool colorTwoSides = false;
       bool invertNormals = false;
       node->GetBoolProperty("draw normals 3D", displayNormals, renderer);
       node->GetBoolProperty("color two sides", colorTwoSides, renderer);
       node->GetBoolProperty("invert normals", invertNormals, renderer);
 
       //if we want to draw the display normals or render two sides we have to get the colors
       if( displayNormals || colorTwoSides )
       {
         //get colors
         float frontColor[3] = { 0.0, 0.0, 1.0 };
         node->GetColor( frontColor, renderer, "front color" );
         float backColor[3] = { 1.0, 0.0, 0.0 };
         node->GetColor( backColor, renderer, "back color" );
 
         if ( displayNormals )
         {
-          m_NormalsTransformer->SetInput( surface->GetVtkPolyData() );
+          m_NormalsTransformer->SetInputData( surface->GetVtkPolyData() );
           m_NormalsTransformer->SetTransform(node->GetVtkTransform(this->GetTimestep()) );
 
-          m_FrontHedgeHog->SetInput( m_NormalsTransformer->GetOutput() );
+          m_FrontHedgeHog->SetInputData( m_NormalsTransformer->GetOutput() );
           m_FrontHedgeHog->SetVectorModeToUseNormal();
           m_FrontHedgeHog->SetScaleFactor( invertNormals ? 1.0 : -1.0 );
 
           m_FrontNormalsActor->GetProperty()->SetColor( frontColor[0], frontColor[1], frontColor[2] );
 
-          m_BackHedgeHog->SetInput( m_NormalsTransformer->GetOutput() );
+          m_BackHedgeHog->SetInputData( m_NormalsTransformer->GetOutput() );
           m_BackHedgeHog->SetVectorModeToUseNormal();
           m_BackHedgeHog->SetScaleFactor( invertNormals ? -1.0 : 1.0 );
 
           m_BackNormalsActor->GetProperty()->SetColor( backColor[0], backColor[1], backColor[2] );
 
           //if there is no actor added yet, add one
           if ( !m_NormalsActorAdded )
           {
             m_Prop3DAssembly->AddPart( m_FrontNormalsActor );
             m_Prop3DAssembly->AddPart( m_BackNormalsActor );
             m_NormalsActorAdded = true;
           }
         }
         //if we don't want to display normals AND there is an actor added remove the actor
         else if ( m_NormalsActorAdded )
         {
           m_Prop3DAssembly->RemovePart( m_FrontNormalsActor );
           m_Prop3DAssembly->RemovePart( m_BackNormalsActor );
           m_NormalsActorAdded = false;
         }
 
         if ( colorTwoSides )
         {
           if ( !invertNormals )
           {
             m_BackgroundActor->GetProperty()->SetColor( backColor[0], backColor[1], backColor[2] );
             m_BackgroundActor->GetBackfaceProperty()->SetColor( frontColor[0], frontColor[1], frontColor[2] );
           }
           else
           {
             m_BackgroundActor->GetProperty()->SetColor( frontColor[0], frontColor[1], frontColor[2] );
             m_BackgroundActor->GetBackfaceProperty()->SetColor( backColor[0], backColor[1], backColor[2] );
           }
         }
       }
 
       // Add black background for all images (which may be transparent)
-      m_BackgroundMapper->SetInput( surface->GetVtkPolyData() );
+      m_BackgroundMapper->SetInputData( surface->GetVtkPolyData() );
       m_ImageAssembly->AddPart( m_BackgroundActor );
 
       LayerSortedActorList layerSortedActors;
 
       // Traverse the data tree to find nodes resliced by ImageMapperGL2D
       //use a predicate to get all data nodes which are "images" or inherit from mitk::Image
       mitk::TNodePredicateDataType< mitk::Image >::Pointer predicateAllImages = mitk::TNodePredicateDataType< mitk::Image >::New();
       mitk::DataStorage::SetOfObjects::ConstPointer all = m_DataStorage->GetSubset(predicateAllImages);
       //process all found images
       for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
       {
 
         DataNode *node = it->Value();
         if (node != NULL)
           this->ProcessNode(node, renderer, surface, layerSortedActors);
       }
 
       // Add all image actors to the assembly, sorted according to
       // layer property
       LayerSortedActorList::iterator actorIt;
       for ( actorIt = layerSortedActors.begin(); actorIt != layerSortedActors.end(); ++actorIt )
       {
         m_ImageAssembly->AddPart( actorIt->second );
       }
 
       // Configurate the tube-shaped frame: size according to the surface
       // bounds, color as specified in the plane's properties
       vtkPolyData *surfacePolyData = surface->GetVtkPolyData();
-      m_Cleaner->SetInput(surfacePolyData);
+      m_Cleaner->SetInputData(surfacePolyData);
       m_EdgeTransformer->SetTransform(this->GetDataNode()->GetVtkTransform(this->GetTimestep()) );
 
       // Adjust the radius according to extent
       m_EdgeTuber->SetRadius( tubeRadius );
 
       // Get the plane's color and set the tube properties accordingly
       ColorProperty::Pointer colorProperty;
       colorProperty = dynamic_cast<ColorProperty*>(this->GetDataNode()->GetProperty( "color" ));
       if ( colorProperty.IsNotNull() )
       {
         const Color& color = colorProperty->GetColor();
         m_EdgeActor->GetProperty()->SetColor(color.GetRed(), color.GetGreen(), color.GetBlue());
       }
       else
       {
         m_EdgeActor->GetProperty()->SetColor( 1.0, 1.0, 1.0 );
       }
 
       m_ImageAssembly->SetUserTransform(this->GetDataNode()->GetVtkTransform(this->GetTimestep()) );
     }
 
     VtkRepresentationProperty* representationProperty;
     this->GetDataNode()->GetProperty(representationProperty, "material.representation", renderer);
     if ( representationProperty != NULL )
       m_BackgroundActor->GetProperty()->SetRepresentation( representationProperty->GetVtkRepresentation() );
   }
 
   void Geometry2DDataVtkMapper3D::ProcessNode( DataNode * node, BaseRenderer* renderer,
                                                Surface * surface, LayerSortedActorList &layerSortedActors )
   {
     if ( node != NULL )
     {
       //we need to get the information from the 2D mapper to render the texture on the 3D plane
       ImageVtkMapper2D *imageMapper = dynamic_cast< ImageVtkMapper2D * >( node->GetMapper(1) ); //GetMapper(1) provides the 2D mapper for the data node
 
       //if there is a 2D mapper, which is not the standard image mapper...
       if(!imageMapper && node->GetMapper(1))
       { //... check if it is the composite mapper
         std::string cname(node->GetMapper(1)->GetNameOfClass());
         if(!cname.compare("CompositeMapper")) //string.compare returns 0 if the two strings are equal.
         {
           //get the standard image mapper.
           //This is a special case in MITK and does only work for the CompositeMapper.
           imageMapper = dynamic_cast<ImageVtkMapper2D* >( node->GetMapper(3) );
         }
       }
 
       if ( (node->IsVisible(renderer)) && imageMapper )
       {
         WeakPointerProperty::Pointer rendererProp =
             dynamic_cast< WeakPointerProperty * >(GetDataNode()->GetPropertyList()->GetProperty("renderer"));
 
         if ( rendererProp.IsNotNull() )
         {
           BaseRenderer::Pointer planeRenderer = dynamic_cast< BaseRenderer * >(rendererProp->GetWeakPointer().GetPointer());
           // Retrieve and update image to be mapped
           const ImageVtkMapper2D::LocalStorage* localStorage = imageMapper->GetLocalStorage(planeRenderer);
 
           if ( planeRenderer.IsNotNull() )
           {
             // perform update of imagemapper if needed (maybe the respective 2D renderwindow is not rendered/update before)
             imageMapper->Update(planeRenderer);
 
             // If it has not been initialized already in a previous pass,
             // generate an actor and a texture object to
             // render the image associated with the ImageVtkMapper2D.
             vtkActor *imageActor;
             vtkDataSetMapper *dataSetMapper = NULL;
             vtkTexture *texture;
             if ( m_ImageActors.count( imageMapper ) == 0 )
             {
               dataSetMapper = vtkDataSetMapper::New();
               //Enable rendering without copying the image.
               dataSetMapper->ImmediateModeRenderingOn();
 
               texture = vtkNeverTranslucentTexture::New();
               texture->RepeatOff();
 
               imageActor = vtkActor::New();
               imageActor->SetMapper( dataSetMapper );
               imageActor->SetTexture( texture );
               imageActor->GetProperty()->SetOpacity(0.999); // HACK! otherwise VTK wouldn't recognize this as translucent surface (if LUT values map to alpha < 255
               // improvement: apply "opacity" property onle HERE and also in 2D image mapper. DO NOT change LUT to achieve translucent images (see method ChangeOpacity in image mapper 2D)
 
               // Make imageActor the sole owner of the mapper and texture
               // objects
               dataSetMapper->UnRegister( NULL );
               texture->UnRegister( NULL );
 
               // Store the actor so that it may be accessed in following
               // passes.
               m_ImageActors[imageMapper].Initialize(imageActor, imageMapper, m_ImageMapperDeletedCommand);
             }
             else
             {
               // Else, retrieve the actor and associated objects from the
               // previous pass.
               imageActor = m_ImageActors[imageMapper].m_Actor;
               dataSetMapper = (vtkDataSetMapper *)imageActor->GetMapper();
               texture = imageActor->GetTexture();
             }
 
             // Set poly data new each time its object changes (e.g. when
             // switching between planar and curved geometries)
             if ( (dataSetMapper != NULL) && (dataSetMapper->GetInput() != surface->GetVtkPolyData()) )
             {
-              dataSetMapper->SetInput( surface->GetVtkPolyData() );
+              dataSetMapper->SetInputData( surface->GetVtkPolyData() );
             }
 
             //Check if the m_ReslicedImage is NULL.
             //This is the case when no image geometry is met by
             //the reslicer. In that case, the texture has to be
             //empty (black) and we don't have to do anything.
             //See fixed bug #13275
             if(localStorage->m_ReslicedImage != NULL)
             {
               texture->SetInputConnection(localStorage->m_LevelWindowFilter->GetOutputPort());
 
               // do not use a VTK lookup table (we do that ourselves in m_LevelWindowFilter)
               texture->MapColorScalarsThroughLookupTableOff();
 
               //re-use properties from the 2D image mapper
               imageActor->SetProperty( localStorage->m_Actor->GetProperty() );
               imageActor->GetProperty()->SetAmbient(0.5);
 
               // Set texture interpolation on/off
               bool textureInterpolation = node->IsOn( "texture interpolation", renderer );
               texture->SetInterpolate( textureInterpolation );
 
               // Store this actor to be added to the actor assembly, sort
               // by layer
               int layer = 1;
               node->GetIntProperty( "layer", layer );
               layerSortedActors.insert(std::pair< int, vtkActor * >( layer, imageActor ) );
             }
           }
         }
       }
     }
   }
 
   void Geometry2DDataVtkMapper3D::ActorInfo::Initialize(vtkActor* actor, itk::Object* sender, itk::Command* command)
   {
     m_Actor = actor;
     m_Sender = sender;
     // Get informed when ImageMapper object is deleted, so that
     // the data structures built here can be deleted as well
     m_ObserverID = sender->AddObserver( itk::DeleteEvent(), command );
   }
 
   Geometry2DDataVtkMapper3D::ActorInfo::ActorInfo() : m_Actor(NULL), m_Sender(NULL), m_ObserverID(0)
   {
   }
 
   Geometry2DDataVtkMapper3D::ActorInfo::~ActorInfo()
   {
     if(m_Sender != NULL)
     {
       m_Sender->RemoveObserver(m_ObserverID);
     }
     if(m_Actor != NULL)
     {
       m_Actor->Delete();
     }
   }
 } // namespace mitk
diff --git a/Core/Code/Rendering/mitkGradientBackground.cpp b/Core/Code/Rendering/mitkGradientBackground.cpp
index 833349dbb1..1cfaf63290 100644
--- a/Core/Code/Rendering/mitkGradientBackground.cpp
+++ b/Core/Code/Rendering/mitkGradientBackground.cpp
@@ -1,239 +1,239 @@
 /*===================================================================
 
 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 "mitkGradientBackground.h"
 
 #include "mitkVtkLayerController.h"
 
 
 #include <vtkRenderer.h>
 #include <vtkRenderWindow.h>
 #include <vtkMapper.h>
 #include <vtkActor.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkPolyData.h>
 #include <vtkCamera.h>
 #include <vtkLookupTable.h>
 #include <vtkCellArray.h>
 #include <vtkUnsignedIntArray.h>
 #include <vtkPoints.h>
 #include <vtkPointData.h>
 #include <vtkObjectFactory.h>
 #include <vtkRendererCollection.h>
 
 
 mitk::GradientBackground::GradientBackground()
 {
   m_RenderWindow = NULL;
   m_Renderer = vtkRenderer::New();
   m_Actor = vtkActor::New();
   m_Mapper = vtkPolyDataMapper::New();
   m_Lut = vtkLookupTable::New();
   m_Plane = vtkPolyData::New();
 
   vtkPoints* points = vtkPoints::New( );
   points->InsertPoint(0,-10,0,0);
   points->InsertPoint(1,-10,1,0);
   points->InsertPoint(2,10,1,0);
   points->InsertPoint(3,10,0,0);
 
   vtkCellArray* cellArray = vtkCellArray::New();
   cellArray->InsertNextCell(4);
   cellArray->InsertCellPoint(0);
   cellArray->InsertCellPoint(1);
   cellArray->InsertCellPoint(2);
   cellArray->InsertCellPoint(3);
 
   vtkUnsignedIntArray* data = vtkUnsignedIntArray::New();
   data->InsertTuple1(0,1);
   data->InsertTuple1(1,0);
   data->InsertTuple1(2,0);
   data->InsertTuple1(3,1);
 
   m_Plane->SetPoints( points );
   m_Plane->SetPolys( cellArray );
   m_Plane->GetPointData()->SetScalars( data );
 
   points->Delete();
   cellArray->Delete();
   data->Delete();
 
   m_Lut->SetNumberOfColors( 2 );
   m_Lut->Build();
   m_Lut->SetTableValue( m_Lut->GetIndex(0), 1, 1, 1 );
   m_Lut->SetTableValue( m_Lut->GetIndex(1), 0, 0, 0 );
 
-  m_Mapper->SetInput( m_Plane );
+  m_Mapper->SetInputData( m_Plane );
   m_Mapper->SetLookupTable( m_Lut );
 
   //m_Mapper->ImmediateModeRenderingOn();
 
   m_Actor->SetMapper( m_Mapper );
 
   m_Renderer->AddActor( m_Actor );
   m_Renderer->InteractiveOff();
   m_Renderer->GetActiveCamera()->ParallelProjectionOn();
   m_Renderer->ResetCamera();
   m_Renderer->GetActiveCamera()->SetParallelScale(0.5);
 }
 
 mitk::GradientBackground::~GradientBackground()
 {
   if ( m_RenderWindow != NULL )
     if ( this->IsEnabled() )
       this->Disable();
 
   if ( m_Plane != NULL )
     m_Plane->Delete();
 
   if( m_Lut != NULL )
     m_Lut->Delete();
 
   if ( m_Mapper != NULL )
     m_Mapper->Delete();
 
   if ( m_Actor!=NULL )
     m_Actor->Delete();
 
   if ( m_Renderer != NULL )
     m_Renderer->Delete();
 }
 
 /**
  * Sets the renderwindow, in which the gradient background
  * will be shown. Make sure, you have called this function
  * before calling Enable()
  */
 void mitk::GradientBackground::SetRenderWindow( vtkRenderWindow * renderWindow )
 {
   m_RenderWindow = renderWindow;
 }
 
 /**
  * Returns the vtkRenderWindow, which is used
  * for displaying the gradient background
  */
 vtkRenderWindow* mitk::GradientBackground::GetRenderWindow()
 {
   return m_RenderWindow;
 }
 
 /**
  * Returns the renderer responsible for
  * rendering the color gradient into the
  * vtkRenderWindow
  */
 vtkRenderer* mitk::GradientBackground::GetVtkRenderer()
 {
   return m_Renderer;
 }
 
 /**
  * Returns the actor associated with the color gradient
  */
 vtkActor* mitk::GradientBackground::GetActor()
 {
   return m_Actor;
 }
 
 /**
  * Returns the mapper associated with the color
  * gradient.
  */
 vtkPolyDataMapper* mitk::GradientBackground::GetMapper()
 {
   return m_Mapper;
 }
 
 
 /**
  * Sets the gradient colors. The gradient
  * will smoothly fade from color1 to color2
  */
 void mitk::GradientBackground::SetGradientColors( double r1, double g1, double b1, double r2, double g2, double b2 )
 {
   m_Lut->SetTableValue( m_Lut->GetIndex(0), r1, g1, b1 );
   m_Lut->SetTableValue( m_Lut->GetIndex(1), r2, g2, b2 );
 }
 
 
 void mitk::GradientBackground::SetUpperColor(double r, double g, double b )
 {
   m_Lut->SetTableValue( m_Lut->GetIndex(0), r, g, b );
 }
 
 
 void mitk::GradientBackground::SetLowerColor(double r, double g, double b )
 {
   m_Lut->SetTableValue( m_Lut->GetIndex(1), r, g, b );
 }
 
 
 /**
  * Enables drawing of the color gradient background.
  * If you want to disable it, call the Disable() function.
  */
 void mitk::GradientBackground::Enable()
 {
   mitk::VtkLayerController::GetInstance(m_RenderWindow)->InsertBackgroundRenderer(m_Renderer,true);
 }
 
 /**
  * Disables drawing of the color gradient background.
  * If you want to enable it, call the Enable() function.
  */
 void mitk::GradientBackground::Disable()
 {
   if ( this->IsEnabled() )
   {
     mitk::VtkLayerController::GetInstance(m_RenderWindow)->RemoveRenderer(m_Renderer);
   }
 }
 
 
 
 /**
  * Checks, if the gradient background is currently
  * enabled (visible)
  */
 bool mitk::GradientBackground::IsEnabled()
 {
     if ( m_RenderWindow == NULL )
         return false;
     else
         return ( mitk::VtkLayerController::GetInstance(m_RenderWindow)->IsRendererInserted(m_Renderer));
 }
 
 void mitk::GradientBackground::SetRequestedRegionToLargestPossibleRegion()
 {
     //nothing to do
 }
 
 bool mitk::GradientBackground::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
     return false;
 }
 
 bool mitk::GradientBackground::VerifyRequestedRegion()
 {
     return true;
 }
 
 void mitk::GradientBackground::SetRequestedRegion( const itk::DataObject*)
 {
     //nothing to do
 }
 
diff --git a/Core/Code/Rendering/mitkManufacturerLogo.cpp b/Core/Code/Rendering/mitkManufacturerLogo.cpp
index 6cc9163583..8f76cf2b22 100644
--- a/Core/Code/Rendering/mitkManufacturerLogo.cpp
+++ b/Core/Code/Rendering/mitkManufacturerLogo.cpp
@@ -1,380 +1,380 @@
 /*===================================================================
 
 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 "mitkManufacturerLogo.h"
 
 #include "mitkVtkLayerController.h"
 
 #include <mitkStandardFileLocations.h>
 #include <mitkConfig.h>
 #include <itkObject.h>
 #include <itkMacro.h>
 #include <itksys/SystemTools.hxx>
 
 #include <vtkImageImport.h>
 #include <vtkRenderer.h>
 #include <vtkRenderWindow.h>
 #include <vtkMapper.h>
 #include <vtkImageActor.h>
 #include <vtkImageMapper.h>
 #include <vtkPolyData.h>
 #include <vtkCamera.h>
 #include <vtkObjectFactory.h>
 #include <vtkRendererCollection.h>
 #include <vtkPNGReader.h>
 #include <vtkImageData.h>
 #include <vtkConfigure.h>
 #include <vtkImageFlip.h>
 
 #include <mbilogo.h>
 
 #include <algorithm>
 
 
 mitk::ManufacturerLogo::ManufacturerLogo()
 :m_ImageData(NULL)
 {
   m_RenderWindow      = NULL;
   m_Renderer          = vtkRenderer::New();
   m_Actor             = vtkImageActor::New();
   m_Mapper            = vtkImageMapper::New();
   m_PngReader         = vtkPNGReader::New();
   m_VtkImageImport    = vtkImageImport::New();
 
   m_LogoPosition  = mitk::ManufacturerLogo::LowerRight;
 
   m_IsEnabled                  = false;
   m_ForceShowMBIDepartmentLogo = false;
 
   m_ZoomFactor = 1.15;
   m_Opacity    = 0.5;
 
   m_FileName  = "";
   m_PngReader->SetFileName(m_FileName.c_str());
 }
 
 mitk::ManufacturerLogo::~ManufacturerLogo()
 {
   if ( m_RenderWindow != NULL )
     if ( this->IsEnabled() )
       this->Disable();
 
   if ( m_Mapper != NULL )
     m_Mapper->Delete();
 
   if ( m_Actor!=NULL )
     m_Actor->Delete();
 
   if ( m_Renderer != NULL )
     m_Renderer->Delete();
 
   if ( m_PngReader != NULL )
     m_PngReader->Delete();
 
   if ( m_VtkImageImport != NULL )
     m_VtkImageImport->Delete();
 
   if ( m_ImageData != NULL)
     delete[] m_ImageData;
 }
 
 /**
  * Sets the renderwindow, in which the logo
  * will be shown. Make sure, you have called this function
  * before calling Enable()
  */
 void mitk::ManufacturerLogo::SetRenderWindow( vtkRenderWindow* renderWindow )
 {
   m_RenderWindow = renderWindow;
 }
 
 /**
  * Returns the vtkRenderWindow, which is used
  * for displaying the logo
  */
 vtkRenderWindow* mitk::ManufacturerLogo::GetRenderWindow()
 {
   return m_RenderWindow;
 }
 
 /**
  * Returns the renderer responsible for
  * rendering the  logo into the
  * vtkRenderWindow
  */
 vtkRenderer* mitk::ManufacturerLogo::GetVtkRenderer()
 {
   return m_Renderer;
 }
 
 /**
  * Returns the actor associated with the  logo
  */
 vtkImageActor* mitk::ManufacturerLogo::GetActor()
 {
   return m_Actor;
 }
 
 /**
  * Returns the mapper associated with the
  * logo.
  */
 vtkImageMapper* mitk::ManufacturerLogo::GetMapper()
 {
   return m_Mapper;
 }
 
 void mitk::ManufacturerLogo::SetLogoSource(const char* filename)
 {
   std::string file = filename;
   if(file.length() != 0)
   {
     m_FileName  = filename;
     m_PngReader->SetFileName(m_FileName.c_str());
   }
 }
 
 /**
  * Enables drawing of the logo.
  * If you want to disable it, call the Disable() function.
  */
 void mitk::ManufacturerLogo::Enable()
 {
   if(m_IsEnabled)
     return;
 
   if(m_RenderWindow != NULL)
   {
     if(itksys::SystemTools::FileExists(m_FileName.c_str()) && !m_ForceShowMBIDepartmentLogo)
     {
       m_PngReader->Update();
-      m_Actor->SetInput(m_PngReader->GetOutput());
+      m_Actor->SetInputData(m_PngReader->GetOutput());
     }
     else // either logo file not found or logo renderer is forced to show the MBI logo
     {
       m_VtkImageImport->SetDataScalarTypeToUnsignedChar();
       m_VtkImageImport->SetNumberOfScalarComponents(mbiLogo_NumberOfScalars);
       m_VtkImageImport->SetWholeExtent(0,mbiLogo_Width-1,0,mbiLogo_Height-1,0,1-1);
       m_VtkImageImport->SetDataExtentToWholeExtent();
 
       // flip mbi logo around y axis and change color order
       m_ImageData = new char[mbiLogo_Height*mbiLogo_Width*mbiLogo_NumberOfScalars];
 
       unsigned int column, row;
       char * dest   = m_ImageData;
       char * source = (char*) &mbiLogo_Data[0];;
       char r, g, b, a;
       for (column = 0; column < mbiLogo_Height; column++)
         for (row = 0; row < mbiLogo_Width; row++)
         {   //change r with b
             b = *source++;
             g = *source++;
             r = *source++;
             a = *source++;
 
             *dest++ = r;
             *dest++ = g;
             *dest++ = b;
             *dest++ = a;
           }
 
       m_VtkImageImport->SetImportVoidPointer(m_ImageData);
       m_VtkImageImport->Modified();
       m_VtkImageImport->Update();
 
-      m_Actor->SetInput(m_VtkImageImport->GetOutput());
+      m_Actor->SetInputData(m_VtkImageImport->GetOutput());
     }
 
     m_Actor->SetOpacity(m_Opacity);
 
     m_Renderer->AddActor( m_Actor );
     m_Renderer->InteractiveOff();
 
     SetupCamera();
     SetupPosition();
 
     mitk::VtkLayerController::GetInstance(m_RenderWindow)->InsertForegroundRenderer(m_Renderer,false);
 
     m_IsEnabled = true;
   }
 }
 
 
 void mitk::ManufacturerLogo::SetupCamera()
 {
   // set the vtk camera in way that stretches the logo all over the renderwindow
 
   vtkImageData * image = m_Actor->GetInput();
   m_Camera = m_Renderer->GetActiveCamera();
   m_Camera->SetClippingRange(1,100000);
 
   if ( !image )
     return;
 
   double spacing[3];
   double origin[3];
   int   dimensions[3];
 
   image->GetSpacing(spacing);
   image->GetOrigin(origin);
   image->GetDimensions(dimensions);
 
   double focalPoint[3];
   double position[3];
 
   for ( unsigned int cc = 0; cc < 3; cc++)
   {
     focalPoint[cc] = origin[cc] + ( spacing[cc] * dimensions[cc] ) / 2.0;
     position[cc]   = focalPoint[cc];
   }
 
 
   m_Camera->SetViewUp (0,1,0);
   int idx = 2;
   const double distanceToFocalPoint = 1000;
   position[idx] = distanceToFocalPoint;
 
   m_Camera->ParallelProjectionOn();
   m_Camera->SetPosition (position);
   m_Camera->SetFocalPoint (focalPoint);
 
   int d1 = (idx + 1) % 3;
   int d2 = (idx + 2) % 3;
 
   double max = std::max(dimensions[d1],dimensions[d2]);
 
   m_Camera->SetParallelScale( max / 2 );
 }
 
 void mitk::ManufacturerLogo::SetupPosition()
 { // Position and Scale of the logo
 
   double newPos[4];
   int dimensions[3];
   vtkImageData * image = m_Actor->GetInput();
   image->GetDimensions(dimensions);
   // normalize image dimensions
   double max = std::max(dimensions[0],dimensions[1]);
   double normX = dimensions[0] / max;
   double normY = dimensions[1] / max;
 
   double buffer = 0; // buffer to the boarder of the renderwindow
 
   switch(m_LogoPosition)
   {
     case mitk::ManufacturerLogo::LowerLeft:
     {
       newPos[0] = (0 + buffer);
       newPos[1] = (0 + buffer);
       newPos[2] = 0.2 * normX * m_ZoomFactor;
       newPos[3] = 0.2 * normY * m_ZoomFactor;
       break;
     }
     case mitk::ManufacturerLogo::LowerRight:
     {
       newPos[0] = (1 - buffer) - 0.2 * normX * m_ZoomFactor;
       newPos[1] = 0.0;
       newPos[2] = (1 - buffer);
       newPos[3] = 0.2 * normY * m_ZoomFactor;
       break;
     }
     case mitk::ManufacturerLogo::UpperLeft:
     {
       newPos[0] = (0 + buffer);
       newPos[1] = (1 - buffer) - 0.2 * normY * m_ZoomFactor;
       newPos[2] = 0.2 * normX * m_ZoomFactor;
       newPos[3] = (1 - buffer);
       break;
     }
     case mitk::ManufacturerLogo::UpperRight:
     {
       newPos[0] = (1 - buffer) - 0.2 * normX * m_ZoomFactor;
       newPos[1] = (1 - buffer) - 0.2 * normY * m_ZoomFactor;
       newPos[2] = (1 - buffer);
       newPos[3] = (1 - buffer);
       break;
     }
     case mitk::ManufacturerLogo::Middle:
     default:
     {
       newPos[0] = 0.5 - 0.2 * normX * m_ZoomFactor;
       newPos[1] = 0.5 + 0.2 * normY * m_ZoomFactor;
       newPos[2] = 0.5 - 0.2 * normX * m_ZoomFactor;
       newPos[3] = 0.5 + 0.2 * normY * m_ZoomFactor;
       break;
     }
   }
 
   m_Renderer->SetViewport(newPos);
 }
 
 void mitk::ManufacturerLogo::ForceMBILogoVisible(bool visible)
 {
   m_ForceShowMBIDepartmentLogo = visible;
 }
 
 void mitk::ManufacturerLogo::SetZoomFactor( double factor )
 {
   m_ZoomFactor = factor;
 }
 void mitk::ManufacturerLogo::SetOpacity(double opacity)
 {
   m_Opacity = opacity;
 }
 
 /**
  * Disables drawing of the logo.
  * If you want to enable it, call the Enable() function.
  */
 void mitk::ManufacturerLogo::Disable()
 {
   if ( this->IsEnabled() && !m_ForceShowMBIDepartmentLogo )
   {
     mitk::VtkLayerController::GetInstance(m_RenderWindow)->RemoveRenderer(m_Renderer);
     m_IsEnabled = false;
   }
 }
 
 /**
  * Checks, if the logo is currently
  * enabled (visible)
  */
 bool mitk::ManufacturerLogo::IsEnabled()
 {
   return  m_IsEnabled;
 }
 
 
 void mitk::ManufacturerLogo::SetRequestedRegionToLargestPossibleRegion()
 {
     //nothing to do
 }
 
 bool mitk::ManufacturerLogo::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
     return false;
 }
 
 bool mitk::ManufacturerLogo::VerifyRequestedRegion()
 {
     return true;
 }
 
 void mitk::ManufacturerLogo::SetRequestedRegion( const itk::DataObject*)
 {
     //nothing to do
 }
 
diff --git a/Core/Code/Rendering/mitkPointSetVtkMapper2D.cpp b/Core/Code/Rendering/mitkPointSetVtkMapper2D.cpp
index 889e2d5727..44d93110a8 100644
--- a/Core/Code/Rendering/mitkPointSetVtkMapper2D.cpp
+++ b/Core/Code/Rendering/mitkPointSetVtkMapper2D.cpp
@@ -1,734 +1,734 @@
 /*===================================================================
 
 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 "mitkPointSetVtkMapper2D.h"
 
 //mitk includes
 #include "mitkDataNode.h"
 #include "mitkProperties.h"
 #include "mitkVtkPropRenderer.h"
 #include "mitkPointSet.h"
 
 //vtk includes
 #include <vtkActor.h>
 #include <vtkPropAssembly.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkTransform.h>
 #include <vtkGlyph3D.h>
 #include <vtkTransformFilter.h>
 #include <vtkLine.h>
 #include <vtkGlyphSource2D.h>
 #include <vtkFloatArray.h>
 #include <vtkPointData.h>
 #include <vtkTextActor.h>
 #include <vtkTextProperty.h>
 #include <vtkCellArray.h>
 
 #include <stdlib.h>
 
 // constructor LocalStorage
 mitk::PointSetVtkMapper2D::LocalStorage::LocalStorage()
 {
 
   // points
   m_UnselectedPoints = vtkSmartPointer<vtkPoints>::New();
   m_SelectedPoints = vtkSmartPointer<vtkPoints>::New();
   m_ContourPoints = vtkSmartPointer<vtkPoints>::New();
 
   // scales
   m_UnselectedScales = vtkSmartPointer<vtkFloatArray>::New();
   m_SelectedScales = vtkSmartPointer<vtkFloatArray>::New();
 
   // distances
   m_DistancesBetweenPoints = vtkSmartPointer<vtkFloatArray>::New();
 
   // lines
   m_ContourLines = vtkSmartPointer<vtkCellArray>::New();
 
   // glyph source (provides the different shapes)
   m_UnselectedGlyphSource2D = vtkSmartPointer<vtkGlyphSource2D>::New();
   m_SelectedGlyphSource2D = vtkSmartPointer<vtkGlyphSource2D>::New();
 
   // glyphs
   m_UnselectedGlyph3D = vtkSmartPointer<vtkGlyph3D>::New();
   m_SelectedGlyph3D = vtkSmartPointer<vtkGlyph3D>::New();
 
   // polydata
   m_VtkUnselectedPointListPolyData = vtkSmartPointer<vtkPolyData>::New();
   m_VtkSelectedPointListPolyData = vtkSmartPointer <vtkPolyData>::New();
   m_VtkContourPolyData = vtkSmartPointer<vtkPolyData>::New();
 
   // actors
   m_UnselectedActor = vtkSmartPointer <vtkActor>::New();
   m_SelectedActor = vtkSmartPointer <vtkActor>::New();
   m_ContourActor = vtkSmartPointer <vtkActor>::New();
 
   // mappers
   m_VtkUnselectedPolyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   m_VtkSelectedPolyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   m_VtkContourPolyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
 
   // propassembly
   m_PropAssembly = vtkSmartPointer <vtkPropAssembly>::New();
 
 }
 // destructor LocalStorage
 mitk::PointSetVtkMapper2D::LocalStorage::~LocalStorage()
 {
 }
 
 // input for this mapper ( = point set)
 const mitk::PointSet* mitk::PointSetVtkMapper2D::GetInput() const
 {
   return static_cast<const mitk::PointSet * > ( GetDataNode()->GetData() );
 }
 
 // constructor PointSetVtkMapper2D
 mitk::PointSetVtkMapper2D::PointSetVtkMapper2D()
 : m_ShowContour(false),
 m_CloseContour(false),
 m_ShowPoints(true),
 m_ShowDistances(false),
 m_DistancesDecimalDigits(1),
 m_ShowAngles(false),
 m_ShowDistantLines(false),
 m_LineWidth(1),
 m_PointLineWidth(1),
 m_Point2DSize(6),
 m_IDShapeProperty(mitk::PointSetShapeProperty::CROSS),
 m_FillShape(false),
 m_DistanceToPlane(4.0f)
 {
 }
 
 // destructor
 mitk::PointSetVtkMapper2D::~PointSetVtkMapper2D()
 {
 }
 
 // reset mapper so that nothing is displayed e.g. toggle visiblity of the propassembly
 void mitk::PointSetVtkMapper2D::ResetMapper( BaseRenderer* renderer )
 {
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
   ls->m_PropAssembly->VisibilityOff();
 }
 
 // returns propassembly
 vtkProp* mitk::PointSetVtkMapper2D::GetVtkProp(mitk::BaseRenderer * renderer)
 {
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
   return ls->m_PropAssembly;
 }
 
 
 static bool makePerpendicularVector2D(const mitk::Vector2D& in, mitk::Vector2D& out)
 {
   // The dot product of orthogonal vectors is zero.
   // In two dimensions the slopes of perpendicular lines are negative reciprocals.
   if((fabs(in[0])>0) && ( (fabs(in[0])>fabs(in[1])) || (in[1] == 0) ) )
   {
     // negative reciprocal
     out[0]=-in[1]/in[0];
     out[1]=1;
     out.Normalize();
     return true;
   }
   else
     if(fabs(in[1])>0)
     {
       out[0]=1;
       // negative reciprocal
       out[1]=-in[0]/in[1];
       out.Normalize();
       return true;
     }
     else
       return false;
 }
 
 
 void mitk::PointSetVtkMapper2D::CreateVTKRenderObjects(mitk::BaseRenderer* renderer)
 {
 
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
   unsigned i = 0;
 
   // The vtk text actors need to be removed manually from the propassembly
   // since the same vtk text actors are not overwriten within this function,
   // but new actors are added to the propassembly each time this function is executed.
   // Thus, the actors from the last call must be removed in the beginning.
   for(i=0; i< ls->m_VtkTextLabelActors.size(); i++)
   {
     if(ls->m_PropAssembly->GetParts()->IsItemPresent(ls->m_VtkTextLabelActors.at(i)))
       ls->m_PropAssembly->RemovePart(ls->m_VtkTextLabelActors.at(i));
   }
 
   for(i=0; i< ls->m_VtkTextDistanceActors.size(); i++)
   {
     if(ls->m_PropAssembly->GetParts()->IsItemPresent(ls->m_VtkTextDistanceActors.at(i)))
       ls->m_PropAssembly->RemovePart(ls->m_VtkTextDistanceActors.at(i));
   }
 
   for(i=0; i< ls->m_VtkTextAngleActors.size(); i++)
   {
     if(ls->m_PropAssembly->GetParts()->IsItemPresent(ls->m_VtkTextAngleActors.at(i)))
       ls->m_PropAssembly->RemovePart(ls->m_VtkTextAngleActors.at(i));
   }
 
   // initialize polydata here, otherwise we have update problems when
   // executing this function again
   ls->m_VtkUnselectedPointListPolyData = vtkSmartPointer<vtkPolyData>::New();
   ls->m_VtkSelectedPointListPolyData = vtkSmartPointer <vtkPolyData>::New();
   ls->m_VtkContourPolyData = vtkSmartPointer<vtkPolyData>::New();
 
 
   // get input point set and update the PointSet
   mitk::PointSet::Pointer input  = const_cast<mitk::PointSet*>(this->GetInput());
 
   // only update the input data, if the property tells us to
   bool update = true;
   this->GetDataNode()->GetBoolProperty("updateDataOnRender", update);
   if (update == true)
     input->Update();
 
   int timestep = this->GetTimestep();
   mitk::PointSet::DataType::Pointer itkPointSet = input->GetPointSet( timestep );
 
   if ( itkPointSet.GetPointer() == NULL)
   {
     ls->m_PropAssembly->VisibilityOff();
     return;
   }
 
   //iterator for point set
   mitk::PointSet::PointsContainer::Iterator pointsIter = itkPointSet->GetPoints()->Begin();
 
   // PointDataContainer has additional information to each point, e.g. whether
   // it is selected or not
   mitk::PointSet::PointDataContainer::Iterator pointDataIter;
   pointDataIter = itkPointSet->GetPointData()->Begin();
 
   //check if the list for the PointDataContainer is the same size as the PointsContainer.
   //If not, then the points were inserted manually and can not be visualized according to the PointData (selected/unselected)
   bool pointDataBroken = (itkPointSet->GetPointData()->Size() != itkPointSet->GetPoints()->Size());
 
   if(itkPointSet->GetPointData()->size() == 0 || pointDataBroken)
   {
     return;
   }
 
   // empty point sets, cellarrays, scalars
   ls->m_UnselectedPoints->Reset();
   ls->m_SelectedPoints->Reset();
 
   ls->m_ContourPoints->Reset();
   ls->m_ContourLines->Reset();
 
   ls->m_UnselectedScales->Reset();
   ls->m_SelectedScales->Reset();
 
   ls->m_DistancesBetweenPoints->Reset();
 
   ls->m_VtkTextLabelActors.clear();
   ls->m_VtkTextDistanceActors.clear();
   ls->m_VtkTextAngleActors.clear();
 
   ls->m_UnselectedScales->SetNumberOfComponents(3);
   ls->m_SelectedScales->SetNumberOfComponents(3);
 
   int NumberContourPoints = 0;
   bool pointsOnSameSideOfPlane = false;
 
   const int text2dDistance = 10;
 
   // initialize points with a random start value
 
   // current point in point set
   itk::Point<float> point = pointsIter->Value();
 
   mitk::Point3D p = point;              // currently visited point
   mitk::Point3D lastP = point;          // last visited point (predecessor in point set of "point")
   mitk::Vector3D vec;                   // p - lastP
   mitk::Vector3D lastVec;               // lastP - point before lastP
   vec.Fill(0);
   lastVec.Fill(0);
 
   mitk::Point3D projected_p = point;     // p projected on viewplane
 
   mitk::Point2D pt2d;
   pt2d[0] = point[0];                    // projected_p in display coordinates
   pt2d[1] = point[1];
   mitk::Point2D lastPt2d = pt2d;         // last projected_p in display coordinates (predecessor in point set of "pt2d")
   mitk::Point2D preLastPt2d = pt2d ;     // projected_p in display coordinates before lastPt2
 
 
   mitk::DisplayGeometry::Pointer displayGeometry = renderer->GetDisplayGeometry();
   mitk::PlaneGeometry::ConstPointer planeGeometry = renderer->GetSliceNavigationController()->GetCurrentPlaneGeometry();
 
   vtkLinearTransform* dataNodeTransform = input->GetGeometry()->GetVtkTransform();
 
   int count = 0;
 
   for (pointsIter=itkPointSet->GetPoints()->Begin();
     pointsIter!=itkPointSet->GetPoints()->End();
     pointsIter++)
   {
 
     lastP = p; // valid for number of points count > 0
     preLastPt2d = lastPt2d; // valid only for count > 1
     lastPt2d = pt2d;  // valid for number of points count > 0
 
     lastVec = vec;    // valid only for counter > 1
 
     // get current point in point set
     point = pointsIter->Value();
 
     // transform point
     {
       float vtkp[3];
       itk2vtk(point, vtkp);
       dataNodeTransform->TransformPoint(vtkp, vtkp);
       vtk2itk(vtkp,point);
     }
 
     p[0] = point[0];
     p[1] = point[1];
     p[2] = point[2];
 
     displayGeometry->Project(p, projected_p);
     displayGeometry->Map(projected_p, pt2d);
     displayGeometry->WorldToDisplay(pt2d, pt2d);
 
     vec = p-lastP;    // valid only for counter > 0
 
     // compute distance to current plane
     float diff = planeGeometry->DistanceFromPlane(point);
     diff = diff * diff;
 
     // draw markers on slices a certain distance away from the points true location according to the tolerance threshold (m_DistanceToPlane)
     if(diff < m_DistanceToPlane)
     {
 
       // is point selected or not?
       if (pointDataIter->Value().selected)
       {
         ls->m_SelectedPoints->InsertNextPoint(point[0],point[1],point[2]);
         // point is scaled according to its distance to the plane
         ls->m_SelectedScales->InsertNextTuple3(m_Point2DSize - (2*diff),0,0);
       }
       else
       {
         ls->m_UnselectedPoints->InsertNextPoint(point[0],point[1],point[2]);
         // point is scaled according to its distance to the plane
         ls->m_UnselectedScales->InsertNextTuple3(m_Point2DSize - (2*diff),0,0);
       }
 
       //---- LABEL -----//
 
       //  paint label for each point if available
       if (dynamic_cast<mitk::StringProperty *>(this->GetDataNode()->GetProperty("label")) != NULL)
       {
         const char * pointLabel = dynamic_cast<mitk::StringProperty *>(
           this->GetDataNode()->GetProperty("label"))->GetValue();
         std::string l = pointLabel;
         if (input->GetSize()>1)
         {
           std::stringstream ss;
           ss << pointsIter->Index();
           l.append(ss.str());
         }
 
         ls->m_VtkTextActor = vtkSmartPointer<vtkTextActor>::New();
 
         ls->m_VtkTextActor->SetPosition(pt2d[0] + text2dDistance, pt2d[1] + text2dDistance);
         ls->m_VtkTextActor->SetInput(l.c_str());
         ls->m_VtkTextActor->GetTextProperty()->SetOpacity( 100 );
 
         float unselectedColor[4];
 
         //check if there is a color property
         GetDataNode()->GetColor(unselectedColor);
 
         if (unselectedColor != NULL)
           ls->m_VtkTextActor->GetTextProperty()->SetColor(unselectedColor[0], unselectedColor[1], unselectedColor[2]);
         else
           ls->m_VtkTextActor->GetTextProperty()->SetColor(0.0f, 1.0f, 0.0f);
 
         ls->m_VtkTextLabelActors.push_back(ls->m_VtkTextActor);
 
       }
     }
 
     // draw contour, distance text and angle text in render window
 
     // lines between points, which intersect the current plane, are drawn
     if( m_ShowContour && count > 0 )
     {
       ScalarType distance =    displayGeometry->GetWorldGeometry()->SignedDistance(point);
       ScalarType lastDistance =    displayGeometry->GetWorldGeometry()->SignedDistance(lastP);
 
       pointsOnSameSideOfPlane = (distance * lastDistance) > 0.5;
 
       // Points must be on different side of plane in order to draw a contour.
       // If "show distant lines" is enabled this condition is disregarded.
       if ( !pointsOnSameSideOfPlane || m_ShowDistantLines)
       {
         vtkSmartPointer<vtkLine> line = vtkSmartPointer<vtkLine>::New();
 
         ls->m_ContourPoints->InsertNextPoint(lastP[0],lastP[1],lastP[2]);
         line->GetPointIds()->SetId(0, NumberContourPoints);
         NumberContourPoints++;
 
         ls->m_ContourPoints->InsertNextPoint(point[0], point[1], point[2]);
         line->GetPointIds()->SetId(1, NumberContourPoints);
         NumberContourPoints++;
 
         ls->m_ContourLines->InsertNextCell(line);
 
 
         if(m_ShowDistances) // calculate and print distance between adjacent points
         {
           float distancePoints = point.EuclideanDistanceTo(lastP);
 
           std::stringstream buffer;
           buffer<<std::fixed <<std::setprecision(m_DistancesDecimalDigits)<<distancePoints<<" mm";
 
           // compute desired display position of text
           Vector2D vec2d = pt2d-lastPt2d;
           makePerpendicularVector2D(vec2d, vec2d); // text is rendered within text2dDistance perpendicular to current line
           Vector2D pos2d = (lastPt2d.GetVectorFromOrigin() + pt2d ) * 0.5 + vec2d * text2dDistance;
 
           ls->m_VtkTextActor = vtkSmartPointer<vtkTextActor>::New();
 
           ls->m_VtkTextActor->SetPosition(pos2d[0],pos2d[1]);
           ls->m_VtkTextActor->SetInput(buffer.str().c_str());
           ls->m_VtkTextActor->GetTextProperty()->SetColor(0.0, 1.0, 0.0);
 
           ls->m_VtkTextDistanceActors.push_back(ls->m_VtkTextActor);
 
         }
 
         if(m_ShowAngles && count > 1) // calculate and print angle between connected lines
         {
           std::stringstream buffer;
           //(char) 176 is the degree sign
           buffer << angle(vec.GetVnlVector(), -lastVec.GetVnlVector())*180/vnl_math::pi << (char)176;
 
           //compute desired display position of text
           Vector2D vec2d = pt2d-lastPt2d;             // first arm enclosing the angle
           vec2d.Normalize();
           Vector2D lastVec2d = lastPt2d-preLastPt2d;  // second arm enclosing the angle
           lastVec2d.Normalize();
           vec2d=vec2d-lastVec2d;                      // vector connecting both arms
           vec2d.Normalize();
 
           // middle between two vectors that enclose the angle
           Vector2D pos2d = lastPt2d.GetVectorFromOrigin() + vec2d * text2dDistance * text2dDistance;
 
           ls->m_VtkTextActor = vtkSmartPointer<vtkTextActor>::New();
 
           ls->m_VtkTextActor->SetPosition(pos2d[0],pos2d[1]);
           ls->m_VtkTextActor->SetInput(buffer.str().c_str());
           ls->m_VtkTextActor->GetTextProperty()->SetColor(0.0, 1.0, 0.0);
 
           ls->m_VtkTextAngleActors.push_back(ls->m_VtkTextActor);
         }
       }
     }
 
     if(pointDataIter != itkPointSet->GetPointData()->End())
     {
       pointDataIter++;
       count++;
     }
   }
 
   // add each single text actor to the assembly
   for(i=0; i< ls->m_VtkTextLabelActors.size(); i++)
   {
     ls->m_PropAssembly->AddPart(ls->m_VtkTextLabelActors.at(i));
   }
 
   for(i=0; i< ls->m_VtkTextDistanceActors.size(); i++)
   {
     ls->m_PropAssembly->AddPart(ls->m_VtkTextDistanceActors.at(i));
   }
 
   for(i=0; i< ls->m_VtkTextAngleActors.size(); i++)
   {
     ls->m_PropAssembly->AddPart(ls->m_VtkTextAngleActors.at(i));
   }
 
   //---- CONTOUR -----//
 
 
   //create lines between the points which intersect the plane
   if (m_ShowContour)
   {
     // draw line between first and last point which is rendered
     if(m_CloseContour && NumberContourPoints > 1){
 
       vtkSmartPointer<vtkLine> closingLine = vtkSmartPointer<vtkLine>::New();
       closingLine->GetPointIds()->SetId(0, 0); // index of first point
       closingLine->GetPointIds()->SetId(1, NumberContourPoints-1); // index of last point
       ls->m_ContourLines->InsertNextCell(closingLine);
     }
 
     ls->m_VtkContourPolyData->SetPoints(ls->m_ContourPoints);
     ls->m_VtkContourPolyData->SetLines(ls->m_ContourLines);
 
-    ls->m_VtkContourPolyDataMapper->SetInput(ls->m_VtkContourPolyData);
+    ls->m_VtkContourPolyDataMapper->SetInputData(ls->m_VtkContourPolyData);
     ls->m_ContourActor->SetMapper(ls->m_VtkContourPolyDataMapper);
     ls->m_ContourActor->GetProperty()->SetLineWidth(m_LineWidth);
 
     ls->m_PropAssembly->AddPart(ls->m_ContourActor);
 
   }
 
   // the point set must be transformed in order to obtain the appropriate glyph orientation
   // according to the current view
   vtkSmartPointer<vtkTransform> transform = vtkSmartPointer<vtkTransform>::New();
   vtkSmartPointer<vtkMatrix4x4> a,b = vtkSmartPointer<vtkMatrix4x4>::New();
 
   a = planeGeometry->GetVtkTransform()->GetMatrix();
   b->DeepCopy( a );
 
   // delete transformation from matrix, only take orientation
   b->SetElement(3,3,1);
   b->SetElement(2,3,0);
   b->SetElement(1,3,0);
   b->SetElement(0,3,0);
   b->SetElement(3,2,0);
   b->SetElement(3,1,0);
   b->SetElement(3,0,0);
 
   transform->SetMatrix(  b );
 
   //---- UNSELECTED POINTS  -----//
 
   // apply properties to glyph
   ls->m_UnselectedGlyphSource2D->SetGlyphType(m_IDShapeProperty);
 
   if(m_FillShape)
     ls->m_UnselectedGlyphSource2D->FilledOn();
   else
     ls->m_UnselectedGlyphSource2D->FilledOff();
 
   // apply transform
   vtkSmartPointer<vtkTransformFilter> transformFilterU = vtkSmartPointer<vtkTransformFilter>::New();
   transformFilterU->SetInputConnection(ls->m_UnselectedGlyphSource2D->GetOutputPort());
   transformFilterU->SetTransform(transform);
 
   ls->m_VtkUnselectedPointListPolyData->SetPoints(ls->m_UnselectedPoints);
   ls->m_VtkUnselectedPointListPolyData->GetPointData()->SetVectors(ls->m_UnselectedScales);
 
   // apply transform of current plane to glyphs
   ls->m_UnselectedGlyph3D->SetSourceConnection(transformFilterU->GetOutputPort());
-  ls->m_UnselectedGlyph3D->SetInput(ls->m_VtkUnselectedPointListPolyData);
+  ls->m_UnselectedGlyph3D->SetInputData(ls->m_VtkUnselectedPointListPolyData);
   ls->m_UnselectedGlyph3D->SetScaleModeToScaleByVector();
   ls->m_UnselectedGlyph3D->SetVectorModeToUseVector();
 
-  ls->m_VtkUnselectedPolyDataMapper->SetInput(ls->m_UnselectedGlyph3D->GetOutput());
+  ls->m_VtkUnselectedPolyDataMapper->SetInputData(ls->m_UnselectedGlyph3D->GetOutput());
   ls->m_UnselectedActor->SetMapper(ls->m_VtkUnselectedPolyDataMapper);
   ls->m_UnselectedActor->GetProperty()->SetLineWidth(m_PointLineWidth);
 
   ls->m_PropAssembly->AddPart(ls->m_UnselectedActor);
 
 
   //---- SELECTED POINTS  -----//
 
   ls->m_SelectedGlyphSource2D->SetGlyphTypeToDiamond();
   ls->m_SelectedGlyphSource2D->CrossOn();
   ls->m_SelectedGlyphSource2D->FilledOff();
 
   // apply transform
   vtkSmartPointer<vtkTransformFilter> transformFilterS = vtkSmartPointer<vtkTransformFilter>::New();
   transformFilterS->SetInputConnection(ls->m_SelectedGlyphSource2D->GetOutputPort());
   transformFilterS->SetTransform(transform);
 
   ls->m_VtkSelectedPointListPolyData->SetPoints(ls->m_SelectedPoints);
   ls->m_VtkSelectedPointListPolyData->GetPointData()->SetVectors(ls->m_SelectedScales);
 
 
   // apply transform of current plane to glyphs
   ls->m_SelectedGlyph3D->SetSourceConnection(transformFilterS->GetOutputPort());
-  ls->m_SelectedGlyph3D->SetInput(ls->m_VtkSelectedPointListPolyData);
+  ls->m_SelectedGlyph3D->SetInputData(ls->m_VtkSelectedPointListPolyData);
   ls->m_SelectedGlyph3D->SetScaleModeToScaleByVector();
   ls->m_SelectedGlyph3D->SetVectorModeToUseVector();
 
-  ls->m_VtkSelectedPolyDataMapper->SetInput(ls->m_SelectedGlyph3D->GetOutput());
+  ls->m_VtkSelectedPolyDataMapper->SetInputData(ls->m_SelectedGlyph3D->GetOutput());
   ls->m_SelectedActor->SetMapper(ls->m_VtkSelectedPolyDataMapper);
   ls->m_SelectedActor->GetProperty()->SetLineWidth(m_PointLineWidth);
 
   ls->m_PropAssembly->AddPart(ls->m_SelectedActor);
 
 }
 
 
 void mitk::PointSetVtkMapper2D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
 {
 
   const mitk::DataNode* node = GetDataNode();
   if( node == NULL )
     return;
 
   LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
   // check whether the input data has been changed
   bool needGenerateData = ls->IsGenerateDataRequired( renderer, this, GetDataNode() );
 
   // toggle visibility
   bool visible = true;
   node->GetVisibility(visible, renderer, "visible");
   if(!visible)
   {
     ls->m_UnselectedActor->VisibilityOff();
     ls->m_SelectedActor->VisibilityOff();
     ls->m_ContourActor->VisibilityOff();
     ls->m_PropAssembly->VisibilityOff();
     return;
   }else{
     ls->m_PropAssembly->VisibilityOn();
   }
 
   node->GetBoolProperty("show contour",       m_ShowContour, renderer);
   node->GetBoolProperty("close contour",      m_CloseContour, renderer);
   node->GetBoolProperty("show points",        m_ShowPoints, renderer);
   node->GetBoolProperty("show distances",     m_ShowDistances, renderer);
   node->GetIntProperty("distance decimal digits",     m_DistancesDecimalDigits, renderer);
   node->GetBoolProperty("show angles",        m_ShowAngles, renderer);
   node->GetBoolProperty("show distant lines", m_ShowDistantLines, renderer);
   node->GetIntProperty("line width",          m_LineWidth, renderer);
   node->GetIntProperty("point line width",    m_PointLineWidth, renderer);
   node->GetIntProperty("point 2D size",       m_Point2DSize, renderer);
   node->GetBoolProperty("Pointset.2D.fill shape", m_FillShape, renderer);
   node->GetFloatProperty("Pointset.2D.distance to plane", m_DistanceToPlane, renderer );
 
   mitk::PointSetShapeProperty::Pointer shape = dynamic_cast<mitk::PointSetShapeProperty*>(this->GetDataNode()->GetProperty( "Pointset.2D.shape", renderer ));
   if(shape.IsNotNull())
   {
     m_IDShapeProperty = shape->GetPointSetShape();
   }
 
   //check for color props and use it for rendering of selected/unselected points and contour
   //due to different params in VTK (double/float) we have to convert
 
   float unselectedColor[4];
   double selectedColor[4]={1.0f,0.0f,0.0f,1.0f};    //red
   double contourColor[4]={1.0f,0.0f,0.0f,1.0f};     //red
 
   float opacity = 1.0;
 
   GetDataNode()->GetOpacity(opacity, renderer);
 
   // apply color and opacity
   if(m_ShowPoints)
   {
     ls->m_UnselectedActor->VisibilityOn();
     ls->m_SelectedActor->VisibilityOn();
 
     //check if there is a color property
     GetDataNode()->GetColor(unselectedColor);
 
     //get selected color property
     if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("selectedcolor")) != NULL)
     {
       mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("selectedcolor"))->GetValue();
       selectedColor[0] = tmpColor[0];
       selectedColor[1] = tmpColor[1];
       selectedColor[2] = tmpColor[2];
       selectedColor[3] = 1.0f; // alpha value
     }
     else if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("selectedcolor")) != NULL)
     {
       mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("selectedcolor"))->GetValue();
       selectedColor[0] = tmpColor[0];
       selectedColor[1] = tmpColor[1];
       selectedColor[2] = tmpColor[2];
       selectedColor[3] = 1.0f; // alpha value
     }
 
     ls->m_SelectedActor->GetProperty()->SetColor(selectedColor);
     ls->m_SelectedActor->GetProperty()->SetOpacity(opacity);
 
     ls->m_UnselectedActor->GetProperty()->SetColor(unselectedColor[0],unselectedColor[1],unselectedColor[2]);
     ls->m_UnselectedActor->GetProperty()->SetOpacity(opacity);
 
   }
   else
   {
     ls->m_UnselectedActor->VisibilityOff();
     ls-> m_SelectedActor->VisibilityOff();
   }
 
   if (m_ShowContour)
   {
     ls->m_ContourActor->VisibilityOn();
 
     //get contour color property
     if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("contourcolor")) != NULL)
     {
       mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("contourcolor"))->GetValue();
       contourColor[0] = tmpColor[0];
       contourColor[1] = tmpColor[1];
       contourColor[2] = tmpColor[2];
       contourColor[3] = 1.0f;
     }
     else if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("contourcolor")) != NULL)
     {
       mitk::Color tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("contourcolor"))->GetValue();
       contourColor[0] = tmpColor[0];
       contourColor[1] = tmpColor[1];
       contourColor[2] = tmpColor[2];
       contourColor[3] = 1.0f;
     }
 
     ls->m_ContourActor->GetProperty()->SetColor(contourColor);
     ls->m_ContourActor->GetProperty()->SetOpacity(opacity);
   }
   else
   {
     ls->m_ContourActor->VisibilityOff();
   }
 
   if(needGenerateData)
   {
     // create new vtk render objects (e.g. a circle for a point)
     this->CreateVTKRenderObjects(renderer);
   }
 }
 
 void mitk::PointSetVtkMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   node->AddProperty( "line width", mitk::IntProperty::New(2), renderer, overwrite );
   node->AddProperty( "point line width", mitk::IntProperty::New(1), renderer, overwrite );
   node->AddProperty( "point 2D size", mitk::IntProperty::New(6), renderer, overwrite );
   node->AddProperty( "show contour", mitk::BoolProperty::New(false), renderer, overwrite );
   node->AddProperty( "close contour", mitk::BoolProperty::New(false), renderer, overwrite );
   node->AddProperty( "show points", mitk::BoolProperty::New(true), renderer, overwrite );
   node->AddProperty( "show distances", mitk::BoolProperty::New(false), renderer, overwrite );
   node->AddProperty( "distance decimal digits", mitk::IntProperty::New(2), renderer, overwrite );
   node->AddProperty( "show angles", mitk::BoolProperty::New(false), renderer, overwrite );
   node->AddProperty( "show distant lines", mitk::BoolProperty::New(false), renderer, overwrite );
   node->AddProperty( "layer", mitk::IntProperty::New(1), renderer, overwrite );
   node->AddProperty( "Pointset.2D.fill shape", mitk::BoolProperty::New(false), renderer, overwrite); // fill or do not fill the glyph shape
   mitk::PointSetShapeProperty::Pointer pointsetShapeProperty = mitk::PointSetShapeProperty::New();
   node->AddProperty( "Pointset.2D.shape", pointsetShapeProperty, renderer, overwrite);
   node->AddProperty( "Pointset.2D.distance to plane", mitk::FloatProperty::New(4.0f), renderer, overwrite ); //show the point at a certain distance above/below the 2D imaging plane.
 
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
diff --git a/Core/Code/Rendering/mitkPointSetVtkMapper3D.cpp b/Core/Code/Rendering/mitkPointSetVtkMapper3D.cpp
index f1f6069414..cd761c196e 100644
--- a/Core/Code/Rendering/mitkPointSetVtkMapper3D.cpp
+++ b/Core/Code/Rendering/mitkPointSetVtkMapper3D.cpp
@@ -1,642 +1,642 @@
 /*===================================================================
 
 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 "mitkPointSetVtkMapper3D.h"
 #include "mitkDataNode.h"
 #include "mitkProperties.h"
 #include "mitkColorProperty.h"
 #include "mitkVtkPropRenderer.h"
 #include "mitkPointSet.h"
 
 #include <vtkActor.h>
 #include <vtkAppendPolyData.h>
 #include <vtkPropAssembly.h>
 #include <vtkTubeFilter.h>
 #include <vtkRenderer.h>
 #include <vtkSphereSource.h>
 #include <vtkCubeSource.h>
 #include <vtkConeSource.h>
 #include <vtkCylinderSource.h>
 #include <vtkProperty.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkCellArray.h>
 #include <vtkVectorText.h>
 #include <vtkTransform.h>
 #include <vtkTransformPolyDataFilter.h>
 #include <vtkPolyDataAlgorithm.h>
 
 #include <stdlib.h>
 
 
 
 const mitk::PointSet* mitk::PointSetVtkMapper3D::GetInput()
 {
   return static_cast<const mitk::PointSet * > ( GetDataNode()->GetData() );
 }
 
 mitk::PointSetVtkMapper3D::PointSetVtkMapper3D()
 : m_vtkSelectedPointList(NULL),
  m_vtkUnselectedPointList(NULL),
  m_VtkSelectedPolyDataMapper(NULL),
  m_VtkUnselectedPolyDataMapper(NULL),
  m_vtkTextList(NULL),
  m_NumberOfSelectedAdded(0),
  m_NumberOfUnselectedAdded(0),
  m_PointSize(1.0),
  m_ContourRadius(0.5)
 {
   //propassembly
   m_PointsAssembly = vtkSmartPointer<vtkPropAssembly>::New();
 
   //creating actors to be able to set transform
   m_SelectedActor = vtkSmartPointer<vtkActor>::New();
   m_UnselectedActor = vtkSmartPointer<vtkActor>::New();
   m_ContourActor = vtkSmartPointer<vtkActor>::New();
 }
 
 mitk::PointSetVtkMapper3D::~PointSetVtkMapper3D()
 {
 }
 
 void mitk::PointSetVtkMapper3D::ReleaseGraphicsResources(vtkWindow *renWin)
 {
   m_PointsAssembly->ReleaseGraphicsResources(renWin);
 
   m_SelectedActor->ReleaseGraphicsResources(renWin);
   m_UnselectedActor->ReleaseGraphicsResources(renWin);
   m_ContourActor->ReleaseGraphicsResources(renWin);
 }
 
 void mitk::PointSetVtkMapper3D::ReleaseGraphicsResources(mitk::BaseRenderer* renderer)
 {
   m_PointsAssembly->ReleaseGraphicsResources(renderer->GetRenderWindow());
 
   m_SelectedActor->ReleaseGraphicsResources(renderer->GetRenderWindow());
   m_UnselectedActor->ReleaseGraphicsResources(renderer->GetRenderWindow());
   m_ContourActor->ReleaseGraphicsResources(renderer->GetRenderWindow());
 
 }
 
 void mitk::PointSetVtkMapper3D::CreateVTKRenderObjects()
 {
   m_vtkSelectedPointList = vtkSmartPointer<vtkAppendPolyData>::New();
   m_vtkUnselectedPointList = vtkSmartPointer<vtkAppendPolyData>::New();
 
   m_PointsAssembly->VisibilityOn();
 
   if(m_PointsAssembly->GetParts()->IsItemPresent(m_SelectedActor))
     m_PointsAssembly->RemovePart(m_SelectedActor);
   if(m_PointsAssembly->GetParts()->IsItemPresent(m_UnselectedActor))
     m_PointsAssembly->RemovePart(m_UnselectedActor);
   if(m_PointsAssembly->GetParts()->IsItemPresent(m_ContourActor))
     m_PointsAssembly->RemovePart(m_ContourActor);
 
   // exceptional displaying for PositionTracker -> MouseOrientationTool
   int mapperID;
   bool isInputDevice=false;
   if( this->GetDataNode()->GetBoolProperty("inputdevice",isInputDevice) && isInputDevice )
   {
     if( this->GetDataNode()->GetIntProperty("BaseRendererMapperID",mapperID) && mapperID == 2)
       return; //The event for the PositionTracker came from the 3d widget and  not needs to be displayed
   }
 
   // get and update the PointSet
   mitk::PointSet::Pointer input  = const_cast<mitk::PointSet*>(this->GetInput());
 
   /* only update the input data, if the property tells us to */
   bool update = true;
   this->GetDataNode()->GetBoolProperty("updateDataOnRender", update);
   if (update == true)
     input->Update();
 
   int timestep = this->GetTimestep();
 
   mitk::PointSet::DataType::Pointer itkPointSet = input->GetPointSet( timestep );
 
   if ( itkPointSet.GetPointer() == NULL)
   {
     m_PointsAssembly->VisibilityOff();
     return;
   }
 
   mitk::PointSet::PointsContainer::Iterator pointsIter;
   mitk::PointSet::PointDataContainer::Iterator pointDataIter;
   int j;
 
   m_NumberOfSelectedAdded = 0;
   m_NumberOfUnselectedAdded = 0;
 
   //create contour
   bool makeContour = false;
   this->GetDataNode()->GetBoolProperty("show contour", makeContour);
   if (makeContour)
   {
     this->CreateContour();
   }
 
   //now fill selected and unselected pointList
   //get size of Points in Property
   m_PointSize = 2;
   mitk::FloatProperty::Pointer pointSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("pointsize"));
   if ( pointSizeProp.IsNotNull() )
     m_PointSize = pointSizeProp->GetValue();
 
   //get the property for creating a label onto every point only once
   bool showLabel = true;
   this->GetDataNode()->GetBoolProperty("show label", showLabel);
   const char * pointLabel=NULL;
   if(showLabel)
   {
     if(dynamic_cast<mitk::StringProperty *>(this->GetDataNode()->GetPropertyList()->GetProperty("label")) != NULL)
       pointLabel =dynamic_cast<mitk::StringProperty *>(this->GetDataNode()->GetPropertyList()->GetProperty("label"))->GetValue();
     else
       showLabel = false;
   }
 
 
   //check if the list for the PointDataContainer is the same size as the PointsContainer. Is not, then the points were inserted manually and can not be visualized according to the PointData (selected/unselected)
   bool pointDataBroken = (itkPointSet->GetPointData()->Size() != itkPointSet->GetPoints()->Size());
   //now add an object for each point in data
   pointDataIter = itkPointSet->GetPointData()->Begin();
   for (j=0, pointsIter=itkPointSet->GetPoints()->Begin();
     pointsIter!=itkPointSet->GetPoints()->End();
     pointsIter++, j++)
   {
     //check for the pointtype in data and decide which geom-object to take and then add to the selected or unselected list
     int pointType;
 
     if(itkPointSet->GetPointData()->size() == 0 || pointDataBroken)
       pointType = mitk::PTUNDEFINED;
     else
       pointType = pointDataIter.Value().pointSpec;
 
     vtkSmartPointer<vtkPolyDataAlgorithm> source;
 
     switch (pointType)
     {
     case mitk::PTUNDEFINED:
       {
         vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
         sphere->SetRadius(m_PointSize);
         itk::Point<float> point1 = pointsIter->Value();
         sphere->SetCenter(point1[0],point1[1],point1[2]);
         //sphere->SetCenter(pointsIter.Value()[0],pointsIter.Value()[1],pointsIter.Value()[2]);
 
         //MouseOrientation Tool (PositionTracker)
         if(isInputDevice)
         {
           sphere->SetThetaResolution(10);
           sphere->SetPhiResolution(10);
         }
         else
         {
           sphere->SetThetaResolution(20);
           sphere->SetPhiResolution(20);
         }
         source = sphere;
       }
       break;
     case mitk::PTSTART:
       {
         vtkSmartPointer<vtkCubeSource> cube = vtkSmartPointer<vtkCubeSource>::New();
         cube->SetXLength(m_PointSize/2);
         cube->SetYLength(m_PointSize/2);
         cube->SetZLength(m_PointSize/2);
         itk::Point<float> point1 = pointsIter->Value();
         cube->SetCenter(point1[0],point1[1],point1[2]);
         source = cube;
       }
       break;
     case mitk::PTCORNER:
       {
         vtkSmartPointer<vtkConeSource> cone = vtkSmartPointer<vtkConeSource>::New();
         cone->SetRadius(m_PointSize);
         itk::Point<float> point1 = pointsIter->Value();
         cone->SetCenter(point1[0],point1[1],point1[2]);
         cone->SetResolution(20);
         source = cone;
       }
       break;
     case mitk::PTEDGE:
       {
         vtkSmartPointer<vtkCylinderSource> cylinder = vtkSmartPointer<vtkCylinderSource>::New();
         cylinder->SetRadius(m_PointSize);
         itk::Point<float> point1 = pointsIter->Value();
         cylinder->SetCenter(point1[0],point1[1],point1[2]);
         cylinder->SetResolution(20);
         source = cylinder;
       }
       break;
     case mitk::PTEND:
       {
         vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
         sphere->SetRadius(m_PointSize);
         //itk::Point<float> point1 = pointsIter->Value();
         sphere->SetThetaResolution(20);
         sphere->SetPhiResolution(20);
         source = sphere;
       }
       break;
     default:
       {
         vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
         sphere->SetRadius(m_PointSize);
         itk::Point<float> point1 = pointsIter->Value();
         sphere->SetCenter(point1[0],point1[1],point1[2]);
         sphere->SetThetaResolution(20);
         sphere->SetPhiResolution(20);
         source = sphere;
       }
       break;
     }
     if (!pointDataBroken)
     {
       if (pointDataIter.Value().selected)
       {
-        m_vtkSelectedPointList->AddInput(source->GetOutput());
+        m_vtkSelectedPointList->AddInputData(source->GetOutput());
         ++m_NumberOfSelectedAdded;
       }
       else
       {
-        m_vtkUnselectedPointList->AddInput(source->GetOutput());
+        m_vtkUnselectedPointList->AddInputData(source->GetOutput());
         ++m_NumberOfUnselectedAdded;
       }
     }
     else
     {
-      m_vtkUnselectedPointList->AddInput(source->GetOutput());
+      m_vtkUnselectedPointList->AddInputData(source->GetOutput());
       ++m_NumberOfUnselectedAdded;
     }
 
     if (showLabel)
     {
       char buffer[20];
       std::string l = pointLabel;
       if ( input->GetSize()>1 )
       {
         sprintf(buffer,"%d",j+1);
         l.append(buffer);
       }
       // Define the text for the label
       vtkSmartPointer<vtkVectorText> label = vtkSmartPointer<vtkVectorText>::New();
       label->SetText(l.c_str());
 
       //# Set up a transform to move the label to a new position.
       vtkSmartPointer<vtkTransform> aLabelTransform = vtkSmartPointer<vtkTransform>::New();
       aLabelTransform->Identity();
       itk::Point<float> point1 = pointsIter->Value();
       aLabelTransform->Translate(point1[0]+2,point1[1]+2,point1[2]);
       aLabelTransform->Scale(5.7,5.7,5.7);
 
       //# Move the label to a new position.
       vtkSmartPointer<vtkTransformPolyDataFilter> labelTransform = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
       labelTransform->SetTransform(aLabelTransform);
-      labelTransform->SetInput(label->GetOutput());
+      labelTransform->SetInputData(label->GetOutput());
 
       //add it to the wright PointList
       if (pointType)
       {
-        m_vtkSelectedPointList->AddInput(labelTransform->GetOutput());
+        m_vtkSelectedPointList->AddInputData(labelTransform->GetOutput());
         ++m_NumberOfSelectedAdded;
       }
       else
       {
-        m_vtkUnselectedPointList->AddInput(labelTransform->GetOutput());
+        m_vtkUnselectedPointList->AddInputData(labelTransform->GetOutput());
         ++m_NumberOfUnselectedAdded;
       }
     }
 
     if(pointDataIter != itkPointSet->GetPointData()->End())
       pointDataIter++;
   } // end FOR
 
 
   //now according to number of elements added to selected or unselected, build up the rendering pipeline
   if (m_NumberOfSelectedAdded > 0)
   {
     m_VtkSelectedPolyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-    m_VtkSelectedPolyDataMapper->SetInput(m_vtkSelectedPointList->GetOutput());
+    m_VtkSelectedPolyDataMapper->SetInputData(m_vtkSelectedPointList->GetOutput());
 
     //create a new instance of the actor
     m_SelectedActor = vtkSmartPointer<vtkActor>::New();
 
     m_SelectedActor->SetMapper(m_VtkSelectedPolyDataMapper);
     m_PointsAssembly->AddPart(m_SelectedActor);
   }
 
   if (m_NumberOfUnselectedAdded > 0)
   {
     m_VtkUnselectedPolyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-    m_VtkUnselectedPolyDataMapper->SetInput(m_vtkUnselectedPointList->GetOutput());
+    m_VtkUnselectedPolyDataMapper->SetInputData(m_vtkUnselectedPointList->GetOutput());
 
     //create a new instance of the actor
     m_UnselectedActor = vtkSmartPointer<vtkActor>::New();
 
     m_UnselectedActor->SetMapper(m_VtkUnselectedPolyDataMapper);
     m_PointsAssembly->AddPart(m_UnselectedActor);
   }
 }
 
 
 void mitk::PointSetVtkMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
   if(!visible)
   {
     m_UnselectedActor->VisibilityOff();
     m_SelectedActor->VisibilityOff();
     m_ContourActor->VisibilityOff();
     return;
   }
 
   // create new vtk render objects (e.g. sphere for a point)
 
   SetVtkMapperImmediateModeRendering(m_VtkSelectedPolyDataMapper);
   SetVtkMapperImmediateModeRendering(m_VtkUnselectedPolyDataMapper);
 
   BaseLocalStorage *ls = m_LSH.GetLocalStorage(renderer);
   bool needGenerateData = ls->IsGenerateDataRequired( renderer, this, GetDataNode() );
 
   if(!needGenerateData)
   {
     mitk::FloatProperty * pointSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("pointsize"));
     mitk::FloatProperty * contourSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("contoursize"));
 
     // only create new vtk render objects if property values were changed
     if(pointSizeProp && m_PointSize!=pointSizeProp->GetValue() )
       needGenerateData = true;
     if(contourSizeProp && m_ContourRadius!=contourSizeProp->GetValue() )
       needGenerateData = true;
   }
 
   if(needGenerateData)
   {
     this->CreateVTKRenderObjects();
     ls->UpdateGenerateDataTime();
   }
 
   this->ApplyAllProperties(renderer, m_ContourActor);
 
   bool showPoints = true;
   this->GetDataNode()->GetBoolProperty("show points", showPoints);
 
   if(showPoints)
   {
     m_UnselectedActor->VisibilityOn();
     m_SelectedActor->VisibilityOn();
   }
   else
   {
     m_UnselectedActor->VisibilityOff();
     m_SelectedActor->VisibilityOff();
   }
 
   if(dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("opacity")) != NULL)
   {
     mitk::FloatProperty::Pointer pointOpacity =dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("opacity"));
     float opacity = pointOpacity->GetValue();
     m_ContourActor->GetProperty()->SetOpacity(opacity);
     m_UnselectedActor->GetProperty()->SetOpacity(opacity);
     m_SelectedActor->GetProperty()->SetOpacity(opacity);
   }
 
   bool makeContour = false;
   this->GetDataNode()->GetBoolProperty("show contour", makeContour);
   if (makeContour)
   {
     m_ContourActor->VisibilityOn();
   }
   else
   {
     m_ContourActor->VisibilityOff();
   }
 }
 
 
 void mitk::PointSetVtkMapper3D::ResetMapper( BaseRenderer* /*renderer*/ )
 {
   m_PointsAssembly->VisibilityOff();
 }
 
 
 vtkProp* mitk::PointSetVtkMapper3D::GetVtkProp(mitk::BaseRenderer * /*renderer*/)
 {
   return m_PointsAssembly;
 }
 
 void mitk::PointSetVtkMapper3D::UpdateVtkTransform(mitk::BaseRenderer * /*renderer*/)
 {
   vtkSmartPointer<vtkLinearTransform> vtktransform =
     this->GetDataNode()->GetVtkTransform(this->GetTimestep());
 
   m_SelectedActor->SetUserTransform(vtktransform);
   m_UnselectedActor->SetUserTransform(vtktransform);
   m_ContourActor->SetUserTransform(vtktransform);
 }
 
 void mitk::PointSetVtkMapper3D::ApplyAllProperties(mitk::BaseRenderer* renderer, vtkActor* actor)
 {
   Superclass::ApplyColorAndOpacityProperties(renderer, actor);
   //check for color props and use it for rendering of selected/unselected points and contour
   //due to different params in VTK (double/float) we have to convert!
 
   //vars to convert to
   double unselectedColor[4]={1.0f,1.0f,0.0f,1.0f};//yellow
   double selectedColor[4]={1.0f,0.0f,0.0f,1.0f};//red
   double contourColor[4]={1.0f,0.0f,0.0f,1.0f};//red
 
   //different types for color!!!
   mitk::Color tmpColor;
   double opacity = 1.0;
 
   //check if there is an unselected property
   if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("unselectedcolor")) != NULL)
   {
     tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("unselectedcolor"))->GetValue();
     unselectedColor[0] = tmpColor[0];
     unselectedColor[1] = tmpColor[1];
     unselectedColor[2] = tmpColor[2];
     unselectedColor[3] = 1.0f; //!!define a new ColorProp to be able to pass alpha value
   }
   else if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("unselectedcolor")) != NULL)
   {
     tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("unselectedcolor"))->GetValue();
     unselectedColor[0] = tmpColor[0];
     unselectedColor[1] = tmpColor[1];
     unselectedColor[2] = tmpColor[2];
     unselectedColor[3] = 1.0f; //!!define a new ColorProp to be able to pass alpha value
   }
   else
   {
     //check if the node has a color
     float unselectedColorTMP[4]={1.0f,1.0f,0.0f,1.0f};//yellow
     m_DataNode->GetColor(unselectedColorTMP, NULL);
     unselectedColor[0] = unselectedColorTMP[0];
     unselectedColor[1] = unselectedColorTMP[1];
     unselectedColor[2] = unselectedColorTMP[2];
     //unselectedColor[3] stays 1.0f
   }
 
   //get selected property
   if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("selectedcolor")) != NULL)
   {
     tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("selectedcolor"))->GetValue();
     selectedColor[0] = tmpColor[0];
     selectedColor[1] = tmpColor[1];
     selectedColor[2] = tmpColor[2];
     selectedColor[3] = 1.0f;
   }
   else if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("selectedcolor")) != NULL)
   {
     tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("selectedcolor"))->GetValue();
     selectedColor[0] = tmpColor[0];
     selectedColor[1] = tmpColor[1];
     selectedColor[2] = tmpColor[2];
     selectedColor[3] = 1.0f;
   }
 
   //get contour property
   if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("contourcolor")) != NULL)
   {
     tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("contourcolor"))->GetValue();
     contourColor[0] = tmpColor[0];
     contourColor[1] = tmpColor[1];
     contourColor[2] = tmpColor[2];
     contourColor[3] = 1.0f;
   }
   else if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("contourcolor")) != NULL)
   {
     tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("contourcolor"))->GetValue();
     contourColor[0] = tmpColor[0];
     contourColor[1] = tmpColor[1];
     contourColor[2] = tmpColor[2];
     contourColor[3] = 1.0f;
   }
 
   if(dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("opacity")) != NULL)
   {
     mitk::FloatProperty::Pointer pointOpacity =dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("opacity"));
     opacity = pointOpacity->GetValue();
   }
   else if(dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("opacity")) != NULL)
   {
     mitk::FloatProperty::Pointer pointOpacity =dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("opacity"));
     opacity = pointOpacity->GetValue();
   }
   //finished color / opacity fishing!
 
   //check if a contour shall be drawn
   bool makeContour = false;
   this->GetDataNode()->GetBoolProperty("show contour", makeContour, renderer);
   if(makeContour && (m_ContourActor != NULL) )
   {
     this->CreateContour();
     m_ContourActor->GetProperty()->SetColor(contourColor);
     m_ContourActor->GetProperty()->SetOpacity(opacity);
   }
 
   m_SelectedActor->GetProperty()->SetColor(selectedColor);
   m_SelectedActor->GetProperty()->SetOpacity(opacity);
 
   m_UnselectedActor->GetProperty()->SetColor(unselectedColor);
   m_UnselectedActor->GetProperty()->SetOpacity(opacity);
 
 }
 
 void mitk::PointSetVtkMapper3D::CreateContour()
 {
   vtkSmartPointer<vtkAppendPolyData> vtkContourPolyData = vtkSmartPointer<vtkAppendPolyData>::New();
   vtkSmartPointer<vtkPolyDataMapper> vtkContourPolyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
 
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkCellArray> polys = vtkSmartPointer<vtkCellArray>::New();
 
   mitk::PointSet::PointsContainer::Iterator pointsIter;
 //  mitk::PointSet::PointDataContainer::Iterator pointDataIter;
   int j;
 
   // get and update the PointSet
   mitk::PointSet::Pointer input  = const_cast<mitk::PointSet*>(this->GetInput());
 
   int timestep = this->GetTimestep();
   mitk::PointSet::DataType::Pointer itkPointSet = input->GetPointSet( timestep );
   if ( itkPointSet.GetPointer() == NULL)
   {
     return;
   }
 
   for (j=0, pointsIter=itkPointSet->GetPoints()->Begin(); pointsIter!=itkPointSet->GetPoints()->End() ; pointsIter++,j++)
   {
     vtkIdType cell[2] = {j-1,j};
     itk::Point<float> point1 = pointsIter->Value();
     points->InsertPoint(j,point1[0],point1[1],point1[2]);
     if (j>0)
       polys->InsertNextCell(2,cell);
   }
 
   bool close = false;
   this->GetDataNode()->GetBoolProperty("close contour", close);
   if (close)
   {
     vtkIdType cell[2] = {j-1,0};
     polys->InsertNextCell(2,cell);
   }
 
   vtkSmartPointer<vtkPolyData> contour = vtkSmartPointer<vtkPolyData>::New();
   contour->SetPoints(points);
   contour->SetLines(polys);
-  contour->Update();
+//  contour->Update(); //VTK6_TODO pipeline changes
 
   vtkSmartPointer<vtkTubeFilter> tubeFilter = vtkSmartPointer<vtkTubeFilter>::New();
   tubeFilter->SetNumberOfSides( 12 );
-  tubeFilter->SetInput(contour);
+  tubeFilter->SetInputData(contour);
 
   //check for property contoursize.
   m_ContourRadius = 0.5;
   mitk::FloatProperty::Pointer contourSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("contoursize") );
 
   if (contourSizeProp.IsNotNull())
     m_ContourRadius = contourSizeProp->GetValue();
 
   tubeFilter->SetRadius( m_ContourRadius );
   tubeFilter->Update();
 
   //add to pipeline
-  vtkContourPolyData->AddInput(tubeFilter->GetOutput());
-  vtkContourPolyDataMapper->SetInput(vtkContourPolyData->GetOutput());
+  vtkContourPolyData->AddInputData(tubeFilter->GetOutput());
+  vtkContourPolyDataMapper->SetInputData(vtkContourPolyData->GetOutput());
 
   m_ContourActor->SetMapper(vtkContourPolyDataMapper);
   m_PointsAssembly->AddPart(m_ContourActor);
 }
 
 void mitk::PointSetVtkMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   node->AddProperty( "line width", mitk::IntProperty::New(2), renderer, overwrite );
   node->AddProperty( "pointsize", mitk::FloatProperty::New(1.0), renderer, overwrite);
   node->AddProperty( "selectedcolor", mitk::ColorProperty::New(1.0f, 0.0f, 0.0f), renderer, overwrite);  //red
   node->AddProperty( "color", mitk::ColorProperty::New(1.0f, 1.0f, 0.0f), renderer, overwrite);  //yellow
   node->AddProperty( "opacity", mitk::FloatProperty::New(1.0f), renderer, overwrite );
   node->AddProperty( "show contour", mitk::BoolProperty::New(false), renderer, overwrite );
   node->AddProperty( "close contour", mitk::BoolProperty::New(false), renderer, overwrite );
   node->AddProperty( "contourcolor", mitk::ColorProperty::New(1.0f, 0.0f, 0.0f), renderer, overwrite);
   node->AddProperty( "contoursize", mitk::FloatProperty::New(0.5), renderer, overwrite );
   node->AddProperty( "show points", mitk::BoolProperty::New(true), renderer, overwrite );
   node->AddProperty( "updateDataOnRender", mitk::BoolProperty::New(true), renderer, overwrite );
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
 
diff --git a/Core/Code/Rendering/mitkPolyDataGLMapper2D.cpp b/Core/Code/Rendering/mitkPolyDataGLMapper2D.cpp
index 41f832c138..8c43e1e306 100644
--- a/Core/Code/Rendering/mitkPolyDataGLMapper2D.cpp
+++ b/Core/Code/Rendering/mitkPolyDataGLMapper2D.cpp
@@ -1,276 +1,275 @@
 /*===================================================================
 
 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 <mitkGL.h>
 #include "mitkPolyDataGLMapper2D.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkSurface.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "mitkAbstractTransformGeometry.h"
 #include "mitkVtkMapper3D.h"
 
 #include <vtkPolyData.h>
-#include <vtkPolyDataSource.h>
 #include <vtkPlane.h>
 #include <vtkCutter.h>
 #include <vtkPoints.h>
 #include <vtkCellArray.h>
 #include <vtkLookupTable.h>
 #include <vtkPointData.h>
 #include <vtkCellData.h>
 #include <vtkDataArray.h>
 #include <vtkPolyData.h>
 #include <vtkLinearTransform.h>
 #include <vtkActor.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkScalarsToColors.h>
 
 #include <itkProcessObject.h>
 
 void mitk::PolyDataGLMapper2D::Paint( mitk::BaseRenderer * renderer )
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
 
     if ( !visible ) return;
 
     // ok, das ist aus GenerateData kopiert
     mitk::BaseData::Pointer input = const_cast<mitk::BaseData*>( GetDataNode()->GetData() );
 
     assert( input );
 
     input->Update();
 
     vtkPolyData * vtkpolydata = this->GetVtkPolyData();
     assert( vtkpolydata );
 
 
     vtkLinearTransform * vtktransform = GetDataNode() ->GetVtkTransform();
 
     if (vtktransform)
     {
       vtkLinearTransform * inversetransform = vtktransform->GetLinearInverse();
 
       Geometry2D::ConstPointer worldGeometry = renderer->GetCurrentWorldGeometry2D();
       PlaneGeometry::ConstPointer worldPlaneGeometry = dynamic_cast<const PlaneGeometry*>( worldGeometry.GetPointer() );
 
       if ( vtkpolydata != NULL )
       {
           Point3D point;
           Vector3D normal;
 
           if(worldPlaneGeometry.IsNotNull())
           {
             // set up vtkPlane according to worldGeometry
             point=worldPlaneGeometry->GetOrigin();
             normal=worldPlaneGeometry->GetNormal(); normal.Normalize();
             m_Plane->SetTransform((vtkAbstractTransform*)NULL);
           }
           else
           {
             //@FIXME: does not work correctly. Does m_Plane->SetTransform really transforms a "plane plane" into a "curved plane"?
             return;
             AbstractTransformGeometry::ConstPointer worldAbstractGeometry = dynamic_cast<const AbstractTransformGeometry*>(renderer->GetCurrentWorldGeometry2D());
             if(worldAbstractGeometry.IsNotNull())
             {
               // set up vtkPlane according to worldGeometry
               point=const_cast<mitk::BoundingBox*>(worldAbstractGeometry->GetParametricBoundingBox())->GetMinimum();
               FillVector3D(normal, 0, 0, 1);
               m_Plane->SetTransform(worldAbstractGeometry->GetVtkAbstractTransform()->GetInverse());
             }
             else
               return;
           }
 
           double vp[ 3 ], vnormal[ 3 ];
 
           vnl2vtk(point.GetVnlVector(), vp);
           vnl2vtk(normal.GetVnlVector(), vnormal);
 
           //normally, we would need to transform the surface and cut the transformed surface with the cutter.
           //This might be quite slow. Thus, the idea is, to perform an inverse transform of the plane instead.
           //@todo It probably does not work for scaling operations yet:scaling operations have to be
           //dealed with after the cut is performed by scaling the contour.
           inversetransform->TransformPoint( vp, vp );
           inversetransform->TransformNormalAtPoint( vp, vnormal, vnormal );
 
           m_Plane->SetOrigin( vp );
           m_Plane->SetNormal( vnormal );
 
           // set data into cutter
-          m_Cutter->SetInput( vtkpolydata );
+          m_Cutter->SetInputData( vtkpolydata );
           //    m_Cutter->GenerateCutScalarsOff();
           //    m_Cutter->SetSortByToSortByCell();
 
           // calculate the cut
           m_Cutter->Update();
 
           // fetch geometry
           mitk::DisplayGeometry::Pointer displayGeometry = renderer->GetDisplayGeometry();
           assert( displayGeometry );
           //  float toGL=displayGeometry->GetSizeInDisplayUnits()[1];
 
           //apply color and opacity read from the PropertyList
           ApplyColorAndOpacityProperties( renderer );
 
           // traverse the cut contour
           vtkPolyData * contour = m_Cutter->GetOutput();
 
           vtkPoints *vpoints = contour->GetPoints();
           vtkCellArray *vpolys = contour->GetLines();
           vtkPointData *vpointdata = contour->GetPointData();
           vtkDataArray* vscalars = vpointdata->GetScalars();
 
           vtkCellData *vcelldata = contour->GetCellData();
           vtkDataArray* vcellscalars = vcelldata->GetScalars();
 
           int i, numberOfCells = vpolys->GetNumberOfCells();
 
           Point3D p;
           Point2D p2d, last, first;
 
           vpolys->InitTraversal();
           vtkScalarsToColors* lut = GetVtkLUT();
           assert ( lut != NULL );
 
           for ( i = 0;i < numberOfCells;++i )
           {
               vtkIdType *cell(NULL);
               vtkIdType cellSize(0);
 
               vpolys->GetNextCell( cellSize, cell );
 
               if ( m_ColorByCellData )
               {  // color each cell according to cell data
                 double* color = lut->GetColor( vcellscalars->GetComponent( i, 0 ) );
                 glColor3f( color[ 0 ], color[ 1 ], color[ 2 ] );
               }
               if ( m_ColorByPointData )
               {
                 double* color = lut->GetColor( vscalars->GetComponent( cell[0], 0 ) );
                 glColor3f( color[ 0 ], color[ 1 ], color[ 2 ] );
               }
 
               glBegin ( GL_LINE_LOOP );
               for ( int j = 0;j < cellSize;++j )
               {
                   vpoints->GetPoint( cell[ j ], vp );
                   //take transformation via vtktransform into account
                   vtktransform->TransformPoint( vp, vp );
 
                   vtk2itk( vp, p );
 
                   //convert 3D point (in mm) to 2D point on slice (also in mm)
                   worldGeometry->Map( p, p2d );
 
                   //convert point (until now mm and in worldcoordinates) to display coordinates (units )
                   displayGeometry->WorldToDisplay( p2d, p2d );
 
                   //convert display coordinates ( (0,0) is top-left ) in GL coordinates ( (0,0) is bottom-left )
                   //p2d[1]=toGL-p2d[1];
 
                   //add the current vertex to the line
                   glVertex2f( p2d[0], p2d[1] );
               }
               glEnd ();
           }
       }
     }
 }
 
 
 
 
 
 vtkPolyDataMapper* mitk::PolyDataGLMapper2D::GetVtkPolyDataMapper()
 {
     return NULL;
     /*
 
     mitk::DataNode::ConstPointer node = this->GetDataNode();
     if ( node.IsNull() )
         return NULL;
 
     mitk::VtkMapper3D::Pointer mitkMapper = dynamic_cast< mitk::VtkMapper3D* > ( node->GetMapper( 2 ) );
     if ( mitkMapper.IsNull() )
         return NULL;
 
     mitkMapper->Update(NULL);
 
     vtkActor* actor = dynamic_cast<vtkActor*>( mitkMapper->GetVtkProp(0) );
 
     if ( actor == NULL )
         return NULL;
 
     return dynamic_cast<vtkPolyDataMapper*>( actor->GetMapper() );
   */
 }
 
 
 
 vtkPolyData* mitk::PolyDataGLMapper2D::GetVtkPolyData( )
 {
     vtkPolyDataMapper * polyDataMapper = GetVtkPolyDataMapper();
     if ( polyDataMapper == NULL )
         return NULL;
     else
         return polyDataMapper->GetInput();
 }
 
 
 
 vtkScalarsToColors* mitk::PolyDataGLMapper2D::GetVtkLUT( )
 {
     vtkPolyDataMapper * polyDataMapper = GetVtkPolyDataMapper();
     if ( polyDataMapper == NULL )
         return NULL;
     else
         return polyDataMapper->GetLookupTable();
 }
 
 
 bool mitk::PolyDataGLMapper2D::IsConvertibleToVtkPolyData()
 {
     return ( GetVtkPolyDataMapper() != NULL );
 }
 
 mitk::PolyDataGLMapper2D::PolyDataGLMapper2D()
 {
     m_Plane = vtkPlane::New();
     m_Cutter = vtkCutter::New();
 
     m_Cutter->SetCutFunction( m_Plane );
     m_Cutter->GenerateValues( 1, 0, 1 );
 
     m_ColorByCellData = false;
     m_ColorByPointData = false;
 
     //m_LUT = vtkLookupTable::New();
     //m_LUT->SetTableRange( 0, 255 );
     //m_LUT->SetNumberOfColors( 255 );
     //m_LUT->SetRampToLinear ();
     //m_LUT->Build();
 }
 
 
 
 mitk::PolyDataGLMapper2D::~PolyDataGLMapper2D()
 {}
 
diff --git a/Core/Code/Rendering/mitkSurfaceGLMapper2D.cpp b/Core/Code/Rendering/mitkSurfaceGLMapper2D.cpp
index b9464cab0c..d0617e7a9f 100644
--- a/Core/Code/Rendering/mitkSurfaceGLMapper2D.cpp
+++ b/Core/Code/Rendering/mitkSurfaceGLMapper2D.cpp
@@ -1,544 +1,544 @@
 /*===================================================================
 
 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 <mitkGL.h>
 
 #include "mitkSurfaceGLMapper2D.h"
 #include "mitkBaseRenderer.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkSurface.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "mitkVtkScalarModeProperty.h"
 #include "mitkAbstractTransformGeometry.h"
 #include "mitkLookupTableProperty.h"
 
 #include <vtkPolyData.h>
 #include <vtkPlane.h>
 #include <vtkCutter.h>
 #include <vtkPoints.h>
 #include <vtkCellArray.h>
 #include <vtkLookupTable.h>
 #include <vtkPointData.h>
 #include <vtkCellData.h>
 #include <vtkDataArray.h>
 #include <vtkLinearTransform.h>
 #include <vtkAbstractMapper.h>
 #include <vtkPKdTree.h>
 #include <vtkStripper.h>
 
 
 mitk::SurfaceGLMapper2D::SurfaceGLMapper2D()
 : m_Plane( vtkPlane::New() ),
   m_Cutter( vtkCutter::New() ),
   m_LUT( vtkLookupTable::New() ),
   m_PointLocator( vtkPKdTree::New() ),
   m_Stripper( vtkStripper::New() ),
   m_DrawNormals(false),
   m_FrontNormalLengthInPixels(10.0),
   m_BackNormalLengthInPixels(10.0)
 {
   // default for normals on front side = green
   m_FrontSideColor[0] = 0.0;
   m_FrontSideColor[1] = 1.0;
   m_FrontSideColor[2] = 0.0;
   m_FrontSideColor[3] = 1.0;
 
   // default for normals on back side = red
   m_BackSideColor[0] = 1.0;
   m_BackSideColor[1] = 0.0;
   m_BackSideColor[2] = 0.0;
   m_BackSideColor[3] = 1.0;
 
   // default for line color = yellow
   m_LineColor[0] = 1.0;
   m_LineColor[1] = 1.0;
   m_LineColor[2] = 0.0;
   m_LineColor[3] = 1.0;
 
   m_Cutter->SetCutFunction(m_Plane);
   m_Cutter->GenerateValues(1,0,1);
 
   m_LUT->SetTableRange(0,255);
   m_LUT->SetNumberOfColors(255);
   m_LUT->SetRampToLinear();
   m_LUT->Build();
 }
 
 mitk::SurfaceGLMapper2D::~SurfaceGLMapper2D()
 {
   m_Plane->Delete();
   m_Cutter->Delete();
   m_LUT->Delete();
   m_PointLocator->Delete();
   m_Stripper->Delete();
 }
 
 const mitk::Surface *mitk::SurfaceGLMapper2D::GetInput(void)
 {
   if(m_Surface.IsNotNull())
     return m_Surface;
 
   return static_cast<const Surface * > ( GetDataNode()->GetData() );
 }
 
 void mitk::SurfaceGLMapper2D::SetDataNode( mitk::DataNode* node )
 {
   Superclass::SetDataNode( node );
 
   bool useCellData;
   if (dynamic_cast<BoolProperty *>(node->GetProperty("deprecated useCellDataForColouring")) == NULL)
     useCellData = false;
   else
     useCellData = dynamic_cast<BoolProperty *>(node->GetProperty("deprecated useCellDataForColouring"))->GetValue();
 
   if (!useCellData)
   {
     // search min/max point scalars over all time steps
     double dataRange[2] = {0,0};
     double range[2];
 
     Surface::Pointer input  = const_cast< Surface* >(dynamic_cast<const Surface*>( this->GetDataNode()->GetData() ));
     if(input.IsNull()) return;
     const TimeGeometry::Pointer inputTimeGeometry = input->GetTimeGeometry();
     if(( inputTimeGeometry.IsNull() ) || ( inputTimeGeometry->CountTimeSteps() == 0 ) ) return;
     for (unsigned int timestep=0; timestep<inputTimeGeometry->CountTimeSteps(); timestep++)
     {
       vtkPolyData * vtkpolydata = input->GetVtkPolyData( timestep );
       if((vtkpolydata==NULL) || (vtkpolydata->GetNumberOfPoints() < 1 )) continue;
       vtkDataArray *vpointscalars = vtkpolydata->GetPointData()->GetScalars();
       if (vpointscalars) {
         vpointscalars->GetRange( range, 0 );
         if (dataRange[0]==0 && dataRange[1]==0) {
           dataRange[0] = range[0];
           dataRange[1] = range[1];
         }
         else {
           if (range[0] < dataRange[0]) dataRange[0] = range[0];
           if (range[1] > dataRange[1]) dataRange[1] = range[1];
         }
       }
     }
     if (dataRange[1] - dataRange[0] > 0) {
       m_LUT->SetTableRange( dataRange );
       m_LUT->Build();
     }
   }
 }
 
 
 void mitk::SurfaceGLMapper2D::Paint(mitk::BaseRenderer * renderer)
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
   if(!visible) return;
 
   Surface::Pointer input  = const_cast<Surface*>(this->GetInput());
 
   if(input.IsNull())
     return;
 
   //
   // get the TimeGeometry of the input object
   //
   const TimeGeometry* inputTimeGeometry = input->GetTimeGeometry();
   if(( inputTimeGeometry == NULL ) || ( inputTimeGeometry->CountTimeSteps() == 0 ) )
     return;
 
   if (dynamic_cast<IntProperty *>(this->GetDataNode()->GetProperty("line width")) == NULL)
     m_LineWidth = 1;
   else
     m_LineWidth = dynamic_cast<IntProperty *>(this->GetDataNode()->GetProperty("line width"))->GetValue();
 
   //
   // get the world time
   //
   Geometry2D::ConstPointer worldGeometry = renderer->GetCurrentWorldGeometry2D();
   assert( worldGeometry.IsNotNull() );
 
   ScalarType time = worldGeometry->GetTimeBounds()[ 0 ];
   int timestep=0;
 
   if( time > ScalarTypeNumericTraits::NonpositiveMin() )
     timestep = inputTimeGeometry->TimePointToTimeStep( time );
 
  // int timestep = this->GetTimestep();
 
   if( inputTimeGeometry->IsValidTimeStep( timestep ) == false )
     return;
 
   vtkPolyData * vtkpolydata = input->GetVtkPolyData( timestep );
   if((vtkpolydata==NULL) || (vtkpolydata->GetNumberOfPoints() < 1 ))
     return;
 
   PlaneGeometry::ConstPointer worldPlaneGeometry = dynamic_cast<const PlaneGeometry*>(worldGeometry.GetPointer());
 
   //apply color and opacity read from the PropertyList
   this->ApplyAllProperties(renderer);
 
   if (m_DrawNormals)
   {
     m_PointLocator->SetDataSet( vtkpolydata );
     m_PointLocator->BuildLocatorFromPoints( vtkpolydata->GetPoints() );
   }
 
   if(vtkpolydata!=NULL)
   {
     Point3D point;
     Vector3D normal;
 
     //Check if Lookup-Table is already given, else use standard one.
     double* scalarLimits = m_LUT->GetTableRange();
     double scalarsMin = scalarLimits[0], scalarsMax = scalarLimits[1];
 
     vtkLookupTable *lut;// = vtkLookupTable::New();
 
     LookupTableProperty::Pointer lookupTableProp;
     this->GetDataNode()->GetProperty(lookupTableProp, "LookupTable", renderer);
     if (lookupTableProp.IsNotNull() )
     {
       lut = lookupTableProp->GetLookupTable()->GetVtkLookupTable();
 
       if (dynamic_cast<FloatProperty *>(this->GetDataNode()->GetProperty("ScalarsRangeMinimum")) != NULL)
         scalarsMin = dynamic_cast<FloatProperty*>(this->GetDataNode()->GetProperty("ScalarsRangeMinimum"))->GetValue();
       if (dynamic_cast<FloatProperty *>(this->GetDataNode()->GetProperty("ScalarsRangeMaximum")) != NULL)
         scalarsMax = dynamic_cast<FloatProperty*>(this->GetDataNode()->GetProperty("ScalarsRangeMaximum"))->GetValue();
 
       // check if the scalar range has been changed, e.g. manually, for the data tree node, and rebuild the LUT if necessary.
       double* oldRange = lut->GetTableRange();
       if( oldRange[0] != scalarsMin || oldRange[1] != scalarsMax )
       {
         lut->SetTableRange(scalarsMin, scalarsMax);
         lut->Build();
       }
     }
     else
     {
       lut = m_LUT;
     }
 
     vtkLinearTransform * vtktransform = GetDataNode()->GetVtkTransform(timestep);
     if(worldPlaneGeometry.IsNotNull())
     {
       // set up vtkPlane according to worldGeometry
       point=worldPlaneGeometry->GetOrigin();
       normal=worldPlaneGeometry->GetNormal(); normal.Normalize();
       m_Plane->SetTransform((vtkAbstractTransform*)NULL);
     }
     else
     {
       AbstractTransformGeometry::ConstPointer worldAbstractGeometry = dynamic_cast<const AbstractTransformGeometry*>(renderer->GetCurrentWorldGeometry2D());
       if(worldAbstractGeometry.IsNotNull())
       {
         AbstractTransformGeometry::ConstPointer surfaceAbstractGeometry = dynamic_cast<const AbstractTransformGeometry*>(input->GetTimeGeometry()->GetGeometryForTimeStep(0).GetPointer());
         if(surfaceAbstractGeometry.IsNotNull()) //@todo substitude by operator== after implementation, see bug id 28
         {
           PaintCells(renderer, vtkpolydata, worldGeometry, renderer->GetDisplayGeometry(), vtktransform, lut);
           return;
         }
         else
         {
           //@FIXME: does not work correctly. Does m_Plane->SetTransform really transforms a "flat plane" into a "curved plane"?
           return;
           // set up vtkPlane according to worldGeometry
           point=const_cast<BoundingBox*>(worldAbstractGeometry->GetParametricBoundingBox())->GetMinimum();
           FillVector3D(normal, 0, 0, 1);
           m_Plane->SetTransform(worldAbstractGeometry->GetVtkAbstractTransform()->GetInverse());
         }
       }
       else
         return;
     }
 
     double vp[3], vnormal[3];
 
     vnl2vtk(point.GetVnlVector(), vp);
     vnl2vtk(normal.GetVnlVector(), vnormal);
 
     //normally, we would need to transform the surface and cut the transformed surface with the cutter.
     //This might be quite slow. Thus, the idea is, to perform an inverse transform of the plane instead.
     //@todo It probably does not work for scaling operations yet:scaling operations have to be
     //dealed with after the cut is performed by scaling the contour.
     vtkLinearTransform * inversetransform = vtktransform->GetLinearInverse();
     inversetransform->TransformPoint(vp, vp);
     inversetransform->TransformNormalAtPoint(vp, vnormal, vnormal);
 
     m_Plane->SetOrigin(vp);
     m_Plane->SetNormal(vnormal);
 
     //set data into cutter
-    m_Cutter->SetInput(vtkpolydata);
+    m_Cutter->SetInputData(vtkpolydata);
     m_Cutter->Update();
     //    m_Cutter->GenerateCutScalarsOff();
     //    m_Cutter->SetSortByToSortByCell();
 
     if (m_DrawNormals)
     {
-      m_Stripper->SetInput( m_Cutter->GetOutput() );
+      m_Stripper->SetInputData( m_Cutter->GetOutput() );
       // calculate the cut
       m_Stripper->Update();
       PaintCells(renderer, m_Stripper->GetOutput(), worldGeometry, renderer->GetDisplayGeometry(), vtktransform, lut, vtkpolydata);
     }
     else
     {
       PaintCells(renderer, m_Cutter->GetOutput(), worldGeometry, renderer->GetDisplayGeometry(), vtktransform, lut, vtkpolydata);
     }
   }
 }
 
 void mitk::SurfaceGLMapper2D::PaintCells(mitk::BaseRenderer* renderer, vtkPolyData* contour,
                                        const Geometry2D* worldGeometry,
                                        const DisplayGeometry* displayGeometry,
                                        vtkLinearTransform * vtktransform,
                                        vtkLookupTable *lut,
                                        vtkPolyData* original3DObject)
 {
   // deprecated settings
   bool usePointData = false;
 
   bool useCellData = false;
   this->GetDataNode()->GetBoolProperty("deprecated useCellDataForColouring", useCellData);
 
   bool scalarVisibility = false;
   this->GetDataNode()->GetBoolProperty("scalar visibility", scalarVisibility);
 
   if(scalarVisibility)
   {
     VtkScalarModeProperty* scalarMode;
     if(this->GetDataNode()->GetProperty(scalarMode, "scalar mode", renderer))
     {
       if( (scalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_USE_POINT_DATA) ||
         (scalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_DEFAULT) )
       {
         usePointData = true;
       }
       if(scalarMode->GetVtkScalarMode() == VTK_SCALAR_MODE_USE_CELL_DATA)
       {
         useCellData = true;
       }
     }
     else
     {
       usePointData = true;
     }
   }
 
   vtkPoints    *vpoints = contour->GetPoints();
   vtkDataArray *vpointscalars = contour->GetPointData()->GetScalars();
 
   vtkCellArray *vlines  = contour->GetLines();
   vtkDataArray* vcellscalars = contour->GetCellData()->GetScalars();
 
   Point3D p; Point2D p2d, last;
   int i, j;
   int numberOfLines = vlines->GetNumberOfCells();
 
   glLineWidth( m_LineWidth );
   glBegin (GL_LINES);
 
   glColor4fv(m_LineColor);
 
   double distanceSinceLastNormal(0.0);
 
   vlines->InitTraversal();
   for(i=0;i<numberOfLines;++i)
   {
     vtkIdType *cell(NULL);
     vtkIdType cellSize(0);
     double vp[3];
 
     vlines->GetNextCell(cellSize, cell);
 
     vpoints->GetPoint(cell[0], vp);
     //take transformation via vtktransform into account
     vtktransform->TransformPoint(vp, vp);
     vtk2itk(vp, p);
 
     //convert 3D point (in mm) to 2D point on slice (also in mm)
     worldGeometry->Map(p, p2d);
 
     //convert point (until now mm and in world coordinates) to display coordinates (units )
     displayGeometry->WorldToDisplay(p2d, p2d);
     last=p2d;
 
     for(j=1; j<cellSize; ++j)
     {
       vpoints->GetPoint(cell[j], vp);
       Point3D originalPoint;
       vtk2itk(vp, originalPoint);
       //take transformation via vtktransform into account
       vtktransform->TransformPoint(vp, vp);
       vtk2itk(vp, p);
 
       //convert 3D point (in mm) to 2D point on slice (also in mm)
       worldGeometry->Map(p, p2d);
 
       //convert point (until now mm and in world coordinates) to display coordinates (units )
       displayGeometry->WorldToDisplay(p2d, p2d);
 
       double color[3];
       if (useCellData && vcellscalars != NULL )
       {
         // color each cell according to cell data
         lut->GetColor( vcellscalars->GetComponent(i,0),color);
         glColor3f(color[0],color[1],color[2]);
         glVertex2f(last[0], last[1]);
         glVertex2f(p2d[0], p2d[1]);
       }
       else if (usePointData && vpointscalars != NULL )
       {
         lut->GetColor( vpointscalars->GetComponent(cell[j-1],0),color);
         glColor3f(color[0],color[1],color[2]);
         glVertex2f(last[0], last[1]);
         lut->GetColor( vpointscalars->GetComponent(cell[j],0),color);
         glColor3f(color[0],color[1],color[2]);
         glVertex2f(p2d[0], p2d[1]);
       }
       else
       {
         glVertex2f(last[0], last[1]);
         glVertex2f(p2d[0], p2d[1]);
 
         // draw normals ?
         if (m_DrawNormals && original3DObject)
         {
           distanceSinceLastNormal += sqrt((p2d[0]-last[0])*(p2d[0]-last[0]) + (p2d[1]-last[1])*(p2d[1]-last[1]));
           if (distanceSinceLastNormal >= 5.0)
           {
             distanceSinceLastNormal = 0.0;
 
             vtkPointData* pointData = original3DObject->GetPointData();
             if (!pointData) break;
 
             vtkDataArray* normalsArray = pointData->GetNormals();
             if (!normalsArray) break;
 
             // find 3D point closest to the currently drawn point
             double distance(0.0);
             vtkIdType closestPointId = m_PointLocator->FindClosestPoint(originalPoint[0], originalPoint[1], originalPoint[2], distance);
             if (closestPointId >= 0)
             {
               // find normal of 3D object at this 3D point
               double* normal = normalsArray->GetTuple3(closestPointId);
               double transformedNormal[3];
               vtktransform->TransformNormal(normal, transformedNormal);
 
               Vector3D normalITK;
               vtk2itk(transformedNormal, normalITK);
               normalITK.Normalize();
 
               // calculate a point (point from the cut 3D object) + (normal vector of closest point)
               Point3D tip3D = p + normalITK;
 
               // map this point into our 2D coordinate system
               Point2D tip2D;
               worldGeometry->Map(tip3D, tip2D);
 
               displayGeometry->WorldToDisplay(tip2D, tip2D);
 
               // calculate 2D vector from point to point+normal, normalize it to standard length
               Vector2D tipVectorGLFront = tip2D - p2d;
               tipVectorGLFront.Normalize();
               tipVectorGLFront *= m_FrontNormalLengthInPixels;
 
               Vector2D tipVectorGLBack = p2d - tip2D;
               tipVectorGLBack.Normalize();
               tipVectorGLBack *= m_BackNormalLengthInPixels;
 
               Point2D tipPoint2D = p2d + tipVectorGLFront;
               Point2D backTipPoint2D = p2d + tipVectorGLBack;
 
               // draw normalized mapped normal vector
               glColor4f(m_BackSideColor[0], m_BackSideColor[1], m_BackSideColor[2], m_BackSideColor[3]); // red backside
               glVertex2f(p2d[0], p2d[1]);
               glVertex2f(tipPoint2D[0], tipPoint2D[1]);
               glColor4f(m_FrontSideColor[0], m_FrontSideColor[1], m_FrontSideColor[2], m_FrontSideColor[3]); // green backside
               glVertex2f(p2d[0], p2d[1]);
               glVertex2f(backTipPoint2D[0], backTipPoint2D[1]);
               glColor4fv(m_LineColor); // back to line color
             }
           }
         }
       }
       last=p2d;
     }
   }
 
   glEnd();
   glLineWidth(1.0);
 }
 
 void mitk::SurfaceGLMapper2D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   node->AddProperty( "line width", IntProperty::New(2), renderer, overwrite );
   node->AddProperty( "scalar mode", VtkScalarModeProperty::New(), renderer, overwrite );
   node->AddProperty( "draw normals 2D", BoolProperty::New(false), renderer, overwrite );
   node->AddProperty( "invert normals", BoolProperty::New(false), renderer, overwrite );
   node->AddProperty( "front color", ColorProperty::New(0.0, 1.0, 0.0), renderer, overwrite );
   node->AddProperty( "back color", ColorProperty::New(1.0, 0.0, 0.0), renderer, overwrite );
   node->AddProperty( "front normal lenth (px)", FloatProperty::New(10.0), renderer, overwrite );
   node->AddProperty( "back normal lenth (px)", FloatProperty::New(10.0), renderer, overwrite );
   node->AddProperty( "layer", mitk::IntProperty::New(100), renderer, overwrite);
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
 
 void mitk::SurfaceGLMapper2D::ApplyAllProperties(mitk::BaseRenderer* renderer)
 {
   ApplyColorAndOpacityProperties(renderer);
 
   DataNode * node = GetDataNode();
 
   if(node == NULL)
   {
     return;
   }
 
   node->GetBoolProperty("draw normals 2D", m_DrawNormals, renderer);
 
   // check for color and opacity properties, use it for rendering if they exists
   node->GetColor(m_LineColor, renderer, "color");
   node->GetOpacity(m_LineColor[3], renderer, "opacity");
 
   bool invertNormals(false);
   node->GetBoolProperty("invert normals", invertNormals, renderer);
 
   if (!invertNormals)
   {
     node->GetColor(m_FrontSideColor, renderer, "front color");
     node->GetOpacity(m_FrontSideColor[3], renderer, "opacity");
 
     node->GetColor(m_BackSideColor, renderer, "back color");
     node->GetOpacity(m_BackSideColor[3], renderer, "opacity");
 
     node->GetFloatProperty( "front normal lenth (px)", m_FrontNormalLengthInPixels, renderer );
     node->GetFloatProperty( "back normal lenth (px)", m_BackNormalLengthInPixels, renderer );
 
   }
   else
   {
     node->GetColor(m_FrontSideColor, renderer, "back color");
     node->GetOpacity(m_FrontSideColor[3], renderer, "opacity");
 
     node->GetColor(m_BackSideColor, renderer, "front color");
     node->GetOpacity(m_BackSideColor[3], renderer, "opacity");
 
     node->GetFloatProperty( "back normal lenth (px)", m_FrontNormalLengthInPixels, renderer );
     node->GetFloatProperty( "front normal lenth (px)", m_BackNormalLengthInPixels, renderer );
 
   }
 }
 
diff --git a/Core/Code/Rendering/mitkSurfaceVtkMapper3D.cpp b/Core/Code/Rendering/mitkSurfaceVtkMapper3D.cpp
index e347a0166c..9a927d9ace 100644
--- a/Core/Code/Rendering/mitkSurfaceVtkMapper3D.cpp
+++ b/Core/Code/Rendering/mitkSurfaceVtkMapper3D.cpp
@@ -1,503 +1,503 @@
 /*===================================================================
 
 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 "mitkSurfaceVtkMapper3D.h"
 #include "mitkDataNode.h"
 #include "mitkProperties.h"
 #include "mitkColorProperty.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkVtkRepresentationProperty.h"
 #include "mitkVtkInterpolationProperty.h"
 #include "mitkVtkScalarModeProperty.h"
 #include "mitkClippingProperty.h"
 #include "mitkSmartPointerProperty.h"
 
 #include "mitkShaderProperty.h"
 #include "mitkIShaderRepository.h"
 #include <mitkExtractSliceFilter.h>
 #include <mitkImageSliceSelector.h>
 #include <mitkCoreServices.h>
 
 //VTK
 #include <vtkActor.h>
 #include <vtkProperty.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkPolyDataNormals.h>
 #include <vtkPointData.h>
 #include <vtkPlaneCollection.h>
 #include <vtkSmartPointer.h>
 
 const mitk::Surface* mitk::SurfaceVtkMapper3D::GetInput()
 {
   return static_cast<const mitk::Surface * > ( GetDataNode()->GetData() );
 }
 
 mitk::SurfaceVtkMapper3D::SurfaceVtkMapper3D()
 {
     // m_Prop3D = vtkActor::New();
     m_GenerateNormals = false;
 }
 
 mitk::SurfaceVtkMapper3D::~SurfaceVtkMapper3D()
 {
     // m_Prop3D->Delete();
 }
 
 void mitk::SurfaceVtkMapper3D::GenerateDataForRenderer(mitk::BaseRenderer* renderer)
 {
     LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
 
   if(!visible)
   {
     ls->m_Actor->VisibilityOff();
     return;
   }
 
   //
   // set the input-object at time t for the mapper
   //
   mitk::Surface::Pointer input  = const_cast< mitk::Surface* >( this->GetInput() );
   vtkPolyData * polydata = input->GetVtkPolyData( this->GetTimestep() );
   if(polydata == NULL)
   {
     ls->m_Actor->VisibilityOff();
     return;
   }
 
   if ( m_GenerateNormals )
   {
-    ls->m_VtkPolyDataNormals->SetInput( polydata );
-    ls->m_VtkPolyDataMapper->SetInput( ls->m_VtkPolyDataNormals->GetOutput() );
+    ls->m_VtkPolyDataNormals->SetInputData( polydata );
+    ls->m_VtkPolyDataMapper->SetInputData( ls->m_VtkPolyDataNormals->GetOutput() );
   }
   else
   {
-    ls->m_VtkPolyDataMapper->SetInput( polydata );
+    ls->m_VtkPolyDataMapper->SetInputData( polydata );
   }
 
   //
   // apply properties read from the PropertyList
   //
   ApplyAllProperties(renderer, ls->m_Actor);
 
   if(visible)
     ls->m_Actor->VisibilityOn();
 }
 
 
 void mitk::SurfaceVtkMapper3D::ResetMapper( BaseRenderer* renderer )
 {
     LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
     ls->m_Actor->VisibilityOff();
 }
 
 void mitk::SurfaceVtkMapper3D::ApplyMitkPropertiesToVtkProperty(mitk::DataNode *node, vtkProperty* property, mitk::BaseRenderer* renderer)
 {
     // Backface culling
     {
         mitk::BoolProperty::Pointer p;
         node->GetProperty(p, "Backface Culling", renderer);
         bool useCulling = false;
         if(p.IsNotNull())
             useCulling = p->GetValue();
         property->SetBackfaceCulling(useCulling);
     }
 
     // Colors
     {
         double ambient [3] = { 0.5,0.5,0.0 };
         double diffuse [3] = { 0.5,0.5,0.0 };
         double specular[3] = { 1.0,1.0,1.0 };
 
         float coeff_ambient = 0.5f;
         float coeff_diffuse = 0.5f;
         float coeff_specular= 0.5f;
         float power_specular=10.0f;
 
         // Color
         {
             mitk::ColorProperty::Pointer p;
             node->GetProperty(p, "color", renderer);
             if(p.IsNotNull())
             {
                 mitk::Color c = p->GetColor();
                 ambient[0]=c.GetRed(); ambient[1]=c.GetGreen(); ambient[2]=c.GetBlue();
                 diffuse[0]=c.GetRed(); diffuse[1]=c.GetGreen(); diffuse[2]=c.GetBlue();
                 // Setting specular color to the same, make physically no real sense, however vtk rendering slows down, if these colors are different.
                 specular[0]=c.GetRed(); specular[1]=c.GetGreen(); specular[2]=c.GetBlue();
             }
         }
 
         // Ambient
         {
             mitk::ColorProperty::Pointer p;
             node->GetProperty(p, "material.ambientColor", renderer);
             if(p.IsNotNull())
             {
                 mitk::Color c = p->GetColor();
                 ambient[0]=c.GetRed(); ambient[1]=c.GetGreen(); ambient[2]=c.GetBlue();
             }
         }
 
         // Diffuse
         {
             mitk::ColorProperty::Pointer p;
             node->GetProperty(p, "material.diffuseColor", renderer);
             if(p.IsNotNull())
             {
                 mitk::Color c = p->GetColor();
                 diffuse[0]=c.GetRed(); diffuse[1]=c.GetGreen(); diffuse[2]=c.GetBlue();
             }
         }
 
         // Specular
         {
             mitk::ColorProperty::Pointer p;
             node->GetProperty(p, "material.specularColor", renderer);
             if(p.IsNotNull())
             {
                 mitk::Color c = p->GetColor();
                 specular[0]=c.GetRed(); specular[1]=c.GetGreen(); specular[2]=c.GetBlue();
             }
         }
 
         // Ambient coeff
         {
             node->GetFloatProperty("material.ambientCoefficient", coeff_ambient, renderer);
         }
 
         // Diffuse coeff
         {
             node->GetFloatProperty("material.diffuseCoefficient", coeff_diffuse, renderer);
         }
 
         // Specular coeff
         {
             node->GetFloatProperty("material.specularCoefficient", coeff_specular, renderer);
         }
 
         // Specular power
         {
             node->GetFloatProperty("material.specularPower", power_specular, renderer);
         }
 
         property->SetAmbient( coeff_ambient );
         property->SetDiffuse( coeff_diffuse );
         property->SetSpecular( coeff_specular );
         property->SetSpecularPower( power_specular );
 
         property->SetAmbientColor( ambient );
         property->SetDiffuseColor( diffuse );
         property->SetSpecularColor( specular );
     }
 
     // Render mode
     {
         // Opacity
         {
             float opacity = 1.0f;
             if( node->GetOpacity(opacity,renderer) )
                 property->SetOpacity( opacity );
         }
 
         // Wireframe line width
         {
             float lineWidth = 1;
             node->GetFloatProperty("material.wireframeLineWidth", lineWidth, renderer);
             property->SetLineWidth( lineWidth );
         }
 
         // Representation
         {
             mitk::VtkRepresentationProperty::Pointer p;
             node->GetProperty(p, "material.representation", renderer);
             if(p.IsNotNull())
                 property->SetRepresentation( p->GetVtkRepresentation() );
         }
 
         // Interpolation
         {
             mitk::VtkInterpolationProperty::Pointer p;
             node->GetProperty(p, "material.interpolation", renderer);
             if(p.IsNotNull())
                 property->SetInterpolation( p->GetVtkInterpolation() );
         }
     }
 }
 
 
 
 void mitk::SurfaceVtkMapper3D::ApplyAllProperties( mitk::BaseRenderer* renderer, vtkActor* /*actor*/)
 {
     LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
     // Applying shading properties
     Superclass::ApplyColorAndOpacityProperties( renderer, ls->m_Actor ) ;
     // VTK Properties
     ApplyMitkPropertiesToVtkProperty( this->GetDataNode(), ls->m_Actor->GetProperty(), renderer );
     // Shaders
     CoreServicePointer<IShaderRepository> shaderRepo(CoreServices::GetShaderRepository());
     shaderRepo->ApplyProperties(this->GetDataNode(),ls->m_Actor,renderer,ls->m_ShaderTimestampUpdate);
 
     mitk::LookupTableProperty::Pointer lookupTableProp;
     this->GetDataNode()->GetProperty(lookupTableProp, "LookupTable", renderer);
     if (lookupTableProp.IsNotNull() )
     {
         ls->m_VtkPolyDataMapper->SetLookupTable(lookupTableProp->GetLookupTable()->GetVtkLookupTable());
     }
 
     mitk::LevelWindow levelWindow;
     if(this->GetDataNode()->GetLevelWindow(levelWindow, renderer, "levelWindow"))
     {
         ls->m_VtkPolyDataMapper->SetScalarRange(levelWindow.GetLowerWindowBound(),levelWindow.GetUpperWindowBound());
     }
     else
         if(this->GetDataNode()->GetLevelWindow(levelWindow, renderer))
         {
             ls->m_VtkPolyDataMapper->SetScalarRange(levelWindow.GetLowerWindowBound(),levelWindow.GetUpperWindowBound());
         }
 
     bool scalarVisibility = false;
     this->GetDataNode()->GetBoolProperty("scalar visibility", scalarVisibility);
     ls->m_VtkPolyDataMapper->SetScalarVisibility( (scalarVisibility ? 1 : 0) );
 
     if(scalarVisibility)
     {
         mitk::VtkScalarModeProperty* scalarMode;
         if(this->GetDataNode()->GetProperty(scalarMode, "scalar mode", renderer))
         {
             ls->m_VtkPolyDataMapper->SetScalarMode(scalarMode->GetVtkScalarMode());
         }
         else
             ls->m_VtkPolyDataMapper->SetScalarModeToDefault();
 
         bool colorMode = false;
         this->GetDataNode()->GetBoolProperty("color mode", colorMode);
         ls->m_VtkPolyDataMapper->SetColorMode( (colorMode ? 1 : 0) );
 
         float scalarsMin = 0;
         if (dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("ScalarsRangeMinimum")) != NULL)
             scalarsMin = dynamic_cast<mitk::FloatProperty*>(this->GetDataNode()->GetProperty("ScalarsRangeMinimum"))->GetValue();
 
         float scalarsMax = 1.0;
         if (dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("ScalarsRangeMaximum")) != NULL)
             scalarsMax = dynamic_cast<mitk::FloatProperty*>(this->GetDataNode()->GetProperty("ScalarsRangeMaximum"))->GetValue();
 
         ls->m_VtkPolyDataMapper->SetScalarRange(scalarsMin,scalarsMax);
     }
 
     mitk::SmartPointerProperty::Pointer imagetextureProp;
     imagetextureProp = dynamic_cast< mitk::SmartPointerProperty * >(
                 GetDataNode()->GetProperty("Surface.Texture", renderer));
     if(imagetextureProp.IsNotNull())
     {
         mitk::Image* miktTexture = dynamic_cast< mitk::Image* >( imagetextureProp->GetSmartPointer().GetPointer() );
         vtkSmartPointer<vtkTexture> vtkTxture = vtkSmartPointer<vtkTexture>::New();
         //Either select the first slice of a volume
         if(miktTexture->GetDimension(2) > 1)
         {
             MITK_WARN << "3D Textures are not supported by VTK and MITK. The first slice of the volume will be used instead!";
             mitk::ImageSliceSelector::Pointer sliceselector = mitk::ImageSliceSelector::New();
             sliceselector->SetSliceNr(0);
             sliceselector->SetChannelNr(0);
             sliceselector->SetTimeNr(0);
             sliceselector->SetInput(miktTexture);
             sliceselector->Update();
-            vtkTxture->SetInput(sliceselector->GetOutput()->GetVtkImageData());
+            vtkTxture->SetInputData(sliceselector->GetOutput()->GetVtkImageData());
         }
         else //or just use the 2D image
         {
-            vtkTxture->SetInput(miktTexture->GetVtkImageData());
+            vtkTxture->SetInputData(miktTexture->GetVtkImageData());
         }
         //pass the texture to the actor
         ls->m_Actor->SetTexture(vtkTxture);
         if(ls->m_VtkPolyDataMapper->GetInput()->GetPointData()->GetTCoords() == NULL)
         {
             MITK_ERROR << "Surface.Texture property was set, but there are no texture coordinates. Please provide texture coordinates for the vtkPolyData via vtkPolyData->GetPointData()->SetTCoords().";
         }
     }
 
     // deprecated settings
     bool deprecatedUseCellData = false;
     this->GetDataNode()->GetBoolProperty("deprecated useCellDataForColouring", deprecatedUseCellData);
 
     bool deprecatedUsePointData = false;
     this->GetDataNode()->GetBoolProperty("deprecated usePointDataForColouring", deprecatedUsePointData);
 
     if (deprecatedUseCellData)
     {
         ls->m_VtkPolyDataMapper->SetColorModeToDefault();
         ls->m_VtkPolyDataMapper->SetScalarRange(0,255);
         ls->m_VtkPolyDataMapper->ScalarVisibilityOn();
         ls->m_VtkPolyDataMapper->SetScalarModeToUseCellData();
         ls->m_Actor->GetProperty()->SetSpecular (1);
         ls->m_Actor->GetProperty()->SetSpecularPower (50);
         ls->m_Actor->GetProperty()->SetInterpolationToPhong();
     }
     else if (deprecatedUsePointData)
     {
         float scalarsMin = 0;
         if (dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("ScalarsRangeMinimum")) != NULL)
             scalarsMin = dynamic_cast<mitk::FloatProperty*>(this->GetDataNode()->GetProperty("ScalarsRangeMinimum"))->GetValue();
 
         float scalarsMax = 0.1;
         if (dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("ScalarsRangeMaximum")) != NULL)
             scalarsMax = dynamic_cast<mitk::FloatProperty*>(this->GetDataNode()->GetProperty("ScalarsRangeMaximum"))->GetValue();
 
         ls->m_VtkPolyDataMapper->SetScalarRange(scalarsMin,scalarsMax);
         ls->m_VtkPolyDataMapper->SetColorModeToMapScalars();
         ls->m_VtkPolyDataMapper->ScalarVisibilityOn();
         ls->m_Actor->GetProperty()->SetSpecular (1);
         ls->m_Actor->GetProperty()->SetSpecularPower (50);
         ls->m_Actor->GetProperty()->SetInterpolationToPhong();
     }
 
     int deprecatedScalarMode = VTK_COLOR_MODE_DEFAULT;
     if(this->GetDataNode()->GetIntProperty("deprecated scalar mode", deprecatedScalarMode, renderer))
     {
         ls->m_VtkPolyDataMapper->SetScalarMode(deprecatedScalarMode);
         ls->m_VtkPolyDataMapper->ScalarVisibilityOn();
         ls->m_Actor->GetProperty()->SetSpecular (1);
         ls->m_Actor->GetProperty()->SetSpecularPower (50);
         //m_Actor->GetProperty()->SetInterpolationToPhong();
     }
 
 
     // Check whether one or more ClippingProperty objects have been defined for
     // this node. Check both renderer specific and global property lists, since
     // properties in both should be considered.
     const PropertyList::PropertyMap *rendererProperties = this->GetDataNode()->GetPropertyList( renderer )->GetMap();
     const PropertyList::PropertyMap *globalProperties = this->GetDataNode()->GetPropertyList( NULL )->GetMap();
 
     // Add clipping planes (if any)
     ls->m_ClippingPlaneCollection->RemoveAllItems();
 
     PropertyList::PropertyMap::const_iterator it;
     for ( it = rendererProperties->begin(); it != rendererProperties->end(); ++it )
     {
         this->CheckForClippingProperty( renderer,(*it).second.GetPointer() );
     }
 
     for ( it = globalProperties->begin(); it != globalProperties->end(); ++it )
     {
         this->CheckForClippingProperty( renderer,(*it).second.GetPointer() );
     }
 
     if ( ls->m_ClippingPlaneCollection->GetNumberOfItems() > 0 )
     {
         ls->m_VtkPolyDataMapper->SetClippingPlanes( ls->m_ClippingPlaneCollection );
     }
     else
     {
         ls->m_VtkPolyDataMapper->RemoveAllClippingPlanes();
     }
 
 
 }
 
 vtkProp *mitk::SurfaceVtkMapper3D::GetVtkProp(mitk::BaseRenderer *renderer)
 {
     LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
     return ls->m_Actor;
 }
 
 void mitk::SurfaceVtkMapper3D::CheckForClippingProperty( mitk::BaseRenderer* renderer, mitk::BaseProperty *property )
 {
     LocalStorage *ls = m_LSH.GetLocalStorage(renderer);
     //  m_Prop3D = ls->m_Actor;
 
     ClippingProperty *clippingProperty = dynamic_cast< ClippingProperty * >( property );
 
     if ( (clippingProperty != NULL)
          && (clippingProperty->GetClippingEnabled()) )
     {
         const Point3D &origin = clippingProperty->GetOrigin();
         const Vector3D &normal = clippingProperty->GetNormal();
 
         vtkPlane *clippingPlane = vtkPlane::New();
         clippingPlane->SetOrigin( origin[0], origin[1], origin[2] );
         clippingPlane->SetNormal( normal[0], normal[1], normal[2] );
 
         ls->m_ClippingPlaneCollection->AddItem( clippingPlane );
 
         clippingPlane->UnRegister( NULL );
     }
 }
 
 
 void mitk::SurfaceVtkMapper3D::SetDefaultPropertiesForVtkProperty(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
     // Shading
     {
         node->AddProperty( "material.wireframeLineWidth", mitk::FloatProperty::New(1.0f)          , renderer, overwrite );
 
         node->AddProperty( "material.ambientCoefficient" , mitk::FloatProperty::New(0.05f)          , renderer, overwrite );
         node->AddProperty( "material.diffuseCoefficient" , mitk::FloatProperty::New(0.9f)          , renderer, overwrite );
         node->AddProperty( "material.specularCoefficient", mitk::FloatProperty::New(1.0f)          , renderer, overwrite );
         node->AddProperty( "material.specularPower"      , mitk::FloatProperty::New(16.0f)          , renderer, overwrite );
 
         //node->AddProperty( "material.ambientColor"       , mitk::ColorProperty::New(1.0f,1.0f,1.0f), renderer, overwrite );
         //node->AddProperty( "material.diffuseColor"       , mitk::ColorProperty::New(1.0f,1.0f,1.0f), renderer, overwrite );
         //node->AddProperty( "material.specularColor"      , mitk::ColorProperty::New(1.0f,1.0f,1.0f), renderer, overwrite );
 
         node->AddProperty( "material.representation"      , mitk::VtkRepresentationProperty::New()  , renderer, overwrite );
         node->AddProperty( "material.interpolation"       , mitk::VtkInterpolationProperty::New()   , renderer, overwrite );
     }
 
     // Shaders
     CoreServicePointer<IShaderRepository> shaderRepo(CoreServices::GetShaderRepository());
     shaderRepo->AddDefaultProperties(node,renderer,overwrite);
 }
 
 
 void mitk::SurfaceVtkMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
     node->AddProperty( "color", mitk::ColorProperty::New(1.0f,1.0f,1.0f), renderer, overwrite );
     node->AddProperty( "opacity", mitk::FloatProperty::New(1.0), renderer, overwrite );
 
     mitk::SurfaceVtkMapper3D::SetDefaultPropertiesForVtkProperty(node,renderer,overwrite); // Shading
 
     node->AddProperty( "scalar visibility", mitk::BoolProperty::New(false), renderer, overwrite );
     node->AddProperty( "color mode", mitk::BoolProperty::New(false), renderer, overwrite );
     node->AddProperty( "scalar mode", mitk::VtkScalarModeProperty::New(), renderer, overwrite );
     mitk::Surface::Pointer surface = dynamic_cast<Surface*>(node->GetData());
     if(surface.IsNotNull())
     {
         if((surface->GetVtkPolyData() != 0) && (surface->GetVtkPolyData()->GetPointData() != NULL) && (surface->GetVtkPolyData()->GetPointData()->GetScalars() != 0))
         {
             node->AddProperty( "scalar visibility", mitk::BoolProperty::New(true), renderer, overwrite );
             node->AddProperty( "color mode", mitk::BoolProperty::New(true), renderer, overwrite );
         }
     }
 
     // Backface culling
     node->AddProperty( "Backface Culling", mitk::BoolProperty::New(false), renderer, overwrite );
 
     Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
 
 
 void mitk::SurfaceVtkMapper3D::SetImmediateModeRenderingOn(int  /*on*/)
 {
     /*
   if (m_VtkPolyDataMapper != NULL)
     m_VtkPolyDataMapper->SetImmediateModeRendering(on);
 */
 }
diff --git a/Core/Code/Rendering/mitkVolumeDataVtkMapper3D.cpp b/Core/Code/Rendering/mitkVolumeDataVtkMapper3D.cpp
index 22b02a96e2..5a8cb4ea7d 100644
--- a/Core/Code/Rendering/mitkVolumeDataVtkMapper3D.cpp
+++ b/Core/Code/Rendering/mitkVolumeDataVtkMapper3D.cpp
@@ -1,707 +1,705 @@
 /*===================================================================
 
 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 "mitkVolumeDataVtkMapper3D.h"
 
 #include "mitkDataNode.h"
 
 #include "mitkProperties.h"
 #include "mitkLevelWindow.h"
 #include "mitkColorProperty.h"
 #include "mitkLevelWindowProperty.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkTransferFunctionProperty.h"
 #include "mitkTransferFunctionInitializer.h"
 #include "mitkColorProperty.h"
 #include "mitkVtkPropRenderer.h"
 #include "mitkRenderingManager.h"
 
 
 #include <vtkActor.h>
 #include <vtkProperty.h>
 #include <vtkVolumeRayCastMapper.h>
 
 #include <vtkVolumeTextureMapper2D.h>
 #include <vtkVolume.h>
 #include <vtkVolumeProperty.h>
 #include <vtkColorTransferFunction.h>
 #include <vtkPiecewiseFunction.h>
 #include <vtkVolumeRayCastCompositeFunction.h>
 #include <vtkVolumeRayCastMIPFunction.h>
 #include <vtkFiniteDifferenceGradientEstimator.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkImageShiftScale.h>
 #include <vtkImageChangeInformation.h>
 #include <vtkImageWriter.h>
 #include <vtkImageData.h>
 #include <vtkLODProp3D.h>
 #include <vtkImageResample.h>
 #include <vtkPlane.h>
 #include <vtkImplicitPlaneWidget.h>
 #include <vtkAssembly.h>
 
 #include <vtkCubeSource.h>
 #include <vtkPolyDataMapper.h>
 #include "mitkVtkVolumeRenderingProperty.h"
 
 
 #include <itkMultiThreader.h>
 
 const mitk::Image* mitk::VolumeDataVtkMapper3D::GetInput()
 {
   return static_cast<const mitk::Image*> ( GetDataNode()->GetData() );
 }
 
 mitk::VolumeDataVtkMapper3D::VolumeDataVtkMapper3D()
 : m_Mask( NULL )
 {
   m_PlaneSet = false;
 
   m_ClippingPlane = vtkPlane::New();
   m_PlaneWidget = vtkImplicitPlaneWidget::New();
 
   /*
   m_T2DMapper =  vtkVolumeTextureMapper2D::New();
   m_T2DMapper->SetMaximumNumberOfPlanes( 100 );
 */
   m_HiResMapper = vtkVolumeRayCastMapper::New();
   m_HiResMapper->SetSampleDistance(1.0); // 4 rays for every pixel
 
   m_HiResMapper->IntermixIntersectingGeometryOn();
   m_HiResMapper->SetNumberOfThreads( itk::MultiThreader::GetGlobalDefaultNumberOfThreads() );
   /*
   vtkVolumeRayCastCompositeFunction* compositeFunction = vtkVolumeRayCastCompositeFunction::New();
   compositeFunction->SetCompositeMethodToClassifyFirst();
   m_HiResMapper->SetVolumeRayCastFunction(compositeFunction);
   compositeFunction->Delete();
 
   vtkVolumeRayCastMIPFunction* mipFunction = vtkVolumeRayCastMIPFunction::New();
   m_HiResMapper->SetVolumeRayCastFunction(mipFunction);
   mipFunction->Delete();
  */
 
   vtkFiniteDifferenceGradientEstimator* gradientEstimator =
   vtkFiniteDifferenceGradientEstimator::New();
   m_HiResMapper->SetGradientEstimator(gradientEstimator);
   gradientEstimator->Delete();
 
   m_VolumePropertyLow = vtkVolumeProperty::New();
   m_VolumePropertyMed = vtkVolumeProperty::New();
   m_VolumePropertyHigh = vtkVolumeProperty::New();
 
   m_VolumeLOD = vtkLODProp3D::New();
   m_VolumeLOD->VisibilityOff();
 
   m_HiResID = m_VolumeLOD->AddLOD(m_HiResMapper,m_VolumePropertyHigh,0.0); // RayCast
 
 //  m_LowResID = m_VolumeLOD->AddLOD(m_T2DMapper,m_VolumePropertyLow,0.0); // TextureMapper2D
 
 
   m_MedResID = m_VolumeLOD->AddLOD(m_HiResMapper,m_VolumePropertyMed,0.0); // RayCast
 
 
   m_Resampler = vtkImageResample::New();
   m_Resampler->SetAxisMagnificationFactor(0,0.25);
   m_Resampler->SetAxisMagnificationFactor(1,0.25);
   m_Resampler->SetAxisMagnificationFactor(2,0.25);
 
   // For abort rendering mechanism
   m_VolumeLOD->AutomaticLODSelectionOff();
 
 
   m_BoundingBox = vtkCubeSource::New();
   m_BoundingBox->SetXLength( 0.0 );
   m_BoundingBox->SetYLength( 0.0 );
   m_BoundingBox->SetZLength( 0.0 );
 
   m_BoundingBoxMapper = vtkPolyDataMapper::New();
-  m_BoundingBoxMapper->SetInput( m_BoundingBox->GetOutput() );
+  m_BoundingBoxMapper->SetInputData( m_BoundingBox->GetOutput() );
 
   m_BoundingBoxActor = vtkActor::New();
   m_BoundingBoxActor->SetMapper( m_BoundingBoxMapper );
   m_BoundingBoxActor->GetProperty()->SetColor( 1.0, 1.0, 1.0 );
   m_BoundingBoxActor->GetProperty()->SetRepresentationToWireframe();
 
 
   // BoundingBox rendering is not working due to problem with assembly
   // transformation; see bug #454
   // If commenting in the following, do not forget to comment in the
   // m_Prop3DAssembly->Delete() line in the destructor.
   //m_Prop3DAssembly = vtkAssembly::New();
   //m_Prop3DAssembly->AddPart( m_VolumeLOD );
   //m_Prop3DAssembly->AddPart( m_BoundingBoxActor );
   //m_Prop3D = m_Prop3DAssembly;
 
   m_ImageCast = vtkImageShiftScale::New();
   m_ImageCast->SetOutputScalarTypeToUnsignedShort();
   m_ImageCast->ClampOverflowOn();
 
   m_UnitSpacingImageFilter = vtkImageChangeInformation::New();
-  m_UnitSpacingImageFilter->SetInput(m_ImageCast->GetOutput());
+  m_UnitSpacingImageFilter->SetInputData(m_ImageCast->GetOutput());
   m_UnitSpacingImageFilter->SetOutputSpacing( 1.0, 1.0, 1.0 );
 
   m_ImageMaskFilter = vtkImageMask::New();
   m_ImageMaskFilter->SetMaskedOutputValue(0xffff);
 
-  this->m_Resampler->SetInput( this->m_UnitSpacingImageFilter->GetOutput() );
-  this->m_HiResMapper->SetInput( this->m_UnitSpacingImageFilter->GetOutput() );
+  this->m_Resampler->SetInputData( this->m_UnitSpacingImageFilter->GetOutput() );
+  this->m_HiResMapper->SetInputData( this->m_UnitSpacingImageFilter->GetOutput() );
 
 //  m_T2DMapper->SetInput(m_Resampler->GetOutput());
 
 
   this->CreateDefaultTransferFunctions();
 }
 
 vtkProp *mitk::VolumeDataVtkMapper3D::GetVtkProp(mitk::BaseRenderer * /*renderer*/)
 {
   return m_VolumeLOD;
 }
 
 mitk::VolumeDataVtkMapper3D::~VolumeDataVtkMapper3D()
 {
   m_UnitSpacingImageFilter->Delete();
   m_ImageCast->Delete();
 //  m_T2DMapper->Delete();
   m_HiResMapper->Delete();
   m_Resampler->Delete();
   m_VolumePropertyLow->Delete();
   m_VolumePropertyMed->Delete();
   m_VolumePropertyHigh->Delete();
   m_VolumeLOD->Delete();
   m_ClippingPlane->Delete();
   m_PlaneWidget->Delete();
   // m_Prop3DAssembly->Delete();
   m_BoundingBox->Delete();
   m_BoundingBoxMapper->Delete();
   m_BoundingBoxActor->Delete();
   m_ImageMaskFilter->Delete();
   m_DefaultColorTransferFunction->Delete();
   m_DefaultOpacityTransferFunction->Delete();
   m_DefaultGradientTransferFunction->Delete();
 
   if (m_Mask)
   {
     m_Mask->Delete();
   }
 }
 
 void mitk::VolumeDataVtkMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer )
 {
   SetVtkMapperImmediateModeRendering(m_BoundingBoxMapper);
 
   mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() );
   if ( !input || !input->IsInitialized() )
     return;
 
   vtkRenderWindow* renderWindow = renderer->GetRenderWindow();
 
   bool volumeRenderingEnabled = true;
 
   bool visible = true;
 
   GetDataNode()->GetVisibility(visible, renderer, "visible");
 
   if ( !visible ||
       this->GetDataNode() == NULL ||
       dynamic_cast<mitk::BoolProperty*>(GetDataNode()->GetProperty("volumerendering",renderer))==NULL ||
       dynamic_cast<mitk::BoolProperty*>(GetDataNode()->GetProperty("volumerendering",renderer))->GetValue() == false
     )
   {
     volumeRenderingEnabled = false;
 
     // Check if a bounding box should be displayed around the dataset
     // (even if volume rendering is disabled)
     bool hasBoundingBox = false;
     this->GetDataNode()->GetBoolProperty( "bounding box", hasBoundingBox );
 
     if ( !hasBoundingBox )
     {
       m_BoundingBoxActor->VisibilityOff();
     }
     else
     {
       m_BoundingBoxActor->VisibilityOn();
 
       const BoundingBox::BoundsArrayType &bounds =
         input->GetTimeGeometry()->GetBoundsInWorld();
 
       m_BoundingBox->SetBounds(
         bounds[0], bounds[1],
         bounds[2], bounds[3],
         bounds[4], bounds[5] );
 
       ColorProperty *colorProperty;
       if ( this->GetDataNode()->GetProperty(
         colorProperty, "color" ) )
       {
         const mitk::Color &color = colorProperty->GetColor();
         m_BoundingBoxActor->GetProperty()->SetColor(
           color[0], color[1], color[2] );
       }
       else
       {
         m_BoundingBoxActor->GetProperty()->SetColor(
           1.0, 1.0, 1.0 );
       }
     }
   }
 
   // Don't do anything if VR is disabled
   if ( !volumeRenderingEnabled )
   {
     m_VolumeLOD->VisibilityOff();
     return;
   }
   else
   {
         mitk::VtkVolumeRenderingProperty* vrp=dynamic_cast<mitk::VtkVolumeRenderingProperty*>(GetDataNode()->GetProperty("volumerendering configuration",renderer));
         if(vrp)
         {
           int renderingValue = vrp->GetValueAsId();
 
           switch(renderingValue)
           {
               case  VTK_VOLUME_RAY_CAST_MIP_FUNCTION:
               {
                   vtkVolumeRayCastMIPFunction* mipFunction = vtkVolumeRayCastMIPFunction::New();
                   m_HiResMapper->SetVolumeRayCastFunction(mipFunction);
                   mipFunction->Delete();
                   MITK_INFO <<"in switch" <<std::endl;
                   break;
               }
 
               case VTK_RAY_CAST_COMPOSITE_FUNCTION:
               {
                   vtkVolumeRayCastCompositeFunction* compositeFunction = vtkVolumeRayCastCompositeFunction::New();
                   compositeFunction->SetCompositeMethodToClassifyFirst();
                   m_HiResMapper->SetVolumeRayCastFunction(compositeFunction);
                   compositeFunction->Delete();
                   break;
               }
               default:
                   MITK_ERROR <<"Warning: invalid volume rendering option.  " << std::endl;
 
           }
         }
     m_VolumeLOD->VisibilityOn();
   }
 
   this->SetPreferences();
 /*
   switch ( mitk::RenderingManager::GetInstance()->GetNextLOD( renderer ) )
   {
   case 0:
     m_VolumeLOD->SetSelectedLODID(m_MedResID);  m_LowResID );
     break;
 
   default:
   case 1:
     m_VolumeLOD->SetSelectedLODID( m_HiResID );
     break;
   }
 */
   m_VolumeLOD->SetSelectedLODID( m_HiResID );
 
   assert(input->GetTimeGeometry());
 
   const Geometry3D* worldgeometry = renderer->GetCurrentWorldGeometry();
   if(worldgeometry==NULL)
   {
     GetDataNode()->SetProperty("volumerendering",mitk::BoolProperty::New(false));
     return;
   }
 
   vtkImageData *inputData = input->GetVtkImageData( this->GetTimestep() );
   if(inputData==NULL)
     return;
 
 
-  m_ImageCast->SetInput( inputData );
+  m_ImageCast->SetInputData( inputData );
 
   //If mask exists, process mask before resampling.
   if (this->m_Mask)
   {
-    this->m_ImageMaskFilter->SetImageInput(this->m_UnitSpacingImageFilter->GetOutput());
-    this->m_Resampler->SetInput(this->m_ImageMaskFilter->GetOutput());
-    this->m_HiResMapper->SetInput(this->m_ImageMaskFilter->GetOutput());
+    this->m_ImageMaskFilter->SetImageInputData(this->m_UnitSpacingImageFilter->GetOutput());
+    this->m_Resampler->SetInputData(this->m_ImageMaskFilter->GetOutput());
+    this->m_HiResMapper->SetInputData(this->m_ImageMaskFilter->GetOutput());
   }
   else
   {
-    this->m_Resampler->SetInput(this->m_UnitSpacingImageFilter->GetOutput());
-    this->m_HiResMapper->SetInput(this->m_UnitSpacingImageFilter->GetOutput());
+    this->m_Resampler->SetInputData(this->m_UnitSpacingImageFilter->GetOutput());
+    this->m_HiResMapper->SetInputData(this->m_UnitSpacingImageFilter->GetOutput());
   }
 
   this->UpdateTransferFunctions( renderer );
 
   vtkRenderWindowInteractor *interactor = renderWindow->GetInteractor();
 
   float frameRate;
   if( this->GetDataNode()->GetFloatProperty( "framerate", frameRate ) && frameRate > 0 && frameRate <= 60)
   {
     interactor->SetDesiredUpdateRate(  frameRate );
     interactor->SetStillUpdateRate( frameRate );
   }
   else if( frameRate > 60 )
   {
     this->GetDataNode()->SetProperty( "framerate",mitk::FloatProperty::New(60));
     interactor->SetDesiredUpdateRate(  60 );
     interactor->SetStillUpdateRate( 60 );
   }
   else
   {
     this->GetDataNode()->SetProperty( "framerate",mitk::FloatProperty::New(0.00001));
     interactor->SetDesiredUpdateRate(  0.00001 );
     interactor->SetStillUpdateRate( 0.00001 );
   }
 
   if ( m_RenderWindowInitialized.find( renderWindow ) == m_RenderWindowInitialized.end() )
   {
     m_RenderWindowInitialized.insert( renderWindow );
 
 //    mitk::RenderingManager::GetInstance()->SetNextLOD( 0, renderer );
 
     mitk::RenderingManager::GetInstance()->SetShading( true, 0 );
     mitk::RenderingManager::GetInstance()->SetShading( true, 1 );
     //mitk::RenderingManager::GetInstance()->SetShading( true, 2 );
 
     mitk::RenderingManager::GetInstance()->SetShadingValues(
       m_VolumePropertyHigh->GetAmbient(),
       m_VolumePropertyHigh->GetDiffuse(),
       m_VolumePropertyHigh->GetSpecular(),
       m_VolumePropertyHigh->GetSpecularPower());
 
     mitk::RenderingManager::GetInstance()->SetClippingPlaneStatus(false);
   }
 
   this->SetClippingPlane( interactor );
 }
 
 
 void mitk::VolumeDataVtkMapper3D::CreateDefaultTransferFunctions()
 {
   m_DefaultOpacityTransferFunction = vtkPiecewiseFunction::New();
   m_DefaultOpacityTransferFunction->AddPoint( 0.0, 0.0 );
   m_DefaultOpacityTransferFunction->AddPoint( 255.0, 0.8 );
   m_DefaultOpacityTransferFunction->ClampingOn();
 
   m_DefaultGradientTransferFunction = vtkPiecewiseFunction::New();
   m_DefaultGradientTransferFunction->AddPoint( 0.0, 0.0 );
   m_DefaultGradientTransferFunction->AddPoint( 255.0, 0.8 );
   m_DefaultGradientTransferFunction->ClampingOn();
 
   m_DefaultColorTransferFunction = vtkColorTransferFunction::New();
   m_DefaultColorTransferFunction->AddRGBPoint( 0.0, 0.0, 0.0, 0.0 );
   m_DefaultColorTransferFunction->AddRGBPoint( 127.5, 1, 1, 0.0 );
   m_DefaultColorTransferFunction->AddRGBPoint( 255.0, 0.8, 0.2, 0 );
   m_DefaultColorTransferFunction->ClampingOn();
 }
 
 void mitk::VolumeDataVtkMapper3D::UpdateTransferFunctions( mitk::BaseRenderer *renderer )
 {
   vtkPiecewiseFunction *opacityTransferFunction = NULL;
   vtkPiecewiseFunction *gradientTransferFunction = NULL;
   vtkColorTransferFunction *colorTransferFunction = NULL;
 
   mitk::LookupTableProperty::Pointer lookupTableProp;
   lookupTableProp = dynamic_cast<mitk::LookupTableProperty*>(this->GetDataNode()->GetProperty("LookupTable"));
   mitk::TransferFunctionProperty::Pointer transferFunctionProp = dynamic_cast<mitk::TransferFunctionProperty*>(this->GetDataNode()->GetProperty("TransferFunction"));
 
   if ( transferFunctionProp.IsNotNull() )   {
 
     opacityTransferFunction = transferFunctionProp->GetValue()->GetScalarOpacityFunction();
     gradientTransferFunction = transferFunctionProp->GetValue()->GetGradientOpacityFunction();
     colorTransferFunction = transferFunctionProp->GetValue()->GetColorTransferFunction();
   }
   else if (lookupTableProp.IsNotNull() )
   {
     lookupTableProp->GetLookupTable()->CreateOpacityTransferFunction(opacityTransferFunction);
     opacityTransferFunction->ClampingOn();
     lookupTableProp->GetLookupTable()->CreateGradientTransferFunction(gradientTransferFunction);
     gradientTransferFunction->ClampingOn();
     lookupTableProp->GetLookupTable()->CreateColorTransferFunction(colorTransferFunction);
     colorTransferFunction->ClampingOn();
   }
   else
   {
     opacityTransferFunction = m_DefaultOpacityTransferFunction;
     gradientTransferFunction = m_DefaultGradientTransferFunction;
     colorTransferFunction = m_DefaultColorTransferFunction;
 
     float rgb[3]={1.0f,1.0f,1.0f};
     // check for color prop and use it for rendering if it exists
     if(GetDataNode()->GetColor(rgb, renderer, "color"))
     {
       colorTransferFunction->AddRGBPoint( 0.0, 0.0, 0.0, 0.0 );
       colorTransferFunction->AddRGBPoint( 127.5, rgb[0], rgb[1], rgb[2] );
       colorTransferFunction->AddRGBPoint( 255.0, rgb[0], rgb[1], rgb[2] );
     }
   }
 
   if (this->m_Mask)
   {
     opacityTransferFunction->AddPoint(0xffff, 0.0);
   }
 
   m_VolumePropertyLow->SetColor( colorTransferFunction );
   m_VolumePropertyLow->SetScalarOpacity( opacityTransferFunction );
   m_VolumePropertyLow->SetGradientOpacity( gradientTransferFunction );
   m_VolumePropertyLow->SetInterpolationTypeToNearest();
 
   m_VolumePropertyMed->SetColor( colorTransferFunction );
   m_VolumePropertyMed->SetScalarOpacity( opacityTransferFunction );
   m_VolumePropertyMed->SetGradientOpacity( gradientTransferFunction );
   m_VolumePropertyMed->SetInterpolationTypeToNearest();
 
   m_VolumePropertyHigh->SetColor( colorTransferFunction );
   m_VolumePropertyHigh->SetScalarOpacity( opacityTransferFunction );
   m_VolumePropertyHigh->SetGradientOpacity( gradientTransferFunction );
   m_VolumePropertyHigh->SetInterpolationTypeToLinear();
 }
 
 
 /* Shading enabled / disabled */
 void mitk::VolumeDataVtkMapper3D::SetPreferences()
 {
   //LOD 0
   /*if(mitk::RenderingManager::GetInstance()->GetShading(0))
   {
     m_VolumePropertyLow->ShadeOn();
     m_VolumePropertyLow->SetAmbient(mitk::RenderingManager::GetInstance()->GetShadingValues()[0]);
     m_VolumePropertyLow->SetDiffuse(mitk::RenderingManager::GetInstance()->GetShadingValues()[1]);
     m_VolumePropertyLow->SetSpecular(mitk::RenderingManager::GetInstance()->GetShadingValues()[2]);
     m_VolumePropertyLow->SetSpecularPower(mitk::RenderingManager::GetInstance()->GetShadingValues()[3]);
   }
   else*/
   {
     m_VolumePropertyLow->ShadeOff();
   }
 
   //LOD 1
   /*if(mitk::RenderingManager::GetInstance()->GetShading(1))
   {
     m_VolumePropertyMed->ShadeOn();
     m_VolumePropertyMed->SetAmbient(mitk::RenderingManager::GetInstance()->GetShadingValues()[0]);
     m_VolumePropertyMed->SetDiffuse(mitk::RenderingManager::GetInstance()->GetShadingValues()[1]);
     m_VolumePropertyMed->SetSpecular(mitk::RenderingManager::GetInstance()->GetShadingValues()[2]);
     m_VolumePropertyMed->SetSpecularPower(mitk::RenderingManager::GetInstance()->GetShadingValues()[3]);
   }
   else*/
   {
     m_VolumePropertyMed->ShadeOff();
   }
 
   //LOD 2
   /*
   if(mitk::RenderingManager::GetInstance()->GetShading(2))
   {
     m_VolumePropertyHigh->ShadeOn();
     //Shading Properties
     m_VolumePropertyHigh->SetAmbient(mitk::RenderingManager::GetInstance()->GetShadingValues()[0]);
     m_VolumePropertyHigh->SetDiffuse(mitk::RenderingManager::GetInstance()->GetShadingValues()[1]);
     m_VolumePropertyHigh->SetSpecular(mitk::RenderingManager::GetInstance()->GetShadingValues()[2]);
     m_VolumePropertyHigh->SetSpecularPower(mitk::RenderingManager::GetInstance()->GetShadingValues()[3]);
   }
   else
   {
     m_VolumePropertyHigh->ShadeOff();
   }
   */
 
 }
 
 /* Adds A Clipping Plane to the Mapper */
 void mitk::VolumeDataVtkMapper3D::SetClippingPlane(vtkRenderWindowInteractor* interactor)
 {
 
   if(mitk::RenderingManager::GetInstance()->GetClippingPlaneStatus()) //if clipping plane is enabled
   {
 
     if(!m_PlaneSet)
     {
     m_PlaneWidget->SetInteractor(interactor);
     m_PlaneWidget->SetPlaceFactor(1.0);
-    m_PlaneWidget->SetInput(m_UnitSpacingImageFilter->GetOutput());
+    m_PlaneWidget->SetInputData(m_UnitSpacingImageFilter->GetOutput());
     m_PlaneWidget->OutlineTranslationOff(); //disables scaling of the bounding box
     m_PlaneWidget->ScaleEnabledOff(); //disables scaling of the bounding box
     m_PlaneWidget->DrawPlaneOff(); //clipping plane is transparent
     mitk::Image* input  = const_cast<mitk::Image *>(this->GetInput());
 
     /*places the widget within the specified bounds*/
     m_PlaneWidget->PlaceWidget(
         input->GetGeometry()->GetOrigin()[0],(input->GetGeometry()->GetOrigin()[0])+(input->GetDimension(0))*(input->GetVtkImageData()->GetSpacing()[0]),                               input->GetGeometry()->GetOrigin()[1],(input->GetGeometry()->GetOrigin()[1])+(input->GetDimension(1))*(input->GetVtkImageData()->GetSpacing()[1]),                               input->GetGeometry()->GetOrigin()[2],(input->GetGeometry()->GetOrigin()[2])+(input->GetDimension(2))*(input->GetVtkImageData()->GetSpacing()[2]));
 
 //    m_T2DMapper->AddClippingPlane(m_ClippingPlane);
     m_HiResMapper->AddClippingPlane(m_ClippingPlane);
     }
 
     m_PlaneWidget->GetPlane(m_ClippingPlane);
     m_PlaneSet = true;
   }
   else //if clippingplane is disabled
   {
     if(m_PlaneSet) //if plane exists
     {
     DelClippingPlane();
     }
   }
 
 }
 
 
 /* Removes the clipping plane */
 void mitk::VolumeDataVtkMapper3D::DelClippingPlane()
 {
 //  m_T2DMapper->RemoveAllClippingPlanes();
   m_HiResMapper->RemoveAllClippingPlanes();
   m_PlaneSet = false;
 }
 
 
 void mitk::VolumeDataVtkMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite)
 {
   node->AddProperty( "volumerendering", mitk::BoolProperty::New( false ), renderer, overwrite );
   node->AddProperty( "volumerendering configuration", mitk::VtkVolumeRenderingProperty::New( 1 ), renderer, overwrite );
   node->AddProperty( "binary", mitk::BoolProperty::New( false ), renderer, overwrite );
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if(image.IsNotNull() && image->IsInitialized())
   {
     if((overwrite) || (node->GetProperty("levelwindow", renderer)==NULL))
     {
       mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
       mitk::LevelWindow levelwindow;
       levelwindow.SetAuto( image );
       levWinProp->SetLevelWindow( levelwindow );
       node->SetProperty( "levelwindow", levWinProp, renderer );
     }
     //This mapper used to set a default lut "LookupTable" for images. However, this will
     //overwrite the default lut of the 2D image mapper. Thus, this property here is renamed.
     /*
     if((overwrite) || (node->GetProperty("Volume.LookupTable", renderer)==NULL))
     {
       // add a default rainbow lookup table for color mapping
       mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New();
       vtkLookupTable* vtkLut = mitkLut->GetVtkLookupTable();
       vtkLut->SetHueRange(0.6667, 0.0);
       vtkLut->SetTableRange(0.0, 20.0);
       vtkLut->Build();
       mitk::LookupTableProperty::Pointer mitkLutProp = mitk::LookupTableProperty::New();
       mitkLutProp->SetLookupTable(mitkLut);
       node->SetProperty( "Volume.LookupTable", mitkLutProp );
     }*/
     if((overwrite) || (node->GetProperty("TransferFunction", renderer)==NULL))
     {
       // add a default transfer function
       mitk::TransferFunction::Pointer tf = mitk::TransferFunction::New();
       mitk::TransferFunctionInitializer::Pointer tfInit = mitk::TransferFunctionInitializer::New(tf);
       tfInit->SetTransferFunctionMode(0);
       node->SetProperty ( "TransferFunction", mitk::TransferFunctionProperty::New ( tf.GetPointer() ) );
     }
   }
 
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
 
 
 bool mitk::VolumeDataVtkMapper3D::IsLODEnabled( mitk::BaseRenderer * /*renderer*/ ) const
 {
   return false;
 
 
   // Volume mapper is LOD enabled if volumerendering is enabled
   /*
   return
     dynamic_cast<mitk::BoolProperty*>(GetDataNode()->GetProperty("volumerendering",renderer)) != NULL &&
     dynamic_cast<mitk::BoolProperty*>(GetDataNode()->GetProperty("volumerendering",renderer))->GetValue() == true;
   */
 }
 
 
 void mitk::VolumeDataVtkMapper3D::EnableMask()
 {
   if (!this->m_Mask)
   {
     const Image *orig_image = this->GetInput();
     unsigned int *dimensions = orig_image->GetDimensions();
 
     this->m_Mask = vtkImageData::New();
     this->m_Mask->SetDimensions(dimensions[0], dimensions[1], dimensions[2]);
-    this->m_Mask->SetScalarTypeToUnsignedChar();
-    this->m_Mask->SetNumberOfScalarComponents(1);
-    this->m_Mask->AllocateScalars();
+    this->m_Mask->AllocateScalars(VTK_UNSIGNED_CHAR,1);
 
     unsigned char *mask_data = static_cast<unsigned char*>(this->m_Mask->GetScalarPointer());
     unsigned int size = dimensions[0] * dimensions[1] * dimensions[2];
 
     for (unsigned int i = 0u; i < size; ++i)
     {
       *mask_data++ = 1u;
     }
-    this->m_ImageMaskFilter->SetMaskInput(this->m_Mask);
+    this->m_ImageMaskFilter->SetMaskInputData(this->m_Mask);
     this->m_ImageMaskFilter->Modified();
   }
 }
 
 void mitk::VolumeDataVtkMapper3D::DisableMask()
 {
   if (this->m_Mask)
   {
     this->m_Mask->Delete();
     this->m_Mask = 0;
   }
 }
 
 mitk::Image::Pointer mitk::VolumeDataVtkMapper3D::GetMask()
 {
   if (this->m_Mask)
   {
     Image::Pointer mask = Image::New();
 
     mask->Initialize(this->m_Mask);
     mask->SetImportVolume(this->m_Mask->GetScalarPointer(), 0, 0, Image::ReferenceMemory);
     mask->SetGeometry(this->GetInput()->GetGeometry());
     return mask;
   }
 
   return 0;
 }
 
 void mitk::VolumeDataVtkMapper3D::UpdateMask()
 {
   if (this->m_Mask)
   {
     this->m_ImageMaskFilter->Modified();
   }
 }
 
 bool mitk::VolumeDataVtkMapper3D::SetMask(const mitk::Image* mask)
 {
   if (this->m_Mask)
   {
     if ( (mask->GetPixelType().GetComponentType() == itk::ImageIOBase::UCHAR)
          &&(mask->GetPixelType().GetPixelType() == itk::ImageIOBase::SCALAR ))
     {
       Image *img = const_cast<Image*>(mask);
 
       this->m_Mask->DeepCopy(img->GetVtkImageData());
       this->m_ImageMaskFilter->Modified();
       return true;
     }
   }
 
   return false;
 }