diff --git a/Core/Code/IO/mitkIOUtil.cpp b/Core/Code/IO/mitkIOUtil.cpp
index 3d930571fb..fa19c45c0c 100644
--- a/Core/Code/IO/mitkIOUtil.cpp
+++ b/Core/Code/IO/mitkIOUtil.cpp
@@ -1,751 +1,751 @@
 /*===================================================================
 
 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 "mitkIOUtil.h"
 #include "mitkDataNodeFactory.h"
 #include "mitkImageWriter.h"
 #include "mitkPointSetWriter.h"
 #include "mitkSurfaceVtkWriter.h"
 
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 #include <mitkStandaloneDataStorage.h>
 #include <mitkIDataNodeReader.h>
 #include <mitkProgressBar.h>
 #include <mitkExceptionMacro.h>
 #include <mitkCoreObjectFactory.h>
 
 //ITK
 #include <itksys/SystemTools.hxx>
 
 //VTK
 #include <vtkPolyData.h>
 #include <vtkTriangleFilter.h>
 #include <vtkSmartPointer.h>
 
 #include <cerrno>
 #include <cstdlib>
 
 static std::string GetLastErrorStr()
 {
 #ifdef US_PLATFORM_POSIX
   return std::string(strerror(errno));
 #else
   // Retrieve the system error message for the last-error code
   LPVOID lpMsgBuf;
   DWORD dw = GetLastError();
 
   FormatMessage(
     FORMAT_MESSAGE_ALLOCATE_BUFFER |
     FORMAT_MESSAGE_FROM_SYSTEM |
     FORMAT_MESSAGE_IGNORE_INSERTS,
     NULL,
     dw,
     MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
     (LPTSTR) &lpMsgBuf,
     0, NULL );
 
   std::string errMsg((LPCTSTR)lpMsgBuf);
 
   LocalFree(lpMsgBuf);
 
   return errMsg;
 #endif
 }
 
 #ifdef US_PLATFORM_WINDOWS
 
 #include <io.h>
 #include <direct.h>
 
 #else
 
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #endif
 
 #include <fcntl.h>
 #include <sys/stat.h>
 
 static const char validLetters[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 
 // A cross-platform version of the mkstemps function
 static int mkstemps_compat(char* tmpl, int suffixlen)
 {
   static unsigned long long value = 0;
   int savedErrno = errno;
 
   // Lower bound on the number of temporary files to attempt to generate.
 #define ATTEMPTS_MIN (62 * 62 * 62)
 
   /* The number of times to attempt to generate a temporary file.  To
      conform to POSIX, this must be no smaller than TMP_MAX.  */
 #if ATTEMPTS_MIN < TMP_MAX
   const unsigned int attempts = TMP_MAX;
 #else
   const unsigned int attempts = ATTEMPTS_MIN;
 #endif
 
   const int len = strlen(tmpl);
   if ((len - suffixlen) < 6 || strncmp(&tmpl[len - 6 - suffixlen], "XXXXXX", 6))
   {
     errno = EINVAL;
     return -1;
   }
 
   /* This is where the Xs start.  */
   char* XXXXXX = &tmpl[len - 6 - suffixlen];
 
   /* Get some more or less random data.  */
 #ifdef US_PLATFORM_WINDOWS
   {
     SYSTEMTIME stNow;
     FILETIME ftNow;
 
     // get system time
     GetSystemTime(&stNow);
     stNow.wMilliseconds = 500;
     if (!SystemTimeToFileTime(&stNow, &ftNow))
     {
       errno = -1;
       return -1;
     }
     unsigned long long randomTimeBits = ((static_cast<unsigned long long>(ftNow.dwHighDateTime) << 32)
                                          | static_cast<unsigned long long>(ftNow.dwLowDateTime));
     value = randomTimeBits ^ static_cast<unsigned long long>(GetCurrentThreadId());
   }
 #else
   {
     struct timeval tv;
     gettimeofday(&tv, NULL);
     unsigned long long randomTimeBits = ((static_cast<unsigned long long>(tv.tv_usec) << 32)
                                          | static_cast<unsigned long long>(tv.tv_sec));
     value = randomTimeBits ^ static_cast<unsigned long long>(getpid());
   }
 #endif
 
   for (unsigned int count = 0; count < attempts; value += 7777, ++count)
   {
     unsigned long long v = value;
 
     /* Fill in the random bits.  */
     XXXXXX[0] = validLetters[v % 62];
     v /= 62;
     XXXXXX[1] = validLetters[v % 62];
     v /= 62;
     XXXXXX[2] = validLetters[v % 62];
     v /= 62;
     XXXXXX[3] = validLetters[v % 62];
     v /= 62;
     XXXXXX[4] = validLetters[v % 62];
     v /= 62;
     XXXXXX[5] = validLetters[v % 62];
 
     int fd = open (tmpl, O_RDWR | O_CREAT | O_EXCL, S_IREAD | S_IWRITE);
     if (fd >= 0)
     {
       errno = savedErrno;
       return fd;
     }
     else if (errno != EEXIST)
     {
       return -1;
     }
   }
 
   /* We got out of the loop because we ran out of combinations to try.  */
   errno = EEXIST;
   return -1;
 }
 
 // A cross-platform version of the POSIX mkdtemp function
 static char* mkdtemps_compat(char* tmpl, int suffixlen)
 {
   static unsigned long long value = 0;
   int savedErrno = errno;
 
   // Lower bound on the number of temporary dirs to attempt to generate.
 #define ATTEMPTS_MIN (62 * 62 * 62)
 
   /* The number of times to attempt to generate a temporary dir.  To
      conform to POSIX, this must be no smaller than TMP_MAX.  */
 #if ATTEMPTS_MIN < TMP_MAX
   const unsigned int attempts = TMP_MAX;
 #else
   const unsigned int attempts = ATTEMPTS_MIN;
 #endif
 
   const int len = strlen(tmpl);
   if ((len - suffixlen) < 6 || strncmp(&tmpl[len - 6 - suffixlen], "XXXXXX", 6))
   {
     errno = EINVAL;
     return NULL;
   }
 
   /* This is where the Xs start.  */
   char* XXXXXX = &tmpl[len - 6 - suffixlen];
 
   /* Get some more or less random data.  */
 #ifdef US_PLATFORM_WINDOWS
   {
     SYSTEMTIME stNow;
     FILETIME ftNow;
 
     // get system time
     GetSystemTime(&stNow);
     stNow.wMilliseconds = 500;
     if (!SystemTimeToFileTime(&stNow, &ftNow))
     {
       errno = -1;
       return NULL;
     }
     unsigned long long randomTimeBits = ((static_cast<unsigned long long>(ftNow.dwHighDateTime) << 32)
                                          | static_cast<unsigned long long>(ftNow.dwLowDateTime));
     value = randomTimeBits ^ static_cast<unsigned long long>(GetCurrentThreadId());
   }
 #else
   {
     struct timeval tv;
     gettimeofday(&tv, NULL);
     unsigned long long randomTimeBits = ((static_cast<unsigned long long>(tv.tv_usec) << 32)
                                          | static_cast<unsigned long long>(tv.tv_sec));
     value = randomTimeBits ^ static_cast<unsigned long long>(getpid());
   }
 #endif
 
   unsigned int count = 0;
   for (; count < attempts; value += 7777, ++count)
   {
     unsigned long long v = value;
 
     /* Fill in the random bits.  */
     XXXXXX[0] = validLetters[v % 62];
     v /= 62;
     XXXXXX[1] = validLetters[v % 62];
     v /= 62;
     XXXXXX[2] = validLetters[v % 62];
     v /= 62;
     XXXXXX[3] = validLetters[v % 62];
     v /= 62;
     XXXXXX[4] = validLetters[v % 62];
     v /= 62;
     XXXXXX[5] = validLetters[v % 62];
 
 #ifdef US_PLATFORM_WINDOWS
     int fd = _mkdir (tmpl); //, _S_IREAD | _S_IWRITE | _S_IEXEC);
 #else
     int fd = mkdir (tmpl, S_IRUSR | S_IWUSR | S_IXUSR);
 #endif
     if (fd >= 0)
     {
       errno = savedErrno;
       return tmpl;
     }
     else if (errno != EEXIST)
     {
       return NULL;
     }
   }
 
   /* We got out of the loop because we ran out of combinations to try.  */
   errno = EEXIST;
   return NULL;
 }
 
 //#endif
 
 namespace mitk {
 
 const std::string IOUtil::DEFAULTIMAGEEXTENSION = ".nrrd";
 const std::string IOUtil::DEFAULTSURFACEEXTENSION = ".stl";
 const std::string IOUtil::DEFAULTPOINTSETEXTENSION = ".mps";
 
 #ifdef US_PLATFORM_WINDOWS
 std::string IOUtil::GetProgramPath()
 {
   char path[512];
   std::size_t index = std::string(path, GetModuleFileName(NULL, path, 512)).find_last_of('\\');
   return std::string(path, index);
 }
 #elif defined(US_PLATFORM_APPLE)
 #include <mach-o/dyld.h>
 std::string IOUtil::GetProgramPath()
 {
   char path[512];
   uint32_t size = sizeof(path);
   if (_NSGetExecutablePath(path, &size) == 0)
   {
     std::size_t index = std::string(path).find_last_of('/');
     std::string strPath = std::string(path, index);
     //const char* execPath = strPath.c_str();
     //mitk::StandardFileLocations::GetInstance()->AddDirectoryForSearch(execPath,false);
     return strPath;
   }
   return std::string();
 }
 #else
 #include <sys/types.h>
 #include <unistd.h>
 #include <sstream>
 std::string IOUtil::GetProgramPath()
 {
   std::stringstream ss;
   ss << "/proc/" << getpid() << "/exe";
   char proc[512] = {0};
   ssize_t ch = readlink(ss.str().c_str(), proc, 512);
   if (ch == -1) return std::string();
   std::size_t index = std::string(proc).find_last_of('/');
   return std::string(proc, index);
 }
 #endif
 
 std::string IOUtil::GetTempPath()
 {
   static std::string result;
   if (result.empty())
   {
 #ifdef US_PLATFORM_WINDOWS
     char tempPathTestBuffer[1];
     DWORD bufferLength = ::GetTempPath(1, tempPathTestBuffer);
     if (bufferLength == 0)
     {
       mitkThrow() << GetLastErrorStr();
     }
     std::vector<char> tempPath(bufferLength);
     bufferLength = ::GetTempPath(bufferLength, &tempPath[0]);
     if (bufferLength == 0)
     {
       mitkThrow() << GetLastErrorStr();
     }
     result.assign(tempPath.begin(), tempPath.begin() + static_cast<std::size_t>(bufferLength));
 #else
     result = "/tmp/";
 #endif
   }
 
   return result;
 }
 
 std::string IOUtil::CreateTemporaryFile(std::ofstream& f, const std::string& templateName, std::string path)
 {
   return CreateTemporaryFile(f, std::ios_base::out | std::ios_base::trunc, templateName, path);
 }
 
 std::string IOUtil::CreateTemporaryFile(std::ofstream& f, std::ios_base::openmode mode, const std::string& templateName, std::string path)
 {
   if (path.empty())
   {
     path = GetTempPath();
   }
 
   path += "/" + templateName;
   std::vector<char> dst_path(path.begin(), path.end());
   dst_path.push_back('\0');
 
   std::size_t lastX = path.find_last_of('X');
   std::size_t firstX = path.find_last_not_of('X', lastX);
   int firstNonX = firstX == std::string::npos ? - 1 : firstX - 1;
   while (lastX != std::string::npos && (lastX - firstNonX) < 6)
   {
     lastX = path.find_last_of('X', firstX);
     firstX = path.find_last_not_of('X', lastX);
     firstNonX = firstX == std::string::npos ? - 1 : firstX - 1;
   }
   std::size_t suffixlen = lastX == std::string::npos ? path.size() : path.size() - lastX  - 1;
 
   int fd = mkstemps_compat(&dst_path[0], suffixlen);
   if(fd != -1)
   {
     path.assign(dst_path.begin(), dst_path.end() - 1);
     f.open(path.c_str(), mode | std::ios_base::out | std::ios_base::trunc);
     close(fd);
   }
   else
   {
     mitkThrow() << "Creating temporary file " << &dst_path[0] << " failed: " << GetLastErrorStr();
   }
   return path;
 }
 
 std::string IOUtil::CreateTemporaryDirectory(const std::string& templateName, std::string path)
 {
   if (path.empty())
   {
     path = GetTempPath();
   }
 
   path += "/" + templateName;
   std::vector<char> dst_path(path.begin(), path.end());
   dst_path.push_back('\0');
 
   std::size_t lastX = path.find_last_of('X');
   std::size_t firstX = path.find_last_not_of('X', lastX);
   int firstNonX = firstX == std::string::npos ? - 1 : firstX - 1;
   while (lastX != std::string::npos && (lastX - firstNonX) < 6)
   {
     lastX = path.find_last_of('X', firstX);
     firstX = path.find_last_not_of('X', lastX);
     firstNonX = firstX == std::string::npos ? - 1 : firstX - 1;
   }
   std::size_t suffixlen = lastX == std::string::npos ? path.size() : path.size() - lastX  - 1;
 
   if(mkdtemps_compat(&dst_path[0], suffixlen) == NULL)
   {
     mitkThrow() << "Creating temporary directory " << &dst_path[0] << " failed: " << GetLastErrorStr();
   }
 
   path.assign(dst_path.begin(), dst_path.end() - 1);
   return path;
 }
 
 int IOUtil::LoadFiles(const std::vector<std::string> &fileNames, DataStorage &ds)
 {
     // Get the set of registered mitk::IDataNodeReader services
     us::ModuleContext* context = us::GetModuleContext();
     const std::vector<us::ServiceReference<IDataNodeReader> > refs = context->GetServiceReferences<IDataNodeReader>();
     std::vector<IDataNodeReader*> services;
     services.reserve(refs.size());
     for (std::vector<us::ServiceReference<IDataNodeReader> >::const_iterator i = refs.begin();
          i != refs.end(); ++i)
     {
         IDataNodeReader* s = context->GetService(*i);
         if (s != 0)
         {
             services.push_back(s);
         }
     }
 
     mitk::ProgressBar::GetInstance()->AddStepsToDo(2*fileNames.size());
 
     // Iterate over all file names and use the IDataNodeReader services
     // to load them.
     int nodesRead = 0;
     for (std::vector<std::string>::const_iterator i = fileNames.begin();
          i != fileNames.end(); ++i)
     {
         for (std::vector<IDataNodeReader*>::const_iterator readerIt = services.begin();
              readerIt != services.end(); ++readerIt)
         {
             try
             {
                 int n = (*readerIt)->Read(*i, ds);
                 nodesRead += n;
                 if (n > 0) break;
             }
             catch (const std::exception& e)
             {
                 MITK_WARN << e.what();
             }
         }
         mitk::ProgressBar::GetInstance()->Progress(2);
     }
 
     for (std::vector<us::ServiceReference<IDataNodeReader> >::const_iterator i = refs.begin();
          i != refs.end(); ++i)
     {
         context->UngetService(*i);
     }
 
     return nodesRead;
 }
 
 DataStorage::Pointer IOUtil::LoadFiles(const std::vector<std::string>& fileNames)
 {
     mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
     LoadFiles(fileNames, *ds);
     return ds.GetPointer();
 }
 
 DataNode::Pointer IOUtil::LoadDataNode(const std::string path)
 {
     mitk::DataNodeFactory::Pointer reader = mitk::DataNodeFactory::New();
     try
     {
         reader->SetFileName( path );
         reader->Update();
 
         if((reader->GetNumberOfOutputs()<1))
         {
             MITK_ERROR << "Could not find data '" << path << "'";
             mitkThrow() << "An exception occured during loading the file " << path << ". Exception says could not find data.";
         }
 
         mitk::DataNode::Pointer node = reader->GetOutput();
 
         if(node.IsNull())
         {
             MITK_ERROR << "Could not find path: '" << path << "'" << " datanode is NULL" ;
             mitkThrow() << "An exception occured during loading the file " << path << ". Exception says datanode is NULL.";
         }
 
         return reader->GetOutput( 0 );
      }
     catch ( itk::ExceptionObject & e )
     {
         MITK_ERROR << "Exception occured during load data of '" << path << "': Exception: " << e.what();
         mitkThrow() << "An exception occured during loading the file " << path << ". Exception says: " << e.what();
     }
 }
 
 Image::Pointer IOUtil::LoadImage(const std::string path)
 {
     mitk::DataNode::Pointer node = LoadDataNode(path);
     mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
     if(image.IsNull())
     {
         MITK_ERROR << "Image is NULL '" << path << "'";
         mitkThrow() << "An exception occured during loading the image " << path << ". Exception says: Image is NULL.";
     }
     return image;
 }
 
 Surface::Pointer IOUtil::LoadSurface(const std::string path)
 {
     mitk::DataNode::Pointer node = LoadDataNode(path);
     mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface*>(node->GetData());
     if(surface.IsNull())
     {
         MITK_ERROR << "Surface is NULL '" << path << "'";
         mitkThrow() << "An exception occured during loading the file " << path << ". Exception says: Surface is NULL.";
     }
     return surface;
 }
 
 PointSet::Pointer IOUtil::LoadPointSet(const std::string path)
 {
     mitk::DataNode::Pointer node = LoadDataNode(path);
     mitk::PointSet::Pointer pointset = dynamic_cast<mitk::PointSet*>(node->GetData());
     if(pointset.IsNull())
     {
         MITK_ERROR << "PointSet is NULL '" << path << "'";
         mitkThrow() << "An exception occured during loading the file " << path << ". Exception says: Pointset is NULL.";
     }
     return pointset;
 }
 
 bool IOUtil::SaveImage(mitk::Image::Pointer image, const std::string path)
 {
     std::string dir = itksys::SystemTools::GetFilenamePath( path );
     std::string baseFilename = itksys::SystemTools::GetFilenameWithoutExtension( path );
     std::string extension = itksys::SystemTools::GetFilenameExtension( path );
     if (dir == "")
       dir = ".";
     std::string finalFileName = dir + "/" + baseFilename;
 
     mitk::ImageWriter::Pointer imageWriter = mitk::ImageWriter::New();
     //check if an extension is given, else use the defaul extension
     if( extension == "" )
     {
         MITK_WARN << extension << " extension is not set. Extension set to default: " << finalFileName
                   << DEFAULTIMAGEEXTENSION;
         extension = DEFAULTIMAGEEXTENSION;
     }
 
     // check if extension is suitable for writing image data
     if (!imageWriter->IsExtensionValid(extension))
     {
         MITK_WARN << extension << " extension is unknown. Extension set to default: " << finalFileName
                   << DEFAULTIMAGEEXTENSION;
         extension = DEFAULTIMAGEEXTENSION;
     }
 
     try
     {
         //write the data
         imageWriter->SetInput(image);
         imageWriter->SetFileName(finalFileName.c_str());
         imageWriter->SetExtension(extension.c_str());
         imageWriter->Write();
     }
     catch ( std::exception& e )
     {
         MITK_ERROR << " during attempt to write '" << finalFileName + extension << "' Exception says:";
         MITK_ERROR << e.what();
         mitkThrow() << "An exception occured during writing the file " << finalFileName << ". Exception says " << e.what();
     }
     return true;
 }
 
 bool IOUtil::SaveSurface(Surface::Pointer surface, const std::string path)
 {
     std::string dir = itksys::SystemTools::GetFilenamePath( path );
     std::string baseFilename = itksys::SystemTools::GetFilenameWithoutLastExtension( path );
     std::string extension = itksys::SystemTools::GetFilenameLastExtension( path );
     if (dir == "")
       dir = ".";
     std::string finalFileName = dir + "/" + baseFilename;
 
     if (extension == "") // if no extension has been set we use the default extension
     {
         MITK_WARN << extension << " extension is not set. Extension set to default: " << finalFileName
                   << DEFAULTSURFACEEXTENSION;
         extension = DEFAULTSURFACEEXTENSION;
     }
     try
     {
         finalFileName += extension;
         if(extension == ".stl" )
         {
             mitk::SurfaceVtkWriter<vtkSTLWriter>::Pointer surfaceWriter = mitk::SurfaceVtkWriter<vtkSTLWriter>::New();
 
             // check if surface actually consists of triangles; if not, the writer will not do anything; so, convert to triangles...
             vtkPolyData* polys = surface->GetVtkPolyData();
             if( polys->GetNumberOfStrips() > 0 )
             {
                 vtkSmartPointer<vtkTriangleFilter> triangleFilter = vtkSmartPointer<vtkTriangleFilter>::New();
-                triangleFilter->SetInput(polys);
+                triangleFilter->SetInputData(polys);
                 triangleFilter->Update();
                 polys = triangleFilter->GetOutput();
                 polys->Register(NULL);
                 surface->SetVtkPolyData(polys);
             }
             surfaceWriter->SetInput( surface );
             surfaceWriter->SetFileName( finalFileName.c_str() );
             surfaceWriter->GetVtkWriter()->SetFileTypeToBinary();
             surfaceWriter->Write();
         }
         else if(extension == ".vtp")
         {
             mitk::SurfaceVtkWriter<vtkXMLPolyDataWriter>::Pointer surfaceWriter = mitk::SurfaceVtkWriter<vtkXMLPolyDataWriter>::New();
             surfaceWriter->SetInput( surface );
             surfaceWriter->SetFileName( finalFileName.c_str() );
             surfaceWriter->GetVtkWriter()->SetDataModeToBinary();
             surfaceWriter->Write();
         }
         else if(extension == ".vtk")
         {
             mitk::SurfaceVtkWriter<vtkPolyDataWriter>::Pointer surfaceWriter = mitk::SurfaceVtkWriter<vtkPolyDataWriter>::New();
             surfaceWriter->SetInput( surface );
             surfaceWriter->SetFileName( finalFileName.c_str() );
             surfaceWriter->Write();
         }
         else
         {
             // file extension not suitable for writing specified data type
             MITK_ERROR << "File extension is not suitable for writing'" << finalFileName;
             mitkThrow() << "An exception occured during writing the file " << finalFileName <<
                            ". File extension " << extension << " is not suitable for writing.";
         }
     }
     catch(std::exception& e)
     {
         MITK_ERROR << " during attempt to write '" << finalFileName << "' Exception says:";
         MITK_ERROR << e.what();
         mitkThrow() << "An exception occured during writing the file " << finalFileName << ". Exception says " << e.what();
     }
     return true;
 }
 
 bool IOUtil::SavePointSet(PointSet::Pointer pointset, const std::string path)
 {
     mitk::PointSetWriter::Pointer pointSetWriter = mitk::PointSetWriter::New();
 
     std::string dir = itksys::SystemTools::GetFilenamePath( path );
     std::string baseFilename = itksys::SystemTools::GetFilenameWithoutLastExtension( path );
     std::string extension = itksys::SystemTools::GetFilenameLastExtension( path );
     if (dir == "")
       dir = ".";
     std::string finalFileName = dir + "/" + baseFilename;
 
     if (extension == "") // if no extension has been entered manually into the filename
     {
         MITK_WARN << extension << " extension is not set. Extension set to default: " << finalFileName
                   << DEFAULTPOINTSETEXTENSION;
         extension = DEFAULTPOINTSETEXTENSION;
     }
 
     // check if extension is valid
     if (!pointSetWriter->IsExtensionValid(extension))
     {
         MITK_WARN << extension << " extension is unknown. Extension set to default: " << finalFileName
                   << DEFAULTPOINTSETEXTENSION;
         extension = DEFAULTPOINTSETEXTENSION;
     }
     try
     {
         pointSetWriter->SetInput( pointset );
         finalFileName += extension;
         pointSetWriter->SetFileName( finalFileName.c_str() );
         pointSetWriter->Update();
     }
     catch( std::exception& e )
     {
         MITK_ERROR << " during attempt to write '" << finalFileName << "' Exception says:";
         MITK_ERROR << e.what();
         mitkThrow() << "An exception occured during writing the file " << finalFileName << ". Exception says " << e.what();
     }
     return true;
 }
 
 bool IOUtil::SaveBaseData( mitk::BaseData* data, const std::string& path )
 {
   if (data == NULL || path.empty()) return false;
 
   std::string dir = itksys::SystemTools::GetFilenamePath( path );
   std::string baseFilename = itksys::SystemTools::GetFilenameWithoutExtension( path );
   std::string extension = itksys::SystemTools::GetFilenameExtension( path );
   if (dir == "")
     dir = ".";
   std::string fileNameWithoutExtension = dir + "/" + baseFilename;
 
   mitk::CoreObjectFactory::FileWriterList fileWriters = mitk::CoreObjectFactory::GetInstance()->GetFileWriters();
 
   for (mitk::CoreObjectFactory::FileWriterList::iterator it = fileWriters.begin() ; it != fileWriters.end() ; ++it)
   {
     if ( (*it)->CanWriteBaseDataType(data) )
     {
       // Ensure a valid filename
       if(baseFilename=="")
       {
         baseFilename = (*it)->GetDefaultFilename();
       }
       // Check if an extension exists already and if not, append the default extension
       if (extension=="" )
       {
         extension=(*it)->GetDefaultExtension();
       }
       else
       {
         if (!(*it)->IsExtensionValid(extension))
         {
           MITK_WARN << extension << " extension is unknown";
           continue;
         }
       }
 
       std::string finalFileName = fileNameWithoutExtension + extension;
       try
       {
         (*it)->SetFileName( finalFileName.c_str() );
         (*it)->DoWrite( data );
         return true;
       }
       catch( const std::exception& e )
       {
         MITK_ERROR << " during attempt to write '" << finalFileName << "' Exception says:";
         MITK_ERROR << e.what();
         mitkThrow() << "An exception occured during writing the file " << finalFileName << ". Exception says " << e.what();
       }
     }
   }
 
   return false;
 }
 
 }
diff --git a/Core/Code/IO/mitkImageWriter.cpp b/Core/Code/IO/mitkImageWriter.cpp
index 4b75cdea47..86ab6a81b2 100644
--- a/Core/Code/IO/mitkImageWriter.cpp
+++ b/Core/Code/IO/mitkImageWriter.cpp
@@ -1,466 +1,466 @@
 /*===================================================================
 
 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 "mitkImageWriter.h"
 
 #include "mitkItkPictureWrite.h"
 #include "mitkImage.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageReadAccessor.h"
 
 #include <itkImageIOBase.h>
 #include <itkImageIOFactory.h>
 
 
 mitk::ImageWriter::ImageWriter()
 {
   this->SetNumberOfRequiredInputs( 1 );
   m_MimeType = "";
   SetDefaultExtension();
 }
 
 mitk::ImageWriter::~ImageWriter()
 {
 }
 
 void mitk::ImageWriter::SetFileName(const char* fileName)
 {
   if ( fileName && ( fileName == this->m_FileName ) )
   {
     return;
   }
   if ( fileName )
   {
     this->m_FileName = fileName;
     this->m_FileNameWithoutExtension = this->m_FileName;
     this->m_Extension.clear();
     std::size_t pos = this->m_FileName.find_last_of("/\\");
     if (pos != std::string::npos)
     {
       std::size_t ppos = this->m_FileName.find_first_of('.', pos);
       if (ppos != std::string::npos)
       {
         this->m_FileNameWithoutExtension = this->m_FileName.substr(0, ppos);
         this->m_Extension = this->m_FileName.substr(ppos);
       }
     }
   }
   else
   {
     this->m_FileName.clear();
     this->m_FileNameWithoutExtension.clear();
     this->m_Extension.clear();
   }
   this->Modified();
 }
 
 void mitk::ImageWriter::SetFileName(const std::string & fileName)
 {
   this->SetFileName( fileName.c_str() );
 }
 
 void mitk::ImageWriter::SetExtension(const char* extension)
 {
   if ( extension && ( extension == this->m_Extension ) )
   {
     return;
   }
   if ( extension )
   {
     this->m_Extension = extension;
     this->m_FileName = this->m_FileNameWithoutExtension + this->m_Extension;
   }
   else
   {
     this->m_Extension.clear();
     this->m_FileName = this->m_FileNameWithoutExtension;
   }
   this->Modified();
 }
 
 void mitk::ImageWriter::SetExtension(const std::string & extension)
 {
   this->SetFileName( extension.c_str() );
 }
 
 void mitk::ImageWriter::SetDefaultExtension()
 {
   this->m_Extension = ".mhd";
   this->m_FileName = this->m_FileNameWithoutExtension + this->m_Extension;
   this->Modified();
 }
 
 #include <vtkConfigure.h>
 #include <vtkImageData.h>
 #include <vtkXMLImageDataWriter.h>
 static void writeVti(const char * filename, mitk::Image* image, int t=0)
 {
   vtkXMLImageDataWriter * vtkwriter = vtkXMLImageDataWriter::New();
   vtkwriter->SetFileName( filename );
-  vtkwriter->SetInput(image->GetVtkImageData(t));
+  vtkwriter->SetInputData(image->GetVtkImageData(t));
   vtkwriter->Write();
   vtkwriter->Delete();
 }
 
 #include <itkRGBAPixel.h>
 
 void mitk::ImageWriter::WriteByITK(mitk::Image* image, const std::string& fileName)
 {
   MITK_INFO << "Writing image: " << fileName << std::endl;
   // Pictures and picture series like .png are written via a different mechanism then volume images.
   // So, they are still multiplexed and thus not support vector images.
   if (fileName.find(".png") != std::string::npos || fileName.find(".tif") != std::string::npos || fileName.find(".jpg") != std::string::npos || fileName.find(".bmp") != std::string::npos)
   {
     try
     {
       // switch processing of single/multi-component images
       if( image->GetPixelType(0).GetNumberOfComponents() == 1)
       {
         AccessByItk_1( image, _mitkItkPictureWrite, fileName );
       }
       else
       {
         AccessFixedPixelTypeByItk_1( image, _mitkItkPictureWriteComposite, MITK_ACCESSBYITK_PIXEL_TYPES_SEQ MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES_SEQ , fileName);
       }
     }
     catch(itk::ExceptionObject &e)
     {
       std::cerr << "Caught " << e.what() << std::endl;
     }
     catch(std::exception &e)
     {
       std::cerr << "Caught std::exception " << e.what() << std::endl;
     }
 
     return;
   }
 
   // Implementation of writer using itkImageIO directly. This skips the use
   // of templated itkImageFileWriter, which saves the multiplexing on MITK side.
 
   unsigned int dimension = image->GetDimension();
   unsigned int* dimensions = image->GetDimensions();
   mitk::PixelType pixelType = image->GetPixelType();
   mitk::Vector3D spacing = image->GetGeometry()->GetSpacing();
   mitk::Point3D origin = image->GetGeometry()->GetOrigin();
 
   itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO( fileName.c_str(),
     itk::ImageIOFactory::WriteMode );
 
   if(imageIO.IsNull())
   {
     itkExceptionMacro(<< "Error: Could not create itkImageIO via factory for file " << fileName);
   }
 
   // Set the necessary information for imageIO
   imageIO->SetNumberOfDimensions(dimension);
   imageIO->SetPixelType( pixelType.GetPixelType() );
   imageIO->SetComponentType( pixelType.GetComponentType() < PixelComponentUserType ?
                              static_cast<itk::ImageIOBase::IOComponentType>(pixelType.GetComponentType()) :
                              itk::ImageIOBase::UNKNOWNCOMPONENTTYPE);
   imageIO->SetNumberOfComponents( pixelType.GetNumberOfComponents() );
 
   itk::ImageIORegion ioRegion( dimension );
 
   for(unsigned int i=0; i<dimension; i++)
   {
     imageIO->SetDimensions(i,dimensions[i]);
     imageIO->SetSpacing(i,spacing[i]);
     imageIO->SetOrigin(i,origin[i]);
 
     mitk::Vector3D direction;
     direction.SetVnlVector(image->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(i));
     vnl_vector< double > axisDirection(dimension);
     for(unsigned int j=0; j<dimension; j++)
     {
       axisDirection[j] = direction[j]/spacing[i];
     }
     imageIO->SetDirection( i, axisDirection );
 
     ioRegion.SetSize(i, image->GetLargestPossibleRegion().GetSize(i) );
     ioRegion.SetIndex(i, image->GetLargestPossibleRegion().GetIndex(i) );
   }
 
   //use compression if available
   imageIO->UseCompressionOn();
 
   imageIO->SetIORegion(ioRegion);
   imageIO->SetFileName(fileName);
 
   ImageReadAccessor imageAccess(image);
   imageIO->Write(imageAccess.GetData());
 }
 
 void mitk::ImageWriter::GenerateData()
 {
   const std::string& locale = "C";
   const std::string& currLocale = setlocale( LC_ALL, NULL );
 
   if ( locale.compare(currLocale)!=0 )
   {
     try
     {
       setlocale(LC_ALL, locale.c_str());
     }
     catch(...)
     {
       MITK_INFO << "Could not set locale " << locale;
     }
   }
 
   if ( m_FileName == "" )
   {
     itkWarningMacro( << "Sorry, filename has not been set!" );
     return ;
   }
 
   FILE* tempFile = fopen(m_FileName.c_str(),"w");
   if (tempFile==NULL)
   {
     itkExceptionMacro(<<"File location not writeable");
     return;
   }
   fclose(tempFile);
   remove(m_FileName.c_str());
 
   // Creating clone of input image, since i might change the geometry
   mitk::Image::Pointer input = const_cast<mitk::Image*>(this->GetInput())->Clone();
 
   // Check if geometry information will be lost
   if (input->GetDimension() == 2)
   {
      if (!input->GetGeometry()->Is2DConvertable())
      {
         MITK_WARN << "Saving a 2D image with 3D geometry information. Geometry information will be lost! You might consider using Convert2Dto3DImageFilter before saving.";
 
         // set matrix to identity
         mitk::AffineTransform3D::Pointer affTrans = mitk::AffineTransform3D::New();
         affTrans->SetIdentity();
         mitk::Vector3D spacing = input->GetGeometry()->GetSpacing();
         mitk::Point3D origin = input->GetGeometry()->GetOrigin();
         input->GetGeometry()->SetIndexToWorldTransform(affTrans);
         input->GetGeometry()->SetSpacing(spacing);
         input->GetGeometry()->SetOrigin(origin);
      }
   }
 
   bool vti = (m_Extension.find(".vti") != std::string::npos);
 
   // If the extension is NOT .pic and NOT .nrrd and NOT .nii and NOT .nii.gz the following block is entered
   if ( m_Extension.find(".pic") == std::string::npos
        && m_Extension.find(".nrrd") == std::string::npos
        && m_Extension.find(".nii") == std::string::npos
        && m_Extension.find(".nii.gz") == std::string::npos
        )
   {
     if(input->GetDimension() > 3)
     {
       int t, timesteps;
 
       timesteps = input->GetDimension(3);
       ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
       timeSelector->SetInput(input);
       mitk::Image::Pointer image = timeSelector->GetOutput();
       for(t = 0; t < timesteps; ++t)
       {
         std::ostringstream filename;
         timeSelector->SetTimeNr(t);
         timeSelector->Update();
         if(input->GetTimeGeometry()->IsValidTimeStep(t))
         {
           const mitk::TimeBounds& timebounds = input->GetTimeGeometry()->GetGeometryForTimeStep(t)->GetTimeBounds();
           filename <<  m_FileNameWithoutExtension << "_S" << std::setprecision(0) << timebounds[0] << "_E" << std::setprecision(0) << timebounds[1] << "_T" << t << m_Extension;
         }
         else
         {
           itkWarningMacro(<<"Error on write: TimeGeometry invalid of image " << filename << ".");
           filename <<  m_FileNameWithoutExtension << "_T" << t << m_Extension;
         }
         if ( vti )
         {
           writeVti(filename.str().c_str(), input, t);
         }
         else
         {
           WriteByITK(image, filename.str());
         }
       }
     }
     else if ( vti )
     {
       writeVti(m_FileName.c_str(), input);
     }
     else
     {
       WriteByITK(input, m_FileName);
     }
   }
   else
   {
     // use the PicFileWriter for the .pic data type
     if( m_Extension.find(".pic") != std::string::npos )
     {
 /*    PicFileWriter::Pointer picWriter = PicFileWriter::New();
     size_t found;
     found = m_FileName.find( m_Extension ); // !!! HAS to be at the very end of the filename (not somewhere in the middle)
     if( m_FileName.length() > 3 && found != m_FileName.length() - 4 )
     {
       //if Extension not in Filename
       std::ostringstream filename;
       filename <<  m_FileName.c_str() << m_Extension;
       picWriter->SetFileName( filename.str().c_str() );
     }
     else
     {
       picWriter->SetFileName( m_FileName.c_str() );
     }
     picWriter->SetInputImage( input );
     picWriter->Write();
 */    }
 
     // use the ITK .nrrd Image writer
     if( m_Extension.find(".nrrd") != std::string::npos
         || m_Extension.find(".nii") != std::string::npos
         || m_Extension.find(".nii.gz") != std::string::npos
         )
     {
         WriteByITK(input, this->m_FileName);
     }
   }
   m_MimeType = "application/MITK.Pic";
 
   try
   {
     setlocale(LC_ALL, currLocale.c_str());
   }
   catch(...)
   {
     MITK_INFO << "Could not reset locale " << currLocale;
   }
 }
 
 bool mitk::ImageWriter::CanWriteDataType( DataNode* input )
 {
   if ( input )
   {
     return this->CanWriteBaseDataType(input->GetData());
   }
   return false;
 }
 
 void mitk::ImageWriter::SetInput( DataNode* input )
 {
   if( input && CanWriteDataType( input ) )
     this->ProcessObject::SetNthInput( 0, dynamic_cast<mitk::Image*>( input->GetData() ) );
 }
 
 std::string mitk::ImageWriter::GetWritenMIMEType()
 {
   return m_MimeType;
 }
 
 std::vector<std::string> mitk::ImageWriter::GetPossibleFileExtensions()
 {
   std::vector<std::string> possibleFileExtensions;
   possibleFileExtensions.push_back(".pic");
   possibleFileExtensions.push_back(".pic.gz");
   possibleFileExtensions.push_back(".bmp");
   possibleFileExtensions.push_back(".dcm");
   possibleFileExtensions.push_back(".DCM");
   possibleFileExtensions.push_back(".dicom");
   possibleFileExtensions.push_back(".DICOM");
   possibleFileExtensions.push_back(".gipl");
   possibleFileExtensions.push_back(".gipl.gz");
   possibleFileExtensions.push_back(".mha");
   possibleFileExtensions.push_back(".nii");
   possibleFileExtensions.push_back(".nii.gz");
   possibleFileExtensions.push_back(".nrrd");
   possibleFileExtensions.push_back(".nhdr");
   possibleFileExtensions.push_back(".png");
   possibleFileExtensions.push_back(".PNG");
   possibleFileExtensions.push_back(".spr");
   possibleFileExtensions.push_back(".mhd");
   possibleFileExtensions.push_back(".vtk");
   possibleFileExtensions.push_back(".vti");
   possibleFileExtensions.push_back(".hdr");
   possibleFileExtensions.push_back(".img");
   possibleFileExtensions.push_back(".img.gz");
   possibleFileExtensions.push_back(".png");
   possibleFileExtensions.push_back(".tif");
   possibleFileExtensions.push_back(".jpg");
   return possibleFileExtensions;
 }
 
 std::string mitk::ImageWriter::GetFileExtension()
 {
   return m_Extension;
 }
 
 void mitk::ImageWriter::SetInput( mitk::Image* image )
 {
   this->ProcessObject::SetNthInput( 0, image );
 }
 
 const mitk::Image* mitk::ImageWriter::GetInput()
 {
   if ( this->GetNumberOfInputs() < 1 )
   {
     return NULL;
   }
   else
   {
     return static_cast< const mitk::Image * >( this->ProcessObject::GetInput( 0 ) );
   }
 }
 
 const char* mitk::ImageWriter::GetDefaultFilename()
 {
   return "Image.nrrd";
 }
 
 const char* mitk::ImageWriter::GetFileDialogPattern()
 {
   return
       "Nearly Raw Raster Data (*.nrrd);;"
       "NIfTI format (*.nii *.nii.gz);;"
       "VTK Image Data Files (*.vti);;"
       "NRRD with detached header (*.nhdr);;"
       "Analyze Format (*.hdr);;"
       "MetaImage (*.mhd);;"
       "Sets of 2D slices (*.png *.tiff *.jpg *.jpeg *.bmp);;"
       "DICOM (*.dcm *.DCM *.dicom *.DICOM);;"
       "UMDS GIPL Format Files (*.gipl *.gipl.gz)";
 }
 
 const char *mitk::ImageWriter::GetDefaultExtension()
 {
   return ".nrrd";
 }
 
 bool mitk::ImageWriter::CanWriteBaseDataType(BaseData::Pointer data)
 {
   return dynamic_cast<mitk::Image*>( data.GetPointer() );
 }
 
 void mitk::ImageWriter::DoWrite(BaseData::Pointer data)
 {
   if (this->CanWriteBaseDataType(data))
   {
     this->SetInput(dynamic_cast<mitk::Image *>(data.GetPointer()));
     this->Update();
   }
 }
diff --git a/Core/Code/IO/mitkSTLFileReader.cpp b/Core/Code/IO/mitkSTLFileReader.cpp
index 5de5378a91..f9459d84cb 100644
--- a/Core/Code/IO/mitkSTLFileReader.cpp
+++ b/Core/Code/IO/mitkSTLFileReader.cpp
@@ -1,94 +1,94 @@
 /*===================================================================
 
 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 "mitkSTLFileReader.h"
 #include <mitkSurface.h>
 #include <vtkSmartPointer.h>
 #include <vtkSTLReader.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataNormals.h>
 #include <vtkCleanPolyData.h>
 
 
 mitk::STLFileReader::STLFileReader() : mitk::SurfaceSource(), m_FileName("")
 {
 }
 
 mitk::STLFileReader::~STLFileReader()
 {
 }
 
 void mitk::STLFileReader::GenerateData()
 {
   mitk::Surface::Pointer output = this->GetOutput();
 
   if( m_FileName != "")
   {
     MITK_INFO << "Loading " << m_FileName << " as stl..." << std::endl;
     vtkSmartPointer<vtkSTLReader> stlReader = vtkSmartPointer<vtkSTLReader>::New();
     stlReader->SetFileName( m_FileName.c_str() );
 
     vtkSmartPointer<vtkPolyDataNormals> normalsGenerator = vtkSmartPointer<vtkPolyDataNormals>::New();
-    normalsGenerator->SetInput( stlReader->GetOutput() );
+    normalsGenerator->SetInputData( stlReader->GetOutput() );
 
     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();
 
     if ( ( stlReader->GetOutput() != NULL ) && ( cleanPolyDataFilter->GetOutput() != NULL ) )
     {
       vtkSmartPointer<vtkPolyData> surfaceWithNormals = cleanPolyDataFilter->GetOutput();
       output->SetVtkPolyData( surfaceWithNormals );
     }
   }
 }
 
 bool mitk::STLFileReader::CanReadFile(const std::string filename, const std::string /*filePrefix*/, const std::string /*filePattern*/)
 {
   // First check the extension
   if(  filename == "" )
     {
       //MITK_INFO<<"No filename specified."<<std::endl;
     return false;
     }
 
   bool extensionFound = false;
   std::string::size_type STLPos = filename.rfind(".stl");
   if ((STLPos != std::string::npos)
       && (STLPos == filename.length() - 4))
     {
     extensionFound = true;
     }
 
   STLPos = filename.rfind(".STL");
   if ((STLPos != std::string::npos)
       && (STLPos == filename.length() - 4))
     {
     extensionFound = true;
     }
 
   if( !extensionFound )
     {
       //MITK_INFO<<"The filename extension is not recognized."<<std::endl;
     return false;
     }
 
   return true;
 }
diff --git a/Core/Code/IO/mitkSurfaceVtkWriter.txx b/Core/Code/IO/mitkSurfaceVtkWriter.txx
index 34930d5a99..91521b6a1f 100644
--- a/Core/Code/IO/mitkSurfaceVtkWriter.txx
+++ b/Core/Code/IO/mitkSurfaceVtkWriter.txx
@@ -1,174 +1,174 @@
 /*===================================================================
 
 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 "mitkSurfaceVtkWriter.h"
 #include <vtkConfigure.h>
 #include <vtkPolyData.h>
 #include <vtkLinearTransform.h>
 #include <vtkTransformPolyDataFilter.h>
 #include <vtkErrorCode.h>
 
 #include <sstream>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <stdio.h>
 
 template <class VTKWRITER>
 mitk::SurfaceVtkWriter<VTKWRITER>::SurfaceVtkWriter()
 : m_WriterWriteHasReturnValue( false )
 {
   this->SetNumberOfRequiredInputs( 1 );
 
   m_VtkWriter = vtkSmartPointer<VtkWriterType>::New();
 
   //enable to write ascii-formatted-file
   //m_VtkWriter->SetFileTypeToASCII();
 
   SetDefaultExtension(); // and information about the Writer's Write() method
 }
 
 template <class VTKWRITER>
 mitk::SurfaceVtkWriter<VTKWRITER>::~SurfaceVtkWriter()
 {
 }
 
 template <class VTKWRITER>
 void mitk::SurfaceVtkWriter<VTKWRITER>::SetDefaultExtension()
 {
   m_Extension = ".vtk";
 }
 
 template<class VTKWRITER>
 void mitk::SurfaceVtkWriter<VTKWRITER>::ExecuteWrite( VtkWriterType* vtkWriter )
 {
   if ( vtkWriter->Write() == 0 || vtkWriter->GetErrorCode() != 0 )
   {
     itkExceptionMacro(<<"Error during surface writing: " << vtkErrorCode::GetStringFromErrorCode(vtkWriter->GetErrorCode()) );
   }
 }
 
 template <class VTKWRITER>
 void mitk::SurfaceVtkWriter<VTKWRITER>::GenerateData()
 {
   if ( m_FileName == "" )
   {
     itkWarningMacro( << "Sorry, filename has not been set!" );
     return ;
   }
 
   mitk::Surface::Pointer input = const_cast<mitk::Surface*>(this->GetInput());
 
   vtkSmartPointer<vtkTransformPolyDataFilter> transformPolyData = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
   vtkPolyData * polyData;
   Geometry3D* geometry;
 
   unsigned int t, timesteps = input->GetTimeGeometry()->CountTimeSteps();
 
   for(t = 0; t < timesteps; ++t)
   {
     // surfaces do not have to exist in all timeteps; therefor, only write valid surfaces
     if( input->GetVtkPolyData(t) == NULL ) continue;
 
     std::ostringstream filename;
     filename.imbue(::std::locale::classic());
     geometry = input->GetGeometry(t);
     if ( timesteps > 1 )
     {
       if(input->GetTimeGeometry()->IsValidTimeStep(t))
       {
         const TimeBounds& timebounds = geometry->GetTimeBounds();
         filename <<  m_FileName.c_str() << "_S" << std::setprecision(0) << timebounds[0] << "_E" << std::setprecision(0) << timebounds[1] << "_T" << t << m_Extension;
       }
       else
       {
         itkWarningMacro(<<"Error on write: TimeGeometry invalid of surface " << filename << ".");
         filename <<  m_FileName.c_str() << "_T" << t << m_Extension;
       }
       m_VtkWriter->SetFileName(filename.str().c_str());
     }
     else
       m_VtkWriter->SetFileName(m_FileName.c_str());
 
     geometry->TransferItkToVtkTransform();
-    transformPolyData->SetInput(input->GetVtkPolyData(t));
+    transformPolyData->SetInputData(input->GetVtkPolyData(t));
     transformPolyData->SetTransform(geometry->GetVtkTransform());
     transformPolyData->UpdateWholeExtent();
     polyData = transformPolyData->GetOutput();
 
-    m_VtkWriter->SetInput(polyData);
+    m_VtkWriter->SetInputData(polyData);
 
     ExecuteWrite( m_VtkWriter );
   }
 
   m_MimeType = "application/MITK.Surface";
 }
 
 template <class VTKWRITER>
 void mitk::SurfaceVtkWriter<VTKWRITER>::SetInput( mitk::Surface* surface )
 {
   this->ProcessObject::SetNthInput( 0, surface );
 }
 
 template <class VTKWRITER>
 const mitk::Surface* mitk::SurfaceVtkWriter<VTKWRITER>::GetInput()
 {
   if ( this->GetNumberOfInputs() < 1 )
   {
     return NULL;
   }
   else
   {
     return static_cast< const Surface * >( this->ProcessObject::GetInput( 0 ) );
   }
 }
 
 template <class VTKWRITER>
 bool mitk::SurfaceVtkWriter<VTKWRITER>::CanWriteDataType( DataNode* input )
 {
   if ( input )
   {
     BaseData* data = input->GetData();
     if ( data )
     {
       Surface::Pointer surface = dynamic_cast<Surface*>( data );
       if( surface.IsNotNull() )
       {
         SetDefaultExtension();
         return true;
       }
     }
   }
   return false;
 }
 
 template <class VTKWRITER>
 void mitk::SurfaceVtkWriter<VTKWRITER>::SetInput( DataNode* input )
 {
   if( input && CanWriteDataType( input ) )
     SetInput( dynamic_cast<Surface*>( input->GetData() ) );
 }
 
 template <class VTKWRITER>
 std::string mitk::SurfaceVtkWriter<VTKWRITER>::GetWritenMIMEType()
 {
   return m_MimeType;
 }
 
 template <class VTKWRITER>
 std::string mitk::SurfaceVtkWriter<VTKWRITER>::GetFileExtension()
 {
   return m_Extension;
 }