diff --git a/Core/Code/Algorithms/mitkExtractSliceFilter.cpp b/Core/Code/Algorithms/mitkExtractSliceFilter.cpp
index d2e87f977d..718625e5b9 100644
--- a/Core/Code/Algorithms/mitkExtractSliceFilter.cpp
+++ b/Core/Code/Algorithms/mitkExtractSliceFilter.cpp
@@ -1,486 +1,486 @@
 /*===================================================================
 
 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 "mitkExtractSliceFilter.h"
 #include <vtkImageData.h>
 #include <vtkSmartPointer.h>
 #include <vtkLinearTransform.h>
 #include <vtkImageChangeInformation.h>
 #include <mitkAbstractTransformGeometry.h>
 #include <vtkGeneralTransform.h>
 #include <mitkPlaneClipping.h>
 
 mitk::ExtractSliceFilter::ExtractSliceFilter(vtkImageReslice* reslicer ){
 
   if(reslicer == NULL){
     m_Reslicer = vtkSmartPointer<vtkImageReslice>::New();
   }
   else
   {
     m_Reslicer = reslicer;
   }
 
   m_TimeStep = 0;
   m_Reslicer->ReleaseDataFlagOn();
   m_InterpolationMode = ExtractSliceFilter::RESLICE_NEAREST;
   m_ResliceTransform = NULL;
   m_InPlaneResampleExtentByGeometry = false;
   m_OutPutSpacing = new mitk::ScalarType[2];
   m_OutputDimension = 2;
   m_ZSpacing = 1.0;
   m_ZMin = 0;
   m_ZMax = 0;
   m_VtkOutputRequested = false;
 
 }
 
 mitk::ExtractSliceFilter::~ExtractSliceFilter(){
   m_ResliceTransform = NULL;
   m_WorldGeometry = NULL;
   delete [] m_OutPutSpacing;
 }
 
 void mitk::ExtractSliceFilter::GenerateOutputInformation(){
   Superclass::GenerateOutputInformation();
   //TODO try figure out how to set the specs of the slice before it is actually extracted
   /*Image::Pointer output = this->GetOutput();
   Image::ConstPointer input = this->GetInput();
   if (input.IsNull()) return;
   unsigned int dimensions[2];
   dimensions[0] = m_WorldGeometry->GetExtent(0);
   dimensions[1] = m_WorldGeometry->GetExtent(1);
   output->Initialize(input->GetPixelType(), 2, dimensions, 1);*/
 }
 
 void mitk::ExtractSliceFilter::GenerateInputRequestedRegion(){
   //As we want all pixel information fo the image in our plane, the requested region
   //is set to the largest possible region in the image.
   //This is needed because an oblique plane has a larger extent then the image
   //and the in pipeline it is checked via PropagateResquestedRegion(). But the
   //extent of the slice is actually fitting because it is oblique within the image.
   ImageToImageFilter::InputImagePointer input =  const_cast< ImageToImageFilter::InputImageType* > ( this->GetInput() );
   input->SetRequestedRegionToLargestPossibleRegion();
 }
 
 
 mitk::ScalarType* mitk::ExtractSliceFilter::GetOutputSpacing(){
   return m_OutPutSpacing;
 }
 
 
 void mitk::ExtractSliceFilter::GenerateData(){
 
   mitk::Image *input = const_cast< mitk::Image * >( this->GetInput() );
 
   if (!input)
   {
     MITK_ERROR << "mitk::ExtractSliceFilter: No input image available. Please set the input!" << std::endl;
     itkExceptionMacro("mitk::ExtractSliceFilter: No input image available. Please set the input!");
     return;
   }
 
   if(!m_WorldGeometry)
   {
     MITK_ERROR << "mitk::ExtractSliceFilter: No Geometry for reslicing available." << std::endl;
     itkExceptionMacro("mitk::ExtractSliceFilter: No Geometry for reslicing available.");
     return;
   }
 
 
   const TimeGeometry* inputTimeGeometry = this->GetInput()->GetTimeGeometry();
   if ( ( inputTimeGeometry == NULL )
     || ( inputTimeGeometry->CountTimeSteps() <= 0 ) )
   {
     itkWarningMacro(<<"Error reading input image TimeGeometry.");
     return;
   }
 
   // is it a valid timeStep?
   if ( inputTimeGeometry->IsValidTimeStep( m_TimeStep ) == false )
   {
     itkWarningMacro(<<"This is not a valid timestep: "<< m_TimeStep );
     return;
   }
 
   // check if there is something to display.
   if ( ! input->IsVolumeSet( m_TimeStep ) )
   {
     itkWarningMacro(<<"No volume data existent at given timestep "<< m_TimeStep );
     return;
   }
 
 
 
 
   /*================#BEGIN setup vtkImageRslice properties================*/
   Point3D origin;
   Vector3D right, bottom, normal;
   double widthInMM, heightInMM;
   Vector2D extent;
 
 
   const PlaneGeometry* planeGeometry = dynamic_cast<const PlaneGeometry*>(m_WorldGeometry);
 
 
   if ( planeGeometry != NULL )
   {
     //if the worldGeomatry is a PlaneGeometry everthing is straight forward
 
     origin = planeGeometry->GetOrigin();
     right  = planeGeometry->GetAxisVector( 0 );
     bottom = planeGeometry->GetAxisVector( 1 );
     normal = planeGeometry->GetNormal();
 
     if ( m_InPlaneResampleExtentByGeometry )
     {
       // Resampling grid corresponds to the current world geometry. This
       // means that the spacing of the output 2D image depends on the
       // currently selected world geometry, and *not* on the image itself.
       extent[0] = m_WorldGeometry->GetExtent( 0 );
       extent[1] = m_WorldGeometry->GetExtent( 1 );
     }
     else
     {
       // Resampling grid corresponds to the input geometry. This means that
       // the spacing of the output 2D image is directly derived from the
       // associated input image, regardless of the currently selected world
       // geometry.
       Vector3D rightInIndex, bottomInIndex;
       inputTimeGeometry->GetGeometryForTimeStep( m_TimeStep )->WorldToIndex( right, rightInIndex );
       inputTimeGeometry->GetGeometryForTimeStep( m_TimeStep )->WorldToIndex( bottom, bottomInIndex );
       extent[0] = rightInIndex.GetNorm();
       extent[1] = bottomInIndex.GetNorm();
     }
 
     // Get the extent of the current world geometry and calculate resampling
     // spacing therefrom.
     widthInMM = m_WorldGeometry->GetExtentInMM( 0 );
     heightInMM = m_WorldGeometry->GetExtentInMM( 1 );
 
 
     m_OutPutSpacing[0] = widthInMM / extent[0];
     m_OutPutSpacing[1] = heightInMM / extent[1];
 
 
     right.Normalize();
     bottom.Normalize();
     normal.Normalize();
 
 
     /*
     * Transform the origin to center based coordinates.
     * Note:
     * This is needed besause vtk's origin is center based too (!!!) ( see 'The VTK book' page 88 )
     * and the worldGeometry surrouding the image is no imageGeometry. So the worldGeometry
     * has its origin at the corner of the voxel and needs to be transformed.
     */
     origin += right * ( m_OutPutSpacing[0] * 0.5 );
     origin += bottom * ( m_OutPutSpacing[1] * 0.5 );
 
 
 
     //set the tranform for reslicing.
     // Use inverse transform of the input geometry for reslicing the 3D image.
     // This is needed if the image volume already transformed
     if(m_ResliceTransform.IsNotNull())
       m_Reslicer->SetResliceTransform(m_ResliceTransform->GetVtkTransform()->GetLinearInverse());
 
 
     // Set background level to TRANSLUCENT (see Geometry2DDataVtkMapper3D),
     // else the background of the image turns out gray
     m_Reslicer->SetBackgroundLevel( -32768 );
 
   }
   else{
     //Code for curved planes, mostly taken 1:1 from imageVtkMapper2D and not tested yet.
     // Do we have an AbstractTransformGeometry?
     // This is the case for AbstractTransformGeometry's (e.g. a ThinPlateSplineCurvedGeometry )
     const mitk::AbstractTransformGeometry* abstractGeometry =
       dynamic_cast< const AbstractTransformGeometry * >(m_WorldGeometry);
 
     if(abstractGeometry != NULL)
     {
       m_ResliceTransform = abstractGeometry;
 
       extent[0] = abstractGeometry->GetParametricExtent(0);
       extent[1] = abstractGeometry->GetParametricExtent(1);
 
       widthInMM = abstractGeometry->GetParametricExtentInMM(0);
       heightInMM = abstractGeometry->GetParametricExtentInMM(1);
 
       m_OutPutSpacing[0] = widthInMM / extent[0];
       m_OutPutSpacing[1] = heightInMM / extent[1];
 
       origin = abstractGeometry->GetPlane()->GetOrigin();
 
       right = abstractGeometry->GetPlane()->GetAxisVector(0);
       right.Normalize();
 
       bottom = abstractGeometry->GetPlane()->GetAxisVector(1);
       bottom.Normalize();
 
       normal = abstractGeometry->GetPlane()->GetNormal();
       normal.Normalize();
 
       // Use a combination of the InputGeometry *and* the possible non-rigid
       // AbstractTransformGeometry for reslicing the 3D Image
       vtkSmartPointer<vtkGeneralTransform> composedResliceTransform = vtkSmartPointer<vtkGeneralTransform>::New();
       composedResliceTransform->Identity();
       composedResliceTransform->Concatenate(
         inputTimeGeometry->GetGeometryForTimeStep( m_TimeStep )->GetVtkTransform()->GetLinearInverse() );
       composedResliceTransform->Concatenate(
         abstractGeometry->GetVtkAbstractTransform()
         );
 
       m_Reslicer->SetResliceTransform( composedResliceTransform );
 
       // Set background level to BLACK instead of translucent, to avoid
       // boundary artifacts (see Geometry2DDataVtkMapper3D)
       m_Reslicer->SetBackgroundLevel( -1023 );
     }
     else
     {
       itkExceptionMacro("mitk::ExtractSliceFilter: No fitting geometry for reslice axis!");
       return;
     }
 
   }
 
   if(m_ResliceTransform.IsNotNull()){
     //if the resliceTransform is set the reslice axis are recalculated.
     //Thus the geometry information is not fitting. Therefor a unitSpacingFilter
     //is used to set up a global spacing of 1 and compensate the transform.
     vtkSmartPointer<vtkImageChangeInformation> unitSpacingImageFilter = vtkSmartPointer<vtkImageChangeInformation>::New() ;
     unitSpacingImageFilter->ReleaseDataFlagOn();
 
     unitSpacingImageFilter->SetOutputSpacing( 1.0, 1.0, 1.0 );
-    unitSpacingImageFilter->SetInput( input->GetVtkImageData(m_TimeStep) );
+    unitSpacingImageFilter->SetInputData( input->GetVtkImageData(m_TimeStep) );
 
-    m_Reslicer->SetInput(unitSpacingImageFilter->GetOutput() );
+    m_Reslicer->SetInputData(unitSpacingImageFilter->GetOutput() );
   }
   else
   {
     //if no tranform is set the image can be used directly
-    m_Reslicer->SetInput(input->GetVtkImageData(m_TimeStep));
+    m_Reslicer->SetInputData(input->GetVtkImageData(m_TimeStep));
   }
 
 
   /*setup the plane where vktImageReslice extracts the slice*/
 
   //ResliceAxesOrigin is the ancor point of the plane
   double originInVtk[3];
   itk2vtk(origin, originInVtk);
   m_Reslicer->SetResliceAxesOrigin(originInVtk);
 
 
   //the cosines define the plane: x and y are the direction vectors, n is the planes normal
   //this specifies a matrix 3x3
   //  x1 y1 n1
   //  x2 y2 n2
   //  x3 y3 n3
   double cosines[9];
 
   vnl2vtk(right.GetVnlVector(), cosines);//x
 
   vnl2vtk(bottom.GetVnlVector(), cosines + 3);//y
 
   vnl2vtk(normal.GetVnlVector(), cosines + 6);//n
 
   m_Reslicer->SetResliceAxesDirectionCosines(cosines);
 
 
   //we only have one slice, not a volume
   m_Reslicer->SetOutputDimensionality(m_OutputDimension);
 
 
   //set the interpolation mode for slicing
   switch(this->m_InterpolationMode){
     case RESLICE_NEAREST:
       m_Reslicer->SetInterpolationModeToNearestNeighbor();
       break;
     case RESLICE_LINEAR:
       m_Reslicer->SetInterpolationModeToLinear();
       break;
     case RESLICE_CUBIC:
       m_Reslicer->SetInterpolationModeToCubic();
       break;
     default:
       //the default interpolation used by mitk
       m_Reslicer->SetInterpolationModeToNearestNeighbor();
   }
 
 
   /*========== BEGIN setup extent of the slice ==========*/
   int xMin, xMax, yMin, yMax;
 
   xMin = yMin = 0;
   xMax = static_cast< int >( extent[0]);
   yMax = static_cast< int >( extent[1]);
 
   double sliceBounds[6];
   if (m_WorldGeometry->GetReferenceGeometry())
   {
     for ( int i = 0; i < 6; ++i )
     {
       sliceBounds[i] = 0.0;
     }
 
     if (this->GetClippedPlaneBounds( m_WorldGeometry->GetReferenceGeometry(), planeGeometry, sliceBounds ))
     {
       // Calculate output extent (integer values)
       xMin = static_cast< int >( sliceBounds[0] / m_OutPutSpacing[0] + 0.5 );
       xMax = static_cast< int >( sliceBounds[1] / m_OutPutSpacing[0] + 0.5 );
       yMin = static_cast< int >( sliceBounds[2] / m_OutPutSpacing[1] + 0.5 );
       yMax = static_cast< int >( sliceBounds[3] / m_OutPutSpacing[1] + 0.5 );
     } // ELSE we use the default values
   }
 
   // Set the output extents! First included pixel index and last included pixel index
   // xMax and yMax are one after the last pixel. so they have to be decremented by 1.
   // In case we have a 2D image, xMax or yMax might be 0. in this case, do not decrement, but take 0.
 
   m_Reslicer->SetOutputExtent(xMin, std::max(0, xMax-1), yMin, std::max(0, yMax-1), m_ZMin, m_ZMax );
   /*========== END setup extent of the slice ==========*/
 
 
   m_Reslicer->SetOutputOrigin( 0.0, 0.0, 0.0 );
 
   m_Reslicer->SetOutputSpacing( m_OutPutSpacing[0], m_OutPutSpacing[1], m_ZSpacing );
 
 
   //TODO check the following lines, they are responsible wether vtk error outputs appear or not
   m_Reslicer->UpdateWholeExtent(); //this produces a bad allocation error for 2D images
   //m_Reslicer->GetOutput()->UpdateInformation();
   //m_Reslicer->GetOutput()->SetUpdateExtentToWholeExtent();
 
   //start the pipeline
   m_Reslicer->Update();
 
   /*================ #END setup vtkImageRslice properties================*/
 
   if(m_VtkOutputRequested){
     return;
     //no converting to mitk
     //no mitk geometry will be set, as the output is vtkImageData only!!!
   }
   else
   {
     /*================ #BEGIN Get the slice from vtkImageReslice and convert it to mit::Image================*/
     vtkImageData* reslicedImage;
     reslicedImage = m_Reslicer->GetOutput();
 
 
     if(!reslicedImage)
     {
       itkWarningMacro(<<"Reslicer returned empty image");
       return;
     }
 
 
     mitk::Image::Pointer resultImage = this->GetOutput();
 
     //initialize resultimage with the specs of the vtkImageData object returned from vtkImageReslice
     if (reslicedImage->GetDataDimension() == 1)
     {
        // If original image was 2D, the slice might have an y extent of 0.
        // Still i want to ensure here that Image is 2D
          resultImage->Initialize(reslicedImage,1,-1,-1,1);
     }
     else
     {
        resultImage->Initialize(reslicedImage);
     }
 
 
     //transfer the voxel data
     resultImage->SetVolume(reslicedImage->GetScalarPointer());
 
 
     //set the geometry from current worldgeometry for the reusultimage
     //this is needed that the image has the correct mitk geometry
     //the originalGeometry is the Geometry of the result slice
 
 //    mitk::AffineGeometryFrame3D::Pointer originalGeometryAGF = m_WorldGeometry->Clone();
 //    Geometry2D::Pointer originalGeometry = dynamic_cast<Geometry2D*>( originalGeometryAGF.GetPointer() );
     Geometry2D::Pointer originalGeometry = m_WorldGeometry->Clone();
 
     originalGeometry->GetIndexToWorldTransform()->SetMatrix(m_WorldGeometry->GetIndexToWorldTransform()->GetMatrix());
 
     //the origin of the worldGeometry is transformed to center based coordinates to be an imageGeometry
     Point3D sliceOrigin = originalGeometry->GetOrigin();
 
     sliceOrigin += right * ( m_OutPutSpacing[0] * 0.5 );
     sliceOrigin += bottom * ( m_OutPutSpacing[1] * 0.5 );
 
     //a worldGeometry is no imageGeometry, thus it is manually set to true
     originalGeometry->ImageGeometryOn();
 
 
     /*At this point we have to adjust the geometry because the origin isn't correct.
     The wrong origin is related to the rotation of the current world geometry plane.
     This causes errors on transfering world to index coordinates. We just shift the
     origin in each direction about the amount of the expanding (needed while rotating
     the plane).
     */
     Vector3D axis0 = originalGeometry->GetAxisVector(0);
     Vector3D axis1 = originalGeometry->GetAxisVector(1);
     axis0.Normalize();
     axis1.Normalize();
 
 
     //adapt the origin. Note that for orthogonal planes the minima are '0' and thus the origin stays the same.
     sliceOrigin += (axis0 * (xMin * m_OutPutSpacing[0])) + (axis1 * (yMin * m_OutPutSpacing[1]));
 
     originalGeometry->SetOrigin(sliceOrigin);
 
     originalGeometry->Modified();
 
 
     resultImage->SetGeometry( originalGeometry );
 
 
     /*the bounds as well as the extent of the worldGeometry are not adapted correctly during crosshair rotation.
     This is only a quick fix and has to be evaluated.
     The new bounds are set via the max values of the calcuted slice extent. It will look like [ 0, x, 0, y, 0, 1].
     */
     mitk::BoundingBox::BoundsArrayType boundsCopy;
     boundsCopy[0] = boundsCopy[2] = boundsCopy[4] = 0;
     boundsCopy[5] = 1;
     boundsCopy[1] =  xMax - xMin;
     boundsCopy[3] =  yMax - yMin;
     resultImage->GetGeometry()->SetBounds(boundsCopy);
 
     /*================ #END Get the slice from vtkImageReslice and convert it to mitk Image================*/
   }
 }
 
 
 bool mitk::ExtractSliceFilter::GetClippedPlaneBounds(double bounds[6]){
 
   if(!m_WorldGeometry || !this->GetInput())
     return false;
 
   return this->GetClippedPlaneBounds(m_WorldGeometry->GetReferenceGeometry(), dynamic_cast< const PlaneGeometry * >( m_WorldGeometry ), bounds);
 
 }
 
 
 bool mitk::ExtractSliceFilter::GetClippedPlaneBounds( const Geometry3D *boundingGeometry,
                                                      const PlaneGeometry *planeGeometry, double *bounds )
 {
   bool b =  mitk::PlaneClipping::CalculateClippedPlaneBounds(boundingGeometry, planeGeometry, bounds);
 
   return b;
 }
diff --git a/Core/Code/Algorithms/mitkGeometry2DDataToSurfaceFilter.cpp b/Core/Code/Algorithms/mitkGeometry2DDataToSurfaceFilter.cpp
index a79f6e52ed..02fb878c1a 100644
--- a/Core/Code/Algorithms/mitkGeometry2DDataToSurfaceFilter.cpp
+++ b/Core/Code/Algorithms/mitkGeometry2DDataToSurfaceFilter.cpp
@@ -1,445 +1,445 @@
 /*===================================================================
 
 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 "mitkGeometry2DDataToSurfaceFilter.h"
 #include "mitkSurface.h"
 #include "mitkGeometry3D.h"
 #include "mitkGeometry2DData.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkAbstractTransformGeometry.h"
 
 #include <vtkPolyData.h>
 #include <vtkPlaneSource.h>
 #include <vtkTransformPolyDataFilter.h>
 
 #include <vtkCubeSource.h>
 #include <vtkTransformPolyDataFilter.h>
 #include <vtkTransform.h>
 #include <vtkGeneralTransform.h>
 #include <vtkPlane.h>
 #include <vtkPPolyDataNormals.h>
 #include <vtkCutter.h>
 #include <vtkStripper.h>
 #include <vtkTriangleFilter.h>
 #include <vtkBox.h>
 #include <vtkClipPolyData.h>
 #include <vtkTextureMapToPlane.h>
 
 
 mitk::Geometry2DDataToSurfaceFilter::Geometry2DDataToSurfaceFilter()
 : m_UseGeometryParametricBounds( true ), m_XResolution( 10 ),
   m_YResolution( 10 ), m_PlaceByGeometry( false ), m_UseBoundingBox( false )
 {
   m_PlaneSource = vtkPlaneSource::New();
   m_Transform = vtkTransform::New();
 
   m_CubeSource = vtkCubeSource::New();
   m_PolyDataTransformer = vtkTransformPolyDataFilter::New();
 
   m_Plane = vtkPlane::New();
   m_PlaneCutter = vtkCutter::New();
   m_PlaneStripper = vtkStripper::New();
   m_PlanePolyData = vtkPolyData::New();
   m_NormalsUpdater = vtkPPolyDataNormals::New();
   m_PlaneTriangler = vtkTriangleFilter::New();
   m_TextureMapToPlane = vtkTextureMapToPlane::New();
 
   m_Box = vtkBox::New();
   m_PlaneClipper = vtkClipPolyData::New();
 
   m_VtkTransformPlaneFilter = vtkTransformPolyDataFilter::New();
-  m_VtkTransformPlaneFilter->SetInput( m_PlaneSource->GetOutput() );
+  m_VtkTransformPlaneFilter->SetInputData( m_PlaneSource->GetOutput() );
 }
 
 
 mitk::Geometry2DDataToSurfaceFilter::~Geometry2DDataToSurfaceFilter()
 {
   m_PlaneSource->Delete();
   m_Transform->Delete();
 
   m_CubeSource->Delete();
   m_PolyDataTransformer->Delete();
 
   m_Plane->Delete();
   m_PlaneCutter->Delete();
   m_PlaneStripper->Delete();
   m_PlanePolyData->Delete();
   m_NormalsUpdater->Delete();
   m_PlaneTriangler->Delete();
   m_TextureMapToPlane->Delete();
 
   m_Box->Delete();
   m_PlaneClipper->Delete();
 
   m_VtkTransformPlaneFilter->Delete();
 }
 
 
 void mitk::Geometry2DDataToSurfaceFilter::GenerateOutputInformation()
 {
   mitk::Geometry2DData::ConstPointer input = this->GetInput();
   mitk::Surface::Pointer output = this->GetOutput();
 
   if ( input.IsNull() || (input->GetGeometry2D() == NULL)
     || (input->GetGeometry2D()->IsValid() == false)
     || (m_UseBoundingBox && (m_BoundingBox.IsNull() || (m_BoundingBox->GetDiagonalLength2() < mitk::eps))) )
   {
     return;
   }
 
   Point3D origin;
   Point3D right, bottom;
 
   vtkPolyData *planeSurface = NULL;
 
 
   // Does the Geometry2DData contain a PlaneGeometry?
   if ( dynamic_cast< PlaneGeometry * >( input->GetGeometry2D() ) != NULL )
   {
     mitk::PlaneGeometry *planeGeometry =
       dynamic_cast< PlaneGeometry * >( input->GetGeometry2D() );
 
     if ( m_PlaceByGeometry )
     {
       // Let the output use the input geometry to appropriately transform the
       // coordinate system.
       mitk::Geometry3D::TransformType *affineTransform =
         planeGeometry->GetIndexToWorldTransform();
 
       TimeGeometry *timeGeometry = output->GetTimeGeometry();
       Geometry3D *geometrie3d = timeGeometry->GetGeometryForTimeStep( 0 );
       geometrie3d->SetIndexToWorldTransform( affineTransform );
     }
 
     if ( !m_UseBoundingBox)
     {
       // We do not have a bounding box, so no clipping is required.
 
       if ( m_PlaceByGeometry )
       {
         // Derive coordinate axes and origin from input geometry extent
         origin.Fill( 0.0 );
         FillVector3D( right,  planeGeometry->GetExtent(0), 0.0, 0.0 );
         FillVector3D( bottom, 0.0, planeGeometry->GetExtent(1), 0.0 );
       }
       else
       {
         // Take the coordinate axes and origin directly from the input geometry.
         origin = planeGeometry->GetOrigin();
         right = planeGeometry->GetCornerPoint( false, true );
         bottom = planeGeometry->GetCornerPoint( true, false );
       }
 
       // Since the plane is planar, there is no need to subdivide the grid
       // (cf. AbstractTransformGeometry case)
       m_PlaneSource->SetXResolution( 1 );
       m_PlaneSource->SetYResolution( 1 );
 
       m_PlaneSource->SetOrigin( origin[0], origin[1], origin[2] );
       m_PlaneSource->SetPoint1( right[0], right[1], right[2] );
       m_PlaneSource->SetPoint2( bottom[0], bottom[1], bottom[2] );
 
       planeSurface = m_PlaneSource->GetOutput();
-      planeSurface->Update();
+//      planeSurface->Update(); //VTK6_TODO vtk pipeline
     }
     else
     {
       // Set up a cube with the extent and origin of the bounding box. This
       // cube will be clipped by a plane later on. The intersection of the
       // cube and the plane will be the surface we are interested in. Note
       // that the bounding box needs to be explicitly specified by the user
       // of this class, since it is not necessarily clear from the data
       // available herein which bounding box to use. In most cases, this
       // would be the bounding box of the input geometry's reference
       // geometry, but this is not an inevitable requirement.
       mitk::BoundingBox::PointType boundingBoxMin = m_BoundingBox->GetMinimum();
       mitk::BoundingBox::PointType boundingBoxMax = m_BoundingBox->GetMaximum();
       mitk::BoundingBox::PointType boundingBoxCenter = m_BoundingBox->GetCenter();
 
       m_CubeSource->SetXLength( boundingBoxMax[0] - boundingBoxMin[0] );
       m_CubeSource->SetYLength( boundingBoxMax[1] - boundingBoxMin[1] );
       m_CubeSource->SetZLength( boundingBoxMax[2] - boundingBoxMin[2] );
       m_CubeSource->SetCenter(
         boundingBoxCenter[0],
         boundingBoxCenter[1],
         boundingBoxCenter[2] );
 
 
       // Now we have to transform the cube, so that it will cut our plane
       // appropriately. (As can be seen below, the plane corresponds to the
       // z-plane in the coordinate system and is *not* transformed.) Therefore,
       // we get the inverse of the plane geometry's transform and concatenate
       // it with the transform of the reference geometry, if available.
       m_Transform->Identity();
       m_Transform->Concatenate(
         planeGeometry->GetVtkTransform()->GetLinearInverse()
       );
 
       Geometry3D *referenceGeometry = planeGeometry->GetReferenceGeometry();
       if ( referenceGeometry )
       {
         m_Transform->Concatenate(
           referenceGeometry->GetVtkTransform()
         );
       }
 
       // Transform the cube accordingly (s.a.)
-      m_PolyDataTransformer->SetInput( m_CubeSource->GetOutput() );
+      m_PolyDataTransformer->SetInputData( m_CubeSource->GetOutput() );
       m_PolyDataTransformer->SetTransform( m_Transform );
 
       // Initialize the plane to clip the cube with, as lying on the z-plane
       m_Plane->SetOrigin( 0.0, 0.0, 0.0 );
       m_Plane->SetNormal( 0.0, 0.0, 1.0 );
 
       // Cut the plane with the cube.
-      m_PlaneCutter->SetInput( m_PolyDataTransformer->GetOutput() );
+      m_PlaneCutter->SetInputData( m_PolyDataTransformer->GetOutput() );
       m_PlaneCutter->SetCutFunction( m_Plane );
 
       // The output of the cutter must be converted into appropriate poly data.
-      m_PlaneStripper->SetInput( m_PlaneCutter->GetOutput() );
+      m_PlaneStripper->SetInputData( m_PlaneCutter->GetOutput() );
       m_PlaneStripper->Update();
 
       if ( m_PlaneStripper->GetOutput()->GetNumberOfPoints() < 3 )
       {
         return;
       }
 
       m_PlanePolyData->SetPoints( m_PlaneStripper->GetOutput()->GetPoints() );
       m_PlanePolyData->SetPolys( m_PlaneStripper->GetOutput()->GetLines() );
 
-      m_PlaneTriangler->SetInput( m_PlanePolyData );
+      m_PlaneTriangler->SetInputData( m_PlanePolyData );
 
 
       // Get bounds of the resulting surface and use it to generate the texture
       // mapping information
       m_PlaneTriangler->Update();
       m_PlaneTriangler->GetOutput()->ComputeBounds();
       double *surfaceBounds =
         m_PlaneTriangler->GetOutput()->GetBounds();
 
       origin[0] = surfaceBounds[0];
       origin[1] = surfaceBounds[2];
       origin[2] = surfaceBounds[4];
 
       right[0] = surfaceBounds[1];
       right[1] = surfaceBounds[2];
       right[2] = surfaceBounds[4];
 
       bottom[0] = surfaceBounds[0];
       bottom[1] = surfaceBounds[3];
       bottom[2] = surfaceBounds[4];
 
       // Now we tell the data how it shall be textured afterwards;
       // description see above.
-      m_TextureMapToPlane->SetInput( m_PlaneTriangler->GetOutput() );
+      m_TextureMapToPlane->SetInputData( m_PlaneTriangler->GetOutput() );
       m_TextureMapToPlane->AutomaticPlaneGenerationOn();
       m_TextureMapToPlane->SetOrigin( origin[0], origin[1], origin[2] );
       m_TextureMapToPlane->SetPoint1( right[0], right[1], right[2] );
       m_TextureMapToPlane->SetPoint2( bottom[0], bottom[1], bottom[2] );
 
       // Need to call update so that output data and bounds are immediately
       // available
       m_TextureMapToPlane->Update();
 
 
       // Return the output of this generation process
       planeSurface = dynamic_cast< vtkPolyData * >(
         m_TextureMapToPlane->GetOutput()
       );
     }
   }
 
   // Does the Geometry2DData contain an AbstractTransformGeometry?
   else if ( mitk::AbstractTransformGeometry *abstractGeometry =
     dynamic_cast< AbstractTransformGeometry * >( input->GetGeometry2D() ) )
   {
     // In the case of an AbstractTransformGeometry (which holds a possibly
     // non-rigid transform), we proceed slightly differently: since the
     // plane can be arbitrarily deformed, we need to transform it by the
     // abstract transform before clipping it. The setup for this is partially
     // done in the constructor.
     origin = abstractGeometry->GetPlane()->GetOrigin();
     right = origin + abstractGeometry->GetPlane()->GetAxisVector( 0 );
     bottom = origin + abstractGeometry->GetPlane()->GetAxisVector( 1 );
 
     // Define the plane
     m_PlaneSource->SetOrigin( origin[0], origin[1], origin[2] );
     m_PlaneSource->SetPoint1( right[0], right[1], right[2] );
     m_PlaneSource->SetPoint2( bottom[0], bottom[1], bottom[2] );
 
     // Set the plane's resolution (unlike for non-deformable planes, the plane
     // grid needs to have a certain resolution so that the deformation has the
     // desired effect).
     if ( m_UseGeometryParametricBounds )
     {
       m_PlaneSource->SetXResolution(
         (int)abstractGeometry->GetParametricExtent(0)
       );
       m_PlaneSource->SetYResolution(
         (int)abstractGeometry->GetParametricExtent(1)
       );
     }
     else
     {
       m_PlaneSource->SetXResolution( m_XResolution );
       m_PlaneSource->SetYResolution( m_YResolution );
     }
     if ( m_PlaceByGeometry )
     {
       // Let the output use the input geometry to appropriately transform the
       // coordinate system.
       mitk::Geometry3D::TransformType *affineTransform =
         abstractGeometry->GetIndexToWorldTransform();
 
       TimeGeometry *timeGeometry = output->GetTimeGeometry();
       Geometry3D *g3d = timeGeometry->GetGeometryForTimeStep( 0 );
       g3d->SetIndexToWorldTransform( affineTransform );
 
       vtkGeneralTransform *composedResliceTransform = vtkGeneralTransform::New();
       composedResliceTransform->Identity();
       composedResliceTransform->Concatenate(
         abstractGeometry->GetVtkTransform()->GetLinearInverse() );
       composedResliceTransform->Concatenate(
         abstractGeometry->GetVtkAbstractTransform()
         );
       // Use the non-rigid transform for transforming the plane.
       m_VtkTransformPlaneFilter->SetTransform(
         composedResliceTransform
       );
     }
     else
     {
       // Use the non-rigid transform for transforming the plane.
       m_VtkTransformPlaneFilter->SetTransform(
         abstractGeometry->GetVtkAbstractTransform()
       );
     }
 
     if ( m_UseBoundingBox )
     {
       mitk::BoundingBox::PointType boundingBoxMin = m_BoundingBox->GetMinimum();
       mitk::BoundingBox::PointType boundingBoxMax = m_BoundingBox->GetMaximum();
       //mitk::BoundingBox::PointType boundingBoxCenter = m_BoundingBox->GetCenter();
 
       m_Box->SetXMin( boundingBoxMin[0], boundingBoxMin[1], boundingBoxMin[2] );
       m_Box->SetXMax( boundingBoxMax[0], boundingBoxMax[1], boundingBoxMax[2] );
     }
     else
     {
       // Plane will not be clipped
       m_Box->SetXMin( -10000.0, -10000.0, -10000.0 );
       m_Box->SetXMax( 10000.0, 10000.0, 10000.0 );
     }
 
     m_Transform->Identity();
     m_Transform->Concatenate( input->GetGeometry2D()->GetVtkTransform() );
     m_Transform->PreMultiply();
 
     m_Box->SetTransform( m_Transform );
 
-    m_PlaneClipper->SetInput( m_VtkTransformPlaneFilter->GetOutput() );
+    m_PlaneClipper->SetInputData( m_VtkTransformPlaneFilter->GetOutput() );
     m_PlaneClipper->SetClipFunction( m_Box );
     m_PlaneClipper->GenerateClippedOutputOff(); // important to NOT generate normals data for clipped part
     m_PlaneClipper->InsideOutOn();
     m_PlaneClipper->SetValue( 0.0 );
 
     planeSurface = m_PlaneClipper->GetOutput();
   }
 
-  m_NormalsUpdater->SetInput( planeSurface );
+  m_NormalsUpdater->SetInputData( planeSurface );
   m_NormalsUpdater->AutoOrientNormalsOn(); // that's the trick! Brings consistency between
                                           //  normals direction and front/back faces direction (see bug 1440)
   m_NormalsUpdater->ComputePointNormalsOn();
   m_NormalsUpdater->Update();
 
   output->SetVtkPolyData( m_NormalsUpdater->GetOutput() );
   output->CalculateBoundingBox();
 }
 
 
 void mitk::Geometry2DDataToSurfaceFilter::GenerateData()
 {
   mitk::Surface::Pointer output = this->GetOutput();
 
   if (output.IsNull()) return;
   if (output->GetVtkPolyData()==NULL) return;
 
-  output->GetVtkPolyData()->Update();
+//  output->GetVtkPolyData()->Update(); //VTK6_TODO vtk pipeline
 }
 
 const mitk::Geometry2DData *mitk::Geometry2DDataToSurfaceFilter::GetInput()
 {
   if (this->GetNumberOfInputs() < 1)
   {
     return 0;
   }
 
   return static_cast<const mitk::Geometry2DData * >
     ( this->ProcessObject::GetInput(0) );
 }
 
 
 const mitk::Geometry2DData *
 mitk::Geometry2DDataToSurfaceFilter
 ::GetInput(unsigned int idx)
 {
   return static_cast< const mitk::Geometry2DData * >
     ( this->ProcessObject::GetInput(idx) );
 }
 
 
 void
 mitk::Geometry2DDataToSurfaceFilter
 ::SetInput(const mitk::Geometry2DData *input)
 {
   // Process object is not const-correct so the const_cast is required here
   this->ProcessObject::SetNthInput( 0,
   const_cast< mitk::Geometry2DData * >( input )
   );
 }
 
 
 void
 mitk::Geometry2DDataToSurfaceFilter
 ::SetInput(unsigned int index, const mitk::Geometry2DData *input)
 {
   if( index+1 > this->GetNumberOfInputs() )
   {
     this->SetNumberOfRequiredInputs( index + 1 );
   }
   // Process object is not const-correct so the const_cast is required here
   this->ProcessObject::SetNthInput(index,
     const_cast< mitk::Geometry2DData *>( input )
   );
 }
 
 
 void
 mitk::Geometry2DDataToSurfaceFilter
 ::SetBoundingBox( const mitk::BoundingBox *boundingBox )
 {
   m_BoundingBox = boundingBox;
   this->UseBoundingBoxOn();
 }
 
 
 const mitk::BoundingBox *
 mitk::Geometry2DDataToSurfaceFilter
 ::GetBoundingBox() const
 {
   return m_BoundingBox.GetPointer();
 }
diff --git a/Core/Code/Algorithms/mitkImageToSurfaceFilter.cpp b/Core/Code/Algorithms/mitkImageToSurfaceFilter.cpp
index c7cf9d2161..027e3ff46f 100644
--- a/Core/Code/Algorithms/mitkImageToSurfaceFilter.cpp
+++ b/Core/Code/Algorithms/mitkImageToSurfaceFilter.cpp
@@ -1,234 +1,234 @@
 /*===================================================================
 
 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 <mitkImageToSurfaceFilter.h>
 #include "mitkException.h"
 #include <vtkImageData.h>
 #include <vtkDecimatePro.h>
 #include <vtkImageChangeInformation.h>
 #include <vtkLinearTransform.h>
 #include <vtkMath.h>
 #include <vtkMatrix4x4.h>
 #include <vtkQuadricDecimation.h>
 
 #include <vtkSmartPointer.h>
 #include <vtkPolyDataNormals.h>
 #include <vtkCleanPolyData.h>
 
 #include "mitkProgressBar.h"
 
 mitk::ImageToSurfaceFilter::ImageToSurfaceFilter():
   m_Smooth(false),
   m_Decimate( NoDecimation),
   m_Threshold(1.0),
   m_TargetReduction(0.95f),
   m_SmoothIteration(50),
   m_SmoothRelaxation(0.1)
 {
 }
 
 mitk::ImageToSurfaceFilter::~ImageToSurfaceFilter()
 {
 }
 
 void mitk::ImageToSurfaceFilter::CreateSurface(int time, vtkImageData *vtkimage, mitk::Surface * surface, const ScalarType threshold)
 {
   vtkImageChangeInformation *indexCoordinatesImageFilter = vtkImageChangeInformation::New();
-  indexCoordinatesImageFilter->SetInput(vtkimage);
+  indexCoordinatesImageFilter->SetInputData(vtkimage);
   indexCoordinatesImageFilter->SetOutputOrigin(0.0,0.0,0.0);
 
   //MarchingCube -->create Surface
   vtkMarchingCubes *skinExtractor = vtkMarchingCubes::New();
   skinExtractor->ComputeScalarsOff();
-  skinExtractor->SetInput(indexCoordinatesImageFilter->GetOutput());//RC++
+  skinExtractor->SetInputData(indexCoordinatesImageFilter->GetOutput());//RC++
   indexCoordinatesImageFilter->Delete();
   skinExtractor->SetValue(0, threshold);
 
   vtkPolyData *polydata;
   polydata = skinExtractor->GetOutput();
   polydata->Register(NULL);//RC++
   skinExtractor->Delete();
 
   if (m_Smooth)
   {
     vtkSmoothPolyDataFilter *smoother = vtkSmoothPolyDataFilter::New();
     //read poly1 (poly1 can be the original polygon, or the decimated polygon)
-    smoother->SetInput(polydata);//RC++
+    smoother->SetInputData(polydata);//RC++
     smoother->SetNumberOfIterations( m_SmoothIteration );
     smoother->SetRelaxationFactor( m_SmoothRelaxation );
     smoother->SetFeatureAngle( 60 );
     smoother->FeatureEdgeSmoothingOff();
     smoother->BoundarySmoothingOff();
     smoother->SetConvergence( 0 );
 
     polydata->Delete();//RC--
     polydata = smoother->GetOutput();
     polydata->Register(NULL);//RC++
     smoother->Delete();
   }
   ProgressBar::GetInstance()->Progress();
 
   //decimate = to reduce number of polygons
   if(m_Decimate==DecimatePro)
   {
     vtkDecimatePro *decimate = vtkDecimatePro::New();
     decimate->SplittingOff();
     decimate->SetErrorIsAbsolute(5);
     decimate->SetFeatureAngle(30);
     decimate->PreserveTopologyOn();
     decimate->BoundaryVertexDeletionOff();
     decimate->SetDegree(10); //std-value is 25!
 
-    decimate->SetInput(polydata);//RC++
+    decimate->SetInputData(polydata);//RC++
     decimate->SetTargetReduction(m_TargetReduction);
     decimate->SetMaximumError(0.002);
 
     polydata->Delete();//RC--
     polydata = decimate->GetOutput();
     polydata->Register(NULL);//RC++
     decimate->Delete();
   }
   else if (m_Decimate==QuadricDecimation)
   {
     vtkQuadricDecimation* decimate = vtkQuadricDecimation::New();
     decimate->SetTargetReduction(m_TargetReduction);
 
-    decimate->SetInput(polydata);
+    decimate->SetInputData(polydata);
     polydata->Delete();
     polydata = decimate->GetOutput();
     polydata->Register(NULL);
     decimate->Delete();
   }
 
-  polydata->Update();
+//  polydata->Update(); //VTK6_TODO vtk pipeline
   ProgressBar::GetInstance()->Progress();
 
-  polydata->SetSource(NULL);
+//  polydata->SetSource(NULL); //VTK6_TODO vtk pipeline
 
   if(polydata->GetNumberOfPoints() > 0)
   {
     mitk::Vector3D spacing = GetInput()->GetGeometry(time)->GetSpacing();
 
     vtkPoints * points = polydata->GetPoints();
     vtkMatrix4x4 *vtkmatrix = vtkMatrix4x4::New();
     GetInput()->GetGeometry(time)->GetVtkTransform()->GetMatrix(vtkmatrix);
     double (*matrix)[4] = vtkmatrix->Element;
 
     unsigned int i,j;
     for(i=0;i<3;++i)
       for(j=0;j<3;++j)
         matrix[i][j]/=spacing[j];
 
     unsigned int n = points->GetNumberOfPoints();
     double point[3];
 
     for (i = 0; i < n; i++)
     {
       points->GetPoint(i, point);
       mitkVtkLinearTransformPoint(matrix,point,point);
       points->SetPoint(i, point);
     }
     vtkmatrix->Delete();
   }
   ProgressBar::GetInstance()->Progress();
 
   // determine point_data normals for the poly data points.
   vtkSmartPointer<vtkPolyDataNormals> normalsGenerator = vtkSmartPointer<vtkPolyDataNormals>::New();
-  normalsGenerator->SetInput( polydata );
+  normalsGenerator->SetInputData( polydata );
 
   vtkSmartPointer<vtkCleanPolyData> cleanPolyDataFilter = vtkSmartPointer<vtkCleanPolyData>::New();
-  cleanPolyDataFilter->SetInput(normalsGenerator->GetOutput());
+  cleanPolyDataFilter->SetInputData(normalsGenerator->GetOutput());
   cleanPolyDataFilter->PieceInvariantOff();
   cleanPolyDataFilter->ConvertLinesToPointsOff();
   cleanPolyDataFilter->ConvertPolysToLinesOff();
   cleanPolyDataFilter->ConvertStripsToPolysOff();
   cleanPolyDataFilter->PointMergingOn();
   cleanPolyDataFilter->Update();
 
   surface->SetVtkPolyData(cleanPolyDataFilter->GetOutput(), time);
   polydata->UnRegister(NULL);
 }
 
 
 void mitk::ImageToSurfaceFilter::GenerateData()
 {
   mitk::Surface *surface = this->GetOutput();
   mitk::Image * image        =  (mitk::Image*)GetInput();
   if(image == NULL || !image->IsInitialized())
     mitkThrow() << "No input image set, please set an valid input image!";
 
   mitk::Image::RegionType outputRegion = image->GetRequestedRegion();
 
   int tstart=outputRegion.GetIndex(3);
   int tmax=tstart+outputRegion.GetSize(3); //GetSize()==1 - will aber 0 haben, wenn nicht zeitaufgeloest
 
   if ((tmax-tstart) > 0)
   {
     ProgressBar::GetInstance()->AddStepsToDo( 4 * (tmax - tstart)  );
   }
 
 
   int t;
   for( t=tstart; t < tmax; ++t)
   {
     vtkImageData *vtkimagedata =  image->GetVtkImageData(t);
     CreateSurface(t,vtkimagedata,surface,m_Threshold);
     ProgressBar::GetInstance()->Progress();
   }
 }
 
 void mitk::ImageToSurfaceFilter::SetSmoothIteration(int smoothIteration)
 {
   m_SmoothIteration = smoothIteration;
 }
 
 void mitk::ImageToSurfaceFilter::SetSmoothRelaxation(float smoothRelaxation)
 {
   m_SmoothRelaxation = smoothRelaxation;
 }
 
 void mitk::ImageToSurfaceFilter::SetInput(const mitk::Image *image)
 {
   // Process object is not const-correct so the const_cast is required here
   this->ProcessObject::SetNthInput(0, const_cast< mitk::Image * >( image ) );
 }
 
 
 const mitk::Image *mitk::ImageToSurfaceFilter::GetInput(void)
 {
   if (this->GetNumberOfInputs() < 1)
   {
     return 0;
   }
 
   return static_cast<const mitk::Image * >
     ( this->ProcessObject::GetInput(0) );
 }
 
 
 void mitk::ImageToSurfaceFilter::GenerateOutputInformation()
 {
   mitk::Image::ConstPointer inputImage  =(mitk::Image*) this->GetInput();
 
   //mitk::Image *inputImage = (mitk::Image*)this->GetImage();
   mitk::Surface::Pointer output = this->GetOutput();
 
   itkDebugMacro(<<"GenerateOutputInformation()");
 
   if(inputImage.IsNull()) return;
 
   //Set Data
 }
diff --git a/Core/Code/Algorithms/mitkSurfaceToImageFilter.cpp b/Core/Code/Algorithms/mitkSurfaceToImageFilter.cpp
index c7680fea20..a793459264 100644
--- a/Core/Code/Algorithms/mitkSurfaceToImageFilter.cpp
+++ b/Core/Code/Algorithms/mitkSurfaceToImageFilter.cpp
@@ -1,212 +1,212 @@
 /*===================================================================
 
 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 "mitkSurfaceToImageFilter.h"
 #include "mitkTimeHelper.h"
 #include "mitkImageWriteAccessor.h"
 
 #include <vtkPolyData.h>
 #include <vtkPolyDataToImageStencil.h>
 #include <vtkImageStencil.h>
 #include <vtkImageData.h>
 #include <vtkPolyData.h>
 #include <vtkLinearTransform.h>
 #include <vtkTriangleFilter.h>
 #include <vtkLinearExtrusionFilter.h>
 #include <vtkDataSetTriangleFilter.h>
 #include <vtkImageThreshold.h>
 #include <vtkImageMathematics.h>
 #include <vtkPolyDataNormals.h>
 #include <vtkTransformPolyDataFilter.h>
 #include <vtkTransform.h>
 
 
 mitk::SurfaceToImageFilter::SurfaceToImageFilter()
 : m_MakeOutputBinary( false ),
   m_BackgroundValue( -10000 )
 {
 }
 
 mitk::SurfaceToImageFilter::~SurfaceToImageFilter()
 {
 }
 
 void mitk::SurfaceToImageFilter::GenerateInputRequestedRegion()
 {
   mitk::Image* output = this->GetOutput();
   if((output->IsInitialized()==false) )
     return;
 
   GenerateTimeInInputRegion(output, const_cast< mitk::Image * > ( this->GetImage() ));
 }
 
 void mitk::SurfaceToImageFilter::GenerateOutputInformation()
 {
   mitk::Image *inputImage = (mitk::Image*)this->GetImage();
   mitk::Image::Pointer output = this->GetOutput();
 
   itkDebugMacro(<<"GenerateOutputInformation()");
 
   if((inputImage == NULL) ||
      (inputImage->IsInitialized() == false) ||
      (inputImage->GetTimeGeometry() == NULL)) return;
 
   if (m_MakeOutputBinary)
     output->Initialize(mitk::MakeScalarPixelType<unsigned char>() , *inputImage->GetTimeGeometry());
   else
     output->Initialize(inputImage->GetPixelType(), *inputImage->GetTimeGeometry());
 
   output->SetPropertyList(inputImage->GetPropertyList()->Clone());
 }
 
 void mitk::SurfaceToImageFilter::GenerateData()
 {
   mitk::Image::ConstPointer inputImage = this->GetImage();
   mitk::Image::Pointer output = this->GetOutput();
 
   if(inputImage.IsNull())
     return;
 
   if(output->IsInitialized()==false )
     return;
 
   mitk::Image::RegionType outputRegion = output->GetRequestedRegion();
 
   int tstart=outputRegion.GetIndex(3);
   int tmax=tstart+outputRegion.GetSize(3);
 
   if ( tmax > 0)
   {
     int t;
     for(t=tstart;t<tmax;++t)
     {
       Stencil3DImage( t );
     }
   }
   else
   {
     Stencil3DImage( 0 );
   }
 }
 
 void mitk::SurfaceToImageFilter::Stencil3DImage(int time)
 {
   const mitk::TimeGeometry *surfaceTimeGeometry = GetInput()->GetTimeGeometry();
   const mitk::TimeGeometry *imageTimeGeometry = GetImage()->GetTimeGeometry();
 
   // Convert time step from image time-frame to surface time-frame
   mitk::TimePointType matchingTimePoint = imageTimeGeometry->TimeStepToTimePoint(time);
   mitk::TimeStepType surfaceTimeStep = surfaceTimeGeometry->TimePointToTimeStep(matchingTimePoint);
 
   vtkPolyData * polydata = ( (mitk::Surface*)GetInput() )->GetVtkPolyData( surfaceTimeStep );
 
   vtkTransformPolyDataFilter * move=vtkTransformPolyDataFilter::New();
-  move->SetInput(polydata);
+  move->SetInputData(polydata);
   move->ReleaseDataFlagOn();
 
   vtkTransform *transform=vtkTransform::New();
   Geometry3D* geometry = surfaceTimeGeometry->GetGeometryForTimeStep( surfaceTimeStep );
   geometry->TransferItkToVtkTransform();
   transform->PostMultiply();
   transform->Concatenate(geometry->GetVtkTransform()->GetMatrix());
   // take image geometry into account. vtk-Image information will be changed to unit spacing and zero origin below.
   Geometry3D* imageGeometry = imageTimeGeometry->GetGeometryForTimeStep(time);
   imageGeometry->TransferItkToVtkTransform();
   transform->Concatenate(imageGeometry->GetVtkTransform()->GetLinearInverse());
   move->SetTransform(transform);
   transform->Delete();
 
   vtkPolyDataNormals * normalsFilter = vtkPolyDataNormals::New();
   normalsFilter->SetFeatureAngle(50);
   normalsFilter->SetConsistency(1);
   normalsFilter->SetSplitting(1);
   normalsFilter->SetFlipNormals(0);
   normalsFilter->ReleaseDataFlagOn();
 
-  normalsFilter->SetInput( move->GetOutput() );
+  normalsFilter->SetInputData( move->GetOutput() );
   move->Delete();
 
   vtkPolyDataToImageStencil * surfaceConverter = vtkPolyDataToImageStencil::New();
   surfaceConverter->SetTolerance( 0.0 );
   surfaceConverter->ReleaseDataFlagOn();
 
-  surfaceConverter->SetInput( normalsFilter->GetOutput() );
+  surfaceConverter->SetInputData( normalsFilter->GetOutput() );
   normalsFilter->Delete();
 
   mitk::Image::Pointer binaryImage = mitk::Image::New();
 
   if (m_MakeOutputBinary)
   {
     binaryImage->Initialize(mitk::MakeScalarPixelType<unsigned char>(), *this->GetImage()->GetTimeGeometry());
 
     unsigned int size = sizeof(unsigned char);
     for (unsigned int i = 0; i < binaryImage->GetDimension(); ++i)
       size *= binaryImage->GetDimension(i);
 
     mitk::ImageWriteAccessor accessor( binaryImage );
     memset( accessor.GetData(), 1, size );
   }
 
   vtkImageData *image = m_MakeOutputBinary
     ? binaryImage->GetVtkImageData(time)
     : const_cast<mitk::Image *>(this->GetImage())->GetVtkImageData(time);
 
   // Create stencil and use numerical minimum of pixel type as background value
   vtkImageStencil *stencil = vtkImageStencil::New();
-  stencil->SetInput(image);
+  stencil->SetInputData(image);
   stencil->ReverseStencilOff();
   stencil->ReleaseDataFlagOn();
-  stencil->SetStencil(surfaceConverter->GetOutput());
+  stencil->SetStencilData(surfaceConverter->GetOutput());
   surfaceConverter->Delete();
 
   stencil->SetBackgroundValue(m_MakeOutputBinary ? 0 : m_BackgroundValue);
   stencil->Update();
 
   mitk::Image::Pointer output = this->GetOutput();
   output->SetVolume( stencil->GetOutput()->GetScalarPointer(), time );
   MITK_INFO << "stencil ref count: " << stencil->GetReferenceCount() << std::endl;
 
   stencil->Delete();
 }
 
 
 const mitk::Surface *mitk::SurfaceToImageFilter::GetInput(void)
 {
   if (this->GetNumberOfInputs() < 1)
   {
     return 0;
   }
 
   return static_cast<const mitk::Surface * >
     ( this->ProcessObject::GetInput(0) );
 }
 
 void mitk::SurfaceToImageFilter::SetInput(const mitk::Surface *input)
 {
   // Process object is not const-correct so the const_cast is required here
   this->ProcessObject::SetNthInput(0,
     const_cast< mitk::Surface * >( input ) );
 }
 
 void mitk::SurfaceToImageFilter::SetImage(const mitk::Image *source)
 {
   this->ProcessObject::SetNthInput( 1, const_cast< mitk::Image * >( source ) );
 }
 
 const mitk::Image *mitk::SurfaceToImageFilter::GetImage(void)
 {
   return static_cast< const mitk::Image * >(this->ProcessObject::GetInput(1));
-}
\ No newline at end of file
+}
diff --git a/Core/Code/DataManagement/mitkLookupTable.cpp b/Core/Code/DataManagement/mitkLookupTable.cpp
index d0de567536..3931ca2df8 100644
--- a/Core/Code/DataManagement/mitkLookupTable.cpp
+++ b/Core/Code/DataManagement/mitkLookupTable.cpp
@@ -1,309 +1,309 @@
 /*===================================================================
 
 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 "mitkLookupTable.h"
 #include <itkProcessObject.h>
 
 #include <vtkColorTransferFunction.h>
 #include <vtkPiecewiseFunction.h>
 
 mitk::LookupTable::LookupTable()
 {
   m_LookupTable = vtkLookupTable::New();
   this->SetRequestedRegionToLargestPossibleRegion();
 }
 
 mitk::LookupTable::LookupTable(const LookupTable& other)
   : itk::DataObject()
   , m_LookupTable(vtkLookupTable::New())
 {
   m_LookupTable->DeepCopy(other.m_LookupTable);
 }
 
 mitk::LookupTable::~LookupTable()
 {
   if ( m_LookupTable )
   {
     m_LookupTable->Delete();
     m_LookupTable = NULL;
   }
 }
 
 void mitk::LookupTable::SetVtkLookupTable( vtkLookupTable* lut )
 {
 
   if(m_LookupTable == lut)
   {
     return;
   }
 
   if(m_LookupTable)
   {
     m_LookupTable->UnRegister(NULL);
     m_LookupTable = NULL;
   }
 
   if(lut)
   {
     lut->Register(NULL);
   }
 
   m_LookupTable = lut;
   this->Modified();
 
 }
 
 
 
 void mitk::LookupTable::ChangeOpacityForAll( float opacity )
 {
 
   int noValues = m_LookupTable->GetNumberOfTableValues ();
 
-  vtkFloatingPointType rgba[ 4 ];
+  double rgba[ 4 ];
 
   for ( int i = 0;i < noValues;i++ )
   {
     m_LookupTable->GetTableValue ( i, rgba );
     rgba[ 3 ] = opacity;
     m_LookupTable->SetTableValue ( i, rgba );
   }
   this->Modified();  // need to call modiefied, since LookupTableProperty seems to be unchanged so no widget-updat is executed
 }
 
 void mitk::LookupTable::ChangeOpacity(int index, float opacity )
 {
 
   int noValues = m_LookupTable->GetNumberOfTableValues ();
   if (index>noValues)
   {
     MITK_INFO << "could not change opacity. index exceed size of lut ... " << std::endl;
     return;
   }
 
-  vtkFloatingPointType rgba[ 4 ];
+  double rgba[ 4 ];
 
   m_LookupTable->GetTableValue ( index, rgba );
   rgba[ 3 ] = opacity;
   m_LookupTable->SetTableValue ( index, rgba );
 
   this->Modified();  // need to call modiefied, since LookupTableProperty seems to be unchanged so no widget-updat is executed
 }
 
 
 vtkLookupTable* mitk::LookupTable::GetVtkLookupTable() const
 {
   return m_LookupTable;
 };
 
 mitk::LookupTable::RawLookupTableType * mitk::LookupTable::GetRawLookupTable() const
 {
 
   if (m_LookupTable==NULL) MITK_INFO << "uuups..." << std::endl;
   return m_LookupTable->GetPointer( 0 );
 };
 
 /*!
 * \brief equality operator inplementation
 */
 bool mitk::LookupTable::operator==( const mitk::LookupTable& other ) const
 {
   if ( m_LookupTable == other.GetVtkLookupTable())
     return true;
   vtkLookupTable* olut = other.GetVtkLookupTable();
   if (olut == NULL)
     return false;
 
   bool equal = (m_LookupTable->GetNumberOfColors() == olut->GetNumberOfColors())
             && (m_LookupTable->GetTableRange()[0] == olut->GetTableRange()[0])
             && (m_LookupTable->GetTableRange()[1] == olut->GetTableRange()[1])
             && (m_LookupTable->GetHueRange()[0] == olut->GetHueRange()[0])
             && (m_LookupTable->GetHueRange()[1] == olut->GetHueRange()[1])
             && (m_LookupTable->GetSaturationRange()[0] == olut->GetSaturationRange()[0])
             && (m_LookupTable->GetSaturationRange()[1] == olut->GetSaturationRange()[1])
             && (m_LookupTable->GetValueRange()[0] == olut->GetValueRange()[0])
             && (m_LookupTable->GetValueRange()[1] == olut->GetValueRange()[1])
             && (m_LookupTable->GetAlphaRange()[0] == olut->GetAlphaRange()[0])
             && (m_LookupTable->GetAlphaRange()[1] == olut->GetAlphaRange()[1])
             && (m_LookupTable->GetRamp() == olut->GetRamp())
             && (m_LookupTable->GetScale() == olut->GetScale())
             && (m_LookupTable->GetAlpha() == olut->GetAlpha())
             && (m_LookupTable->GetTable()->GetNumberOfTuples() == olut->GetTable()->GetNumberOfTuples());
   if (equal == false)
     return false;
   //for (vtkIdType i=0; i < m_LookupTable->GetTable()->GetNumberOfTuples(); i++)
   //{
   //  if (m_LookupTable->GetTable()->GetTuple(i) != olut->GetTable()->GetTuple(i))
   //    return false;
   //}
   for (vtkIdType i=0; i < m_LookupTable->GetNumberOfTableValues(); i++)
   {
     //double v0_1 = m_LookupTable->GetTableValue(i)[0]; double v0_2 = olut->GetTableValue(i)[0];
     //double v1_1 = m_LookupTable->GetTableValue(i)[1]; double v1_2 = olut->GetTableValue(i)[1];
     //double v2_1 = m_LookupTable->GetTableValue(i)[2]; double v2_2 = olut->GetTableValue(i)[2];
     //double v3_1 = m_LookupTable->GetTableValue(i)[3]; double v3_2 = olut->GetTableValue(i)[3];
     bool tvequal = (m_LookupTable->GetTableValue(i)[0] == olut->GetTableValue(i)[0])
                 && (m_LookupTable->GetTableValue(i)[1] == olut->GetTableValue(i)[1])
                 && (m_LookupTable->GetTableValue(i)[2] == olut->GetTableValue(i)[2])
                 && (m_LookupTable->GetTableValue(i)[3] == olut->GetTableValue(i)[3]);
     if (tvequal == false)
       return false;
   }
   return true;
 }
 
 /*!
 * \brief un-equality operator implementation
 */
 bool mitk::LookupTable::operator!=( const mitk::LookupTable& other ) const
 {
   return !(*this == other);
 }
 
 /*!
 * \brief assignment operator implementation
 */
 mitk::LookupTable& mitk::LookupTable::operator=( const mitk::LookupTable& LookupTable )
 {
   if ( this == &LookupTable )
   {
     return * this;
   }
   else
   {
     m_LookupTable = LookupTable.GetVtkLookupTable();
     return *this;
   }
 }
 
 void mitk::LookupTable::UpdateOutputInformation( )
 {
   if ( this->GetSource( ) )
   {
     this->GetSource( ) ->UpdateOutputInformation( );
   }
 }
 
 
 void mitk::LookupTable::SetRequestedRegionToLargestPossibleRegion( )
 {}
 
 
 bool mitk::LookupTable::RequestedRegionIsOutsideOfTheBufferedRegion( )
 {
   return false;
 }
 
 
 bool mitk::LookupTable::VerifyRequestedRegion( )
 {
   //normally we should check if the requested region lies within the
   //largest possible region. Since for lookup-tables we assume, that the
   //requested region is always the largest possible region, we can always
   //return true!
   return true;
 }
 
 
 void mitk::LookupTable::SetRequestedRegion(const itk::DataObject *)
 {
   //not implemented, since we always want to have the RequestedRegion
   //to be set to LargestPossibleRegion
 }
 
 void mitk::LookupTable::CreateColorTransferFunction(vtkColorTransferFunction*& colorFunction)
 {
   if(colorFunction==NULL)
     colorFunction = vtkColorTransferFunction::New();
 
   mitk::LookupTable::RawLookupTableType *rgba = GetRawLookupTable();
   int i, num_of_values=m_LookupTable->GetNumberOfTableValues();
 
 
-  vtkFloatingPointType *cols;
-  vtkFloatingPointType *colsHead;
-  colsHead=cols=(vtkFloatingPointType *)malloc(sizeof(vtkFloatingPointType)*num_of_values*3);
+  double *cols;
+  double *colsHead;
+  colsHead=cols=(double *)malloc(sizeof(double)*num_of_values*3);
 
   for(i=0;i<num_of_values;++i)
   {
     *cols=*rgba/255.0; ++cols; ++rgba;
     *cols=*rgba/255.0; ++cols; ++rgba;
     *cols=*rgba/255.0; ++cols; ++rgba;
     ++rgba;
   }
   colorFunction->BuildFunctionFromTable(m_LookupTable->GetTableRange()[0], m_LookupTable->GetTableRange()[1], num_of_values-1, colsHead);
 
   free(colsHead);
 }
 
 void mitk::LookupTable::CreateOpacityTransferFunction(vtkPiecewiseFunction*& opacityFunction)
 {
   if(opacityFunction==NULL)
     opacityFunction = vtkPiecewiseFunction::New();
 
   mitk::LookupTable::RawLookupTableType *rgba = GetRawLookupTable();
   int i, num_of_values=m_LookupTable->GetNumberOfTableValues();
 
-  vtkFloatingPointType *alphas;
-  vtkFloatingPointType *alphasHead;
-  alphasHead=alphas=(vtkFloatingPointType*)malloc(sizeof(vtkFloatingPointType)*num_of_values);
+  double *alphas;
+  double *alphasHead;
+  alphasHead=alphas=(double*)malloc(sizeof(double)*num_of_values);
 
   rgba+=3;
   for(i=0;i<num_of_values;++i)
   {
     *alphas=*rgba * 1024.0; ++alphas; rgba+=4;
   }
 
   opacityFunction->BuildFunctionFromTable(m_LookupTable->GetTableRange()[0], m_LookupTable->GetTableRange()[1], num_of_values-1, alphasHead);
 
   free(alphasHead);
 }
 
 void mitk::LookupTable::CreateGradientTransferFunction(vtkPiecewiseFunction*& gradientFunction)
 {
   if(gradientFunction==NULL)
     gradientFunction = vtkPiecewiseFunction::New();
 
   mitk::LookupTable::RawLookupTableType *rgba = GetRawLookupTable();
   int i, num_of_values=m_LookupTable->GetNumberOfTableValues();
 
-  vtkFloatingPointType *alphas;
-  vtkFloatingPointType *alphasHead;
-  alphasHead=alphas=(vtkFloatingPointType*)malloc(sizeof(vtkFloatingPointType)*num_of_values);
+  double *alphas;
+  double *alphasHead;
+  alphasHead=alphas=(double*)malloc(sizeof(double)*num_of_values);
 
   rgba+=3;
   for(i=0;i<num_of_values;++i)
   {
     *alphas=*rgba * 1024.0; ++alphas; rgba+=4;
   }
 
   gradientFunction->BuildFunctionFromTable(m_LookupTable->GetTableRange()[0], m_LookupTable->GetTableRange()[1], num_of_values-1, alphasHead);
 
   free(alphasHead);
 }
 
 void mitk::LookupTable::PrintSelf(std::ostream &os, itk::Indent indent) const
 {
   os << indent;
   m_LookupTable->PrintHeader(os, vtkIndent());
 }
 
 itk::LightObject::Pointer mitk::LookupTable::InternalClone() const
 {
   itk::LightObject::Pointer result(new Self(*this));
   return result;
 }