diff --git a/Modules/IGT/IGTFilters/mitkTrackingVolumeGenerator.cpp b/Modules/IGT/IGTFilters/mitkTrackingVolumeGenerator.cpp
index 8de2c4dd8c..5415037cf5 100644
--- a/Modules/IGT/IGTFilters/mitkTrackingVolumeGenerator.cpp
+++ b/Modules/IGT/IGTFilters/mitkTrackingVolumeGenerator.cpp
@@ -1,117 +1,117 @@
 /*===================================================================
 
 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 "mitkTrackingVolumeGenerator.h"
 #include "mitkSTLFileReader.h"
 #include "mitkStandardFileLocations.h"
 #include "mitkConfig.h"
 #include <vtkCubeSource.h>
 #include <mitkTrackingTypes.h>
 #include <mitkTrackingDevice.h>
 #include <mitkVirtualTrackingDevice.h>
 #include <vtkSmartPointer.h>
 #include <mitkSurface.h>
 
 mitk::TrackingVolumeGenerator::TrackingVolumeGenerator()
 {
   try
     {
     std::string volumeDir = MITK_ROOT;
     volumeDir += "Modules/IGT/IGTTrackingDevices/TrackingVolumeData"; //folder which contains the trackingdevices configs
     mitk::StandardFileLocations::GetInstance()->AddDirectoryForSearch( volumeDir.c_str(), false ); //add this directory to StdFileLocations for the search
     }
   catch(std::exception e)
     {
     MITK_ERROR << "Error: cannot add path to mitk standard file locations";
     //TODO: add appropriate error handling as soon as there is an error handling concept for MITK
     }
 
   m_Data = mitk::DeviceDataUnspecified;
 }
 
 
 void mitk::TrackingVolumeGenerator::SetTrackingDevice (mitk::TrackingDevice::Pointer tracker)
 {
   this->m_Data = mitk::GetFirstCompatibleDeviceDataForLine(tracker->GetType());
 }
 
 void mitk::TrackingVolumeGenerator::GenerateData()
 {
     mitk::Surface::Pointer output = this->GetOutput();  //the surface wich represents the tracking volume
 
     std::string filepath = ""; // Full path to file (wil be resolved later)
   std::string filename = this->m_Data.VolumeModelLocation; // Name of the file or possibly a magic String, e.g. "cube"
 
   // See if filename matches a magic string.
   if (filename.compare("cube") == 0){
             vtkSmartPointer<vtkCubeSource> cubeSource = vtkSmartPointer<vtkCubeSource>::New();
             double bounds[6];
             bounds[0] = bounds[2] = bounds[4] = -400.0;  // initialize bounds to -400 ... +400 cube. This is the default value of the
             bounds[1] = bounds[3] = bounds[5] =  400.0;  // virtual tracking device, but it can be changed. In that case,
                                                          // the tracking volume polydata has to be updated manually
             cubeSource->SetBounds(bounds);
-            cubeSource->GetOutput()->Update();
+//            cubeSource->GetOutput()->Update(); //VTK6_TODO
 
             output->SetVtkPolyData(cubeSource->GetOutput()); //set the vtkCubeSource as polyData of the surface
             return;
   }
   if (filename.compare("") == 0) // empty String means no model, return empty output
   {
       output->SetVtkPolyData(vtkPolyData::New()); //initialize with empty poly data (otherwise old surfaces may be returned) => so an empty surface is returned
       return;
   }
 
   // from here on, we assume that filename contains an actual filename and not a magic string
 
   filepath = mitk::StandardFileLocations::GetInstance()->FindFile(filename.c_str());
 
     if (filepath.empty())
     {
         MITK_ERROR << ("Volume Generator could not find the specified file " + filename);
         return;
     }
 
     mitk::STLFileReader::Pointer stlReader = mitk::STLFileReader::New();
     stlReader->SetFileName( filepath.c_str() );
     stlReader->Update();
 
     if ( stlReader->GetOutput() == NULL)
     {
         MITK_ERROR << "Error while reading file";
         return ;
     }
     output->SetVtkPolyData( stlReader->GetOutput()->GetVtkPolyData());//set the visible trackingvolume
 }
 
 void mitk::TrackingVolumeGenerator::SetTrackingDeviceType(mitk::TrackingDeviceType deviceType)
 {
   m_Data = mitk::GetFirstCompatibleDeviceDataForLine(deviceType);
 }
 
 mitk::TrackingDeviceType mitk::TrackingVolumeGenerator::GetTrackingDeviceType() const
 {
  return m_Data.Line;
 }
 
 void mitk::TrackingVolumeGenerator::SetTrackingDeviceData(mitk::TrackingDeviceData deviceData)
 {
   m_Data= deviceData;
 }
 
 mitk::TrackingDeviceData mitk::TrackingVolumeGenerator::GetTrackingDeviceData() const
 {
    return m_Data;
 }
diff --git a/Modules/QmitkExt/QmitkVideoBackground.cpp b/Modules/QmitkExt/QmitkVideoBackground.cpp
index 5a3bae3346..33dd4c44e3 100644
--- a/Modules/QmitkExt/QmitkVideoBackground.cpp
+++ b/Modules/QmitkExt/QmitkVideoBackground.cpp
@@ -1,302 +1,302 @@
 /*===================================================================
 
 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 "QmitkVideoBackground.h"
 
 // MITK includes
 #include "mitkVtkLayerController.h"
 #include "mitkRenderingManager.h"
 
 // QT includes
 #include <QTimer>
 
 // itk includes
 #include <itkCommand.h>
 
 // VTK includes
 #include <vtkSystemIncludes.h>
 #include <vtkRenderer.h>
 #include <vtkMapper.h>
 #include <vtkObjectFactory.h>
 #include <vtkImageActor.h>
 #include <vtkRenderWindow.h>
 #include <vtkImageImport.h>
 #include <vtkCommand.h>
 #include <vtkCamera.h>
 #include <vtkCommand.h>
 #include <vtkSmartPointer.h>
 #include <vtkCallbackCommand.h>
 
 QmitkVideoBackground::QmitkVideoBackground( QObject *parent )
 : QObject(parent)
 , m_QTimer(new QTimer(this))
 , m_VideoSource(0)
 , m_VideoSourceObserverTag(0)
 {
   this->ResetVideoBackground();
 }
 
 QmitkVideoBackground::QmitkVideoBackground(mitk::VideoSource* v, int TimerDelay)
 : QObject(0)
 , m_QTimer(new QTimer(this))
 , m_VideoSource(0)
 , m_VideoSourceObserverTag(0)
 {
   this->SetVideoSource( v );
   this->ResetVideoBackground();
 }
 
 void QmitkVideoBackground::ResetVideoBackground()
 {
   m_QTimer->setInterval(25);
   connect( m_QTimer, SIGNAL(timeout()), SLOT(UpdateVideo()) );
   m_renderWindowVectorInfo.clear();
 }
 
 QmitkVideoBackground::~QmitkVideoBackground()
 {
   this->Disable();
 }
 
 void QmitkVideoBackground::AddRenderWindow(vtkRenderWindow* renderWindow )
 {
   if(!renderWindow || !m_VideoSource)
   {
     MITK_WARN << "No Renderwindow or VideoSource set!";
     return;
   }
 
   this->RemoveRenderWindow(renderWindow);
 
   vtkRenderer*    videoRenderer   = vtkRenderer::New();
   vtkImageActor*  videoActor      = vtkImageActor::New();
   vtkImageImport* videoImport     = vtkImageImport::New();
 
   videoImport->SetDataScalarTypeToUnsignedChar();
   videoImport->SetNumberOfScalarComponents(3);
 
   if(m_VideoSource->GetImageWidth() == 0)
     m_VideoSource->FetchFrame();
 
   videoImport->SetWholeExtent(0, m_VideoSource->GetImageWidth()-1,
     0, m_VideoSource->GetImageHeight()-1, 0, 1-1);
   videoImport->SetDataExtentToWholeExtent();
 
   VideoBackgroundVectorInfo v;
   v.renWin        = renderWindow;
   v.videoRenderer = videoRenderer;
   v.videoActor    = videoActor;
   v.videoImport   = videoImport;
 
   // callback for the deletion of the renderwindow
   vtkSmartPointer<vtkCallbackCommand> deleteCallback =
     vtkSmartPointer<vtkCallbackCommand>::New();
   deleteCallback->SetCallback ( QmitkVideoBackground::OnRenderWindowDelete );
   deleteCallback->SetClientData(this);
 
   v.renderWindowObserverTag = renderWindow->AddObserver( vtkCommand::DeleteEvent, deleteCallback );
 
   m_renderWindowVectorInfo.push_back(v);
 
   // completes the initialization
   this->Modified();
 }
 
 void QmitkVideoBackground::RemoveRenderWindow( vtkRenderWindow* renderWindow )
 {
   this->RemoveRenderWindow(renderWindow, true);
 }
 
 void QmitkVideoBackground::RemoveRenderWindow( vtkRenderWindow* renderWindow, bool removeObserver )
 {
   // search for renderwindow and remove it
   for(RenderWindowVectorInfoType::iterator it = m_renderWindowVectorInfo.begin();
     it != m_renderWindowVectorInfo.end(); it++)
   {
     if((*it).renWin == renderWindow)
     {
       mitk::VtkLayerController* layerController =
         mitk::VtkLayerController::GetInstance((*it).renWin);
       // unregister video backround renderer from renderwindow
       if( layerController )
         layerController->RemoveRenderer((*it).videoRenderer);
 
       (*it).videoRenderer->Delete();
       (*it).videoActor->Delete();
       (*it).videoImport->Delete();
       // remove listener
       if(removeObserver)
         renderWindow->RemoveObserver( (*it).renderWindowObserverTag );
       m_renderWindowVectorInfo.erase(it);
       break;
     }
   }
 }
 
 bool QmitkVideoBackground::IsRenderWindowIncluded(vtkRenderWindow* renderWindow )
 {
   for(RenderWindowVectorInfoType::iterator it = m_renderWindowVectorInfo.begin();
     it != m_renderWindowVectorInfo.end(); it++)
   {
     if((*it).renWin == renderWindow)
       return true;
   }
   return false;
 }
 
 void QmitkVideoBackground::Pause()
 {
   m_QTimer->stop();
 }
 
 void QmitkVideoBackground::Resume()
 {
   m_QTimer->start();
 }
 
 /**
  * Enables drawing of the color Video background.
  * If you want to disable it, call the Disable() function.
  */
 void QmitkVideoBackground::Enable()
 {
   UpdateVideo();
   Modified();
 
   m_QTimer->start();
 }
 
 /**
  * Disables drawing of the color Video background.
  * If you want to enable it, call the Enable() function.
  */
 void QmitkVideoBackground::Disable()
 {
   if ( this->IsEnabled() )
   {
     mitk::VtkLayerController* layerController = 0;
     for(RenderWindowVectorInfoType::iterator it = m_renderWindowVectorInfo.begin();
       it != m_renderWindowVectorInfo.end(); it++)
     {
       layerController = mitk::VtkLayerController::GetInstance((*it).renWin);
       if(layerController)
         layerController->RemoveRenderer((*it).videoRenderer);
     }
     m_QTimer->stop();
   }
 }
 
 bool QmitkVideoBackground::IsEnabled()
 {
   return m_QTimer->isActive();
 }
 
 void QmitkVideoBackground::UpdateVideo()
 {
   if( m_renderWindowVectorInfo.size() > 0 )
   {
     unsigned char *src = 0;
     src = m_VideoSource->GetVideoTexture();
     if(src)
     {
       for(RenderWindowVectorInfoType::iterator it = m_renderWindowVectorInfo.begin();
         it != m_renderWindowVectorInfo.end(); it++)
       {
         (*it).videoImport->SetImportVoidPointer(src);
         (*it).videoImport->Modified();
         (*it).videoImport->Update();
         mitk::RenderingManager::GetInstance()->RequestUpdate((*it).renWin);
       }
       emit NewFrameAvailable ( m_VideoSource );
     }
     else
       MITK_WARN << "No video texture available";
   }
 }
 
 void QmitkVideoBackground::Modified()
 {
   // ensures registration of video backrounds in each renderwindow
   for(RenderWindowVectorInfoType::iterator it = m_renderWindowVectorInfo.begin();
     it != m_renderWindowVectorInfo.end(); it++)
   {
-    (*it).videoActor->SetInput((*it).videoImport->GetOutput());
+    (*it).videoActor->SetInputData((*it).videoImport->GetOutput());
     (*it).videoRenderer->AddActor2D((*it).videoActor);
     (*it).videoRenderer->ResetCamera();
     (*it).videoRenderer->InteractiveOff();
     (*it).videoRenderer->GetActiveCamera()->ParallelProjectionOn();
     (*it).videoRenderer->GetActiveCamera()->SetParallelScale(m_VideoSource->GetImageHeight()/2);
 
     mitk::VtkLayerController* layerController =
       mitk::VtkLayerController::GetInstance((*it).renWin);
 
     if( layerController && !layerController->IsRendererInserted((*it).videoRenderer) )
       layerController->InsertBackgroundRenderer((*it).videoRenderer,true);
   }
 }
 
 void QmitkVideoBackground::SetVideoSource( mitk::VideoSource* videoSource )
 {
   if( m_VideoSource == videoSource )
     return;
 
   if( m_VideoSource )
     m_VideoSource->RemoveObserver( m_VideoSourceObserverTag );
 
   m_VideoSource = videoSource;
 
   if( m_VideoSource )
   {
     itk::MemberCommand<QmitkVideoBackground>::Pointer _ModifiedCommand =
       itk::MemberCommand<QmitkVideoBackground>::New();
     _ModifiedCommand->SetCallbackFunction(this, &QmitkVideoBackground::OnVideoSourceDelete);
     m_VideoSourceObserverTag
       = m_VideoSource->AddObserver(itk::DeleteEvent(), _ModifiedCommand);
   }
 
 }
 
 void QmitkVideoBackground::SetTimerDelay( int ms )
 {
   m_QTimer->setInterval( ms );
   //ResetVideoBackground();
 }
 
 mitk::VideoSource* QmitkVideoBackground::GetVideoSource()
 {
   return m_VideoSource;
 }
 
 int QmitkVideoBackground::GetTimerDelay()
 {
   return m_QTimer->interval();
 }
 
 void QmitkVideoBackground::OnVideoSourceDelete( const itk::Object* caller,
                                                const itk::EventObject &event )
 {
   this->Disable(); // will only disable if enabled
   m_VideoSource = 0;
 }
 
 void QmitkVideoBackground::OnRenderWindowDelete( vtkObject * object,
                                                  unsigned long eid,
                                                  void* clientdata,
                                                  void * /*calldata*/ )
 {
   QmitkVideoBackground* instance = static_cast<QmitkVideoBackground*>( clientdata );
   instance->RemoveRenderWindow( static_cast<vtkRenderWindow*>(object), false );
 }
diff --git a/Modules/Segmentation/Algorithms/mitkManualSegmentationToSurfaceFilter.cpp b/Modules/Segmentation/Algorithms/mitkManualSegmentationToSurfaceFilter.cpp
index f307c0e106..1c9b41ee77 100644
--- a/Modules/Segmentation/Algorithms/mitkManualSegmentationToSurfaceFilter.cpp
+++ b/Modules/Segmentation/Algorithms/mitkManualSegmentationToSurfaceFilter.cpp
@@ -1,156 +1,156 @@
 /*===================================================================
 
 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 <mitkManualSegmentationToSurfaceFilter.h>
 
 #include <vtkSmartPointer.h>
 
 #include "mitkProgressBar.h"
 
 mitk::ManualSegmentationToSurfaceFilter::ManualSegmentationToSurfaceFilter()
 {
   m_MedianFilter3D = false;
   m_MedianKernelSizeX = 3;
   m_MedianKernelSizeY = 3;
   m_MedianKernelSizeZ = 3;
   m_UseGaussianImageSmooth = false;
   m_GaussianStandardDeviation = 1.5;
   m_Interpolation = false;
   m_InterpolationX = 1.0f;
   m_InterpolationY = 1.0f;
   m_InterpolationZ = 1.0f;
 };
 
 
 mitk::ManualSegmentationToSurfaceFilter::~ManualSegmentationToSurfaceFilter(){};
 
 void mitk::ManualSegmentationToSurfaceFilter::GenerateData()
 {
   mitk::Surface *surface = this->GetOutput();
   mitk::Image * image    =  (mitk::Image*)GetInput();
   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
 
   ScalarType thresholdExpanded = this->m_Threshold;
 
   if ((tmax-tstart) > 0)
   {
     ProgressBar::GetInstance()->AddStepsToDo( 7 * (tmax - tstart)  );
   }
 
   for( int t=tstart; t<tmax; t++ )
   {
 
     vtkSmartPointer<vtkImageData> vtkimage = image->GetVtkImageData(t);
 
     // Median -->smooth 3D
     MITK_INFO << (m_MedianFilter3D ? "Applying median..." : "No median filtering");
     if(m_MedianFilter3D)
     {
       vtkImageMedian3D *median = vtkImageMedian3D::New();
-      median->SetInput(vtkimage); //RC++ (VTK < 5.0)
+      median->SetInputData(vtkimage); //RC++ (VTK < 5.0)
       median->SetKernelSize(m_MedianKernelSizeX,m_MedianKernelSizeY,m_MedianKernelSizeZ);//Std: 3x3x3
       median->ReleaseDataFlagOn();
       median->UpdateInformation();
       median->Update();
       vtkimage = median->GetOutput(); //->Out
       median->Delete();
     }
     ProgressBar::GetInstance()->Progress();
 
     //Interpolate image spacing
     MITK_INFO << (m_Interpolation ? "Resampling..." : "No resampling");
     if(m_Interpolation)
     {
       vtkImageResample * imageresample = vtkImageResample::New();
-      imageresample->SetInput(vtkimage);
+      imageresample->SetInputData(vtkimage);
 
       //Set Spacing Manual to 1mm in each direction (Original spacing is lost during image processing)
       imageresample->SetAxisOutputSpacing(0, m_InterpolationX);
       imageresample->SetAxisOutputSpacing(1, m_InterpolationY);
       imageresample->SetAxisOutputSpacing(2, m_InterpolationZ);
       imageresample->UpdateInformation();
       imageresample->Update();
       vtkimage=imageresample->GetOutput();//->Output
       imageresample->Delete();
     }
     ProgressBar::GetInstance()->Progress();
 
     MITK_INFO << (m_UseGaussianImageSmooth ? "Applying gaussian smoothing..." : "No gaussian smoothing");
     if(m_UseGaussianImageSmooth)//gauss
     {
       vtkImageThreshold* vtkimagethreshold = vtkImageThreshold::New();
-      vtkimagethreshold->SetInput(vtkimage);
+      vtkimagethreshold->SetInputData(vtkimage);
       vtkimagethreshold->SetInValue( 100 );
       vtkimagethreshold->SetOutValue( 0 );
       vtkimagethreshold->ThresholdByUpper( this->m_Threshold );
       thresholdExpanded = 49;
 
       vtkimagethreshold->SetOutputScalarTypeToUnsignedChar();
       vtkimagethreshold->ReleaseDataFlagOn();
 
       vtkImageGaussianSmooth *gaussian = vtkImageGaussianSmooth::New();
-      gaussian->SetInput(vtkimagethreshold->GetOutput());
+      gaussian->SetInputData(vtkimagethreshold->GetOutput());
       gaussian->SetDimensionality(3);
       gaussian->SetRadiusFactor(0.49);
       gaussian->SetStandardDeviation( m_GaussianStandardDeviation );
       gaussian->ReleaseDataFlagOn();
       gaussian->UpdateInformation();
       gaussian->Update();
 
       vtkimage=vtkimagethreshold->GetOutput();
 
       double range[2];
       vtkimage->GetScalarRange(range);
 
       MITK_DEBUG << "Current scalar max is: " << range[1];
       if (range[1]!=0) //too little slices, image smoothing eliminates all segmentation pixels
       {
         vtkimage = gaussian->GetOutput(); //->Out
       }
       else
       {
         MITK_INFO<<"Smoothing removes all pixels of the segmentation. Use unsmoothed result";
       }
       gaussian->Delete();
       vtkimagethreshold->Delete();
 
     }
     ProgressBar::GetInstance()->Progress();
 
     // Create surface for t-Slice
     CreateSurface(t, vtkimage, surface, thresholdExpanded);
     ProgressBar::GetInstance()->Progress();
   }
 };
 
 
 void mitk::ManualSegmentationToSurfaceFilter::SetMedianKernelSize(int x, int y, int z)
 {
   m_MedianKernelSizeX = x;
   m_MedianKernelSizeY = y;
   m_MedianKernelSizeZ = z;
  }
 
 void mitk::ManualSegmentationToSurfaceFilter::SetInterpolation(vtkDouble x, vtkDouble y, vtkDouble z)
 {
   m_InterpolationX = x;
   m_InterpolationY = y;
   m_InterpolationZ = z;
 }
 
diff --git a/Modules/Segmentation/Algorithms/mitkShowSegmentationAsSmoothedSurface.cpp b/Modules/Segmentation/Algorithms/mitkShowSegmentationAsSmoothedSurface.cpp
index 9707620904..16c6c64985 100644
--- a/Modules/Segmentation/Algorithms/mitkShowSegmentationAsSmoothedSurface.cpp
+++ b/Modules/Segmentation/Algorithms/mitkShowSegmentationAsSmoothedSurface.cpp
@@ -1,512 +1,512 @@
 /*===================================================================
 
 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 "mitkShowSegmentationAsSmoothedSurface.h"
 #include "mitkImageToItk.h"
 #include "itkIntelligentBinaryClosingFilter.h"
 #include <mitkUIDGenerator.h>
 #include <mitkGeometry3D.h>
 #include <mitkProgressBar.h>
 #include <mitkStatusBar.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkImageToSurfaceFilter.h>
 #include <mitkVtkRepresentationProperty.h>
 #include <itkImageRegionIteratorWithIndex.h>
 #include <itkRegionOfInterestImageFilter.h>
 #include <itkConstantPadImageFilter.h>
 #include <itkBinaryMedianImageFilter.h>
 #include <itkBinaryThresholdImageFilter.h>
 #include <itkDiscreteGaussianImageFilter.h>
 #include <itkMultiplyImageFilter.h>
 #include <itkConnectedThresholdImageFilter.h>
 #include <itkAddImageFilter.h>
 #include <vtkQuadricDecimation.h>
 #include <vtkCleanPolyData.h>
 #include <vtkPolyDataNormals.h>
 
 using namespace mitk;
 using namespace std;
 
 ShowSegmentationAsSmoothedSurface::ShowSegmentationAsSmoothedSurface()
 {
 }
 
 ShowSegmentationAsSmoothedSurface::~ShowSegmentationAsSmoothedSurface()
 {
 }
 
 void ShowSegmentationAsSmoothedSurface::Initialize(const NonBlockingAlgorithm *other)
 {
   Superclass::Initialize(other);
 
   bool syncVisibility = false;
 
   if (other != NULL)
     other->GetParameter("Sync visibility", syncVisibility);
 
   SetParameter("Sync visibility", syncVisibility);
   SetParameter("Wireframe", false);
 
   // The Smoothing value is used as variance for a Gauß filter.
   // A reasonable default value equals the image spacing in mm.
   SetParameter("Smoothing", 1.0f);
 
   // Valid range for decimation value is [0, 1). High values
   // increase decimation, especially when very close to 1.
   // A value of 0 disables decimation.
   SetParameter("Decimation", 0.5f);
 
   // Valid range for closing value is [0, 1]. Higher values
   // increase closing. A value of 0 disables closing.
   SetParameter("Closing", 0.0f);
 }
 
 bool ShowSegmentationAsSmoothedSurface::ReadyToRun()
 {
   try
   {
     mitk::Image::Pointer image;
     GetPointerParameter("Input", image);
 
     return image.IsNotNull() && GetGroupNode();
   }
   catch (const invalid_argument &)
   {
     return false;
   }
 }
 
 bool ShowSegmentationAsSmoothedSurface::ThreadedUpdateFunction()
 {
   Image::Pointer image;
   GetPointerParameter("Input", image);
 
   float smoothing;
   GetParameter("Smoothing", smoothing);
 
   float decimation;
   GetParameter("Decimation", decimation);
 
   float closing;
   GetParameter("Closing", closing);
 
   int timeNr = 0;
   GetParameter("TimeNr", timeNr);
 
   if (image->GetDimension() == 4)
     MITK_INFO << "CREATING SMOOTHED POLYGON MODEL (t = " << timeNr << ')';
   else
     MITK_INFO << "CREATING SMOOTHED POLYGON MODEL";
 
   MITK_INFO << "  Smoothing  = " << smoothing;
   MITK_INFO << "  Decimation = " << decimation;
   MITK_INFO << "  Closing    = " << closing;
 
   Geometry3D::Pointer geometry = dynamic_cast<Geometry3D *>(image->GetGeometry()->Clone().GetPointer());
 
   // Make ITK image out of MITK image
 
   typedef itk::Image<unsigned char, 3> CharImageType;
   typedef itk::Image<unsigned short, 3> ShortImageType;
   typedef itk::Image<float, 3> FloatImageType;
 
   if (image->GetDimension() == 4)
   {
     ImageTimeSelector::Pointer imageTimeSelector = ImageTimeSelector::New();
     imageTimeSelector->SetInput(image);
     imageTimeSelector->SetTimeNr(timeNr);
     imageTimeSelector->UpdateLargestPossibleRegion();
     image = imageTimeSelector->GetOutput(0);
   }
 
   ImageToItk<CharImageType>::Pointer imageToItkFilter = ImageToItk<CharImageType>::New();
 
   try
   {
     imageToItkFilter->SetInput(image);
   }
   catch (const itk::ExceptionObject &e)
   {
     // Most probably the input image type is wrong. Binary images are expected to be
     // >unsigned< char images.
     MITK_ERROR << e.GetDescription() << endl;
     return false;
   }
 
   imageToItkFilter->Update();
 
   CharImageType::Pointer itkImage = imageToItkFilter->GetOutput();
 
   // Get bounding box and relabel
 
   MITK_INFO << "Extracting VOI...";
 
   int imageLabel = 1;
   bool roiFound = false;
 
   CharImageType::IndexType minIndex;
   minIndex.Fill(numeric_limits<CharImageType::IndexValueType>::max());
 
   CharImageType::IndexType maxIndex;
   maxIndex.Fill(numeric_limits<CharImageType::IndexValueType>::min());
 
   itk::ImageRegionIteratorWithIndex<CharImageType> iter(itkImage, itkImage->GetLargestPossibleRegion());
 
   for (iter.GoToBegin(); !iter.IsAtEnd(); ++iter)
   {
     if (iter.Get() == imageLabel)
     {
       roiFound = true;
       iter.Set(1);
 
       CharImageType::IndexType currentIndex = iter.GetIndex();
 
       for (unsigned int dim = 0; dim < 3; ++dim)
       {
         minIndex[dim] = min(currentIndex[dim], minIndex[dim]);
         maxIndex[dim] = max(currentIndex[dim], maxIndex[dim]);
       }
     }
     else
     {
       iter.Set(0);
     }
   }
 
   if (!roiFound)
   {
     ProgressBar::GetInstance()->Progress(8);
     MITK_ERROR << "Didn't found segmentation labeled with " << imageLabel << "!" << endl;
     return false;
   }
 
   ProgressBar::GetInstance()->Progress(1);
 
   // Extract and pad bounding box
 
   typedef itk::RegionOfInterestImageFilter<CharImageType, CharImageType> ROIFilterType;
 
   ROIFilterType::Pointer roiFilter = ROIFilterType::New();
   CharImageType::RegionType region;
   CharImageType::SizeType size;
 
   for (unsigned int dim = 0; dim < 3; ++dim)
   {
     size[dim] = maxIndex[dim] - minIndex[dim] + 1;
   }
 
   region.SetIndex(minIndex);
   region.SetSize(size);
 
   roiFilter->SetInput(itkImage);
   roiFilter->SetRegionOfInterest(region);
   roiFilter->ReleaseDataFlagOn();
   roiFilter->ReleaseDataBeforeUpdateFlagOn();
 
   typedef itk::ConstantPadImageFilter<CharImageType, CharImageType> PadFilterType;
 
   PadFilterType::Pointer padFilter = PadFilterType::New();
   const PadFilterType::SizeValueType pad[3] = { 10, 10, 10 };
 
   padFilter->SetInput(roiFilter->GetOutput());
   padFilter->SetConstant(0);
   padFilter->SetPadLowerBound(pad);
   padFilter->SetPadUpperBound(pad);
   padFilter->ReleaseDataFlagOn();
   padFilter->ReleaseDataBeforeUpdateFlagOn();
   padFilter->Update();
 
   CharImageType::Pointer roiImage = padFilter->GetOutput();
 
   roiImage->DisconnectPipeline();
   roiFilter = 0;
   padFilter = 0;
 
   // Correct origin of real geometry (changed by cropping and padding)
 
   typedef Geometry3D::TransformType TransformType;
 
   TransformType::Pointer transform = TransformType::New();
   TransformType::OutputVectorType translation;
 
   for (unsigned int dim = 0; dim < 3; ++dim)
     translation[dim] = (int)minIndex[dim] - (int)pad[dim];
 
   transform->SetIdentity();
   transform->Translate(translation);
   geometry->Compose(transform, true);
 
   ProgressBar::GetInstance()->Progress(1);
 
   // Median
 
   MITK_INFO << "Median...";
 
   typedef itk::BinaryMedianImageFilter<CharImageType, CharImageType> MedianFilterType;
 
   MedianFilterType::Pointer medianFilter = MedianFilterType::New();
   CharImageType::SizeType radius = { 0 };
 
   medianFilter->SetRadius(radius);
   medianFilter->SetBackgroundValue(0);
   medianFilter->SetForegroundValue(1);
   medianFilter->SetInput(roiImage);
   medianFilter->ReleaseDataFlagOn();
   medianFilter->ReleaseDataBeforeUpdateFlagOn();
   medianFilter->Update();
 
   ProgressBar::GetInstance()->Progress(1);
 
   // Intelligent closing
 
   MITK_INFO << "Intelligent closing...";
 
   unsigned int surfaceRatio = (unsigned int)((1.0f - closing) * 100.0f);
 
   typedef itk::IntelligentBinaryClosingFilter<CharImageType, ShortImageType> ClosingFilterType;
 
   ClosingFilterType::Pointer closingFilter = ClosingFilterType::New();
 
   closingFilter->SetInput(medianFilter->GetOutput());
   closingFilter->ReleaseDataFlagOn();
   closingFilter->ReleaseDataBeforeUpdateFlagOn();
   closingFilter->SetSurfaceRatio(surfaceRatio);
   closingFilter->Update();
 
   ShortImageType::Pointer closedImage = closingFilter->GetOutput();
 
   closedImage->DisconnectPipeline();
   roiImage = 0;
   medianFilter = 0;
   closingFilter = 0;
 
   ProgressBar::GetInstance()->Progress(1);
 
   // Gaussian blur
 
   MITK_INFO << "Gauss...";
 
   typedef itk::BinaryThresholdImageFilter<ShortImageType, FloatImageType> BinaryThresholdToFloatFilterType;
 
   BinaryThresholdToFloatFilterType::Pointer binThresToFloatFilter = BinaryThresholdToFloatFilterType::New();
 
   binThresToFloatFilter->SetInput(closedImage);
   binThresToFloatFilter->SetLowerThreshold(1);
   binThresToFloatFilter->SetUpperThreshold(1);
   binThresToFloatFilter->SetInsideValue(100);
   binThresToFloatFilter->SetOutsideValue(0);
   binThresToFloatFilter->ReleaseDataFlagOn();
   binThresToFloatFilter->ReleaseDataBeforeUpdateFlagOn();
 
   typedef itk::DiscreteGaussianImageFilter<FloatImageType, FloatImageType> GaussianFilterType;
 
   // From the following line on, IntelliSense (VS 2008) is broken. Any idea how to fix it?
   GaussianFilterType::Pointer gaussFilter = GaussianFilterType::New();
 
   gaussFilter->SetInput(binThresToFloatFilter->GetOutput());
   gaussFilter->SetUseImageSpacing(true);
   gaussFilter->SetVariance(smoothing);
   gaussFilter->ReleaseDataFlagOn();
   gaussFilter->ReleaseDataBeforeUpdateFlagOn();
 
   typedef itk::BinaryThresholdImageFilter<FloatImageType, CharImageType> BinaryThresholdFromFloatFilterType;
 
   BinaryThresholdFromFloatFilterType::Pointer binThresFromFloatFilter = BinaryThresholdFromFloatFilterType::New();
 
   binThresFromFloatFilter->SetInput(gaussFilter->GetOutput());
   binThresFromFloatFilter->SetLowerThreshold(50);
   binThresFromFloatFilter->SetUpperThreshold(255);
   binThresFromFloatFilter->SetInsideValue(1);
   binThresFromFloatFilter->SetOutsideValue(0);
   binThresFromFloatFilter->ReleaseDataFlagOn();
   binThresFromFloatFilter->ReleaseDataBeforeUpdateFlagOn();
   binThresFromFloatFilter->Update();
 
   CharImageType::Pointer blurredImage = binThresFromFloatFilter->GetOutput();
 
   blurredImage->DisconnectPipeline();
   closedImage = 0;
   binThresToFloatFilter = 0;
   gaussFilter = 0;
 
   ProgressBar::GetInstance()->Progress(1);
 
   // Fill holes
 
   MITK_INFO << "Filling cavities...";
 
   typedef itk::ConnectedThresholdImageFilter<CharImageType, CharImageType> ConnectedThresholdFilterType;
 
   ConnectedThresholdFilterType::Pointer connectedThresFilter = ConnectedThresholdFilterType::New();
 
   CharImageType::IndexType corner;
 
   corner[0] = 0;
   corner[1] = 0;
   corner[2] = 0;
 
   connectedThresFilter->SetInput(blurredImage);
   connectedThresFilter->SetSeed(corner);
   connectedThresFilter->SetLower(0);
   connectedThresFilter->SetUpper(0);
   connectedThresFilter->SetReplaceValue(2);
   connectedThresFilter->ReleaseDataFlagOn();
   connectedThresFilter->ReleaseDataBeforeUpdateFlagOn();
 
   typedef itk::BinaryThresholdImageFilter<CharImageType, CharImageType> BinaryThresholdFilterType;
 
   BinaryThresholdFilterType::Pointer binThresFilter = BinaryThresholdFilterType::New();
 
   binThresFilter->SetInput(connectedThresFilter->GetOutput());
   binThresFilter->SetLowerThreshold(0);
   binThresFilter->SetUpperThreshold(0);
   binThresFilter->SetInsideValue(50);
   binThresFilter->SetOutsideValue(0);
   binThresFilter->ReleaseDataFlagOn();
   binThresFilter->ReleaseDataBeforeUpdateFlagOn();
 
   typedef itk::AddImageFilter<CharImageType, CharImageType, CharImageType> AddFilterType;
 
   AddFilterType::Pointer addFilter = AddFilterType::New();
 
   addFilter->SetInput1(blurredImage);
   addFilter->SetInput2(binThresFilter->GetOutput());
   addFilter->ReleaseDataFlagOn();
   addFilter->ReleaseDataBeforeUpdateFlagOn();
   addFilter->Update();
 
   ProgressBar::GetInstance()->Progress(1);
 
   // Surface extraction
 
   MITK_INFO << "Surface extraction...";
 
   Image::Pointer filteredImage = Image::New();
   CastToMitkImage(addFilter->GetOutput(), filteredImage);
 
   filteredImage->SetGeometry(geometry);
 
   ImageToSurfaceFilter::Pointer imageToSurfaceFilter = ImageToSurfaceFilter::New();
 
   imageToSurfaceFilter->SetInput(filteredImage);
   imageToSurfaceFilter->SetThreshold(50);
   imageToSurfaceFilter->SmoothOn();
   imageToSurfaceFilter->SetDecimate(ImageToSurfaceFilter::NoDecimation);
 
   m_Surface = imageToSurfaceFilter->GetOutput(0);
 
   ProgressBar::GetInstance()->Progress(1);
 
   // Mesh decimation
 
   if (decimation > 0.0f && decimation < 1.0f)
   {
     MITK_INFO << "Quadric mesh decimation...";
 
     vtkQuadricDecimation *quadricDecimation = vtkQuadricDecimation::New();
-    quadricDecimation->SetInput(m_Surface->GetVtkPolyData());
+    quadricDecimation->SetInputData(m_Surface->GetVtkPolyData());
     quadricDecimation->SetTargetReduction(decimation);
     quadricDecimation->AttributeErrorMetricOn();
     quadricDecimation->GlobalWarningDisplayOff();
     quadricDecimation->Update();
 
     vtkCleanPolyData* cleaner = vtkCleanPolyData::New();
-    cleaner->SetInput(quadricDecimation->GetOutput());
+    cleaner->SetInputData(quadricDecimation->GetOutput());
     cleaner->PieceInvariantOn();
     cleaner->ConvertLinesToPointsOn();
     cleaner->ConvertStripsToPolysOn();
     cleaner->PointMergingOn();
     cleaner->Update();
 
     m_Surface->SetVtkPolyData(cleaner->GetOutput());
   }
 
   ProgressBar::GetInstance()->Progress(1);
 
   // Compute Normals
 
   vtkPolyDataNormals* computeNormals = vtkPolyDataNormals::New();
-  computeNormals->SetInput(m_Surface->GetVtkPolyData());
+  computeNormals->SetInputData(m_Surface->GetVtkPolyData());
   computeNormals->SetFeatureAngle(360.0f);
   computeNormals->FlipNormalsOff();
   computeNormals->Update();
 
   m_Surface->SetVtkPolyData(computeNormals->GetOutput());
 
   return true;
 }
 
 void ShowSegmentationAsSmoothedSurface::ThreadedUpdateSuccessful()
 {
   DataNode::Pointer node = DataNode::New();
 
   bool wireframe = false;
   GetParameter("Wireframe", wireframe);
 
   if (wireframe)
   {
     VtkRepresentationProperty *representation = dynamic_cast<VtkRepresentationProperty *>(
       node->GetProperty("material.representation"));
 
     if (representation != NULL)
       representation->SetRepresentationToWireframe();
   }
 
   node->SetProperty("opacity", FloatProperty::New(1.0));
   node->SetProperty("line width", IntProperty::New(1));
   node->SetProperty("scalar visibility", BoolProperty::New(false));
 
   std::string groupNodeName = "surface";
   DataNode *groupNode = GetGroupNode();
 
   if (groupNode != NULL)
     groupNode->GetName(groupNodeName);
 
   node->SetProperty("name", StringProperty::New(groupNodeName));
   node->SetData(m_Surface);
 
   BaseProperty *colorProperty = groupNode->GetProperty("color");
 
   if (colorProperty != NULL)
     node->ReplaceProperty("color", colorProperty);
   else
     node->SetProperty("color", ColorProperty::New(1.0f, 0.0f, 0.0f));
 
   bool showResult = true;
   GetParameter("Show result", showResult);
 
   bool syncVisibility = false;
   GetParameter("Sync visibility", syncVisibility);
 
   Image::Pointer image;
   GetPointerParameter("Input", image);
 
   BaseProperty *organTypeProperty = image->GetProperty("organ type");
 
   if (organTypeProperty != NULL)
     m_Surface->SetProperty("organ type", organTypeProperty);
 
   BaseProperty *visibleProperty = groupNode->GetProperty("visible");
 
   if (visibleProperty != NULL && syncVisibility)
     node->ReplaceProperty("visible", visibleProperty);
   else
     node->SetProperty("visible", BoolProperty::New(showResult));
 
   InsertBelowGroupNode(node);
 
   Superclass::ThreadedUpdateSuccessful();
 }
diff --git a/Modules/Segmentation/Algorithms/mitkShowSegmentationAsSurface.cpp b/Modules/Segmentation/Algorithms/mitkShowSegmentationAsSurface.cpp
index 125e07bc0d..c4bf8c53b4 100644
--- a/Modules/Segmentation/Algorithms/mitkShowSegmentationAsSurface.cpp
+++ b/Modules/Segmentation/Algorithms/mitkShowSegmentationAsSurface.cpp
@@ -1,231 +1,231 @@
 /*===================================================================
 
 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 "mitkShowSegmentationAsSurface.h"
 #include "mitkManualSegmentationToSurfaceFilter.h"
 #include "mitkDataNodeFactory.h"
 #include "mitkVtkRepresentationProperty.h"
 #include <mitkCoreObjectFactory.h>
 
 #include <vtkPolyDataNormals.h>
 
 namespace mitk
 {
 
 ShowSegmentationAsSurface::ShowSegmentationAsSurface()
 :m_UIDGeneratorSurfaces("Surface_"),
  m_AddToTree(false)
 {
 }
 
 
 ShowSegmentationAsSurface::~ShowSegmentationAsSurface()
 {
 }
 
 void ShowSegmentationAsSurface::Initialize(const NonBlockingAlgorithm* other)
 {
   Superclass::Initialize(other);
 
   bool syncVisibility(false);
 
   if (other)
   {
     other->GetParameter("Sync visibility", syncVisibility);
   }
 
   SetParameter("Sync visibility", syncVisibility );
   SetParameter("Median kernel size", 3u);
   SetParameter("Apply median", true );
   SetParameter("Smooth", true );
   SetParameter("Gaussian SD", 1.5f );
   SetParameter("Decimate mesh", true );
   SetParameter("Decimation rate", 0.8f );
   SetParameter("Wireframe", false );
 }
 
 
 bool ShowSegmentationAsSurface::ReadyToRun()
 {
   try
   {
     Image::Pointer image;
     GetPointerParameter("Input", image);
 
     return image.IsNotNull() && GetGroupNode();
   }
   catch (std::invalid_argument&)
   {
     return false;
   }
 }
 
 
 bool ShowSegmentationAsSurface::ThreadedUpdateFunction()
 {
   Image::Pointer image;
   GetPointerParameter("Input", image);
 
   bool smooth(true);
   GetParameter("Smooth", smooth);
 
   bool applyMedian(true);
   GetParameter("Apply median", applyMedian);
 
   bool decimateMesh(true);
   GetParameter("Decimate mesh", decimateMesh);
 
   unsigned int medianKernelSize(3);
   GetParameter("Median kernel size", medianKernelSize);
 
   float gaussianSD(1.5);
   GetParameter("Gaussian SD", gaussianSD );
 
   float reductionRate(0.8);
   GetParameter("Decimation rate", reductionRate );
 
   MITK_INFO << "Creating polygon model with smoothing " << smooth << " gaussianSD " << gaussianSD
                                          << " median " << applyMedian << " median kernel " << medianKernelSize
                                          << " mesh reduction " << decimateMesh << " reductionRate " << reductionRate;
 
   ManualSegmentationToSurfaceFilter::Pointer surfaceFilter = ManualSegmentationToSurfaceFilter::New();
   surfaceFilter->SetInput( image );
   surfaceFilter->SetThreshold( 1 ); //expects binary image with zeros and ones
 
   surfaceFilter->SetUseGaussianImageSmooth(smooth); // apply gaussian to thresholded image ?
   if (smooth)
   {
     surfaceFilter->InterpolationOn();
     surfaceFilter->SetGaussianStandardDeviation( gaussianSD );
     //surfaceFilter->SetGaussianStandardDeviation( 3 );
     //surfaceFilter->SetUseGaussianImageSmooth(true);
   }
 
   surfaceFilter->SetMedianFilter3D(applyMedian); // apply median to segmentation before marching cubes ?
   if (applyMedian)
   {
     surfaceFilter->SetMedianKernelSize(medianKernelSize, medianKernelSize, medianKernelSize); // apply median to segmentation before marching cubes
   }
 
   //fix to avoid vtk warnings see bug #5390
   if ( image->GetDimension() > 3 )
     decimateMesh = false;
 
   if (decimateMesh)
   {
     surfaceFilter->SetDecimate( ImageToSurfaceFilter::QuadricDecimation );
     surfaceFilter->SetTargetReduction( reductionRate );
   }
   else
   {
     surfaceFilter->SetDecimate( ImageToSurfaceFilter::NoDecimation );
   }
 
   surfaceFilter->UpdateLargestPossibleRegion();
 
   // calculate normals for nicer display
   m_Surface = surfaceFilter->GetOutput();
 
   vtkPolyData* polyData = m_Surface->GetVtkPolyData();
 
   if (!polyData) throw std::logic_error("Could not create polygon model");
 
   polyData->SetVerts(0);
   polyData->SetLines(0);
 
   if ( smooth || applyMedian || decimateMesh)
   {
     vtkPolyDataNormals* normalsGen = vtkPolyDataNormals::New();
 
-    normalsGen->SetInput( polyData );
+    normalsGen->SetInputData( polyData );
     normalsGen->Update();
 
     m_Surface->SetVtkPolyData( normalsGen->GetOutput() );
 
     normalsGen->Delete();
   }
   else
   {
     m_Surface->SetVtkPolyData( polyData );
   }
 
   return true;
 }
 
 void ShowSegmentationAsSurface::ThreadedUpdateSuccessful()
 {
   m_Node = DataNode::New();
 
   bool wireframe(false);
   GetParameter("Wireframe", wireframe );
   if (wireframe)
   {
     VtkRepresentationProperty *np = dynamic_cast<VtkRepresentationProperty*>(m_Node->GetProperty("material.representation"));
     if (np)
       np->SetRepresentationToWireframe();
   }
 
   m_Node->SetProperty("opacity", FloatProperty::New(0.3) );
   m_Node->SetProperty("line width", IntProperty::New(1) );
   m_Node->SetProperty("scalar visibility", BoolProperty::New(false) );
 
   std::string groupNodesName ("surface");
 
   DataNode* groupNode = GetGroupNode();
   if (groupNode)
   {
     groupNode->GetName( groupNodesName );
   }
   m_Node->SetProperty( "name", StringProperty::New(groupNodesName) );
 
   // synchronize this object's color with the parent's color
   //surfaceNode->SetProperty( "color", parentNode->GetProperty( "color" ) );
   //surfaceNode->SetProperty( "visible", parentNode->GetProperty( "visible" ) );
 
   m_Node->SetData( m_Surface );
 
   BaseProperty* colorProp = groupNode->GetProperty("color");
   if (colorProp)
     m_Node->ReplaceProperty("color", colorProp);
   else
     m_Node->SetProperty("color", ColorProperty::New(1.0, 1.0, 0.0));
 
   bool showResult(true);
   GetParameter("Show result", showResult );
 
   bool syncVisibility(false);
   GetParameter("Sync visibility", syncVisibility );
 
   Image::Pointer image;
   GetPointerParameter("Input", image);
 
   BaseProperty* organTypeProp = image->GetProperty("organ type");
   if (organTypeProp)
     m_Surface->SetProperty("organ type", organTypeProp);
 
   BaseProperty* visibleProp = groupNode->GetProperty("visible");
   if (visibleProp && syncVisibility)
     m_Node->ReplaceProperty("visible", visibleProp);
   else
     m_Node->SetProperty("visible", BoolProperty::New(showResult));
 
   InsertBelowGroupNode(m_Node);
 
   Superclass::ThreadedUpdateSuccessful();
 }
 
 } // namespace
 
diff --git a/Modules/Segmentation/DataManagement/mitkExtrudedContour.cpp b/Modules/Segmentation/DataManagement/mitkExtrudedContour.cpp
index 585b57aa88..96321d7a9a 100644
--- a/Modules/Segmentation/DataManagement/mitkExtrudedContour.cpp
+++ b/Modules/Segmentation/DataManagement/mitkExtrudedContour.cpp
@@ -1,374 +1,374 @@
 /*===================================================================
 
 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 "mitkExtrudedContour.h"
 #include "mitkVector.h"
 #include "mitkBaseProcess.h"
 #include "mitkProportionalTimeGeometry.h"
 
 #include <vtkLinearExtrusionFilter.h>
 #include <vtkPolyData.h>
 #include <vtkPoints.h>
 #include <vtkCellArray.h>
 #include <vtkPlanes.h>
 #include <vtkClipPolyData.h>
 
 #include <vtkPolygon.h>
 #include <vtkFloatArray.h>
 #include <vtkDoubleArray.h>
 #include <vtkPlane.h>
 
 
 //vtkButterflySubdivisionFilter * subdivs;
 #include <vtkSampleFunction.h>
 #include <vtkTriangleFilter.h>
 #include <vtkLinearSubdivisionFilter.h>
 #include <vtkImageData.h>
 #include <vtkCubeSource.h>
 
 mitk::ExtrudedContour::ExtrudedContour()
   : m_Contour(NULL), m_ClippingGeometry(NULL), m_AutomaticVectorGeneration(false)
 {
   ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
   timeGeometry->Initialize(1);
   SetTimeGeometry(timeGeometry);
 
   FillVector3D(m_Vector, 0.0, 0.0, 1.0);
   m_RightVector.Fill(0.0);
 
   m_ExtrusionFilter = vtkLinearExtrusionFilter::New();
 
   m_ExtrusionFilter->CappingOff();
   m_ExtrusionFilter->SetExtrusionTypeToVectorExtrusion();
 
   double vtkvector[3]={0,0,1};
 
   // set extrusion vector
   m_ExtrusionFilter->SetVector(vtkvector);
 
   m_TriangleFilter = vtkTriangleFilter::New();
-  m_TriangleFilter->SetInput(m_ExtrusionFilter->GetOutput());
+  m_TriangleFilter->SetInputData(m_ExtrusionFilter->GetOutput());
 
   m_SubdivisionFilter = vtkLinearSubdivisionFilter::New();
-  m_SubdivisionFilter->SetInput(m_TriangleFilter->GetOutput());
+  m_SubdivisionFilter->SetInputData(m_TriangleFilter->GetOutput());
   m_SubdivisionFilter->SetNumberOfSubdivisions(4);
 
   m_ClippingBox = vtkPlanes::New();
   m_ClipPolyDataFilter = vtkClipPolyData::New();
-  m_ClipPolyDataFilter->SetInput(m_SubdivisionFilter->GetOutput());
+  m_ClipPolyDataFilter->SetInputData(m_SubdivisionFilter->GetOutput());
   m_ClipPolyDataFilter->SetClipFunction(m_ClippingBox);
   m_ClipPolyDataFilter->InsideOutOn();
 
   m_Polygon = vtkPolygon::New();
 
   m_ProjectionPlane = mitk::PlaneGeometry::New();
 }
 
 mitk::ExtrudedContour::~ExtrudedContour()
 {
   m_ClipPolyDataFilter->Delete();
   m_ClippingBox->Delete();
   m_SubdivisionFilter->Delete();
   m_TriangleFilter->Delete();
   m_ExtrusionFilter->Delete();
   m_Polygon->Delete();
 }
 
 bool mitk::ExtrudedContour::IsInside(const Point3D& worldPoint) const
 {
   static double polygonNormal[3]={0.0,0.0,1.0};
 
   // project point onto plane
   float xt[3];
   itk2vtk(worldPoint, xt);
 
   xt[0] = worldPoint[0]-m_Origin[0];
   xt[1] = worldPoint[1]-m_Origin[1];
   xt[2] = worldPoint[2]-m_Origin[2];
 
   float dist=xt[0]*m_Normal[0]+xt[1]*m_Normal[1]+xt[2]*m_Normal[2];
   xt[0] -= dist*m_Normal[0];
   xt[1] -= dist*m_Normal[1];
   xt[2] -= dist*m_Normal[2];
 
   double x[3];
 
   x[0] = xt[0]*m_Right[0]+xt[1]*m_Right[1]+xt[2]*m_Right[2];
   x[1] = xt[0]*m_Down[0] +xt[1]*m_Down[1] +xt[2]*m_Down[2];
   x[2] = 0;
 
   // determine whether it's in the selection loop and then evaluate point
   // in polygon only if absolutely necessary.
   if ( x[0] >= this->m_ProjectedContourBounds[0] && x[0] <= this->m_ProjectedContourBounds[1] &&
     x[1] >= this->m_ProjectedContourBounds[2] && x[1] <= this->m_ProjectedContourBounds[3] &&
     this->m_Polygon->PointInPolygon(x, m_Polygon->Points->GetNumberOfPoints(),
     ((vtkDoubleArray *)this->m_Polygon->Points->GetData())->GetPointer(0),
     (double*)const_cast<mitk::ExtrudedContour*>(this)->m_ProjectedContourBounds, polygonNormal) == 1 )
     return true;
   else
     return false;
 
 }
 
 mitk::ScalarType mitk::ExtrudedContour::GetVolume()
 {
   return -1.0;
 }
 
 void mitk::ExtrudedContour::UpdateOutputInformation()
 {
   if ( this->GetSource() )
   {
     this->GetSource()->UpdateOutputInformation();
   }
   if(GetMTime() > m_LastCalculateExtrusionTime)
   {
     BuildGeometry();
     BuildSurface();
   }
   //if ( ( m_CalculateBoundingBox ) && ( m_PolyDataSeries.size() > 0 ) )
   //  CalculateBoundingBox();
 }
 
 void mitk::ExtrudedContour::BuildSurface()
 {
   if(m_Contour.IsNull())
   {
     SetVtkPolyData(NULL);
     return;
   }
 
   // set extrusion contour
   vtkPolyData *polyData = vtkPolyData::New();
   vtkCellArray *polys   = vtkCellArray::New();
 
   polys->InsertNextCell(m_Polygon->GetPointIds());
   polyData->SetPoints(m_Polygon->GetPoints());
 
   //float vtkpoint[3];
   //unsigned int i, numPts = m_Polygon->GetNumberOfPoints();
   //for(i=0; i<numPts; ++i)
   //{
   //  float * vtkpoint = this->m_Polygon->Points->GetPoint(i);
 
   //  pointids[i]=loopPoints->InsertNextPoint(vtkpoint);
   //}
   //polys->InsertNextCell( i, pointids );
   //delete [] pointids;
 
   //polyData->SetPoints( loopPoints );
   polyData->SetPolys( polys );
   polys->Delete();
 
-  m_ExtrusionFilter->SetInput(polyData);
+  m_ExtrusionFilter->SetInputData(polyData);
 
   polyData->Delete();
 
   // set extrusion scale factor
   m_ExtrusionFilter->SetScaleFactor(GetGeometry()->GetExtentInMM(2));
   SetVtkPolyData(m_SubdivisionFilter->GetOutput());
   //if(m_ClippingGeometry.IsNull())
   //{
   //  SetVtkPolyData(m_SubdivisionFilter->GetOutput());
   //}
   //else
   //{
   //  m_ClipPolyDataFilter->SetInput(m_SubdivisionFilter->GetOutput());
   //  mitk::BoundingBox::BoundsArrayType bounds=m_ClippingGeometry->GetBounds();
 
   //  m_ClippingBox->SetBounds(bounds[0], bounds[1], bounds[2], bounds[3], bounds[4], bounds[5]);
   //  m_ClippingBox->SetTransform(GetGeometry()->GetVtkTransform());
   //  m_ClipPolyDataFilter->SetClipFunction(m_ClippingBox);
   //  m_ClipPolyDataFilter->SetValue(0);
   //  SetVtkPolyData(m_ClipPolyDataFilter->GetOutput());
   //}
 
   m_LastCalculateExtrusionTime.Modified();
 }
 
 void mitk::ExtrudedContour::BuildGeometry()
 {
   if(m_Contour.IsNull())
     return;
 
 //  Initialize(1);
 
   Vector3D nullvector; nullvector.Fill(0.0);
   float xProj[3];
   unsigned int i;
   unsigned int numPts = 20; //m_Contour->GetNumberOfPoints();
   mitk::Contour::PathPointer path = m_Contour->GetContourPath();
   mitk::Contour::PathType::InputType cstart = path->StartOfInput();
   mitk::Contour::PathType::InputType cend   = path->EndOfInput();
   mitk::Contour::PathType::InputType cstep  = (cend-cstart)/numPts;
   mitk::Contour::PathType::InputType ccur;
 
   // Part I: guarantee/calculate legal vectors
 
   m_Vector.Normalize();
   itk2vtk(m_Vector, m_Normal);
   // check m_Vector
   if(mitk::Equal(m_Vector, nullvector) || m_AutomaticVectorGeneration)
   {
     if ( m_AutomaticVectorGeneration == false)
       itkWarningMacro("Extrusion vector is 0 ("<< m_Vector << "); trying to use normal of polygon");
 
     vtkPoints *loopPoints = vtkPoints::New();
     //mitk::Contour::PointsContainerIterator pointsIt = m_Contour->GetPoints()->Begin();
     double vtkpoint[3];
 
     unsigned int i=0;
     for(i=0, ccur=cstart; i<numPts; ++i, ccur+=cstep)
     {
       itk2vtk(path->Evaluate(ccur), vtkpoint);
       loopPoints->InsertNextPoint(vtkpoint);
     }
 
     // Make sure points define a loop with a m_Normal
     vtkPolygon::ComputeNormal(loopPoints, m_Normal);
     loopPoints->Delete();
 
     vtk2itk(m_Normal, m_Vector);
     if(mitk::Equal(m_Vector, nullvector))
     {
       itkExceptionMacro("Cannot calculate normal of polygon");
     }
   }
   // check m_RightVector
   if((mitk::Equal(m_RightVector, nullvector)) || (mitk::Equal(m_RightVector*m_Vector, 0.0)==false))
   {
     if(mitk::Equal(m_RightVector, nullvector))
     {
       itkDebugMacro("Right vector is 0. Calculating.");
     }
     else
     {
       itkWarningMacro("Right vector ("<<m_RightVector<<") not perpendicular to extrusion vector "<<m_Vector<<": "<<m_RightVector*m_Vector);
     }
     // calculate a legal m_RightVector
     if( mitk::Equal( m_Vector[1], 0.0f ) == false )
     {
       FillVector3D( m_RightVector, 1.0f, -m_Vector[0]/m_Vector[1], 0.0f );
       m_RightVector.Normalize();
     }
     else
     {
       FillVector3D( m_RightVector, 0.0f, 1.0f, 0.0f );
     }
   }
 
   // calculate down-vector
   VnlVector rightDV = m_RightVector.GetVnlVector(); rightDV.normalize(); vnl2vtk(rightDV, m_Right);
   VnlVector downDV  = vnl_cross_3d( m_Vector.GetVnlVector(), rightDV ); downDV.normalize();  vnl2vtk(downDV,  m_Down);
 
   // Part II: calculate plane as base for extrusion, project the contour
   // on this plane and store as polygon for IsInside test and BoundingBox calculation
 
   // initialize m_ProjectionPlane, yet with origin at 0
   m_ProjectionPlane->InitializeStandardPlane(rightDV, downDV);
 
   // create vtkPolygon from contour and simultaneously determine 2D bounds of
   // contour projected on m_ProjectionPlane
   //mitk::Contour::PointsContainerIterator pointsIt = m_Contour->GetPoints()->Begin();
   m_Polygon->Points->Reset();
   m_Polygon->Points->SetNumberOfPoints(numPts);
   m_Polygon->PointIds->Reset();
   m_Polygon->PointIds->SetNumberOfIds(numPts);
   mitk::Point2D pt2d;
   mitk::Point3D pt3d;
   mitk::Point2D min, max;
   min.Fill(ScalarTypeNumericTraits::max());
   max.Fill(ScalarTypeNumericTraits::min());
   xProj[2]=0.0;
   for(i=0, ccur=cstart; i<numPts; ++i, ccur+=cstep)
   {
     pt3d.CastFrom(path->Evaluate(ccur));
     m_ProjectionPlane->Map(pt3d, pt2d);
     xProj[0]=pt2d[0];
     if(pt2d[0]<min[0]) min[0]=pt2d[0];
     if(pt2d[0]>max[0]) max[0]=pt2d[0];
     xProj[1]=pt2d[1];
     if(pt2d[1]<min[1]) min[1]=pt2d[1];
     if(pt2d[1]>max[1]) max[1]=pt2d[1];
     m_Polygon->Points->SetPoint(i, xProj);
     m_Polygon->PointIds->SetId(i, i);
   }
   // shift parametric origin to (0,0)
   for(i=0; i<numPts; ++i)
   {
     double * pt = this->m_Polygon->Points->GetPoint(i);
 
     pt[0]-=min[0]; pt[1]-=min[1];
     itkDebugMacro( << i << ": (" << pt[0] << "," << pt[1] << "," << pt[2] << ")" );
   }
   this->m_Polygon->GetBounds(m_ProjectedContourBounds);
   //m_ProjectedContourBounds[4]=-1.0; m_ProjectedContourBounds[5]=1.0;
 
   // calculate origin (except translation along the normal) and bounds
   // of m_ProjectionPlane:
   //  origin is composed of the minimum x-/y-coordinates of the polygon,
   //  bounds from the extent of the polygon, both after projecting on the plane
   mitk::Point3D origin;
   m_ProjectionPlane->Map(min, origin);
   ScalarType bounds[6]={0, max[0]-min[0], 0, max[1]-min[1], 0, 1};
   m_ProjectionPlane->SetBounds(bounds);
   m_ProjectionPlane->SetOrigin(origin);
 
   // Part III: initialize geometry
   if(m_ClippingGeometry.IsNotNull())
   {
     ScalarType min_dist=ScalarTypeNumericTraits::max(), max_dist=ScalarTypeNumericTraits::min(), dist;
     unsigned char i;
     for(i=0; i<8; ++i)
     {
       dist = m_ProjectionPlane->SignedDistance( m_ClippingGeometry->GetCornerPoint(i) );
       if(dist<min_dist) min_dist=dist;
       if(dist>max_dist) max_dist=dist;
     }
     //incorporate translation along the normal into origin
     origin = origin+m_Vector*min_dist;
     m_ProjectionPlane->SetOrigin(origin);
     bounds[5]=max_dist-min_dist;
   }
   else
     bounds[5]=20;
 
   itk2vtk(origin, m_Origin);
 
   mitk::Geometry3D::Pointer g3d = GetGeometry( 0 );
   assert( g3d.IsNotNull() );
   g3d->SetBounds(bounds);
   g3d->SetIndexToWorldTransform(m_ProjectionPlane->GetIndexToWorldTransform());
   g3d->TransferItkToVtkTransform();
 
   ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
   timeGeometry->Initialize(g3d,1);
   SetTimeGeometry(timeGeometry);
 
 }
 
 unsigned long mitk::ExtrudedContour::GetMTime() const
 {
   unsigned long latestTime = Superclass::GetMTime();
   if(m_Contour.IsNotNull())
   {
     unsigned long localTime;
     localTime = m_Contour->GetMTime();
     if(localTime > latestTime) latestTime = localTime;
   }
   return latestTime;
 }
diff --git a/Modules/Segmentation/Rendering/mitkContourSetVtkMapper3D.cpp b/Modules/Segmentation/Rendering/mitkContourSetVtkMapper3D.cpp
index 49752564fb..5bae0c8f36 100644
--- a/Modules/Segmentation/Rendering/mitkContourSetVtkMapper3D.cpp
+++ b/Modules/Segmentation/Rendering/mitkContourSetVtkMapper3D.cpp
@@ -1,166 +1,166 @@
 /*===================================================================
 
 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 "mitkContourSetVtkMapper3D.h"
 #include "mitkDataNode.h"
 #include "mitkProperties.h"
 #include "mitkColorProperty.h"
 #include "mitkVtkPropRenderer.h"
 
 
 #include <vtkActor.h>
 #include <vtkActor.h>
 #include <vtkCellArray.h>
 #include <vtkAppendPolyData.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkFollower.h>
 #include <vtkAssembly.h>
 #include <vtkProp3DCollection.h>
 #include <vtkRenderer.h>
 #include <vtkLinearTransform.h>
 #include <vtkTubeFilter.h>
 #include <vtkPolygon.h>
 
 
 #include <vtkProperty.h>
 #include <vtkPolyDataMapper.h>
 #include <stdlib.h>
 
 
 mitk::ContourSetVtkMapper3D::ContourSetVtkMapper3D()
 {
   m_VtkPolyDataMapper = vtkPolyDataMapper::New();
   m_Actor = vtkActor::New();
   m_Actor->SetMapper(m_VtkPolyDataMapper);
 
   m_ContourSet = vtkPolyData::New();
   m_TubeFilter = vtkTubeFilter::New();
 }
 
 mitk::ContourSetVtkMapper3D::~ContourSetVtkMapper3D()
 {
   if( m_VtkPolyDataMapper )
     m_VtkPolyDataMapper->Delete();;
 
   if( m_TubeFilter )
     m_TubeFilter->Delete();;
 
   if( m_ContourSet )
     m_ContourSet->Delete();;
 
   if( m_Actor )
     m_Actor->Delete();;
 }
 
 vtkProp* mitk::ContourSetVtkMapper3D::GetVtkProp(mitk::BaseRenderer*  /*renderer*/)
 {
   return m_Actor;
 }
 
 void mitk::ContourSetVtkMapper3D::GenerateDataForRenderer(mitk::BaseRenderer* renderer)
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
 
   if(!visible)
   {
     m_Actor->VisibilityOff();
     return;
   }
 
   m_Actor->VisibilityOn();
 
   mitk::ContourSet::Pointer input  = const_cast<mitk::ContourSet*>(this->GetInput());
 
   if ( renderer->GetDisplayGeometryUpdateTime() > this->GetInput()->GetMTime() )
   {
     m_ContourSet = vtkPolyData::New();
 
     vtkPoints *points = vtkPoints::New();
     vtkCellArray *lines = vtkCellArray::New();
 
     mitk::ContourSet::Pointer input =  const_cast<mitk::ContourSet*>(this->GetInput());
     mitk::ContourSet::ContourVectorType contourVec = input->GetContours();
     mitk::ContourSet::ContourIterator contourIt = contourVec.begin();
 
     vtkIdType firstPointIndex= 0, lastPointIndex=0;
 
     vtkIdType ptIndex = 0;
     while ( contourIt != contourVec.end() )
     {
       mitk::Contour* nextContour = (mitk::Contour*) (*contourIt).second;
       Contour::InputType idx = nextContour->GetContourPath()->StartOfInput();
 
 
       Contour::InputType end = nextContour->GetContourPath()->EndOfInput();
       if (end > 50000) end = 0;
 
       mitk::Contour::PointsContainerPointer contourPoints = nextContour->GetPoints();
       mitk::Contour::PointsContainerIterator pointsIt = contourPoints->Begin();
       unsigned int counter = 0;
 
       firstPointIndex=ptIndex;
       while ( pointsIt != contourPoints->End() )
       {
         if (counter %2 == 0)
         {
           Contour::BoundingBoxType::PointType point;
           point = pointsIt.Value();
           points->InsertPoint(ptIndex, point[0],point[1],point[2]);
           if (ptIndex > firstPointIndex)
           {
             int cell[2] = {ptIndex-1,ptIndex};
             lines->InsertNextCell((vtkIdType)2,(vtkIdType*) cell);
           }
           lastPointIndex=ptIndex;
           ptIndex++;
         }
         pointsIt++;
         idx+=1;
       }
 
       if (nextContour->GetClosed())
       {
         int cell[2] = {lastPointIndex,firstPointIndex};
         lines->InsertNextCell((vtkIdType)2,(vtkIdType*) cell);
       }
       contourIt++;
     }
 
     m_ContourSet->SetPoints(points);
     m_ContourSet->SetLines(lines);
-    m_ContourSet->Update();
+//    m_ContourSet->Update(); //VTK6_TODO
 
-    m_TubeFilter->SetInput(m_ContourSet);
+    m_TubeFilter->SetInputData(m_ContourSet);
     m_TubeFilter->SetRadius(1);
     m_TubeFilter->Update();
-    m_VtkPolyDataMapper->SetInput(m_TubeFilter->GetOutput());
+    m_VtkPolyDataMapper->SetInputData(m_TubeFilter->GetOutput());
 
     double rgba[4]={0.0f,1.0f,0.0f,0.6f};
 
     m_Actor->GetProperty()->SetColor(rgba);
     m_Actor->SetMapper(m_VtkPolyDataMapper);
   }
 
   SetVtkMapperImmediateModeRendering(m_VtkPolyDataMapper);
 }
 
 const mitk::ContourSet* mitk::ContourSetVtkMapper3D::GetInput()
 {
   return static_cast<const mitk::ContourSet* > ( GetDataNode()->GetData() );
 }
diff --git a/Modules/Segmentation/Rendering/mitkContourVtkMapper3D.cpp b/Modules/Segmentation/Rendering/mitkContourVtkMapper3D.cpp
index f11fc32859..e3948c22d2 100644
--- a/Modules/Segmentation/Rendering/mitkContourVtkMapper3D.cpp
+++ b/Modules/Segmentation/Rendering/mitkContourVtkMapper3D.cpp
@@ -1,183 +1,183 @@
 /*===================================================================
 
 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 "mitkContourVtkMapper3D.h"
 #include "mitkDataNode.h"
 #include "mitkProperties.h"
 #include "mitkColorProperty.h"
 #include "mitkVtkPropRenderer.h"
 #include "mitkContour.h"
 
 #include <vtkActor.h>
 #include <vtkAppendPolyData.h>
 #include <vtkAssembly.h>
 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
 #include <vtkCellArray.h>
 #pragma GCC diagnostic warning "-Wstrict-aliasing"
 #include <vtkFollower.h>
 #include <vtkLinearTransform.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkPolygon.h>
 #include <vtkProp3DCollection.h>
 #include <vtkProperty.h>
 #include <vtkRenderer.h>
 #include <vtkSphereSource.h>
 #include <vtkTubeFilter.h>
 
 mitk::ContourVtkMapper3D::ContourVtkMapper3D()
 {
   m_VtkPolyDataMapper = vtkPolyDataMapper::New();
   m_VtkPointList = vtkAppendPolyData::New();
   m_Actor = vtkActor::New();
   m_Actor->SetMapper(m_VtkPolyDataMapper);
 
   m_TubeFilter = vtkTubeFilter::New();
 }
 
 mitk::ContourVtkMapper3D::~ContourVtkMapper3D()
 {
   if(m_VtkPolyDataMapper)
     m_VtkPolyDataMapper->Delete();
 
   if(m_TubeFilter)
     m_TubeFilter->Delete();
 
   if(m_VtkPointList)
     m_VtkPointList->Delete();
 
   if(m_Contour)
     m_Contour->Delete();
 
   if(m_Actor)
     m_Actor->Delete();
 }
 
 vtkProp* mitk::ContourVtkMapper3D::GetVtkProp(mitk::BaseRenderer*  /*renderer*/)
 {
   return m_Actor;
 }
 
 void mitk::ContourVtkMapper3D::GenerateDataForRenderer(mitk::BaseRenderer* renderer)
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
 
   if ( !visible )
   {
     m_Actor->VisibilityOff();
     return;
   }
   m_Actor->VisibilityOn();
 
   m_Contour = vtkPolyData::New();
 
   mitk::Contour::Pointer input  = const_cast<mitk::Contour*>(this->GetInput());
   bool makeContour = true;
 
   if ( makeContour )
   {
     vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
 
     int numPts=input->GetNumberOfPoints();
     if ( numPts > 200000 )
       numPts = 200000;
     mitk::Contour::PathPointer path = input->GetContourPath();
     mitk::Contour::PathType::InputType cstart = path->StartOfInput();
     mitk::Contour::PathType::InputType cend   = path->EndOfInput();
     mitk::Contour::PathType::InputType cstep  = (cend-cstart+1)/numPts;
     mitk::Contour::PathType::InputType ccur;
 
     vtkIdType ptIndex = 0;
     vtkIdType lastPointIndex = 0;
 
     mitk::Contour::PointsContainerPointer contourPoints = input->GetPoints();
     mitk::Contour::PointsContainerIterator pointsIt = contourPoints->Begin();
 
     double vtkpoint[3];
 
     int i;
     float pointSize = 2;
     this->GetDataNode()->GetFloatProperty("spheres size", pointSize);
 
     bool showPoints = true;
     this->GetDataNode()->GetBoolProperty("show points", showPoints);
     if ( showPoints )
     {
       m_VtkPointList = vtkAppendPolyData::New();
     }
     for ( i=0, ccur=cstart; i<numPts; ++i, ccur+=cstep )
     {
       itk2vtk(path->Evaluate(ccur), vtkpoint);
       points->InsertPoint(ptIndex, vtkpoint);
       if ( ptIndex > 0 )
       {
         int cell[2] = {ptIndex-1,ptIndex};
         lines->InsertNextCell((vtkIdType)2,(vtkIdType*) cell);
       }
       lastPointIndex = ptIndex;
       ++ptIndex;
 
       if ( showPoints )
       {
         vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
 
         sphere->SetRadius(pointSize);
         sphere->SetCenter(vtkpoint);
 
-        m_VtkPointList->AddInput(sphere->GetOutput());
+        m_VtkPointList->AddInputData(sphere->GetOutput());
         sphere->Update();
       }
     }
 
     if ( input->GetClosed() )
     {
       int cell[2] = {lastPointIndex,0};
       lines->InsertNextCell((vtkIdType)2,(vtkIdType*) cell);
     }
 
     m_Contour->SetPoints(points);
     m_Contour->SetLines(lines);
-    m_Contour->Update();
+//    m_Contour->Update(); //VTK6_TODO
 
-    m_TubeFilter->SetInput(m_Contour);
+    m_TubeFilter->SetInputData(m_Contour);
     m_TubeFilter->SetRadius(pointSize / 2.0f);
     m_TubeFilter->SetNumberOfSides(8);
     m_TubeFilter->Update();
 
     if ( showPoints )
     {
-      m_VtkPointList->AddInput(m_TubeFilter->GetOutput());
-      m_VtkPolyDataMapper->SetInput(m_VtkPointList->GetOutput());
+      m_VtkPointList->AddInputData(m_TubeFilter->GetOutput());
+      m_VtkPolyDataMapper->SetInputData(m_VtkPointList->GetOutput());
     }
     else
     {
-      m_VtkPolyDataMapper->SetInput(m_TubeFilter->GetOutput());
+      m_VtkPolyDataMapper->SetInputData(m_TubeFilter->GetOutput());
     }
     double rgba[4]={0.0f,1.0f,0.0f,0.6f};
     m_Actor->GetProperty()->SetColor(rgba);
     m_Actor->SetMapper(m_VtkPolyDataMapper);
   }
 
   SetVtkMapperImmediateModeRendering(m_VtkPolyDataMapper);
 }
 
 const mitk::Contour* mitk::ContourVtkMapper3D::GetInput()
 {
   return static_cast<const mitk::Contour* > ( GetDataNode()->GetData() );
 }